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

package/script/src/server/workspace/build.js

@@ -0,0 +1,381 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWorkspaceBuildService = void 0;
+const gambit_core_1 = require("@bolt-foundry/gambit-core");
+const helpers_js_1 = require("./helpers.js");
+const run_deck_js_1 = require("./run_deck.js");
+const createWorkspaceBuildService = (deps) => {
+    const buildBotRuns = new Map();
+    const ensureWorkspaceStateForBuild = (workspaceId) => {
+        const state = deps.readSessionStateStrict(workspaceId, {
+            withTraces: true,
+        });
+        if (!state) {
+            throw new Error("Workspace not found");
+        }
+        return state;
+    };
+    const buildAuthorityMeta = (sessionState, workspaceId) => {
+        const sessionMeta = sessionState.meta && typeof sessionState.meta === "object"
+            ? sessionState.meta
+            : {};
+        const next = { workspaceId };
+        for (const key of [
+            "sessionId",
+            "sessionDir",
+            "sessionStatePath",
+            "sessionEventsPath",
+            "sessionBuildStatePath",
+            "sessionSqlitePath",
+            "workspaceSchemaVersion",
+        ]) {
+            const value = sessionMeta[key];
+            if (typeof value === "string" && value.trim().length > 0) {
+                next[key] = value;
+            }
+        }
+        return next;
+    };
+    const normalizeBuildAuthorityState = (args) => ({
+        ...args.state,
+        runId: args.runId,
+        meta: {
+            ...(args.state.meta ?? {}),
+            ...buildAuthorityMeta(args.sessionState, args.workspaceId),
+        },
+    });
+    const broadcastBuild = (workspaceId, payload) => {
+        const state = deps.readSessionState(workspaceId);
+        if (state) {
+            deps.appendWorkspaceEnvelope(state, "build", payload);
+        }
+        deps.appendDurableStreamEvent(deps.workspaceStreamId, payload);
+    };
+    const buildRunFromProjection = (workspaceId) => {
+        const projection = deps.readBuildState(workspaceId);
+        const run = projection?.run;
+        if (!run) {
+            return {
+                id: workspaceId,
+                status: "idle",
+                messages: [],
+                traces: [],
+                toolInserts: [],
+            };
+        }
+        return {
+            id: run.id || workspaceId,
+            status: run.status,
+            error: run.error,
+            startedAt: run.startedAt,
+            finishedAt: run.finishedAt,
+            messages: Array.isArray(run.messages) ? run.messages : [],
+            traces: Array.isArray(run.traces) ? run.traces : [],
+            toolInserts: Array.isArray(run.toolInserts) ? run.toolInserts : [],
+        };
+    };
+    const readWorkspaceBuildRunForGraphql = (workspaceId) => {
+        const active = buildBotRuns.get(workspaceId)?.run;
+        if (active) {
+            return {
+                ...active,
+                messages: Array.isArray(active.messages) ? [...active.messages] : [],
+                traces: Array.isArray(active.traces) ? [...active.traces] : [],
+                toolInserts: Array.isArray(active.toolInserts)
+                    ? [...active.toolInserts]
+                    : [],
+            };
+        }
+        return buildRunFromProjection(workspaceId);
+    };
+    const startWorkspaceBuildRun = (args) => {
+        const workspaceId = args.workspaceId;
+        const active = buildBotRuns.get(workspaceId);
+        if (active?.run.status === "running") {
+            throw new Error("Build run already in progress for this workspace.");
+        }
+        const sessionState = ensureWorkspaceStateForBuild(workspaceId);
+        const projection = deps.readBuildState(workspaceId);
+        const seedRun = projection?.run;
+        const runId = seedRun?.id && seedRun.id.trim().length > 0
+            ? seedRun.id
+            : deps.randomId("build");
+        const seededMessages = (() => {
+            if (projection?.state?.messages && Array.isArray(projection.state.messages)) {
+                return projection.state.messages;
+            }
+            return Array.isArray(seedRun?.messages)
+                ? seedRun.messages.map((message) => {
+                    const role = message.role === "assistant" || message.role === "system" ||
+                        message.role === "tool"
+                        ? message.role
+                        : "user";
+                    return {
+                        role,
+                        content: message.content,
+                    };
+                })
+                : [];
+        })();
+        const seedState = normalizeBuildAuthorityState({
+            state: projection?.state && typeof projection.state === "object"
+                ? projection.state
+                : {
+                    runId,
+                    messages: seededMessages,
+                    messageRefs: [],
+                    traces: Array.isArray(seedRun?.traces) ? [...seedRun.traces] : [],
+                    items: [],
+                    meta: {},
+                },
+            workspaceId,
+            runId,
+            sessionState,
+        });
+        const trimmedMessage = args.message.trim();
+        const run = {
+            id: runId,
+            status: "running",
+            startedAt: new Date().toISOString(),
+            error: undefined,
+            finishedAt: undefined,
+            messages: Array.isArray(seedRun?.messages) ? [...seedRun.messages] : [],
+            traces: Array.isArray(seedRun?.traces) ? [...seedRun.traces] : [],
+            toolInserts: Array.isArray(seedRun?.toolInserts)
+                ? [...seedRun.toolInserts]
+                : [],
+        };
+        if (trimmedMessage.length > 0) {
+            run.messages = [
+                ...run.messages,
+                { role: "user", content: trimmedMessage, messageSource: "manual" },
+            ];
+            deps.persistCanonicalUserInputEvent({
+                state: sessionState,
+                runId,
+                message: trimmedMessage,
+                source: "build",
+            });
+        }
+        const controller = new AbortController();
+        const entry = {
+            run,
+            state: seedState,
+            promise: null,
+            abort: controller,
+        };
+        buildBotRuns.set(workspaceId, entry);
+        const onStateUpdate = (next) => {
+            const buildState = normalizeBuildAuthorityState({
+                state: next,
+                workspaceId,
+                runId,
+                sessionState,
+            });
+            deps.persistOpenResponsesTracesFromState(buildState, runId);
+            entry.state = buildState;
+            const snapshot = (0, helpers_js_1.buildTestBotSnapshot)(buildState);
+            run.messages = snapshot.messages;
+            run.toolInserts = snapshot.toolInserts;
+            const nextTraces = Array.isArray(buildState.traces)
+                ? [...buildState.traces]
+                : [];
+            if (nextTraces.length > 0) {
+                run.traces = nextTraces;
+            }
+            else if (!Array.isArray(run.traces)) {
+                run.traces = [];
+            }
+            broadcastBuild(workspaceId, {
+                type: "buildBotStatus",
+                workspaceId,
+                run,
+                state: buildState,
+            });
+        };
+        const tracer = (trace) => {
+            const event = trace.ts ? trace : { ...trace, ts: Date.now() };
+            const currentTraces = Array.isArray(run.traces) ? run.traces : [];
+            run.traces = [...currentTraces, event];
+            deps.persistOpenResponsesTraceEvent(entry.state, event, runId);
+            broadcastBuild(workspaceId, {
+                type: "buildBotTrace",
+                workspaceId,
+                runId,
+                event,
+            });
+        };
+        const turn = run.messages.filter((message) => message.role === "user")
+            .length;
+        let hasStartedAssistantStreamMessage = false;
+        entry.promise = (async () => {
+            try {
+                broadcastBuild(workspaceId, {
+                    type: "buildBotStatus",
+                    workspaceId,
+                    run,
+                    state: entry.state ?? undefined,
+                });
+                await (0, gambit_core_1.runDeck)({
+                    path: deps.buildAssistantDeckPath,
+                    input: deps.initialContext,
+                    inputProvided: deps.hasInitialContext,
+                    modelProvider: deps.modelProvider,
+                    defaultModel: deps.model,
+                    modelOverride: deps.modelForce ??
+                        (!deps.model && args.buildChatProvider
+                            ? `${args.buildChatProvider}/default`
+                            : undefined),
+                    trace: tracer,
+                    stream: true,
+                    runId,
+                    state: entry.state ?? undefined,
+                    allowRootStringInput: true,
+                    initialUserMessage: trimmedMessage.length > 0 ? trimmedMessage : "",
+                    responsesMode: deps.responsesMode,
+                    workerSandbox: (0, run_deck_js_1.resolveWorkerSandboxForSignalAwareRun)({
+                        workerSandbox: deps.workerSandbox,
+                        signal: controller.signal,
+                    }),
+                    signal: controller.signal,
+                    onStateUpdate,
+                    onStreamText: (chunk) => {
+                        if (typeof chunk === "string" && chunk.length > 0) {
+                            if (!hasStartedAssistantStreamMessage) {
+                                run.messages = [
+                                    ...run.messages,
+                                    {
+                                        role: "assistant",
+                                        content: chunk,
+                                    },
+                                ];
+                                hasStartedAssistantStreamMessage = true;
+                            }
+                            else {
+                                const last = run.messages[run.messages.length - 1];
+                                if (last?.role === "assistant") {
+                                    last.content += chunk;
+                                }
+                                else {
+                                    run.messages = [
+                                        ...run.messages,
+                                        {
+                                            role: "assistant",
+                                            content: chunk,
+                                        },
+                                    ];
+                                }
+                            }
+                        }
+                        broadcastBuild(workspaceId, {
+                            type: "buildBotStream",
+                            workspaceId,
+                            runId,
+                            role: "assistant",
+                            chunk,
+                            turn,
+                            ts: Date.now(),
+                        });
+                    },
+                });
+                broadcastBuild(workspaceId, {
+                    type: "buildBotStreamEnd",
+                    workspaceId,
+                    runId,
+                    role: "assistant",
+                    turn,
+                    ts: Date.now(),
+                });
+                run.status = controller.signal.aborted ? "canceled" : "completed";
+                run.error = undefined;
+            }
+            catch (err) {
+                if (controller.signal.aborted || (0, gambit_core_1.isRunCanceledError)(err)) {
+                    run.status = "canceled";
+                    run.error = undefined;
+                }
+                else {
+                    run.status = "error";
+                    run.error = err instanceof Error ? err.message : String(err);
+                }
+            }
+            finally {
+                run.finishedAt = new Date().toISOString();
+                entry.abort = null;
+                entry.promise = null;
+                broadcastBuild(workspaceId, {
+                    type: "buildBotStatus",
+                    workspaceId,
+                    run,
+                    state: entry.state ?? undefined,
+                });
+            }
+        })();
+        return run;
+    };
+    const stopWorkspaceBuildRun = async (args) => {
+        const active = buildBotRuns.get(args.workspaceId);
+        if (!active || active.run.id !== args.runId) {
+            return buildRunFromProjection(args.workspaceId);
+        }
+        active.abort?.abort();
+        try {
+            await active.promise;
+        }
+        catch {
+            // Abort path can reject internally; projection is still authoritative.
+        }
+        return buildRunFromProjection(args.workspaceId);
+    };
+    const resetWorkspaceBuild = async (workspaceId) => {
+        const active = buildBotRuns.get(workspaceId);
+        active?.abort?.abort();
+        try {
+            await active?.promise;
+        }
+        catch {
+            // Ignore aborted in-flight run.
+        }
+        const run = {
+            id: deps.randomId("build"),
+            status: "idle",
+            messages: [],
+            traces: [],
+            toolInserts: [],
+        };
+        const sessionState = ensureWorkspaceStateForBuild(workspaceId);
+        const reset = normalizeBuildAuthorityState({
+            state: {
+                runId: run.id,
+                messages: [],
+                messageRefs: [],
+                traces: [],
+                items: [],
+            },
+            workspaceId,
+            runId: run.id,
+            sessionState,
+        });
+        deps.appendWorkspaceEnvelope(sessionState, "build", {
+            type: "buildBotStatus",
+            workspaceId,
+            run,
+            state: reset,
+        });
+        deps.appendDurableStreamEvent(deps.workspaceStreamId, {
+            type: "buildBotStatus",
+            workspaceId,
+            run,
+        });
+        return buildRunFromProjection(workspaceId);
+    };
+    return {
+        startWorkspaceBuildRun,
+        stopWorkspaceBuildRun,
+        resetWorkspaceBuild,
+        readWorkspaceBuildRunForGraphql,
+        buildRunFromProjection,
+        getLiveBuildRunEntry: (workspaceId) => buildBotRuns.get(workspaceId),
+    };
+};
+exports.createWorkspaceBuildService = createWorkspaceBuildService;

