@bolt-foundry/gambit 0.8.6-rc.3 → 0.8.6-rc.4

package/esm/simulator-ui/isograph/components/Query/SimulatorTestPage.js

@@ -1,6 +1,7 @@
 import { iso } from "../../../__generated__/__isograph/iso.js";
 import { useCallback, useMemo, useState } from "react";
 import { buildWorkspacePath, parseWorkspaceRoute, } from "../../../../src/workspace_routes.js";
+import gambitWorkspaceFeedbackSaveMutation from "../../../mutations/GambitWorkspaceFeedbackSaveMutation.js";
 import gambitWorkspaceScenarioRunSendMutation from "../../../mutations/GambitWorkspaceScenarioRunSendMutation.js";
 import gambitWorkspaceScenarioRunStartMutation from "../../../mutations/GambitWorkspaceScenarioRunStartMutation.js";
 import gambitWorkspaceScenarioRunStopMutation from "../../../mutations/GambitWorkspaceScenarioRunStopMutation.js";
@@ -42,8 +43,10 @@ function toOptimisticOutputEdges(messages) {
         node: {
             __typename: "OutputMessage",
             id: message.messageRefId ?? `optimistic-message-existing-${index}`,
+            messageRefId: message.messageRefId ?? null,
             role: message.role === "user" ? "user" : "assistant",
             content: message.content,
+            feedback: message.feedback ?? null,
         },
     }));
 }
@@ -106,6 +109,18 @@ function toOptimisticScenarioRunEdges(args) {
             },
         }, ...edges];
 }
+function normalizeFeedbackEntry(feedback) {
+    if (!feedback)
+        return undefined;
+    return {
+        id: feedback.id,
+        runId: feedback.runId,
+        messageRefId: feedback.messageRefId,
+        score: feedback.score,
+        reason: feedback.reason ?? undefined,
+        createdAt: feedback.createdAt ?? undefined,
+    };
+}
 export const SimulatorTestPage = iso(`
   field Workspace.TestTab @component {
     id
@@ -147,8 +162,17 @@ export const SimulatorTestPage = iso(`
                       __typename
                       asOutputMessage {
                         id
+                        messageRefId
                         role
                         content
+                        feedback {
+                          id
+                          runId
+                          messageRefId
+                          score
+                          reason
+                          createdAt
+                        }
                       }
                     }
                   }
