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

package/esm/simulator-ui/isograph/components/WorkspaceConversationRun/WorkbenchConversationRunChat.js

@@ -5,7 +5,10 @@ import { BuildChatRows, deriveBuildChatActivityState, formatElapsedDuration, } f
 import Button from "../../../src/gds/Button.js";
 import Callout from "../../../src/gds/Callout.js";
 import CodexLoginRequiredOverlay from "../../../src/CodexLoginRequiredOverlay.js";
+import WorkbenchChatIntro from "../../../src/WorkbenchChatIntro.js";
+import { countTranscriptMessages, parseTranscriptEntries, toBuildDisplayEntries, toOptimisticTranscriptEntries, } from "../../../src/transcriptEntries.js";
 import WorkbenchDrawerIso from "../../../src/WorkbenchDrawerIso.js";
+import { workbenchChatTopActionsEnabled } from "../../../src/utils.js";
 const RUN_STATUS_VALUES = new Set([
     "IDLE",
     "RUNNING",
@@ -53,9 +56,6 @@ function toRunStatus(value) {
         ? value
         : "IDLE";
 }
-function toMessageRole(value) {
-    return value === "user" ? "user" : "assistant";
-}
 function toErrorMessage(error) {
     if (error instanceof Error && error.message.trim().length > 0) {
         return error.message;
@@ -65,142 +65,6 @@ function toErrorMessage(error) {
     }
     return "GraphQL request failed";
 }
-function toOptimisticOutputEdges(messages) {
-    return messages.map((message, index) => ({
-        node: {
-            __typename: "OutputMessage",
-            asOutputMessage: {
-                id: message.id ?? `optimistic-message-existing-${index}`,
-                role: message.role,
-                content: message.content,
-            },
-        },
-    }));
-}
-function toToolStatus(value) {
-    if (value === "COMPLETED")
-        return "completed";
-    if (value === "ERROR")
-        return "error";
-    if (value === "RUNNING")
-        return "running";
-    return "pending";
-}
-function toOutputDisplayEntries(outputItems) {
-    const messages = [];
-    const display = [];
-    for (const item of outputItems) {
-        if (!item || typeof item !== "object")
-            continue;
-        const node = item;
-        const typeName = typeof node.__typename === "string" ? node.__typename : "";
-        if (typeName === "OutputMessage") {
-            const outputMessage = node.asOutputMessage &&
-                typeof node.asOutputMessage === "object"
-                ? node.asOutputMessage
-                : null;
-            const content = outputMessage && typeof outputMessage.content === "string"
-                ? outputMessage.content
-                : "";
-            if (content.length === 0)
-                continue;
-            const role = toMessageRole(outputMessage?.role);
-            const message = {
-                id: typeof outputMessage?.id === "string"
-                    ? outputMessage.id
-                    : undefined,
-                role,
-                content,
-            };
-            messages.push(message);
-            display.push({
-                kind: "message",
-                role,
-                content,
-            });
-            continue;
-        }
-        if (typeName === "OutputReasoning") {
-            const outputReasoning = node.asOutputReasoning &&
-                typeof node.asOutputReasoning === "object"
-                ? node.asOutputReasoning
-                : null;
-            if (!outputReasoning || typeof outputReasoning.summary !== "string") {
-                continue;
-            }
-            display.push({
-                kind: "reasoning",
-                reasoningId: typeof outputReasoning.id === "string"
-                    ? outputReasoning.id
-                    : undefined,
-                content: outputReasoning.summary,
-                reasoningType: typeof outputReasoning.reasoningType === "string"
-                    ? outputReasoning.reasoningType
-                    : undefined,
-            });
-            continue;
-        }
-        if (typeName === "OutputToolCall") {
-            const outputToolCall = node.asOutputToolCall &&
-                typeof node.asOutputToolCall === "object"
-                ? node.asOutputToolCall
-                : null;
-            if (!outputToolCall)
-                continue;
-            const toolCallId = typeof outputToolCall.toolCallId === "string"
-                ? outputToolCall.toolCallId
-                : undefined;
-            const itemId = typeof outputToolCall.id === "string"
-                ? outputToolCall.id
-                : toolCallId;
-            if (!itemId)
-                continue;
-            display.push({
-                kind: "tool",
-                toolCallId,
-                toolSummary: {
-                    key: itemId,
-                    id: itemId,
-                    actionCallId: toolCallId,
-                    name: typeof outputToolCall.toolName === "string"
-                        ? outputToolCall.toolName
-                        : undefined,
-                    status: toToolStatus(outputToolCall.status),
-                    args: typeof outputToolCall.argumentsText === "string"
-                        ? outputToolCall.argumentsText
-                        : undefined,
-                    result: typeof outputToolCall.resultText === "string"
-                        ? outputToolCall.resultText
-                        : undefined,
-                    error: typeof outputToolCall.error === "string"
-                        ? outputToolCall.error
-                        : undefined,
-                },
-            });
-        }
-    }
-    const outputTypeCounts = {};
-    for (const item of outputItems) {
-        if (!item || typeof item !== "object")
-            continue;
-        const key = typeof item.__typename === "string"
-            ? String(item.__typename)
-            : "unknown";
-        outputTypeCounts[key] = (outputTypeCounts[key] ?? 0) + 1;
-    }
-    const displayTypeCounts = {};
-    for (const entry of display) {
-        displayTypeCounts[entry.kind] = (displayTypeCounts[entry.kind] ?? 0) + 1;
-    }
-    logBuildChatDebug("drawer.toOutputDisplayEntries", {
-        outputCount: outputItems.length,
-        outputTypeCounts,
-        displayCount: display.length,
-        displayTypeCounts,
-        messageCount: messages.length,
-    });
-    return { messages, display };
-}
 function toBuildChatRunStatus(status) {
     switch (status) {
         case "RUNNING":
@@ -273,35 +137,32 @@ export const WorkbenchConversationRunChat = iso(`
         node {
           id
           status
-          outputItems(first: 200) {
-            edges {
-              node {
-                __typename
-                asOutputMessage {
-                  id
-                  role
-                  content
-                }
-                asOutputReasoning {
-                  id
-                  summary
-                  reasoningType
-                }
-                asOutputToolCall {
-                  id
-                  toolCallId
-                  toolName
-                  status
-                  argumentsText
-                  resultText
-                  error
-                }
-              }
-            }
-          }
         }
       }
     }
+    transcriptEntries {
+      asWorkspaceConversationTranscriptMessage {
+        id
+        role
+        content
+        messageRefId
+        feedbackEligible
+      }
+      asWorkspaceConversationTranscriptReasoning {
+        id
+        summary
+        reasoningType
+      }
+      asWorkspaceConversationTranscriptToolCall {
+        id
+        toolCallId
+        toolName
+        status
+        argumentsText
+        resultText
+        error
+      }
+    }
   }
 `)(function WorkbenchConversationRunChat({ data }, componentProps) {
     const [chatError, setChatError] = useState(null);
@@ -310,7 +171,6 @@ export const WorkbenchConversationRunChat = iso(`
     const testIdPrefix = (componentProps.testIdPrefix ?? "build").trim() ||
         "build";
     const chatInputTestId = `${testIdPrefix}-chat-input`;
-    const startButtonTestId = `${testIdPrefix}-start`;
     const sendButtonTestId = `${testIdPrefix}-send`;
     const stopButtonTestId = `${testIdPrefix}-stop`;
     const activityIndicatorTestId = `${testIdPrefix}-chat-activity-indicator`;
@@ -325,36 +185,33 @@ export const WorkbenchConversationRunChat = iso(`
         : false;
     const showCodexLoginOverlay = codexLoginRequired && !codexOverlayDismissed;
     const codexLoginCommand = "codex login";
-    const firstOpenResponse = (data.openResponses?.edges ?? []).flatMap((edge) => edge?.node ? [edge.node] : [])[0] ?? null;
     const startedAtMs = typeof data.startedAt === "string"
         ? Date.parse(data.startedAt)
         : Number.NaN;
     const resolvedStartedAtMs = Number.isFinite(startedAtMs) ? startedAtMs : null;
+    const firstOpenResponse = (data.openResponses?.edges ?? []).flatMap((edge) => edge?.node ? [edge.node] : [])[0] ?? null;
     const runStatus = toRunStatus(firstOpenResponse?.status ?? data.status);
     const scenarioRunError = typeof data.error === "string" &&
         data.error.trim().length > 0
         ? data.error.trim()
         : null;
-    const outputNodes = (firstOpenResponse?.outputItems?.edges ?? []).flatMap((edge) => edge?.node ? [edge.node] : []);
-    const outputDisplay = useMemo(() => toOutputDisplayEntries(outputNodes), [outputNodes]);
-    const messages = outputDisplay.messages;
-    const optimisticOutputEdges = useMemo(() => toOptimisticOutputEdges(messages), [messages]);
-    const transcriptDisplay = outputDisplay.display;
+    const transcriptEntries = useMemo(() => {
+        return parseTranscriptEntries(data.transcriptEntries);
+    }, [data.transcriptEntries]);
+    const transcriptMessageCount = useMemo(() => countTranscriptMessages(transcriptEntries), [transcriptEntries]);
+    const optimisticTranscriptEntries = useMemo(() => toOptimisticTranscriptEntries(transcriptEntries), [transcriptEntries]);
+    const transcriptDisplay = useMemo(() => toBuildDisplayEntries(transcriptEntries), [transcriptEntries]);
     useEffect(() => {
         logBuildChatDebug("drawer.state", {
             runId: data.id ?? null,
-            openResponseId: firstOpenResponse?.id ?? null,
             runStatus,
-            outputNodeCount: outputNodes.length,
-            messageCount: messages.length,
+            messageCount: transcriptMessageCount,
             transcriptCount: transcriptDisplay.length,
         });
     }, [
-        firstOpenResponse?.id,
         data.id,
-        messages.length,
-        outputNodes.length,
         runStatus,
+        transcriptMessageCount,
         transcriptDisplay.length,
     ]);
     const runId = typeof data.id === "string" && data.id.trim().length > 0
@@ -389,7 +246,7 @@ export const WorkbenchConversationRunChat = iso(`
                 message: trimmedMessage,
                 optimisticOpenResponseId,
                 optimisticMessageId,
-                optimisticOutputEdges,
+                optimisticTranscriptEntries,
                 onComplete: () => {
                     setChatError(null);
                     resolve();
@@ -405,7 +262,7 @@ export const WorkbenchConversationRunChat = iso(`
         componentProps,
         codexLoginRequired,
         firstOpenResponse?.id,
-        optimisticOutputEdges,
+        optimisticTranscriptEntries,
         runId,
         workspaceId,
     ]);
@@ -426,7 +283,7 @@ export const WorkbenchConversationRunChat = iso(`
                 workspaceId,
                 runId,
                 optimisticOpenResponseId,
-                optimisticOutputEdges,
+                optimisticTranscriptEntries,
                 onComplete: () => {
                     setChatError(null);
                     resolve();
@@ -442,17 +299,17 @@ export const WorkbenchConversationRunChat = iso(`
         componentProps,
         codexLoginRequired,
         firstOpenResponse?.id,
-        optimisticOutputEdges,
+        optimisticTranscriptEntries,
         runId,
         workspaceId,
     ]);
     const isRunning = runStatus === "RUNNING";
     const isBusy = componentProps.isSending || componentProps.isStopping;
     const canStartAssistant = !isRunning && !componentProps.isSending &&
-        messages.length === 0;
+        transcriptMessageCount === 0;
     const canSubmitMessage = !componentProps.isSending && !isRunning &&
         chatDraft.trim().length > 0;
-    const showStartButton = canStartAssistant && chatDraft.trim().length === 0;
+    const showStartOverlay = canStartAssistant;
     const resolvedError = chatError ?? localError;
     const handleCopyCodexLoginCommand = useCallback(() => {
         globalThis.navigator?.clipboard?.writeText(codexLoginCommand);
@@ -514,17 +371,6 @@ export const WorkbenchConversationRunChat = iso(`
             setLocalError(toErrorMessage(error));
         }
     }, [canSubmitMessage, chatDraft, isBusy, onSendMessage]);
-    const startAssistant = useCallback(async () => {
-        if (!showStartButton || isBusy)
-            return;
-        setLocalError(null);
-        try {
-            await onSendMessage("", { allowEmpty: true });
-        }
-        catch (error) {
-            setLocalError(toErrorMessage(error));
-        }
-    }, [isBusy, onSendMessage, showStartButton]);
     const stopMessage = useCallback(async () => {
         if (isBusy || !isRunning)
             return;
@@ -549,7 +395,6 @@ export const WorkbenchConversationRunChat = iso(`
         });
         composerInputRef.current?.focus();
     }, [scenarioRunError]);
-    const newChatButtonTestId = `${testIdPrefix}-new-chat`;
     const errorCalloutTestId = `${testIdPrefix}-error-callout`;
     const addErrorToChatTestId = `${testIdPrefix}-add-error-to-chat`;
     const chatBody = (React.createElement("div", { className: "test-bot-sidebar flex-column gap-8 flex-1 build-chat-panel" },
@@ -559,19 +404,20 @@ export const WorkbenchConversationRunChat = iso(`
         React.createElement("div", { className: "test-bot-thread" },
             React.createElement("div", { className: "imessage-thread", ref: transcriptRef, onScroll: (event) => {
                     shouldAutoScrollRef.current = isNearBottom(event.currentTarget);
-                } }, effectiveTranscriptDisplay.length === 0
-                ? React.createElement(Callout, null, emptyStateText)
-                : React.createElement(BuildChatRows, { display: effectiveTranscriptDisplay }))),
+                } },
+                !showCodexLoginOverlay && showStartOverlay && React.createElement(WorkbenchChatIntro, null),
+                effectiveTranscriptDisplay.length === 0
+                    ? (showStartOverlay && !showCodexLoginOverlay
+                        ? null
+                        : React.createElement(Callout, null, emptyStateText))
+                    : React.createElement(BuildChatRows, { display: effectiveTranscriptDisplay }))),
         React.createElement("div", { className: "composer" },
             React.createElement("div", { className: "composer-inputs" },
                 React.createElement("div", { className: "build-chat-activity-sticky" },
                     React.createElement(BuildChatActivityIndicator, { state: activityState, startedAtMs: resolvedStartedAtMs, testId: activityIndicatorTestId, timerTestId: activityTimerTestId })),
                 scenarioRunError && (React.createElement(Callout, { variant: "danger", title: "Scenario run failed", actions: React.createElement(Button, { variant: "secondary", size: "small", "data-testid": addErrorToChatTestId, onClick: addScenarioErrorToChat }, "Add to chat"), "data-testid": errorCalloutTestId }, scenarioRunError)),
-                showStartButton && (React.createElement(Callout, { variant: "emphasis" }, "Start the assistant to begin editing.")),
                 React.createElement("div", { className: "flex-row gap-4 mb-2" },
-                    React.createElement("textarea", { ref: composerInputRef, className: "message-input flex-1", rows: 1, placeholder: showStartButton
-                            ? "Start the assistant to begin..."
-                            : "Message Gambit Bot...", value: chatDraft, onChange: (event) => setChatDraft(event.target.value), "data-testid": chatInputTestId, disabled: isBusy, onKeyDown: (event) => {
+                    React.createElement("textarea", { ref: composerInputRef, className: "message-input flex-1", rows: 1, placeholder: "Message Gambit Bot...", value: chatDraft, onChange: (event) => setChatDraft(event.target.value), "data-testid": chatInputTestId, disabled: isBusy, onKeyDown: (event) => {
                             if (event.key === "Enter" && !event.shiftKey) {
                                 event.preventDefault();
                                 if (canSubmitMessage) {
@@ -580,19 +426,20 @@ export const WorkbenchConversationRunChat = iso(`
                             }
                         } }),
                     React.createElement("div", { className: "composer-actions" },
-                        componentProps.onNewChat && (React.createElement(Button, { variant: "secondary", disabled: isBusy || isRunning ||
-                                componentProps.canStartNewChat === false, "data-testid": newChatButtonTestId, onClick: componentProps.onNewChat }, "New chat")),
-                        isRunning && (React.createElement(Button, { variant: "secondary", disabled: isBusy, "data-testid": stopButtonTestId, onClick: () => {
-                                void stopMessage();
-                            } }, componentProps.isStopping ? "Stopping..." : "Stop")),
-                        showStartButton
-                            ? (React.createElement(Button, { variant: "primary", disabled: !showStartButton || isBusy || codexLoginRequired, "data-testid": startButtonTestId, onClick: () => {
-                                    void startAssistant();
-                                } }, componentProps.isSending ? "Starting..." : "Start"))
-                            : (React.createElement(Button, { variant: "primary", disabled: !canSubmitMessage || isBusy || codexLoginRequired, "data-testid": sendButtonTestId, onClick: () => {
+                        React.createElement("div", { className: "composer-action-slot composer-action-slot-secondary" }, isRunning
+                            ? (React.createElement(Button, { variant: "secondary", className: "composer-action-button", disabled: isBusy, "data-testid": stopButtonTestId, onClick: () => {
+                                    void stopMessage();
+                                } }, componentProps.isStopping ? "Stopping..." : "Stop"))
+                            : (React.createElement("span", { className: "composer-action-placeholder", "aria-hidden": "true" }))),
+                        React.createElement("div", { className: "composer-action-slot composer-action-slot-primary" }, !showStartOverlay
+                            ? (React.createElement(Button, { variant: "primary", className: "composer-action-button", disabled: !canSubmitMessage || isBusy ||
+                                    codexLoginRequired, "data-testid": sendButtonTestId, onClick: () => {
                                     void sendMessage();
-                                } }, componentProps.isSending ? "Sending..." : "Send")))),
+                                } }, componentProps.isSending ? "Sending..." : "Send"))
+                            : (React.createElement("span", { className: "composer-action-placeholder", "aria-hidden": "true" }))))),
                 resolvedError && React.createElement("div", { className: "error" }, resolvedError)))));