package/script/src/server/workspace/conversation_sessions.d.ts

@@ -0,0 +1,83 @@
+import type { BuildBotRunStatus, TestBotRunStatus, WorkspaceConversationSessionKindForGraphql, WorkspaceConversationSessionRecordForGraphql, WorkspaceGradeRunForGraphql, WorkspaceVerifyBatchRecordForGraphql } from "./types.js";
+export declare const createWorkspaceConversationSessionService: (deps: {
+    readWorkspaceBuildRunForGraphql: (workspaceId: string) => BuildBotRunStatus;
+    startWorkspaceBuildRun: (args: {
+        workspaceId: string;
+        message: string;
+    }) => BuildBotRunStatus;
+    stopWorkspaceBuildRun: (args: {
+        workspaceId: string;
+        runId: string;
+    }) => Promise<BuildBotRunStatus>;
+    startWorkspaceScenarioRunForGraphql: (args: {
+        workspaceId: string;
+        runId?: string;
+        scenarioDeckId?: string | null;
+        scenarioInput?: unknown;
+        assistantInit?: unknown;
+    }) => Promise<TestBotRunStatus>;
+    sendWorkspaceScenarioRunForGraphql: (args: {
+        workspaceId: string;
+        runId: string;
+        message: string;
+    }) => Promise<TestBotRunStatus>;
+    stopWorkspaceScenarioRunForGraphql: (args: {
+        workspaceId: string;
+        runId: string;
+    }) => Promise<TestBotRunStatus>;
+    readWorkspaceScenarioRunsForGraphql: (workspaceId: string) => Array<TestBotRunStatus>;
+    readWorkspaceGradeRunsForGraphql: (workspaceId: string) => Array<WorkspaceGradeRunForGraphql>;
+    createWorkspaceGradeRunForGraphql: (args: {
+        workspaceId: string;
+        graderId: string;
+        scenarioRunId?: string | null;
+    }) => Promise<WorkspaceGradeRunForGraphql>;
+    readWorkspaceVerifyBatchesForGraphql: (workspaceId: string) => Array<WorkspaceVerifyBatchRecordForGraphql>;
+    createWorkspaceVerifyBatchRunForGraphql: (args: {
+        workspaceId: string;
+        scenarioDeckId?: string | null;
+        graderId: string;
+        scenarioRuns: number;
+        graderRepeatsPerScenario: number;
+        concurrency: number;
+    }) => Promise<WorkspaceVerifyBatchRecordForGraphql>;
+    defaultVerifyScenarioRuns: number;
+    defaultVerifyGraderRepeats: number;
+    defaultVerifyConcurrency: number;
+}) => {
+    listWorkspaceConversationSessionsForGraphql: (args: {
+        workspaceId: string;
+        kind?: WorkspaceConversationSessionKindForGraphql | null;
+    }) => Promise<Array<WorkspaceConversationSessionRecordForGraphql>>;
+    readWorkspaceConversationSessionForGraphql: (args: {
+        workspaceId: string;
+        kind: WorkspaceConversationSessionKindForGraphql;
+        sessionId: string;
+    }) => Promise<WorkspaceConversationSessionRecordForGraphql | null>;
+    startWorkspaceConversationSessionForGraphql: (args: {
+        workspaceId: string;
+        kind: WorkspaceConversationSessionKindForGraphql;
+        sessionId?: string | null;
+        message?: string | null;
+        scenarioDeckId?: string | null;
+        scenarioInput?: unknown;
+        assistantInit?: unknown;
+        graderId?: string | null;
+        scenarioRunId?: string | null;
+        scenarioRuns?: number | null;
+        graderRepeatsPerScenario?: number | null;
+        concurrency?: number | null;
+    }) => Promise<WorkspaceConversationSessionRecordForGraphql>;
+    sendWorkspaceConversationSessionForGraphql: (args: {
+        workspaceId: string;
+        kind: WorkspaceConversationSessionKindForGraphql;
+        sessionId: string;
+        message: string;
+    }) => Promise<WorkspaceConversationSessionRecordForGraphql>;
+    stopWorkspaceConversationSessionForGraphql: (args: {
+        workspaceId: string;
+        kind: WorkspaceConversationSessionKindForGraphql;
+        sessionId: string;
+    }) => Promise<WorkspaceConversationSessionRecordForGraphql>;
+};
+//# sourceMappingURL=conversation_sessions.d.ts.map

