@bolt-foundry/gambit 0.8.6-rc.7 → 0.8.6

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

@@ -1,826 +0,0 @@
-import * as dntShim from "../../../../_dnt.shims.js";
-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";
-import gambitWorkspaceTestLiveSubscription from "../../../subscriptions/GambitWorkspaceTestLiveSubscription.js";
-import { useGambitTypedMutation } from "../../../src/hooks/useGambitTypedMutation.js";
-import { useGambitTypedSubscription } from "../../../src/hooks/useGambitTypedSubscription.js";
-import { useRouter } from "../../../src/RouterContext.js";
-import { deriveInitialFromSchema, findMissingRequiredFields, formatJson, } from "../../../src/utils.js";
-import { buildTestRunHistoryDisplayOptions } from "../../../src/testBotSidebarDisplay.js";
-import { runAwaitsAssistantKickoff } from "../../../src/test_tab_start_gate.js";
-import { countTranscriptMessages, countTranscriptUserMessages, getTranscriptMessages, parseTranscriptEntries, toBuildDisplayEntries, toOptimisticTranscriptEntries, } from "../../../src/transcriptEntries.js";
-import TestBotSidebarPanels from "../../../src/TestBotSidebarPanels.js";
-import PageShell from "../../../src/gds/PageShell.js";
-import PageGrid from "../../../src/gds/PageGrid.js";
-import Callout from "../../../src/gds/Callout.js";
-import TestBotChatPanel from "../../../src/TestBotChatPanel.js";
-import { mergeWorkbenchSelectedContextChip, replaceWorkbenchSelectedContextChips, resolveWorkbenchSelectedContextChips, } from "../../../src/workbenchChipStore.js";
-function toTestBotStatus(status) {
-    const normalized = status.trim().toUpperCase();
-    if (normalized === "RUNNING")
-        return "running";
-    if (normalized === "COMPLETED")
-        return "completed";
-    if (normalized === "ERROR" || normalized === "FAILED")
-        return "error";
-    if (normalized === "CANCELED" || normalized === "CANCELLED") {
-        return "canceled";
-    }
-    return "idle";
-}
-function isBuildChatDebugEnabled() {
-    if (typeof dntShim.dntGlobalThis === "undefined")
-        return false;
-    if ("location" in dntShim.dntGlobalThis && globalThis.location) {
-        const search = typeof globalThis.location.search === "string"
-            ? globalThis.location.search
-            : "";
-        if (search.length > 0) {
-            const value = new URLSearchParams(search).get("gambitBuildChatDebug");
-            if (value === "1" || value === "true")
-                return true;
-        }
-    }
-    let stored = "";
-    try {
-        stored = (globalThis.localStorage?.getItem("gambit:build-chat-debug") ?? "")
-            .toLowerCase()
-            .trim();
-    }
-    catch {
-        return false;
-    }
-    return stored === "1" || stored === "true" || stored === "yes";
-}
-function logTestChipDebug(event, payload) {
-    if (!isBuildChatDebugEnabled())
-        return;
-    console.info(`[test-chip-debug] ${event}`, payload);
-}
-function toOptimisticScenarioRunEdges(args) {
-    const edges = args.runs.map((run) => {
-        const isActive = run.id === args.runId;
-        const status = isActive ? args.runStatus : run.status;
-        return {
-            node: {
-                __typename: "WorkspaceScenarioRun",
-                id: run.id,
-                error: run.error ?? null,
-                finishedAt: run.finishedAt ?? null,
-                transcriptEntries: isActive
-                    ? args.transcriptEntries
-                    : toOptimisticTranscriptEntries(run.transcriptEntries),
-                startedAt: run.startedAt ?? null,
-                status,
-            },
-        };
-    });
-    if (edges.some((edge) => edge.node.id === args.runId)) {
-        return edges;
-    }
-    return [{
-            node: {
-                __typename: "WorkspaceScenarioRun",
-                id: args.runId,
-                error: null,
-                finishedAt: null,
-                transcriptEntries: args.transcriptEntries,
-                startedAt: null,
-                status: args.runStatus,
-            },
-        }, ...edges];
-}
-export const SimulatorTestPage = iso(`
-  field Workspace.TestTab @component {
-    id
-    workbenchSelectedContextChips @updatable
-    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 SimulatorTestPage({ data, startUpdate }) {
-    const parseJsonField = useCallback((value) => {
-        if (typeof value !== "string")
-            return value;
-        const trimmed = value.trim();
-        if (trimmed.length === 0)
-            return undefined;
-        try {
-            return JSON.parse(trimmed);
-        }
-        catch {
-            return undefined;
-        }
-    }, []);
-    const parseRootJsonInput = useCallback((text) => {
-        if (text.trim() === "")
-            return { parsed: undefined, error: null };
-        try {
-            return { parsed: JSON.parse(text), error: null };
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : "Invalid JSON";
-            return { error: `Invalid JSON: ${message}` };
-        }
-    }, []);
-    const workspaceId = data.id ?? "";
-    const composerChips = useMemo(() => resolveWorkbenchSelectedContextChips(workspaceId, data.workbenchSelectedContextChips), [data.workbenchSelectedContextChips, workspaceId]);
-    const updateComposerChips = useCallback((next) => {
-        replaceWorkbenchSelectedContextChips(startUpdate, next, workspaceId);
-    }, [startUpdate, workspaceId]);
-    const { currentRoutePath, navigate } = useRouter();
-    const workspaceRoutePath = currentRoutePath;
-    const scenarioDecks = useMemo(() => (data.scenarioDecks ?? []).flatMap((deck) => deck?.id && deck.label && deck.path
-        ? [{
-                id: deck.id,
-                label: deck.label,
-                description: deck.description ?? null,
-                path: deck.path,
-                maxTurns: deck.maxTurns ?? null,
-                inputSchema: parseJsonField(deck.inputSchema),
-                defaults: parseJsonField(deck.defaults),
-                inputSchemaError: deck.inputSchemaError ?? null,
-            }]
-        : []), [data.scenarioDecks, parseJsonField]);
-    const assistantDeck = useMemo(() => {
-        const deck = data.assistantDeck;
-        if (!deck)
-            return null;
-        return {
-            deck: typeof deck.deck === "string" ? deck.deck : null,
-            startMode: deck.startMode === "assistant" || deck.startMode === "user"
-                ? deck.startMode
-                : "assistant",
-            modelParams: parseJsonField(deck.modelParams) ?? null,
-            inputSchema: parseJsonField(deck.inputSchema),
-            defaults: parseJsonField(deck.defaults),
-            tools: Array.isArray(parseJsonField(deck.tools))
-                ? parseJsonField(deck.tools)
-                : [],
-            inputSchemaError: typeof deck.inputSchemaError === "string"
-                ? deck.inputSchemaError
-                : null,
-        };
-    }, [data.assistantDeck, parseJsonField]);
-    const [selectedScenarioDeckId, setSelectedScenarioDeckId] = useState(null);
-    const [scenarioJsonByDeckId, setScenarioJsonByDeckId] = useState({});
-    const [assistantInitJsonOverride, setAssistantInitJsonOverride] = useState(null);
-    const [assistantDeckTab, setAssistantDeckTab] = useState("input");
-    const [chatDraft, setChatDraft] = useState("");
-    const scenarioDeckStorageKey = useMemo(() => workspaceId.trim().length > 0
-        ? `gambit:test:selected-deck:${workspaceId}`
-        : null, [workspaceId]);
-    const persistedScenarioDeckId = useMemo(() => {
-        if (!scenarioDeckStorageKey)
-            return null;
-        try {
-            return globalThis.localStorage?.getItem(scenarioDeckStorageKey) ?? null;
-        }
-        catch {
-            return null;
-        }
-    }, [scenarioDeckStorageKey]);
-    const selectedScenarioDeck = useMemo(() => {
-        if (scenarioDecks.length === 0)
-            return null;
-        if (selectedScenarioDeckId) {
-            const selectedDeck = scenarioDecks.find((deck) => deck.id === selectedScenarioDeckId);
-            if (selectedDeck)
-                return selectedDeck;
-        }
-        if (persistedScenarioDeckId) {
-            const persistedDeck = scenarioDecks.find((deck) => deck.id === persistedScenarioDeckId);
-            if (persistedDeck)
-                return persistedDeck;
-        }
-        return scenarioDecks[0] ??
-            null;
-    }, [persistedScenarioDeckId, scenarioDecks, selectedScenarioDeckId]);
-    const handleScenarioDeckChange = useCallback((deckId) => {
-        setSelectedScenarioDeckId(deckId);
-        if (!scenarioDeckStorageKey)
-            return;
-        try {
-            globalThis.localStorage?.setItem(scenarioDeckStorageKey, deckId);
-        }
-        catch {
-            // localStorage can be unavailable in restricted contexts.
-        }
-    }, [scenarioDeckStorageKey]);
-    const scenarioJsonText = useMemo(() => {
-        if (!selectedScenarioDeck)
-            return "";
-        const edited = scenarioJsonByDeckId[selectedScenarioDeck.id];
-        if (typeof edited === "string")
-            return edited;
-        const defaults = selectedScenarioDeck.defaults ??
-            deriveInitialFromSchema(selectedScenarioDeck.inputSchema ?? undefined);
-        return formatJson(defaults);
-    }, [scenarioJsonByDeckId, selectedScenarioDeck]);
-    const parsedScenarioJson = useMemo(() => parseRootJsonInput(scenarioJsonText), [parseRootJsonInput, scenarioJsonText]);
-    const missingScenarioFields = useMemo(() => findMissingRequiredFields(selectedScenarioDeck?.inputSchema ?? undefined, parsedScenarioJson.parsed), [parsedScenarioJson.parsed, selectedScenarioDeck?.inputSchema]);
-    const assistantInitDefault = useMemo(() => assistantDeck?.defaults ??
-        deriveInitialFromSchema(assistantDeck?.inputSchema ?? undefined), [assistantDeck?.defaults, assistantDeck?.inputSchema]);
-    const assistantInitJsonText = useMemo(() => assistantInitJsonOverride ?? formatJson(assistantInitDefault), [assistantInitDefault, assistantInitJsonOverride]);
-    const parsedAssistantInitJson = useMemo(() => parseRootJsonInput(assistantInitJsonText), [assistantInitJsonText, parseRootJsonInput]);
-    const missingAssistantInitFields = useMemo(() => findMissingRequiredFields(assistantDeck?.inputSchema ?? undefined, parsedAssistantInitJson.parsed), [assistantDeck?.inputSchema, parsedAssistantInitJson.parsed]);
-    const scenarioRuns = useMemo(() => (data.scenarioRuns?.edges ?? []).flatMap((edge) => {
-        const node = edge?.node;
-        if (!node?.id || !node.status)
-            return [];
-        const transcriptEntries = parseTranscriptEntries(node.transcriptEntries);
-        return [{
-                id: node.id,
-                status: node.status,
-                startedAt: node.startedAt ?? null,
-                finishedAt: node.finishedAt ?? null,
-                outputItemCount: transcriptEntries.length,
-                error: node.error ?? null,
-                transcriptEntries,
-            }];
-    }), [data.scenarioRuns?.edges]);
-    const route = parseWorkspaceRoute(workspaceRoutePath);
-    const selectedRunId = route?.tab === "test" ? route.testRunId ?? null : null;
-    const latestRunId = scenarioRuns[0]?.id ?? null;
-    const selectedRun = selectedRunId
-        ? scenarioRuns.find((run) => run.id === selectedRunId) ?? null
-        : null;
-    const hasMissingSelectedRun = selectedRunId !== null && selectedRun === null;
-    const runHistoryOptions = useMemo(() => buildTestRunHistoryDisplayOptions(scenarioRuns), [scenarioRuns]);
-    const selectedRunHistoryValue = selectedRunId ?? latestRunId ?? "";
-    const startScenarioRun = useGambitTypedMutation(gambitWorkspaceScenarioRunStartMutation);
-    const sendScenarioRun = useGambitTypedMutation(gambitWorkspaceScenarioRunSendMutation);
-    const stopScenarioRun = useGambitTypedMutation(gambitWorkspaceScenarioRunStopMutation);
-    const saveFeedbackMutation = useGambitTypedMutation(gambitWorkspaceFeedbackSaveMutation);
-    const canStartScenarioRun = useMemo(() => {
-        if (!workspaceId || !selectedScenarioDeck)
-            return false;
-        if (startScenarioRun.inFlight)
-            return false;
-        if (selectedScenarioDeck.inputSchemaError)
-            return false;
-        if (assistantDeck?.inputSchemaError)
-            return false;
-        if (parsedScenarioJson.error)
-            return false;
-        if (missingScenarioFields.length > 0)
-            return false;
-        if (parsedAssistantInitJson.error)
-            return false;
-        if (missingAssistantInitFields.length > 0)
-            return false;
-        return true;
-    }, [
-        assistantDeck?.inputSchemaError,
-        missingAssistantInitFields.length,
-        missingScenarioFields.length,
-        parsedAssistantInitJson.error,
-        parsedScenarioJson.error,
-        selectedScenarioDeck,
-        startScenarioRun.inFlight,
-        workspaceId,
-    ]);
-    const canStartAssistantRun = useMemo(() => {
-        if (!workspaceId)
-            return false;
-        if (startScenarioRun.inFlight)
-            return false;
-        if (sendScenarioRun.inFlight)
-            return false;
-        if (assistantDeck?.inputSchemaError)
-            return false;
-        if (parsedAssistantInitJson.error)
-            return false;
-        if (missingAssistantInitFields.length > 0)
-            return false;
-        return true;
-    }, [
-        assistantDeck?.inputSchemaError,
-        missingAssistantInitFields.length,
-        parsedAssistantInitJson.error,
-        sendScenarioRun.inFlight,
-        startScenarioRun.inFlight,
-        workspaceId,
-    ]);
-    useGambitTypedSubscription(gambitWorkspaceTestLiveSubscription, workspaceId ? { workspaceId } : null);
-    const startNewScenarioRun = useCallback(() => {
-        if (!workspaceId || !selectedScenarioDeck || !canStartScenarioRun)
-            return;
-        startScenarioRun.commit({
-            input: {
-                workspaceId,
-                scenarioDeckId: selectedScenarioDeck.id,
-                scenarioInput: scenarioJsonText.trim().length > 0
-                    ? scenarioJsonText
-                    : null,
-                assistantInit: assistantInitJsonText.trim().length > 0
-                    ? assistantInitJsonText
-                    : null,
-            },
-        }, {
-            onComplete: (result) => {
-                const runId = result?.run?.id;
-                if (!runId)
-                    return;
-                navigate(buildWorkspacePath("test", workspaceId, { runId }));
-            },
-        });
-    }, [
-        canStartScenarioRun,
-        navigate,
-        assistantInitJsonText,
-        scenarioJsonText,
-        selectedScenarioDeck,
-        startScenarioRun,
-        workspaceId,
-    ]);
-    const startAssistantChatRun = useCallback(async () => {
-        if (!workspaceId || !canStartAssistantRun)
-            return null;
-        const started = await new Promise((resolve) => {
-            startScenarioRun.commit({
-                input: {
-                    workspaceId,
-                    scenarioDeckId: null,
-                    scenarioInput: null,
-                    assistantInit: assistantInitJsonText.trim().length > 0
-                        ? assistantInitJsonText
-                        : null,
-                },
-            }, {
-                onComplete: (result) => {
-                    const runId = result?.run?.id;
-                    if (!runId) {
-                        resolve(null);
-                        return;
-                    }
-                    resolve({
-                        runId,
-                        status: typeof result?.run?.status === "string"
-                            ? result.run.status
-                            : null,
-                    });
-                },
-                onError: () => resolve(null),
-            });
-        });
-        if (!started)
-            return null;
-        navigate(buildWorkspacePath("test", workspaceId, {
-            runId: started.runId,
-        }));
-        return started;
-    }, [
-        assistantInitJsonText,
-        canStartAssistantRun,
-        navigate,
-        startScenarioRun,
-        workspaceId,
-    ]);
-    const kickoffAssistantTurn = useCallback(async (runId) => {
-        if (!workspaceId || !runId)
-            return false;
-        const baseEntries = selectedRun?.id === runId
-            ? selectedRun.transcriptEntries
-            : [];
-        const optimisticTranscriptEntries = toOptimisticTranscriptEntries(baseEntries);
-        const optimisticScenarioRunEdges = toOptimisticScenarioRunEdges({
-            runs: scenarioRuns,
-            runId,
-            runStatus: "RUNNING",
-            transcriptEntries: optimisticTranscriptEntries,
-        });
-        return await new Promise((resolve) => {
-            sendScenarioRun.commit({
-                input: {
-                    workspaceId,
-                    runId,
-                    inputItems: [{ role: "user", content: "" }],
-                },
-            }, {
-                optimisticNetworkResponse: {
-                    workspaceScenarioRunSend____input___v_input: {
-                        run: {
-                            __typename: "WorkspaceScenarioRun",
-                            id: runId,
-                            error: null,
-                            finishedAt: null,
-                            transcriptEntries: optimisticTranscriptEntries,
-                            startedAt: selectedRun?.startedAt ?? null,
-                            status: "RUNNING",
-                            workspaceId,
-                        },
-                        workspace: {
-                            id: workspaceId,
-                            scenarioRuns____first___l_25: {
-                                edges: optimisticScenarioRunEdges,
-                            },
-                        },
-                    },
-                },
-                onComplete: () => resolve(true),
-                onError: () => resolve(false),
-            });
-        });
-    }, [scenarioRuns, selectedRun, sendScenarioRun, workspaceId]);
-    const selectedRunState = useMemo(() => {
-        if (!selectedRun) {
-            return {
-                status: "idle",
-                messages: [],
-                traces: [],
-                toolInserts: [],
-            };
-        }
-        return {
-            id: selectedRun.id,
-            workspaceId,
-            status: toTestBotStatus(selectedRun.status),
-            error: selectedRun.error ?? undefined,
-            startedAt: selectedRun.startedAt ?? undefined,
-            finishedAt: selectedRun.finishedAt ?? undefined,
-            messages: getTranscriptMessages(selectedRun.transcriptEntries).map((message) => ({
-                ...message,
-            })),
-            traces: [],
-            toolInserts: [],
-        };
-    }, [selectedRun, workspaceId]);
-    const testChatDisplay = useMemo(() => toBuildDisplayEntries(selectedRun?.transcriptEntries ?? []), [selectedRun?.transcriptEntries]);
-    const transcriptMessageCount = useMemo(() => countTranscriptMessages(selectedRun?.transcriptEntries ?? []), [selectedRun?.transcriptEntries]);
-    const transcriptUserMessageCount = useMemo(() => countTranscriptUserMessages(selectedRun?.transcriptEntries ?? []), [selectedRun?.transcriptEntries]);
-    const runStatusLabel = selectedRunState.status === "running"
-        ? "Running…"
-        : selectedRunState.status === "completed"
-            ? "Completed"
-            : selectedRunState.status === "error"
-                ? "Failed"
-                : selectedRunState.status === "canceled"
-                    ? "Stopped"
-                    : "Idle";
-    const selectedRunNeedsAssistantStart = runAwaitsAssistantKickoff(selectedRun);
-    const showStartOverlay = Boolean(assistantDeck?.startMode !== "user" &&
-        selectedRunNeedsAssistantStart);
-    const hasActiveScenarioTurn = selectedRunState.status === "running";
-    const handleStopRun = useCallback(() => {
-        if (!selectedRun?.id || !workspaceId)
-            return Promise.resolve();
-        stopScenarioRun.commit({
-            input: { workspaceId, runId: selectedRun.id },
-        });
-        return Promise.resolve();
-    }, [selectedRun?.id, stopScenarioRun, workspaceId]);
-    const handleSendChat = useCallback(async () => {
-        const message = chatDraft.trim();
-        if (!message || !workspaceId || hasActiveScenarioTurn)
-            return;
-        let runId = selectedRun?.id ?? null;
-        if (!runId) {
-            const started = await startAssistantChatRun();
-            if (!started)
-                return;
-            runId = started.runId;
-        }
-        sendScenarioRun.commit({
-            input: {
-                workspaceId,
-                runId,
-                inputItems: [{ role: "user", content: message }],
-            },
-        }, {
-            optimisticNetworkResponse: (() => {
-                const baseEntries = selectedRun?.id === runId
-                    ? selectedRun.transcriptEntries
-                    : [];
-                const optimisticMessageId = `${runId}:message:${Date.now()}`;
-                const optimisticTranscriptEntries = [
-                    ...toOptimisticTranscriptEntries(baseEntries),
-                    {
-                        __typename: "WorkspaceConversationTranscriptMessage",
-                        id: optimisticMessageId,
-                        messageRefId: null,
-                        feedbackEligible: false,
-                        role: "user",
-                        content: message,
-                        feedback: null,
-                    },
-                ];
-                const optimisticScenarioRunEdges = toOptimisticScenarioRunEdges({
-                    runs: scenarioRuns,
-                    runId,
-                    runStatus: "RUNNING",
-                    transcriptEntries: optimisticTranscriptEntries,
-                });
-                return {
-                    workspaceScenarioRunSend____input___v_input: {
-                        run: {
-                            __typename: "WorkspaceScenarioRun",
-                            id: runId,
-                            error: null,
-                            finishedAt: null,
-                            transcriptEntries: optimisticTranscriptEntries,
-                            startedAt: selectedRun?.startedAt ?? null,
-                            status: "RUNNING",
-                            workspaceId,
-                        },
-                        workspace: {
-                            id: workspaceId,
-                            scenarioRuns____first___l_25: {
-                                edges: optimisticScenarioRunEdges,
-                            },
-                        },
-                    },
-                };
-            })(),
-            onComplete: () => setChatDraft(""),
-        });
-    }, [
-        chatDraft,
-        hasActiveScenarioTurn,
-        scenarioRuns,
-        selectedRun?.id,
-        selectedRun?.transcriptEntries,
-        selectedRun?.startedAt,
-        sendScenarioRun,
-        startAssistantChatRun,
-        workspaceId,
-    ]);
-    const handleStartAssistant = useCallback(async () => {
-        if (!workspaceId)
-            return;
-        if (selectedRun?.id && selectedRunNeedsAssistantStart) {
-            const kickedSelected = await kickoffAssistantTurn(selectedRun.id);
-            if (kickedSelected)
-                return;
-        }
-        const started = await startAssistantChatRun();
-        if (!started)
-            return;
-        // Backward compatibility: older simulator backends auto-start this run.
-        if (toTestBotStatus(started.status ?? "") !== "idle")
-            return;
-        await kickoffAssistantTurn(started.runId);
-    }, [
-        kickoffAssistantTurn,
-        selectedRun?.id,
-        selectedRunNeedsAssistantStart,
-        startAssistantChatRun,
-        workspaceId,
-    ]);
-    const handleRunHistorySelection = useCallback((nextRunId) => {
-        if (!nextRunId || !workspaceId)
-            return;
-        if (nextRunId === selectedRunHistoryValue)
-            return;
-        navigate(buildWorkspacePath("test", workspaceId, {
-            runId: nextRunId,
-        }));
-    }, [
-        navigate,
-        selectedRunHistoryValue,
-        workspaceId,
-    ]);
-    const handleNewChat = useCallback(() => {
-        if (!workspaceId)
-            return Promise.resolve();
-        setChatDraft("");
-        navigate(buildWorkspacePath("test", workspaceId));
-        return Promise.resolve();
-    }, [navigate, 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 = getTranscriptMessages(selectedRun.transcriptEntries)
-            .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,
-                createdAt: nextFeedback.createdAt,
-            }
-            : 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,
-                            transcriptEntries: toOptimisticTranscriptEntries(selectedRun.transcriptEntries.map((entry) => entry.kind === "message" &&
-                                entry.messageRefId === messageRefId
-                                ? {
-                                    ...entry,
-                                    feedback: nextFeedback,
-                                }
-                                : entry)),
-                            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,
-                                            transcriptEntries: run.transcriptEntries.map((entry) => entry.kind === "message" &&
-                                                entry.messageRefId === messageRefId
-                                                ? {
-                                                    ...entry,
-                                                    feedback: nextFeedback,
-                                                }
-                                                : entry),
-                                        }
-                                        : run),
-                                    runId: selectedRun.id,
-                                    runStatus: selectedRun.status,
-                                    transcriptEntries: toOptimisticTranscriptEntries(selectedRun.transcriptEntries.map((entry) => entry.kind === "message" &&
-                                        entry.messageRefId === messageRefId
-                                        ? {
-                                            ...entry,
-                                            feedback: nextFeedback,
-                                        }
-                                        : entry)),
-                                }),
-                            },
-                        },
-                    },
-                },
-                onComplete: () => resolve(),
-                onError: reject,
-            });
-        });
-    }, [saveFeedbackMutation, scenarioRuns, selectedRun, workspaceId]);
-    const canRunPersona = scenarioDecks.length > 0;
-    const hasPersonaSelection = Boolean(selectedScenarioDeck);
-    return (React.createElement(PageShell, null,
-        React.createElement(PageGrid, { as: "main", className: "editor-main" },
-            React.createElement(TestBotSidebarPanels, { selectedRunValue: selectedRunHistoryValue, onRunHistorySelection: handleRunHistorySelection, runHistoryOptions: runHistoryOptions.map((entry) => ({
-                    value: entry.runId,
-                    label: entry.label,
-                    meta: entry.meta,
-                })), runHistoryDisabled: selectedRunState.status === "running" ||
-                    sendScenarioRun.inFlight || runHistoryOptions.length === 0, runHistoryPlaceholder: runHistoryOptions.length > 0
-                    ? "Select previous run"
-                    : "No previous runs", canStart: canStartScenarioRun, onStartRun: startNewScenarioRun, selectedDeckValue: selectedScenarioDeck?.id ?? null, onDeckSelection: handleScenarioDeckChange, deckOptions: scenarioDecks.map((deck) => ({
-                    value: deck.id,
-                    label: deck.label,
-                    meta: deck.path,
-                })), noScenariosCallout: React.createElement(Callout, null,
-                    "No scenarios found in the workspace root deck. Add",
-                    " ",
-                    React.createElement("code", null, "[[scenarios]]"),
-                    " to ",
-                    React.createElement("code", null, "PROMPT.md"),
-                    " ",
-                    "(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) {
-                        return;
-                    }
-                    setScenarioJsonByDeckId((previous) => ({
-                        ...previous,
-                        [selectedScenarioDeck.id]: text,
-                    }));
-                }, scenarioJsonError: parsedScenarioJson.error, scenarioMissingFields: missingScenarioFields, assistantDeckTab: assistantDeckTab, onAssistantDeckTabChange: setAssistantDeckTab, assistantInputSchemaError: assistantDeck?.inputSchemaError ?? null, hasAssistantInputSchema: Boolean(assistantDeck?.inputSchema), assistantInitJsonText: assistantInitJsonText, onAssistantInitJsonChange: (text) => setAssistantInitJsonOverride(text), assistantInitJsonError: parsedAssistantInitJson.error, assistantMissingFields: missingAssistantInitFields, onAssistantInitReset: () => setAssistantInitJsonOverride(null), onAssistantSchemaRefresh: () => globalThis.location.reload(), tools: (assistantDeck?.tools ?? []).map((tool, index) => ({
-                    key: `${tool?.name ?? "tool"}-${index}`,
-                    title: tool?.label ?? tool?.name ?? "Tool",
-                    meta: tool?.path ?? null,
-                    description: tool?.description ?? null,
-                })), schemaPath: assistantDeck?.deck ?? null, schemaStartMode: assistantDeck?.startMode ?? "assistant", schemaModelParamsJson: assistantDeck?.modelParams
-                    ? formatJson(assistantDeck.modelParams)
-                    : null }),
-            React.createElement(TestBotChatPanel, { run: selectedRunState, runWorkspaceId: workspaceId, runStatusLabel: runStatusLabel, testChatDisplay: testChatDisplay, transcriptMessageCount: transcriptMessageCount, transcriptUserMessageCount: transcriptUserMessageCount, 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 &&
-                    !sendScenarioRun.inFlight && !hasActiveScenarioTurn, chatDraft: chatDraft, setChatDraft: setChatDraft, chatError: null, optimisticUser: null, streamingUser: null, streamingAssistant: null, startRun: () => {
-                    startNewScenarioRun();
-                    return Promise.resolve();
-                }, stopRun: handleStopRun, handleNewChat: handleNewChat, handleSendChat: handleSendChat, handleStartAssistant: handleStartAssistant, onScore: saveFeedback, onReasonChange: saveFeedback, onAddFeedbackToWorkbench: (feedback) => {
-                    const chip = {
-                        chipId: `rating:${feedback.messageRefId}:${feedback.id}`,
-                        source: "message_rating",
-                        workspaceId,
-                        runId: feedback.runId,
-                        capturedAt: feedback.createdAt ?? new Date().toISOString(),
-                        messageRefId: feedback.messageRefId,
-                        score: feedback.score,
-                        reason: feedback.reason,
-                        enabled: true,
-                    };
-                    logTestChipDebug("feedback.add_to_workbench", {
-                        messageRefId: feedback.messageRefId,
-                        score: feedback.score,
-                        reason: feedback.reason,
-                        chip,
-                    });
-                    updateComposerChips(mergeWorkbenchSelectedContextChip(composerChips, chip));
-                }, onAddErrorToWorkbench: (payload) => {
-                    if (!payload.error)
-                        return;
-                    updateComposerChips(mergeWorkbenchSelectedContextChip(composerChips, {
-                        chipId: `scenario_run_error:${payload.runId ?? selectedRunState.id ?? workspaceId}`,
-                        source: payload.source === "grader_run_error"
-                            ? "grader_run_error"
-                            : "scenario_run_error",
-                        workspaceId: payload.workspaceId ?? workspaceId,
-                        runId: payload.runId ?? selectedRunState.id,
-                        capturedAt: new Date().toISOString(),
-                        error: payload.error,
-                        enabled: true,
-                    }));
-                } }))));
-});
-export default SimulatorTestPage;