-    return (React.createElement(WorkbenchDrawerIso, { open: componentProps.open, runStatus: runStatus, chatHeaderActions: componentProps.chatHeaderActions, chatHistoryOpen: componentProps.chatHistoryOpen, onToggleChatHistory: componentProps.onToggleChatHistory, chatHistoryContent: componentProps.chatHistoryContent, chatBody: chatBody }));
+    return (React.createElement(WorkbenchDrawerIso, { open: componentProps.open, runStatus: runStatus, chatHeaderActions: componentProps.chatHeaderActions, chatHistoryOpen: workbenchChatTopActionsEnabled
+            ? componentProps.chatHistoryOpen
+            : false, chatHistoryContent: componentProps.chatHistoryContent, chatBody: chatBody }));
 });
 export default WorkbenchConversationRunChat;

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

@@ -1 +1 @@
-{"version":3,"file":"EntrypointSimulatorRedirect.d.ts","sourceRoot":"","sources":["../../../../src/simulator-ui/isograph/entrypoints/EntrypointSimulatorRedirect.tsx"],"names":[],"mappings":"AAGA,eAAO,MAAM,2BAA2B;;;;;;;CAwEtC,CAAC;AAEH,eAAe,2BAA2B,CAAC"}
+{"version":3,"file":"EntrypointSimulatorRedirect.d.ts","sourceRoot":"","sources":["../../../../src/simulator-ui/isograph/entrypoints/EntrypointSimulatorRedirect.tsx"],"names":[],"mappings":"AAGA,eAAO,MAAM,2BAA2B;;;;;;;CAuDtC,CAAC;AAEH,eAAe,2BAA2B,CAAC"}

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