package/script/src/server/workspace/conversation_sessions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation_sessions.d.ts","sourceRoot":"","sources":["../../../../src/src/server/workspace/conversation_sessions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,gBAAgB,EAChB,0CAA0C,EAC1C,4CAA4C,EAC5C,2BAA2B,EAC3B,oCAAoC,EACrC,MAAM,YAAY,CAAC;AAyDpB,eAAO,MAAM,yCAAyC,GAAI,MAAM;IAC9D,+BAA+B,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,iBAAiB,CAAC;IAC5E,sBAAsB,EAAE,CAAC,IAAI,EAAE;QAC7B,WAAW,EAAE,MAAM,CAAC;QACpB,OAAO,EAAE,MAAM,CAAC;KACjB,KAAK,iBAAiB,CAAC;IACxB,qBAAqB,EAAE,CAAC,IAAI,EAAE;QAC5B,WAAW,EAAE,MAAM,CAAC;QACpB,KAAK,EAAE,MAAM,CAAC;KACf,KAAK,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACjC,mCAAmC,EAAE,CAAC,IAAI,EAAE;QAC1C,WAAW,EAAE,MAAM,CAAC;QACpB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAC/B,aAAa,CAAC,EAAE,OAAO,CAAC;QACxB,aAAa,CAAC,EAAE,OAAO,CAAC;KACzB,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAChC,kCAAkC,EAAE,CAAC,IAAI,EAAE;QACzC,WAAW,EAAE,MAAM,CAAC;QACpB,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;KACjB,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAChC,kCAAkC,EAAE,CAAC,IAAI,EAAE;QACzC,WAAW,EAAE,MAAM,CAAC;QACpB,KAAK,EAAE,MAAM,CAAC;KACf,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAChC,mCAAmC,EAAE,CACnC,WAAW,EAAE,MAAM,KAChB,KAAK,CAAC,gBAAgB,CAAC,CAAC;IAC7B,gCAAgC,EAAE,CAChC,WAAW,EAAE,MAAM,KAChB,KAAK,CAAC,2BAA2B,CAAC,CAAC;IACxC,iCAAiC,EAAE,CAAC,IAAI,EAAE;QACxC,WAAW,EAAE,MAAM,CAAC;QACpB,QAAQ,EAAE,MAAM,CAAC;QACjB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KAC/B,KAAK,OAAO,CAAC,2BAA2B,CAAC,CAAC;IAC3C,oCAAoC,EAAE,CACpC,WAAW,EAAE,MAAM,KAChB,KAAK,CAAC,oCAAoC,CAAC,CAAC;IACjD,uCAAuC,EAAE,CAAC,IAAI,EAAE;QAC9C,WAAW,EAAE,MAAM,CAAC;QACpB,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAC/B,QAAQ,EAAE,MAAM,CAAC;QACjB,YAAY,EAAE,MAAM,CAAC;QACrB,wBAAwB,EAAE,MAAM,CAAC;QACjC,WAAW,EAAE,MAAM,CAAC;KACrB,KAAK,OAAO,CAAC,oCAAoC,CAAC,CAAC;IACpD,yBAAyB,EAAE,MAAM,CAAC;IAClC,0BAA0B,EAAE,MAAM,CAAC;IACnC,wBAAwB,EAAE,MAAM,CAAC;CAClC;wDAC4D;QACzD,WAAW,EAAE,MAAM,CAAC;QACpB,IAAI,CAAC,EAAE,0CAA0C,GAAG,IAAI,CAAC;KAC1D,KAAG,OAAO,CAAC,KAAK,CAAC,4CAA4C,CAAC,CAAC;uDA+CA;QAC9D,WAAW,EAAE,MAAM,CAAC;QACpB,IAAI,EAAE,0CAA0C,CAAC;QACjD,SAAS,EAAE,MAAM,CAAC;KACnB,KAAG,OAAO,CAAC,4CAA4C,GAAG,IAAI,CAAC;wDASC;QAC/D,WAAW,EAAE,MAAM,CAAC;QACpB,IAAI,EAAE,0CAA0C,CAAC;QACjD,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAC1B,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QACxB,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAC/B,aAAa,CAAC,EAAE,OAAO,CAAC;QACxB,aAAa,CAAC,EAAE,OAAO,CAAC;QACxB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QACzB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAC9B,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAC7B,wBAAwB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QACzC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KAC7B,KAAG,OAAO,CAAC,4CAA4C,CAAC;uDAwCO;QAC9D,WAAW,EAAE,MAAM,CAAC;QACpB,IAAI,EAAE,0CAA0C,CAAC;QACjD,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;KACjB,KAAG,OAAO,CAAC,4CAA4C,CAAC;uDAmBO;QAC9D,WAAW,EAAE,MAAM,CAAC;QACpB,IAAI,EAAE,0CAA0C,CAAC;QACjD,SAAS,EAAE,MAAM,CAAC;KACnB,KAAG,OAAO,CAAC,4CAA4C,CAAC;CA6B1D,CAAC"}

