Feedback score

valhalla/jawn/src/lib/stores/ScoreStore.ts

@@ -10,17 +10,14 @@ export type Score = {
   score_attribute_key: string;
   score_attribute_type: string;
   score_attribute_value: number;
-}
+};
 
 export class ScoreStore extends BaseStore {
   constructor(organizationId: string) {
     super(organizationId);
   }
 
-  public async putScoresIntoSupabase(
-    requestId: string,
-    scores: Score[]
-  ) {
+  public async putScoresIntoSupabase(requestId: string, scores: Score[]) {
     try {
       const scoreKeys = scores.map((score) => score.score_attribute_key);
       const scoreTypes = scores.map((score) => score.score_attribute_type);
@@ -51,7 +48,7 @@ export class ScoreStore extends BaseStore {
         SELECT id, score_key
         FROM upserted_attributes;
       `;
-      
+
       const { data: upsertedAttributes, error: upsertError } = await dbExecute(
         upsertQuery,
         [scoreKeys, scoreTypes, organizationIds]
@@ -169,6 +166,92 @@ export class ScoreStore extends BaseStore {
     return ok(rowContents.data);
   }
 
+  public async putScoreIntoClickhouse(newVersion: {
+    id: string;
+    version: number;
+    provider: string;
+    score: Score;
+  }): Promise<Result<InsertRequestResponseVersioned, string>> {
+    let rowContents = resultMap(
+      await clickhouseDb.dbQuery<InsertRequestResponseVersioned>(
+        `
+      SELECT *
+      FROM request_response_versioned
+      WHERE request_id = {val_0: UUID}
+      AND version = {val_1: UInt64}
+      AND organization_id = {val_2: String}
+      AND provider = {val_3: String}
+    `,
+        [
+          newVersion.id,
+          newVersion.version - 1,
+          this.organizationId,
+          newVersion.provider,
+        ]
+      ),
+      (x) => x[0]
+    );
+
+    if (rowContents.error) {
+      return rowContents;
+    }
+    if (!rowContents.data) {
+      rowContents = resultMap(
+        await clickhouseDb.dbQuery<InsertRequestResponseVersioned>(
+          `
+        SELECT *
+        FROM request_response_versioned
+        WHERE request_id = {val_0: UUID}
+        AND organization_id = {val_1: String}
+        AND provider = {val_2: String}
+        ORDER BY version DESC
+        LIMIT 1
+      `,
+          [newVersion.id, this.organizationId, newVersion.provider]
+        ),
+        (x) => x[0]
+      );
+    }
+
+    if (rowContents.error || !rowContents.data) {
+      return err("Could not find previous version of request");
+    }
+
+    const res = await clickhouseDb.dbInsertClickhouse(
+      "request_response_versioned",
+      [
+        // Delete the previous version
+        {
+          sign: -1,
+          version: rowContents.data.version,
+          request_id: newVersion.id,
+          organization_id: this.organizationId,
+          provider: newVersion.provider,
+          model: rowContents.data.model,
+          request_created_at: rowContents.data.request_created_at,
+        },
+        // Insert the new version
+        {
+          ...rowContents.data,
+          sign: 1,
+          version: newVersion.version,
+          scores: {
+            ...rowContents.data.scores,
+            ...{
+              [newVersion.score.score_attribute_key]:
+                newVersion.score.score_attribute_value,
+            },
+          },
+        },
+      ]
+    );
+    if (res.error) {
+      return err(res.error);
+    }
+
+    return ok(rowContents.data);
+  }
+
   public async bumpRequestVersion(requestId: string) {
     return await dbExecute<{
       id: string;

valhalla/jawn/src/managers/request/RequestManager.ts

@@ -16,6 +16,7 @@ import {
 } from "../../lib/stores/request/request";
 import { costOfPrompt } from "../../packages/cost";
 import { BaseManager } from "../BaseManager";
+import { ScoreManager } from "../score/ScoreManager";
 
 export class RequestManager extends BaseManager {
   private versionedRequestStore: VersionedRequestStore;
@@ -147,6 +148,21 @@ export class RequestManager extends BaseManager {
       return err(feedbackResult.error.message);
     }
 
+    const scoreManager = new ScoreManager(this.authParams);
+    const feedbackScoreResult = await scoreManager.addSignleScoreToClickhouse(
+      requestId,
+      {
+        score_attribute_key: "helicone-score-feedback",
+        score_attribute_type: "number",
+        score_attribute_value: feedback ? 1 : 0,
+      }
+    );
+
+    if (feedbackScoreResult.error) {
+      console.error("Error upserting feedback:", feedbackScoreResult.error);
+      return err(feedbackScoreResult.error);
+    }
+
     return ok(null);
   }
 

valhalla/jawn/src/managers/score/ScoreManager.ts

@@ -68,12 +68,38 @@ export class ScoreManager extends BaseManager {
     }
   }
 
+  public async addSignleScoreToClickhouse(
+    requestId: string,
+    mappedScores: Score
+  ): Promise<Result<string, string>> {
+    const request = await this.scoreStore.bumpRequestVersion(requestId);
+
+    if (request.error || !request.data) {
+      return err(request.error);
+    }
+
+    if (request.data.length === 0) {
+      return err(`Request not found: ${requestId}`);
+    }
+
+    const requestInClickhouse = await this.scoreStore.putScoreIntoClickhouse({
+      ...request.data[0],
+      score: mappedScores,
+    });
+
+    if (requestInClickhouse.error || !requestInClickhouse.data) {
+      return requestInClickhouse;
+    }
+    return { data: "Scores added to Clickhouse successfully", error: null };
+  }
+
   private mapScores(scores: Scores): Score[] {
     return Object.entries(scores).map(([key, value]) => {
       return {
         score_attribute_key: key,
         score_attribute_type: typeof value === "boolean" ? "boolean" : "number",
-        score_attribute_value: typeof value === "boolean" ? (value ? 1 : 0) : value,
+        score_attribute_value:
+          typeof value === "boolean" ? (value ? 1 : 0) : value,
       };
     });
   }

web/components/templates/playground/playgroundPage.tsx

@@ -602,7 +602,6 @@ export default PlaygroundPage;
 interface PlaygroundPageProps {
   showNewButton?: boolean;
   request?: string;
-  showNewButton: boolean;
 }
 
 export type PlaygroundModel = {