@@ -15,10 +15,6 @@ export const EntrypointSimulatorRedirect = iso(`
             ? globals.__GAMBIT_CURRENT_PATH__
             : "/";
     })();
-    const isIsographPrefixed = currentPath === "/isograph" ||
-        currentPath.startsWith("/isograph/");
-    const routePrefix = isIsographPrefixed ? "/isograph" : "";
-    const withPrefix = (path) => `${routePrefix}${path}`;
     if (currentPath === "/" || currentPath === "/build" ||
         currentPath === "/debug" || currentPath === "/simulate") {
         return {
@@ -28,16 +24,7 @@ export const EntrypointSimulatorRedirect = iso(`
             headers: { Location: "/workspaces" },
         };
     }
-    if (currentPath === "/isograph" || currentPath === "/isograph/build" ||
-        currentPath === "/isograph/debug" || currentPath === "/isograph/simulate") {
-        return {
-            Body: null,
-            title: "Gambit Simulator",
-            status: 302,
-            headers: { Location: "/isograph/workspaces" },
-        };
-    }
-    const bareWorkspaceMatch = currentPath.match(/^(?:\/isograph)?\/workspaces\/([^/]+)$/);
+    const bareWorkspaceMatch = currentPath.match(/^\/workspaces\/([^/]+)$/);
     if (bareWorkspaceMatch && bareWorkspaceMatch[1] !== "new") {
         const workspaceId = (() => {
             try {
@@ -51,14 +38,14 @@ export const EntrypointSimulatorRedirect = iso(`
             Body: null,
             title: "Gambit Simulator",
             status: 302,
-            headers: { Location: withPrefix(`/workspaces/${workspaceId}/build`) },
+            headers: { Location: `/workspaces/${workspaceId}/build` },
         };
     }
     return {
         Body: null,
         title: "Gambit Simulator",
         status: 302,
-        headers: { Location: withPrefix("/workspaces") },
+        headers: { Location: "/workspaces" },
     };
 });
 export default EntrypointSimulatorRedirect;

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":"AAsDA,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":"AA6CA,eAAO,MAAM,iCAAiC;;;;;;;;CAkC5C,CAAC;AAEH,eAAe,iCAAiC,CAAC"}

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

@@ -12,17 +12,9 @@ function isThenable(value) {
         (typeof value === "object" || typeof value === "function") &&
         typeof value.then === "function";
 }
-function toWorkspaceRoutePath(path) {
-    if (path === "/isograph" || path.startsWith("/isograph/")) {
-        const stripped = path.slice("/isograph".length);
-        return stripped.length > 0 ? stripped : "/";
-    }
-    return path;
-}
 function WorkspaceMainPane(props) {
     const { currentRoutePath } = useRouter();
-    const workspaceRoutePath = toWorkspaceRoutePath(currentRoutePath);
-    const route = parseWorkspaceRoute(workspaceRoutePath);
+    const route = parseWorkspaceRoute(currentRoutePath);
     const tab = route?.tab === "test" || route?.tab === "grade" ||
         route?.tab === "verify"
         ? route.tab

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

@@ -1 +1 @@
-{"version":3,"file":"EntrypointWorkspaceBuildLiveWrite.d.ts","sourceRoot":"","sources":["../../../../src/simulator-ui/isograph/entrypoints/EntrypointWorkspaceBuildLiveWrite.tsx"],"names":[],"mappings":"AAMA,eAAO,MAAM,iCAAiC;;;CAkH5C,CAAC;AAEH,eAAe,iCAAiC,CAAC"}
+{"version":3,"file":"EntrypointWorkspaceBuildLiveWrite.d.ts","sourceRoot":"","sources":["../../../../src/simulator-ui/isograph/entrypoints/EntrypointWorkspaceBuildLiveWrite.tsx"],"names":[],"mappings":"AAMA,eAAO,MAAM,iCAAiC;;;CA2F5C,CAAC;AAEH,eAAe,iCAAiC,CAAC"}

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

@@ -27,38 +27,15 @@ export const EntrypointWorkspaceBuildLiveWrite = iso(`
         edges {
           node {
             id
+            workspaceId
             status
+            error
+            startedAt
             openResponses(first: 1) {
               edges {
                 node {
                   id
                   status
-                  outputItems(first: 200) {
-                    edges {
-                      node {
-                        __typename
-                        asOutputMessage {
-                          id
-                          role
-                          content
-                        }
-                        asOutputReasoning {
-                          id
-                          summary
-                          reasoningType
-                        }
-                        asOutputToolCall {
-                          id
-                          toolCallId
-                          toolName
-                          status
-                          argumentsText
-                          resultText
-                          error
-                        }
-                      }
-                    }
-                  }
                 }
               }
             }

package/esm/simulator-ui/isograph/entrypoints/EntrypointWorkspaceTestLiveWrite.d.ts

@@ -0,0 +1,6 @@
+export declare const EntrypointWorkspaceTestLiveWrite: (param: import("../../__generated__/__isograph/Query/EntrypointWorkspaceTestLiveWrite/param_type.js").Query__EntrypointWorkspaceTestLiveWrite__param) => {
+    Body: null;
+    title: string;
+};
+export default EntrypointWorkspaceTestLiveWrite;
+//# sourceMappingURL=EntrypointWorkspaceTestLiveWrite.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EntrypointWorkspaceTestLiveWrite.d.ts","sourceRoot":"","sources":["../../../../src/simulator-ui/isograph/entrypoints/EntrypointWorkspaceTestLiveWrite.tsx"],"names":[],"mappings":"AAMA,eAAO,MAAM,gCAAgC;;;CAwE3C,CAAC;AAEH,eAAe,gCAAgC,CAAC"}

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

@@ -0,0 +1,79 @@
+import { iso } from "../../__generated__/__isograph/iso.js";
+// This entrypoint exists to type/normalize external subscription writes.
+// NOTE: keep this rooted on Query for now. Isograph 0.5.x currently does not
+// emit full artifacts for Subscription entrypoints (missing entrypoint.ts),
+// which breaks generated route imports/codegen in this repo.
+export const EntrypointWorkspaceTestLiveWrite = iso(`
+  field Query.EntrypointWorkspaceTestLiveWrite($workspaceId: ID!) {
+    workspace(id: $workspaceId) {
+      id
+      scenarioDecks {
+        id
+        label
+        description
+        path
+        maxTurns
+        inputSchema
+        defaults
+        inputSchemaError
+      }
+      assistantDeck {
+        deck
+        startMode
+        modelParams
+        inputSchema
+        defaults
+        tools
+        inputSchemaError
+      }
+      scenarioRuns(first: 25) {
+        edges {
+          node {
+            id
+            status
+            startedAt
+            finishedAt
+            error
+            transcriptEntries {
+              asWorkspaceConversationTranscriptMessage {
+                id
+                messageRefId
+                feedbackEligible
+                role
+                content
+                feedback {
+                  id
+                  runId
+                  messageRefId
+                  score
+                  reason
+                  createdAt
+                }
+              }
+              asWorkspaceConversationTranscriptReasoning {
+                id
+                summary
+                reasoningType
+              }
+              asWorkspaceConversationTranscriptToolCall {
+                id
+                toolCallId
+                toolName
+                status
+                argumentsText
+                resultText
+                error
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`)(function EntrypointWorkspaceTestLiveWrite() {
+    return {
+        Body: null,
+        title: "Gambit Simulator",
+    };
+});
+export default EntrypointWorkspaceTestLiveWrite;

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

@@ -6,6 +6,29 @@ export declare const GambitSimulatorResetWorkspaceMutation: (param: import("../_
                 readonly node: {
                     readonly id: string;
                     readonly status: string;
+                    readonly transcriptEntries: ReadonlyArray<{
+                        readonly asWorkspaceConversationTranscriptMessage: ({
+                            readonly id: string;
+                            readonly role: string;
+                            readonly content: string;
+                            readonly messageRefId: (string | null);
+                            readonly feedbackEligible: boolean;
+                        } | null);
+                        readonly asWorkspaceConversationTranscriptReasoning: ({
+                            readonly id: string;
+                            readonly summary: string;
+                            readonly reasoningType: (string | null);
+                        } | null);
+                        readonly asWorkspaceConversationTranscriptToolCall: ({
+                            readonly id: string;
+                            readonly toolCallId: string;
+                            readonly toolName: string;
+                            readonly status: string;
+                            readonly argumentsText: (string | null);
+                            readonly resultText: (string | null);
+                            readonly error: (string | null);
+                        } | null);
+                    }>;
                     readonly openResponses: {
                         readonly edges: ReadonlyArray<{
                             readonly node: {

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

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