package/script/src/server/workspace/conversation_sessions.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWorkspaceConversationSessionService = void 0;
+const toBuildConversationSessionForGraphql = (workspaceId, run) => ({
+    sessionId: run.id,
+    workspaceId,
+    kind: "build",
+    status: run.status,
+    error: run.error,
+    startedAt: run.startedAt,
+    finishedAt: run.finishedAt,
+    buildRun: run,
+});
+const toScenarioConversationSessionForGraphql = (workspaceId, run) => ({
+    sessionId: run.id,
+    workspaceId,
+    kind: "scenario",
+    status: run.status,
+    error: run.error,
+    startedAt: run.startedAt,
+    finishedAt: run.finishedAt,
+    scenarioRun: run,
+});
+const toGraderConversationSessionForGraphql = (workspaceId, run) => ({
+    sessionId: run.id,
+    workspaceId,
+    kind: "grader",
+    status: run.status,
+    error: run.error,
+    startedAt: run.runAt,
+    finishedAt: run.runAt,
+    gradeRun: run,
+});
+const toVerifyConversationSessionForGraphql = (workspaceId, batch) => ({
+    sessionId: batch.id,
+    workspaceId,
+    kind: "verify",
+    status: batch.status,
+    startedAt: batch.startedAt,
+    finishedAt: batch.finishedAt,
+    verifyBatch: batch,
+});
+const createWorkspaceConversationSessionService = (deps) => {
+    const listWorkspaceConversationSessionsForGraphql = (args) => {
+        const sessions = [];
+        if (!args.kind || args.kind === "build") {
+            sessions.push(toBuildConversationSessionForGraphql(args.workspaceId, deps.readWorkspaceBuildRunForGraphql(args.workspaceId)));
+        }
+        if (!args.kind || args.kind === "scenario") {
+            for (const run of deps.readWorkspaceScenarioRunsForGraphql(args.workspaceId)) {
+                sessions.push(toScenarioConversationSessionForGraphql(args.workspaceId, run));
+            }
+        }
+        if (!args.kind || args.kind === "grader") {
+            for (const run of deps.readWorkspaceGradeRunsForGraphql(args.workspaceId)) {
+                sessions.push(toGraderConversationSessionForGraphql(args.workspaceId, run));
+            }
+        }
+        if (!args.kind || args.kind === "verify") {
+            for (const batch of deps.readWorkspaceVerifyBatchesForGraphql(args.workspaceId)) {
+                sessions.push(toVerifyConversationSessionForGraphql(args.workspaceId, batch));
+            }
+        }
+        sessions.sort((left, right) => {
+            const leftKey = left.finishedAt ?? left.startedAt ?? left.sessionId;
+            const rightKey = right.finishedAt ?? right.startedAt ?? right.sessionId;
+            return rightKey.localeCompare(leftKey);
+        });
+        return Promise.resolve(sessions);
+    };
+    const readWorkspaceConversationSessionForGraphql = async (args) => {
+        const sessions = await listWorkspaceConversationSessionsForGraphql({
+            workspaceId: args.workspaceId,
+            kind: args.kind,
+        });
+        return sessions.find((session) => session.sessionId === args.sessionId) ??
+            null;
+    };
+    const startWorkspaceConversationSessionForGraphql = async (args) => {
+        if (args.kind === "build") {
+            const run = await deps.startWorkspaceBuildRun({
+                workspaceId: args.workspaceId,
+                message: args.message ?? "",
+            });
+            return toBuildConversationSessionForGraphql(args.workspaceId, run);
+        }
+        if (args.kind === "scenario") {
+            const run = await deps.startWorkspaceScenarioRunForGraphql({
+                workspaceId: args.workspaceId,
+                runId: args.sessionId ?? undefined,
+                scenarioDeckId: args.scenarioDeckId ?? null,
+                scenarioInput: args.scenarioInput,
+                assistantInit: args.assistantInit,
+            });
+            return toScenarioConversationSessionForGraphql(args.workspaceId, run);
+        }
+        if (args.kind === "grader") {
+            if (!args.graderId)
+                throw new Error("graderId is required");
+            const run = await deps.createWorkspaceGradeRunForGraphql({
+                workspaceId: args.workspaceId,
+                graderId: args.graderId,
+                scenarioRunId: args.scenarioRunId ?? null,
+            });
+            return toGraderConversationSessionForGraphql(args.workspaceId, run);
+        }
+        if (!args.graderId)
+            throw new Error("graderId is required");
+        const batch = await deps.createWorkspaceVerifyBatchRunForGraphql({
+            workspaceId: args.workspaceId,
+            scenarioDeckId: args.scenarioDeckId ?? null,
+            graderId: args.graderId,
+            scenarioRuns: args.scenarioRuns ?? deps.defaultVerifyScenarioRuns,
+            graderRepeatsPerScenario: args.graderRepeatsPerScenario ??
+                deps.defaultVerifyGraderRepeats,
+            concurrency: args.concurrency ?? deps.defaultVerifyConcurrency,
+        });
+        return toVerifyConversationSessionForGraphql(args.workspaceId, batch);
+    };
+    const sendWorkspaceConversationSessionForGraphql = async (args) => {
+        if (args.kind === "build") {
+            const run = await deps.startWorkspaceBuildRun({
+                workspaceId: args.workspaceId,
+                message: args.message,
+            });
+            return toBuildConversationSessionForGraphql(args.workspaceId, run);
+        }
+        if (args.kind !== "scenario") {
+            throw new Error(`Send is unavailable for ${args.kind} sessions`);
+        }
+        const run = await deps.sendWorkspaceScenarioRunForGraphql({
+            workspaceId: args.workspaceId,
+            runId: args.sessionId,
+            message: args.message,
+        });
+        return toScenarioConversationSessionForGraphql(args.workspaceId, run);
+    };
+    const stopWorkspaceConversationSessionForGraphql = async (args) => {
+        if (args.kind === "build") {
+            const run = await deps.stopWorkspaceBuildRun({
+                workspaceId: args.workspaceId,
+                runId: args.sessionId,
+            });
+            return toBuildConversationSessionForGraphql(args.workspaceId, run);
+        }
+        if (args.kind !== "scenario") {
+            const existing = await readWorkspaceConversationSessionForGraphql(args);
+            if (!existing) {
+                throw new Error(`Conversation session ${args.sessionId} not found`);
+            }
+            return existing;
+        }
+        const run = await deps.stopWorkspaceScenarioRunForGraphql({
+            workspaceId: args.workspaceId,
+            runId: args.sessionId,
+        });
+        return toScenarioConversationSessionForGraphql(args.workspaceId, run);
+    };
+    return {
+        listWorkspaceConversationSessionsForGraphql,
+        readWorkspaceConversationSessionForGraphql,
+        startWorkspaceConversationSessionForGraphql,
+        sendWorkspaceConversationSessionForGraphql,
+        stopWorkspaceConversationSessionForGraphql,
+    };
+};
+exports.createWorkspaceConversationSessionService = createWorkspaceConversationSessionService;