@@ -310,7 +334,8 @@ export const SimulatorTestPage = iso(`
             return [{
                     role,
                     content: outputMessage.content ?? "",
-                    messageRefId: outputMessage.id,
+                    messageRefId: outputMessage.messageRefId ?? undefined,
+                    feedback: normalizeFeedbackEntry(outputMessage.feedback),
                     outputIndex: extractOutputItemIndex(outputMessage.id),
                     edgeIndex,
                 }];
@@ -332,6 +357,7 @@ export const SimulatorTestPage = iso(`
             role: row.role,
             content: row.content,
             messageRefId: row.messageRefId,
+            feedback: row.feedback,
         }));
         return [{
                 id: node.id,
@@ -356,6 +382,7 @@ export const SimulatorTestPage = iso(`
     const startScenarioRun = useGambitTypedMutation(gambitWorkspaceScenarioRunStartMutation);
     const sendScenarioRun = useGambitTypedMutation(gambitWorkspaceScenarioRunSendMutation);
     const stopScenarioRun = useGambitTypedMutation(gambitWorkspaceScenarioRunStopMutation);
+    const saveFeedbackMutation = useGambitTypedMutation(gambitWorkspaceFeedbackSaveMutation);
     const canStartScenarioRun = useMemo(() => {
         if (!workspaceId || !selectedScenarioDeck)
             return false;
@@ -558,7 +585,9 @@ export const SimulatorTestPage = iso(`
             error: selectedRun.error ?? undefined,
             startedAt: selectedRun.startedAt ?? undefined,
             finishedAt: selectedRun.finishedAt ?? undefined,
-            messages: selectedRun.messages,
+            messages: selectedRun.messages.map((message) => ({
+                ...message,
+            })),
             traces: [],
             toolInserts: [],
         };
@@ -615,8 +644,10 @@ export const SimulatorTestPage = iso(`
                         node: {
                             __typename: "OutputMessage",
                             id: optimisticMessageId,
+                            messageRefId: null,
                             role: "user",
                             content: message,
+                            feedback: null,
                         },
                     },
                 ];
@@ -714,6 +745,111 @@ export const SimulatorTestPage = iso(`
         setChatDraft("");
         navigate(toPrefixedPath(buildWorkspacePath("test", workspaceId)));
     }, [navigate, toPrefixedPath, workspaceId]);
+    const saveFeedback = useCallback(async (messageRefId, score, reason) => {
+        if (!workspaceId) {
+            throw new Error("Missing workspaceId for feedback save.");
+        }
+        if (!selectedRun?.id) {
+            throw new Error("Missing scenario run for feedback save.");
+        }
+        const existingFeedback = selectedRun.messages.find((message) => message.messageRefId === messageRefId)?.feedback;
+        const nextFeedback = score === null
+            ? undefined
+            : {
+                id: existingFeedback?.id ??
+                    `optimistic-feedback:${selectedRun.id}:${messageRefId}`,
+                runId: selectedRun.id,
+                messageRefId,
+                score,
+                reason,
+                createdAt: existingFeedback?.createdAt ?? new Date().toISOString(),
+            };
+        const optimisticFeedback = nextFeedback
+            ? {
+                id: nextFeedback.id,
+                runId: nextFeedback.runId,
+                messageRefId: nextFeedback.messageRefId,
+                score: nextFeedback.score,
+                reason: nextFeedback.reason ?? null,
+                createdAt: nextFeedback.createdAt ?? null,
+            }
+            : null;
+        await new Promise((resolve, reject) => {
+            saveFeedbackMutation.commit({
+                input: {
+                    workspaceId,
+                    runId: selectedRun.id,
+                    messageRefId,
+                    score,
+                    ...(reason !== undefined ? { reason } : {}),
+                },
+            }, {
+                optimisticNetworkResponse: {
+                    workspaceFeedbackSave____input___v_input: {
+                        deleted: score === null,
+                        feedback: optimisticFeedback,
+                        run: {
+                            __typename: "WorkspaceScenarioRun",
+                            id: selectedRun.id,
+                            error: selectedRun.error ?? null,
+                            finishedAt: selectedRun.finishedAt ?? null,
+                            openResponses____first___l_1: {
+                                edges: [{
+                                        node: {
+                                            __typename: "OpenResponse",
+                                            id: selectedRun.openResponseId ??
+                                                `${selectedRun.id}:open-response`,
+                                            status: selectedRun.status,
+                                            outputItems____first___l_200: {
+                                                edges: toOptimisticOutputEdges(selectedRun.messages.map((message) => message.messageRefId === messageRefId
+                                                    ? {
+                                                        ...message,
+                                                        feedback: nextFeedback,
+                                                    }
+                                                    : message)),
+                                            },
+                                        },
+                                    }],
+                            },
+                            startedAt: selectedRun.startedAt ?? null,
+                            status: selectedRun.status,
+                            workspaceId,
+                        },
+                        workspace: {
+                            id: workspaceId,
+                            scenarioRuns____first___l_25: {
+                                edges: toOptimisticScenarioRunEdges({
+                                    runs: scenarioRuns.map((run) => run.id === selectedRun.id
+                                        ? {
+                                            ...run,
+                                            messages: run.messages.map((message) => message.messageRefId === messageRefId
+                                                ? {
+                                                    ...message,
+                                                    feedback: nextFeedback,
+                                                }
+                                                : message),
+                                        }
+                                        : run),
+                                    runId: selectedRun.id,
+                                    runStatus: selectedRun.status,
+                                    openResponseId: selectedRun.openResponseId ??
+                                        `${selectedRun.id}:open-response`,
+                                    outputEdges: toOptimisticOutputEdges(selectedRun.messages.map((message) => message.messageRefId === messageRefId
+                                        ? {
+                                            ...message,
+                                            feedback: nextFeedback,
+                                        }
+                                        : message)),
+                                }),
+                            },
+                        },
+                    },
+                },
+                onComplete: () => resolve(),
+                onError: reject,
+            });
+        });
+    }, [saveFeedbackMutation, scenarioRuns, selectedRun, workspaceId]);
     const canRunPersona = scenarioDecks.length > 0;
     const hasPersonaSelection = Boolean(selectedScenarioDeck);
     return (React.createElement(PageShell, null,
@@ -738,8 +874,9 @@ export const SimulatorTestPage = iso(`
                     " ",
                     "(prefer the Build tab) to enable Test runs."), botDescription: selectedScenarioDeck?.description ?? null, scenarioInputSchemaError: selectedScenarioDeck?.inputSchemaError ??
                     null, hasScenarioInputSchema: Boolean(selectedScenarioDeck?.inputSchema), scenarioJsonText: scenarioJsonText, onScenarioJsonChange: (text) => {
-                    if (!selectedScenarioDeck)
+                    if (!selectedScenarioDeck) {
                         return;
+                    }
                     setScenarioJsonByDeckId((previous) => ({
                         ...previous,
                         [selectedScenarioDeck.id]: text,
@@ -754,6 +891,6 @@ export const SimulatorTestPage = iso(`
                     : null }),
             React.createElement(TestBotChatPanel, { run: selectedRunState, runWorkspaceId: workspaceId, runStatusLabel: runStatusLabel, testChatDisplay: testChatDisplay, activeWorkspaceId: workspaceId || null, requestedRunNotFound: hasMissingSelectedRun, canStart: canStartScenarioRun, canRunPersona: canRunPersona, hasPersonaSelection: hasPersonaSelection, botJsonErrorCount: parsedScenarioJson.error ? 1 : 0, deckJsonErrorCount: parsedAssistantInitJson.error ? 1 : 0, missingBotInput: missingScenarioFields, missingDeckInit: missingAssistantInitFields, lastInitFill: null, isUserStart: assistantDeck?.startMode === "user", showStartOverlay: showStartOverlay, canStartAssistant: canStartAssistantRun, canSendChat: chatDraft.trim().length > 0 && !showStartOverlay &&
                     selectedRunState.status !== "running" &&
-                    !sendScenarioRun.inFlight, chatDraft: chatDraft, setChatDraft: setChatDraft, chatError: null, optimisticUser: null, streamingUser: null, streamingAssistant: null, startRun: async () => startNewScenarioRun(), stopRun: handleStopRun, handleNewChat: handleNewChat, handleSendChat: handleSendChat, handleStartAssistant: handleStartAssistant, onScore: async () => { }, onReasonChange: async () => { } }))));
+                    !sendScenarioRun.inFlight, chatDraft: chatDraft, setChatDraft: setChatDraft, chatError: null, optimisticUser: null, streamingUser: null, streamingAssistant: null, startRun: async () => startNewScenarioRun(), stopRun: handleStopRun, handleNewChat: handleNewChat, handleSendChat: handleSendChat, handleStartAssistant: handleStartAssistant, onScore: saveFeedback, onReasonChange: saveFeedback }))));
 });
 export default SimulatorTestPage;