package/script/src/server/workspace/grading.d.ts

@@ -0,0 +1,52 @@
+import type { ModelProvider, SavedState } from "@bolt-foundry/gambit-core";
+import type { GradingFlag, WorkspaceDeckState } from "../../server_types.js";
+import type { WorkspaceGradeRunForGraphql } from "./types.js";
+export declare const createWorkspaceGradingService: (deps: {
+    randomId: (prefix: string) => string;
+    modelProvider: ModelProvider;
+    responsesMode?: boolean;
+    workerSandbox?: boolean;
+    appendDurableStreamEvent: (streamId: string, payload: unknown) => void;
+    workspaceStreamId: string;
+    activateWorkspaceDeck: (workspaceId?: string | null, options?: {
+        forceReload?: boolean;
+        source?: string;
+        reloadAttemptId?: string;
+    }) => Promise<void>;
+    readWorkspaceDeckStateStrict: (workspaceId: string) => WorkspaceDeckState;
+    resolveGraderDeckFromState: (deckState: WorkspaceDeckState, graderId: string) => WorkspaceDeckState["graderDecks"][number] | undefined;
+    readSessionState: (workspaceId: string) => SavedState | undefined;
+    readSessionStateStrict: (workspaceId: string, options?: {
+        withTraces?: boolean;
+    }) => SavedState | undefined;
+    persistSessionState: (state: SavedState) => SavedState;
+    appendGradingLog: (state: SavedState, payload: Record<string, unknown>) => void;
+    readWorkspaceScenarioRunsForGraphql: (workspaceId: string) => Array<{
+        id: string;
+        messages: Array<{
+            role: string;
+            content: string;
+            messageRefId?: string;
+        }>;
+    }>;
+}) => {
+    readWorkspaceGradeRunsForGraphql: (workspaceId: string) => Array<WorkspaceGradeRunForGraphql>;
+    readWorkspaceGradingFlagsForGraphql: (workspaceId: string) => Array<GradingFlag>;
+    createWorkspaceGradeRunForGraphql: (args: {
+        workspaceId: string;
+        graderId: string;
+        scenarioRunId?: string | null;
+    }) => Promise<WorkspaceGradeRunForGraphql>;
+    toggleWorkspaceGradeFlagForGraphql: (args: {
+        workspaceId: string;
+        refId: string;
+        runId: string;
+        turnIndex?: number | null;
+    }) => Promise<Array<GradingFlag>>;
+    updateWorkspaceGradeFlagReasonForGraphql: (args: {
+        workspaceId: string;
+        refId: string;
+        reason: string;
+    }) => Promise<Array<GradingFlag>>;
+};
+//# sourceMappingURL=grading.d.ts.map