package/esm/simulator-ui/isograph/entrypoints/EntrypointSimulatorWorkspaceShell.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EntrypointSimulatorWorkspaceShell.d.ts","sourceRoot":"","sources":["../../../../src/simulator-ui/isograph/entrypoints/EntrypointSimulatorWorkspaceShell.tsx"],"names":[],"mappings":"AA+CA,eAAO,MAAM,iCAAiC;;;;;;;;CAkC5C,CAAC;AAEH,eAAe,iCAAiC,CAAC"}
+{"version":3,"file":"EntrypointSimulatorWorkspaceShell.d.ts","sourceRoot":"","sources":["../../../../src/simulator-ui/isograph/entrypoints/EntrypointSimulatorWorkspaceShell.tsx"],"names":[],"mappings":"AAsDA,eAAO,MAAM,iCAAiC;;;;;;;;CAkC5C,CAAC;AAEH,eAAe,iCAAiC,CAAC"}

package/esm/simulator-ui/isograph/entrypoints/EntrypointSimulatorWorkspaceShell.js

@@ -6,6 +6,7 @@ import entrypointSimulatorVerifyPage from "../../__generated__/__isograph/Query/
 import { parseWorkspaceRoute } from "../../../src/workspace_routes.js";
 import { AppIsoMinimal } from "../../src/AppIsoMinimal.js";
 import { useRouter } from "../../src/RouterContext.js";
+import Panel from "../../src/gds/Panel.js";
 function isThenable(value) {
     return !!value &&
         (typeof value === "object" || typeof value === "function") &&
@@ -33,7 +34,8 @@ function WorkspaceMainPane(props) {
             : tab === "verify"
                 ? entrypointSimulatorVerifyPage
                 : entrypointSimulatorBuildPage;
-    return (React.createElement(AppIsoMinimal, { key: `workspace-main:${props.workspaceId}:${tab}`, entrypoint: entrypoint, params: { workspaceId: props.workspaceId } }));
+    return (React.createElement(AppIsoMinimal, { key: `workspace-main:${props.workspaceId}:${tab}`, entrypoint: entrypoint, params: { workspaceId: props.workspaceId }, fallback: React.createElement(Panel, null,
+            React.createElement("div", { className: "editor-status" }, "Loading workspace tab\u2026")), shouldFetch: "Yes" }));
 }
 export const EntrypointSimulatorWorkspaceShell = iso(`
   field Query.EntrypointSimulatorWorkspaceShell($workspaceId: ID!) {

package/esm/simulator-ui/mutations/GambitWorkspaceFeedbackSave.d.ts

@@ -0,0 +1,93 @@
+export declare const GambitWorkspaceFeedbackSaveMutation: (param: import("../__generated__/__isograph/Mutation/GambitWorkspaceFeedbackSave/param_type.js").Mutation__GambitWorkspaceFeedbackSave__param) => {
+    readonly deleted: boolean;
+    readonly feedback: ({
+        readonly id: string;
+        readonly runId: string;
+        readonly messageRefId: string;
+        readonly score: number;
+        readonly reason: (string | null);
+        readonly createdAt: (string | null);
+    } | null);
+    readonly workspace: {
+        readonly id: string;
+        readonly scenarioRuns: {
+            readonly edges: ReadonlyArray<{
+                readonly node: {
+                    readonly id: string;
+                    readonly status: string;
+                    readonly startedAt: (string | null);
+                    readonly finishedAt: (string | null);
+                    readonly error: (string | null);
+                    readonly openResponses: {
+                        readonly edges: ReadonlyArray<{
+                            readonly node: {
+                                readonly id: string;
+                                readonly status: string;
+                                readonly outputItems: {
+                                    readonly edges: ReadonlyArray<{
+                                        readonly node: {
+                                            readonly __typename: string;
+                                            readonly asOutputMessage: ({
+                                                readonly id: string;
+                                                readonly messageRefId: (string | null);
+                                                readonly role: string;
+                                                readonly content: string;
+                                                readonly feedback: ({
+                                                    readonly id: string;
+                                                    readonly runId: string;
+                                                    readonly messageRefId: string;
+                                                    readonly score: number;
+                                                    readonly reason: (string | null);
+                                                    readonly createdAt: (string | null);
+                                                } | null);
+                                            } | null);
+                                        };
+                                    }>;
+                                };
+                            };
+                        }>;
+                    };
+                };
+            }>;
+        };
+    };
+    readonly run: {
+        readonly id: string;
+        readonly workspaceId: string;
+        readonly status: string;
+        readonly startedAt: (string | null);
+        readonly finishedAt: (string | null);
+        readonly error: (string | null);
+        readonly openResponses: {
+            readonly edges: ReadonlyArray<{
+                readonly node: {
+                    readonly id: string;
+                    readonly status: string;
+                    readonly outputItems: {
+                        readonly edges: ReadonlyArray<{
+                            readonly node: {
+                                readonly __typename: string;
+                                readonly asOutputMessage: ({
+                                    readonly id: string;
+                                    readonly messageRefId: (string | null);
+                                    readonly role: string;
+                                    readonly content: string;
+                                    readonly feedback: ({
+                                        readonly id: string;
+                                        readonly runId: string;
+                                        readonly messageRefId: string;
+                                        readonly score: number;
+                                        readonly reason: (string | null);
+                                        readonly createdAt: (string | null);
+                                    } | null);
+                                } | null);
+                            };
+                        }>;
+                    };
+                };
+            }>;
+        };
+    };
+};
+export default GambitWorkspaceFeedbackSaveMutation;
+//# sourceMappingURL=GambitWorkspaceFeedbackSave.d.ts.map

package/esm/simulator-ui/mutations/GambitWorkspaceFeedbackSave.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GambitWorkspaceFeedbackSave.d.ts","sourceRoot":"","sources":["../../../src/simulator-ui/mutations/GambitWorkspaceFeedbackSave.tsx"],"names":[],"mappings":"AAEA,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkG9C,CAAC;AAEH,eAAe,mCAAmC,CAAC"}

package/esm/simulator-ui/mutations/GambitWorkspaceFeedbackSave.js

@@ -0,0 +1,101 @@
+import { iso } from "../__generated__/__isograph/iso.js";
+export const GambitWorkspaceFeedbackSaveMutation = iso(`
+  field Mutation.GambitWorkspaceFeedbackSave(
+    $input: WorkspaceFeedbackSaveInput!
+  ) {
+    workspaceFeedbackSave(input: $input) {
+      deleted
+      feedback {
+        id
+        runId
+        messageRefId
+        score
+        reason
+        createdAt
+      }
+      workspace {
+        id
+        scenarioRuns(first: 25) {
+          edges {
+            node {
+              id
+              status
+              startedAt
+              finishedAt
+              error
+              openResponses(first: 1) {
+                edges {
+                  node {
+                    id
+                    status
+                    outputItems(first: 200) {
+                      edges {
+                        node {
+                          __typename
+                          asOutputMessage {
+                            id
+                            messageRefId
+                            role
+                            content
+                            feedback {
+                              id
+                              runId
+                              messageRefId
+                              score
+                              reason
+                              createdAt
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      run {
+        id
+        workspaceId
+        status
+        startedAt
+        finishedAt
+        error
+        openResponses(first: 1) {
+          edges {
+            node {
+              id
+              status
+              outputItems(first: 200) {
+                edges {
+                  node {
+                    __typename
+                    asOutputMessage {
+                      id
+                      messageRefId
+                      role
+                      content
+                      feedback {
+                        id
+                        runId
+                        messageRefId
+                        score
+                        reason
+                        createdAt
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`)(function GambitWorkspaceFeedbackSave({ data }) {
+    return data.workspaceFeedbackSave;
+});
+export default GambitWorkspaceFeedbackSaveMutation;

package/esm/simulator-ui/mutations/GambitWorkspaceFeedbackSaveMutation.d.ts

@@ -0,0 +1,93 @@
+export declare const gambitWorkspaceFeedbackSaveMutation: import("../src/hooks/defineGambitMutation.js").GambitMutationDefinition<import("../__generated__/__isograph/Mutation/GambitWorkspaceFeedbackSave/param_type.js").Mutation__GambitWorkspaceFeedbackSave__param, {
+    readonly deleted: boolean;
+    readonly feedback: ({
+        readonly id: string;
+        readonly runId: string;
+        readonly messageRefId: string;
+        readonly score: number;
+        readonly reason: (string | null);
+        readonly createdAt: (string | null);
+    } | null);
+    readonly workspace: {
+        readonly id: string;
+        readonly scenarioRuns: {
+            readonly edges: ReadonlyArray<{
+                readonly node: {
+                    readonly id: string;
+                    readonly status: string;
+                    readonly startedAt: (string | null);
+                    readonly finishedAt: (string | null);
+                    readonly error: (string | null);
+                    readonly openResponses: {
+                        readonly edges: ReadonlyArray<{
+                            readonly node: {
+                                readonly id: string;
+                                readonly status: string;
+                                readonly outputItems: {
+                                    readonly edges: ReadonlyArray<{
+                                        readonly node: {
+                                            readonly __typename: string;
+                                            readonly asOutputMessage: ({
+                                                readonly id: string;
+                                                readonly messageRefId: (string | null);
+                                                readonly role: string;
+                                                readonly content: string;
+                                                readonly feedback: ({
+                                                    readonly id: string;
+                                                    readonly runId: string;
+                                                    readonly messageRefId: string;
+                                                    readonly score: number;
+                                                    readonly reason: (string | null);
+                                                    readonly createdAt: (string | null);
+                                                } | null);
+                                            } | null);
+                                        };
+                                    }>;
+                                };
+                            };
+                        }>;
+                    };
+                };
+            }>;
+        };
+    };
+    readonly run: {
+        readonly id: string;
+        readonly workspaceId: string;
+        readonly status: string;
+        readonly startedAt: (string | null);
+        readonly finishedAt: (string | null);
+        readonly error: (string | null);
+        readonly openResponses: {
+            readonly edges: ReadonlyArray<{
+                readonly node: {
+                    readonly id: string;
+                    readonly status: string;
+                    readonly outputItems: {
+                        readonly edges: ReadonlyArray<{
+                            readonly node: {
+                                readonly __typename: string;
+                                readonly asOutputMessage: ({
+                                    readonly id: string;
+                                    readonly messageRefId: (string | null);
+                                    readonly role: string;
+                                    readonly content: string;
+                                    readonly feedback: ({
+                                        readonly id: string;
+                                        readonly runId: string;
+                                        readonly messageRefId: string;
+                                        readonly score: number;
+                                        readonly reason: (string | null);
+                                        readonly createdAt: (string | null);
+                                    } | null);
+                                } | null);
+                            };
+                        }>;
+                    };
+                };
+            }>;
+        };
+    };
+}, import("../__generated__/__isograph/Mutation/GambitWorkspaceFeedbackSave/raw_response_type.js").Mutation__GambitWorkspaceFeedbackSave__raw_response_type>;
+export default gambitWorkspaceFeedbackSaveMutation;
+//# sourceMappingURL=GambitWorkspaceFeedbackSaveMutation.d.ts.map

package/esm/simulator-ui/mutations/GambitWorkspaceFeedbackSaveMutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GambitWorkspaceFeedbackSaveMutation.d.ts","sourceRoot":"","sources":["../../../src/simulator-ui/mutations/GambitWorkspaceFeedbackSaveMutation.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4JAG9C,CAAC;AAEH,eAAe,mCAAmC,CAAC"}

package/esm/simulator-ui/mutations/GambitWorkspaceFeedbackSaveMutation.js

@@ -0,0 +1,7 @@
+import workspaceFeedbackSaveEntrypoint from "../__generated__/__isograph/Mutation/GambitWorkspaceFeedbackSave/entrypoint.js";
+import { defineGambitMutation } from "../src/hooks/defineGambitMutation.js";
+export const gambitWorkspaceFeedbackSaveMutation = defineGambitMutation({
+    entrypoint: workspaceFeedbackSaveEntrypoint,
+    flightPolicy: "single",
+});
+export default gambitWorkspaceFeedbackSaveMutation;

package/esm/simulator-ui/mutations/GambitWorkspaceScenarioRunSend.d.ts

@@ -20,8 +20,17 @@ export declare const GambitWorkspaceScenarioRunSendMutation: (param: import("../
                                             readonly __typename: string;
                                             readonly asOutputMessage: ({
                                                 readonly id: string;
+                                                readonly messageRefId: (string | null);
                                                 readonly role: string;
                                                 readonly content: string;
+                                                readonly feedback: ({
+                                                    readonly id: string;
+                                                    readonly runId: string;
+                                                    readonly messageRefId: string;
+                                                    readonly score: number;
+                                                    readonly reason: (string | null);
+                                                    readonly createdAt: (string | null);
+                                                } | null);
                                             } | null);
                                         };
                                     }>;
@@ -51,8 +60,17 @@ export declare const GambitWorkspaceScenarioRunSendMutation: (param: import("../
                                 readonly __typename: string;
                                 readonly asOutputMessage: ({
                                     readonly id: string;
+                                    readonly messageRefId: (string | null);
                                     readonly role: string;
                                     readonly content: string;
+                                    readonly feedback: ({
+                                        readonly id: string;
+                                        readonly runId: string;
+                                        readonly messageRefId: string;
+                                        readonly score: number;
+                                        readonly reason: (string | null);
+                                        readonly createdAt: (string | null);
+                                    } | null);
                                 } | null);
                                 readonly asOutputReasoning: ({
                                     readonly id: string;

package/esm/simulator-ui/mutations/GambitWorkspaceScenarioRunSend.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GambitWorkspaceScenarioRunSend.d.ts","sourceRoot":"","sources":["../../../src/simulator-ui/mutations/GambitWorkspaceScenarioRunSend.tsx"],"names":[],"mappings":"AAEA,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqFjD,CAAC;AAEH,eAAe,sCAAsC,CAAC"}
+{"version":3,"file":"GambitWorkspaceScenarioRunSend.d.ts","sourceRoot":"","sources":["../../../src/simulator-ui/mutations/GambitWorkspaceScenarioRunSend.tsx"],"names":[],"mappings":"AAEA,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuGjD,CAAC;AAEH,eAAe,sCAAsC,CAAC"}

package/esm/simulator-ui/mutations/GambitWorkspaceScenarioRunSend.js

@@ -25,8 +25,17 @@ export const GambitWorkspaceScenarioRunSendMutation = iso(`
                           __typename
                           asOutputMessage {
                             id
+                            messageRefId
                             role
                             content
+                            feedback {
+                              id
+                              runId
+                              messageRefId
+                              score
+                              reason
+                              createdAt
+                            }
                           }
                         }
                       }
@@ -56,8 +65,17 @@ export const GambitWorkspaceScenarioRunSendMutation = iso(`
                     __typename
                     asOutputMessage {
                       id
+                      messageRefId
                       role
                       content
+                      feedback {
+                        id
+                        runId
+                        messageRefId
+                        score
+                        reason
+                        createdAt
+                      }
                     }
                     asOutputReasoning {
                       id