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

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

@@ -0,0 +1 @@
+{"version":3,"file":"grading.d.ts","sourceRoot":"","sources":["../../../../src/src/server/workspace/grading.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAC3E,OAAO,KAAK,EACV,WAAW,EAEX,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,YAAY,CAAC;AAQ9D,eAAO,MAAM,6BAA6B,GAAI,MAAM;IAClD,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;IACrC,aAAa,EAAE,aAAa,CAAC;IAC7B,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,wBAAwB,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IACvE,iBAAiB,EAAE,MAAM,CAAC;IAC1B,qBAAqB,EAAE,CACrB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,EAC3B,OAAO,CAAC,EAAE;QACR,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,eAAe,CAAC,EAAE,MAAM,CAAC;KAC1B,KACE,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,4BAA4B,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,kBAAkB,CAAC;IAC1E,0BAA0B,EAAE,CAC1B,SAAS,EAAE,kBAAkB,EAC7B,QAAQ,EAAE,MAAM,KACb,kBAAkB,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC;IAC3D,gBAAgB,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,UAAU,GAAG,SAAS,CAAC;IAClE,sBAAsB,EAAE,CACtB,WAAW,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,OAAO,CAAA;KAAE,KAC/B,UAAU,GAAG,SAAS,CAAC;IAC5B,mBAAmB,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,UAAU,CAAC;IACvD,gBAAgB,EAAE,CAChB,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC7B,IAAI,CAAC;IACV,mCAAmC,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,KAAK,CAAC;QAClE,EAAE,EAAE,MAAM,CAAC;QACX,QAAQ,EAAE,KAAK,CAAC;YACd,IAAI,EAAE,MAAM,CAAC;YACb,OAAO,EAAE,MAAM,CAAC;YAChB,YAAY,CAAC,EAAE,MAAM,CAAC;SACvB,CAAC,CAAC;KACJ,CAAC,CAAC;CACJ;oDA2QgB,MAAM,KAClB,KAAK,CAAC,2BAA2B,CAAC;uDATtB,MAAM,KAClB,KAAK,CAAC,WAAW,CAAC;8CA2BkC;QACrD,WAAW,EAAE,MAAM,CAAC;QACpB,QAAQ,EAAE,MAAM,CAAC;QACjB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KAC/B,KAAG,OAAO,CAAC,2BAA2B,CAAC;+CAmKU;QAChD,WAAW,EAAE,MAAM,CAAC;QACpB,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,CAAC;QACd,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KAC3B,KAAG,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;qDA0CyB;QACtD,WAAW,EAAE,MAAM,CAAC;QACpB,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;KAChB,KAAG,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;CA2ChC,CAAC"}

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

@@ -0,0 +1,492 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWorkspaceGradingService = 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 createWorkspaceGradingService = (deps) => {
+    const readGradingRunsFromState = (state) => {
+        const meta = state.meta && typeof state.meta === "object"
+            ? state.meta
+            : {};
+        const fromGradingRuns = Array.isArray(meta.gradingRuns)
+            ? meta.gradingRuns
+            : null;
+        const fromCalibrationRuns = Array.isArray(meta.calibrationRuns)
+            ? meta.calibrationRuns
+            : null;
+        const raw = fromGradingRuns ?? fromCalibrationRuns ?? [];
+        return raw.flatMap((entry) => {
+            if (!entry || typeof entry !== "object")
+                return [];
+            const run = entry;
+            const id = typeof run.id === "string" && run.id.trim().length > 0
+                ? run.id
+                : deps.randomId("grade");
+            if (typeof run.graderId !== "string" || typeof run.graderPath !== "string") {
+                return [];
+            }
+            return [{
+                    ...run,
+                    id,
+                }];
+        });
+    };
+    const upsertGradingRunInState = (state, nextRun) => {
+        const runs = readGradingRunsFromState(state);
+        const index = runs.findIndex((entry) => entry.id === nextRun.id);
+        const nextRuns = [...runs];
+        if (index >= 0) {
+            nextRuns[index] = nextRun;
+        }
+        else {
+            nextRuns.unshift(nextRun);
+        }
+        const currentMeta = state.meta && typeof state.meta === "object"
+            ? state.meta
+            : {};
+        const nextMeta = {
+            ...currentMeta,
+            gradingRuns: nextRuns,
+        };
+        delete nextMeta.calibrationRuns;
+        return { ...state, meta: nextMeta };
+    };
+    const readGradingFlagsFromState = (state) => {
+        const meta = state.meta && typeof state.meta === "object"
+            ? state.meta
+            : {};
+        if (!Array.isArray(meta.gradingFlags))
+            return [];
+        return meta.gradingFlags.flatMap((entry) => {
+            if (!entry || typeof entry !== "object")
+                return [];
+            const flag = entry;
+            if (typeof flag.refId !== "string" || flag.refId.trim().length === 0) {
+                return [];
+            }
+            return [{
+                    id: typeof flag.id === "string" && flag.id.trim().length > 0
+                        ? flag.id
+                        : deps.randomId("gflag"),
+                    refId: flag.refId.trim(),
+                    runId: typeof flag.runId === "string" ? flag.runId : undefined,
+                    turnIndex: typeof flag.turnIndex === "number"
+                        ? flag.turnIndex
+                        : undefined,
+                    reason: typeof flag.reason === "string" ? flag.reason : undefined,
+                    createdAt: typeof flag.createdAt === "string" && flag.createdAt
+                        ? flag.createdAt
+                        : new Date().toISOString(),
+                }];
+        });
+    };
+    const writeGradingFlagsToState = (state, flags) => {
+        const currentMeta = state.meta && typeof state.meta === "object"
+            ? state.meta
+            : {};
+        return {
+            ...state,
+            meta: {
+                ...currentMeta,
+                gradingFlags: flags,
+            },
+        };
+    };
+    const extractGradeScoreAndReason = (value) => {
+        if (!value || typeof value !== "object")
+            return {};
+        const record = value;
+        const payload = record.payload && typeof record.payload === "object"
+            ? record.payload
+            : record;
+        const score = typeof payload.score === "number" ? payload.score : undefined;
+        const reason = typeof payload.reason === "string"
+            ? payload.reason
+            : undefined;
+        return { score, reason };
+    };
+    const extractGradeTurnContext = (value) => {
+        if (!value || typeof value !== "object")
+            return {};
+        const input = value;
+        const messageToGrade = input.messageToGrade;
+        const gradedAssistant = messageToGrade && typeof messageToGrade === "object"
+            ? typeof messageToGrade.content === "string"
+                ? messageToGrade.content
+                : undefined
+            : undefined;
+        const session = input.session;
+        const messages = session && typeof session === "object" &&
+            Array.isArray(session.messages)
+            ? session
+                .messages
+            : [];
+        let priorUser;
+        for (let index = messages.length - 1; index >= 0; index -= 1) {
+            const message = messages[index];
+            if (message?.role !== "user")
+                continue;
+            if (typeof message.content === "string" && message.content.trim()) {
+                priorUser = message.content;
+                break;
+            }
+        }
+        return { priorUser, gradedAssistant };
+    };
+    const deriveScenarioRunIdFromGradingRun = (run) => {
+        if (typeof run.scenarioRunId === "string" && run.scenarioRunId.trim()) {
+            return run.scenarioRunId.trim();
+        }
+        if (!run.input || typeof run.input !== "object")
+            return undefined;
+        const input = run.input;
+        const session = input.session;
+        if (!session || typeof session !== "object")
+            return undefined;
+        const meta = session.meta;
+        if (!meta || typeof meta !== "object")
+            return undefined;
+        const scenarioRunId = meta.scenarioRunId;
+        return typeof scenarioRunId === "string" && scenarioRunId.trim().length > 0
+            ? scenarioRunId
+            : undefined;
+    };
+    const toWorkspaceGradeRunForGraphql = (run, flags) => {
+        const flagByRef = new Map(flags.map((entry) => [entry.refId, entry]));
+        const result = run.result && typeof run.result === "object"
+            ? run.result
+            : null;
+        const turns = result && result.mode === "turns" && Array.isArray(result.turns)
+            ? result.turns
+            : [];
+        const totalTurns = typeof result?.totalTurns === "number" &&
+            Number.isFinite(result.totalTurns)
+            ? result.totalTurns
+            : turns.length;
+        const normalizedTurns = turns.map((turn, index) => {
+            const turnIndex = typeof turn.index === "number" && Number.isFinite(turn.index)
+                ? turn.index
+                : index;
+            const turnNumber = totalTurns > 0
+                ? Math.min(totalTurns, index + 1)
+                : index + 1;
+            const turnInput = turn.input;
+            const turnResult = turn.result;
+            const { score, reason } = extractGradeScoreAndReason(turnResult);
+            const context = extractGradeTurnContext(turnInput);
+            const messageToGrade = turnInput && typeof turnInput === "object"
+                ? turnInput.messageToGrade
+                : undefined;
+            const messageRefId = messageToGrade && typeof messageToGrade === "object" &&
+                typeof messageToGrade.messageRefId ===
+                    "string"
+                ? messageToGrade.messageRefId
+                : undefined;
+            const fallbackRefId = `gradingRun:${run.id}#turn:${turnIndex}`;
+            const refId = messageRefId ?? fallbackRefId;
+            const turnFlag = flagByRef.get(refId);
+            return {
+                id: `${run.id}:turn:${turnIndex}`,
+                runId: run.id,
+                turnIndex,
+                turnNumber,
+                refId,
+                score,
+                reason,
+                priorUser: context.priorUser,
+                gradedAssistant: context.gradedAssistant,
+                flagReason: turnFlag?.reason,
+            };
+        });
+        const summaryFromResult = extractGradeScoreAndReason(run.result);
+        const scenarioRunId = deriveScenarioRunIdFromGradingRun(run);
+        return {
+            id: run.id,
+            workspaceId: run.workspaceId ?? "",
+            scenarioRunId,
+            graderId: run.graderId,
+            graderPath: run.graderPath,
+            graderLabel: run.graderLabel,
+            status: run.status,
+            runAt: run.runAt,
+            error: run.error,
+            summary: summaryFromResult.score !== undefined ||
+                summaryFromResult.reason !== undefined
+                ? summaryFromResult
+                : undefined,
+            turns: normalizedTurns.map((turn) => ({
+                id: turn.id,
+                runId: turn.runId,
+                turnIndex: turn.turnIndex,
+                turnNumber: turn.turnNumber,
+                refId: turn.refId,
+                score: turn.score,
+                reason: turn.reason,
+                priorUser: turn.priorUser,
+                gradedAssistant: turn.gradedAssistant,
+            })),
+        };
+    };
+    const emitGradeWorkspaceEvent = (workspaceId, payload) => {
+        deps.appendDurableStreamEvent(deps.workspaceStreamId, {
+            ...payload,
+            workspaceId,
+        });
+    };
+    const readWorkspaceGradingFlagsForGraphql = (workspaceId) => {
+        const state = deps.readSessionState(workspaceId);
+        if (!state)
+            return [];
+        return readGradingFlagsFromState(state);
+    };
+    const readWorkspaceGradeRunsForGraphql = (workspaceId) => {
+        const state = deps.readSessionState(workspaceId);
+        if (!state)
+            return [];
+        const runs = readGradingRunsFromState(state).map((entry) => ({
+            ...entry,
+            workspaceId,
+        }));
+        const flags = readGradingFlagsFromState(state);
+        const projected = runs.map((run) => toWorkspaceGradeRunForGraphql(run, flags));
+        projected.sort((a, b) => {
+            const left = a.runAt ?? a.id;
+            const right = b.runAt ?? b.id;
+            return right.localeCompare(left);
+        });
+        return projected;
+    };
+    const createWorkspaceGradeRunForGraphql = async (args) => {
+        await deps.activateWorkspaceDeck(args.workspaceId, {
+            source: "graphql:createWorkspaceGradeRun",
+        });
+        const deckState = deps.readWorkspaceDeckStateStrict(args.workspaceId);
+        const grader = deps.resolveGraderDeckFromState(deckState, args.graderId);
+        if (!grader) {
+            throw new Error(`Unknown grader deck: ${args.graderId}`);
+        }
+        const state = deps.readSessionStateStrict(args.workspaceId, {
+            withTraces: true,
+        });
+        if (!state) {
+            throw new Error(`Workspace ${args.workspaceId} not found`);
+        }
+        const explicitScenarioRunId = typeof args.scenarioRunId === "string" &&
+            args.scenarioRunId.trim().length > 0
+            ? args.scenarioRunId.trim()
+            : null;
+        const runFromState = state.meta && typeof state.meta.scenarioRunId === "string"
+            ? state.meta.scenarioRunId
+            : null;
+        const selectedScenarioRunId = explicitScenarioRunId ?? runFromState;
+        const scenarioRun = selectedScenarioRunId
+            ? deps.readWorkspaceScenarioRunsForGraphql(args.workspaceId).find((entry) => entry.id === selectedScenarioRunId)
+            : null;
+        if (selectedScenarioRunId && !scenarioRun) {
+            throw new Error(`Scenario run ${selectedScenarioRunId} not found`);
+        }
+        const artifacts = scenarioRun
+            ? (0, helpers_js_1.buildScenarioConversationArtifactsFromRun)(scenarioRun)
+            : (0, helpers_js_1.buildScenarioConversationArtifacts)(state);
+        const metaForGrading = (() => {
+            const baseMeta = state.meta && typeof state.meta === "object"
+                ? state.meta
+                : {};
+            const next = { ...baseMeta };
+            delete next.calibrationRuns;
+            delete next.gradingRuns;
+            return next;
+        })();
+        if (selectedScenarioRunId) {
+            metaForGrading.scenarioRunId = selectedScenarioRunId;
+        }
+        const sessionPayload = {
+            runId: state.runId,
+            messages: artifacts.messages,
+            messageRefs: state.messageRefs,
+            feedback: state.feedback,
+            notes: state.notes,
+            conversationScore: state.conversationScore,
+            traces: Array.isArray(state.traces) ? state.traces : [],
+            meta: metaForGrading,
+        };
+        const runId = deps.randomId("grade");
+        const runAt = new Date().toISOString();
+        const runningRun = {
+            id: runId,
+            workspaceId: args.workspaceId,
+            scenarioRunId: selectedScenarioRunId ?? undefined,
+            graderId: grader.id,
+            graderPath: grader.path,
+            graderLabel: grader.label,
+            status: "running",
+            runAt,
+            input: { session: sessionPayload },
+        };
+        let persistedState = deps.persistSessionState(upsertGradingRunInState(state, runningRun));
+        deps.appendGradingLog(persistedState, {
+            type: "gambit.grade.status",
+            workspaceId: args.workspaceId,
+            run: runningRun,
+        });
+        emitGradeWorkspaceEvent(args.workspaceId, {
+            type: "gambit.grade.status",
+            run: runningRun,
+        });
+        let completedRun = runningRun;
+        try {
+            const graderDeck = await (0, gambit_core_1.loadDeck)(grader.path);
+            const runMode = (0, helpers_js_1.gradeSchemaHasField)(graderDeck.inputSchema, "messageToGrade")
+                ? "turns"
+                : "conversation";
+            const result = runMode === "conversation"
+                ? await (0, run_deck_js_1.runDeckWithFallback)({
+                    path: grader.path,
+                    input: { session: sessionPayload },
+                    inputProvided: true,
+                    modelProvider: deps.modelProvider,
+                    responsesMode: deps.responsesMode,
+                    workerSandbox: deps.workerSandbox,
+                })
+                : {
+                    mode: "turns",
+                    totalTurns: artifacts.assistantTurns.length,
+                    turns: await Promise.all(artifacts.assistantTurns.map(async (turn) => {
+                        const messageToGrade = turn.message && typeof turn.message === "object"
+                            ? {
+                                ...turn.message,
+                                messageRefId: turn.messageRefId,
+                            }
+                            : turn.message;
+                        const input = {
+                            session: sessionPayload,
+                            messageToGrade,
+                        };
+                        const turnResult = await (0, run_deck_js_1.runDeckWithFallback)({
+                            path: grader.path,
+                            input,
+                            inputProvided: true,
+                            modelProvider: deps.modelProvider,
+                            responsesMode: deps.responsesMode,
+                            workerSandbox: deps.workerSandbox,
+                        });
+                        return {
+                            index: turn.conversationIndex,
+                            input,
+                            result: turnResult,
+                        };
+                    })),
+                };
+            completedRun = {
+                ...runningRun,
+                status: "completed",
+                result,
+                error: undefined,
+            };
+        }
+        catch (error) {
+            completedRun = {
+                ...runningRun,
+                status: "error",
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+        persistedState = deps.persistSessionState(upsertGradingRunInState(persistedState, completedRun));
+        deps.appendGradingLog(persistedState, {
+            type: "gambit.grade.status",
+            workspaceId: args.workspaceId,
+            run: completedRun,
+        });
+        emitGradeWorkspaceEvent(args.workspaceId, {
+            type: "gambit.grade.status",
+            run: completedRun,
+        });
+        const flags = readGradingFlagsFromState(persistedState);
+        return toWorkspaceGradeRunForGraphql(completedRun, flags);
+    };
+    const toggleWorkspaceGradeFlagForGraphql = (args) => {
+        const state = deps.readSessionStateStrict(args.workspaceId, {
+            withTraces: true,
+        });
+        if (!state)
+            throw new Error(`Workspace ${args.workspaceId} not found`);
+        const existing = readGradingFlagsFromState(state);
+        const refId = args.refId.trim();
+        if (!refId)
+            throw new Error("Missing grade flag refId");
+        const existingIndex = existing.findIndex((entry) => entry.refId === refId);
+        const nextFlags = [...existing];
+        if (existingIndex >= 0) {
+            nextFlags.splice(existingIndex, 1);
+        }
+        else {
+            nextFlags.push({
+                id: deps.randomId("gflag"),
+                refId,
+                runId: args.runId,
+                turnIndex: typeof args.turnIndex === "number"
+                    ? args.turnIndex
+                    : undefined,
+                createdAt: new Date().toISOString(),
+            });
+        }
+        const persistedState = deps.persistSessionState(writeGradingFlagsToState(state, nextFlags));
+        deps.appendGradingLog(persistedState, {
+            type: "gambit.grade.flag",
+            workspaceId: args.workspaceId,
+            action: existingIndex >= 0 ? "remove" : "add",
+            refId,
+            flags: nextFlags,
+        });
+        emitGradeWorkspaceEvent(args.workspaceId, {
+            type: "gambit.grade.flag",
+            action: existingIndex >= 0 ? "remove" : "add",
+            refId,
+            runId: args.runId,
+        });
+        return Promise.resolve(readGradingFlagsFromState(persistedState));
+    };
+    const updateWorkspaceGradeFlagReasonForGraphql = (args) => {
+        const state = deps.readSessionStateStrict(args.workspaceId, {
+            withTraces: true,
+        });
+        if (!state)
+            throw new Error(`Workspace ${args.workspaceId} not found`);
+        const existing = readGradingFlagsFromState(state);
+        const refId = args.refId.trim();
+        const index = existing.findIndex((entry) => entry.refId === refId);
+        if (index < 0) {
+            throw new Error(`Flag not found for refId: ${refId}`);
+        }
+        const nextFlags = [...existing];
+        nextFlags[index] = {
+            ...nextFlags[index],
+            reason: args.reason,
+        };
+        const persistedState = deps.persistSessionState(writeGradingFlagsToState(state, nextFlags));
+        deps.appendGradingLog(persistedState, {
+            type: "gambit.grade.flag",
+            workspaceId: args.workspaceId,
+            action: "reason",
+            refId,
+            reason: args.reason,
+            flags: nextFlags,
+        });
+        emitGradeWorkspaceEvent(args.workspaceId, {
+            type: "gambit.grade.flag",
+            action: "reason",
+            refId,
+            runId: nextFlags[index]?.runId,
+        });
+        return Promise.resolve(readGradingFlagsFromState(persistedState));
+    };
+    return {
+        readWorkspaceGradeRunsForGraphql,
+        readWorkspaceGradingFlagsForGraphql,
+        createWorkspaceGradeRunForGraphql,
+        toggleWorkspaceGradeFlagForGraphql,
+        updateWorkspaceGradeFlagReasonForGraphql,
+    };
+};
+exports.createWorkspaceGradingService = createWorkspaceGradingService;

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

@@ -0,0 +1,46 @@
+import type { ModelMessage, SavedState } from "@bolt-foundry/gambit-core";
+import type { ZodTypeAny } from "zod";
+import type { TestBotRunStatus } from "./types.js";
+export declare const GAMBIT_TOOL_RESPOND = "gambit_respond";
+export type RespondSummary = {
+    status?: number;
+    code?: string;
+    message?: string;
+    meta?: Record<string, unknown>;
+    payload?: unknown;
+    displayText: string;
+};
+export declare const stringifyContent: (value: unknown) => string;
+export declare const safeParseJson: (text: string | null | undefined) => unknown;
+export declare const summarizeRespondCall: (message: ModelMessage | null | undefined) => RespondSummary | null;
+export declare const deriveToolInsertsFromTraces: (state: SavedState, messageCount: number) => NonNullable<TestBotRunStatus["toolInserts"]>;
+export declare const buildTestBotSnapshot: (state: SavedState) => {
+    messages: TestBotRunStatus["messages"];
+    toolInserts: NonNullable<TestBotRunStatus["toolInserts"]>;
+};
+export declare const buildScenarioConversationArtifacts: (state: SavedState) => {
+    messages: Array<ModelMessage>;
+    assistantTurns: Array<{
+        conversationIndex: number;
+        message: ModelMessage;
+        messageRefId?: string;
+    }>;
+};
+export declare const buildScenarioConversationArtifactsFromRun: (run: {
+    messages: Array<{
+        role: string;
+        content: string;
+        messageRefId?: string;
+    }>;
+}) => {
+    messages: Array<ModelMessage>;
+    assistantTurns: Array<{
+        conversationIndex: number;
+        message: ModelMessage;
+        messageRefId?: string;
+    }>;
+};
+export declare const gradeSchemaHasField: (schema: ZodTypeAny | undefined, field: string) => boolean;
+export declare const applyUserMessageRefSource: (previousState: SavedState | undefined, nextState: SavedState, source: "scenario" | "manual") => SavedState;
+export declare const syncTestBotRunFromState: (run: TestBotRunStatus, state: SavedState) => void;
+//# sourceMappingURL=helpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../../src/src/server/workspace/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EACZ,UAAU,EAEX,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,KAAK,CAAC;AACtC,OAAO,KAAK,EAAmB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEpE,eAAO,MAAM,mBAAmB,mBAAmB,CAAC;AAEpD,MAAM,MAAM,cAAc,GAAG;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,OAAO,OAAO,KAAG,MAQjD,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,GAAG,IAAI,GAAG,SAAS,KAAG,OAO/D,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,SAAS,YAAY,GAAG,IAAI,GAAG,SAAS,KACvC,cAAc,GAAG,IAoCnB,CAAC;AAEF,eAAO,MAAM,2BAA2B,GACtC,OAAO,UAAU,EACjB,cAAc,MAAM,KACnB,WAAW,CAAC,gBAAgB,CAAC,aAAa,CAAC,CAiC7C,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,OAAO,UAAU,KAChB;IACD,QAAQ,EAAE,gBAAgB,CAAC,UAAU,CAAC,CAAC;IACvC,WAAW,EAAE,WAAW,CAAC,gBAAgB,CAAC,aAAa,CAAC,CAAC,CAAC;CAmG3D,CAAC;AAEF,eAAO,MAAM,kCAAkC,GAC7C,OAAO,UAAU,KAChB;IACD,QAAQ,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC;IAC9B,cAAc,EAAE,KAAK,CAAC;QACpB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,OAAO,EAAE,YAAY,CAAC;QACtB,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB,CAAC,CAAC;CAoDJ,CAAC;AAEF,eAAO,MAAM,yCAAyC,GACpD,KAAK;IACH,QAAQ,EAAE,KAAK,CAAC;QACd,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB,CAAC,CAAC;CACJ,KACA;IACD,QAAQ,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC;IAC9B,cAAc,EAAE,KAAK,CAAC;QACpB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,OAAO,EAAE,YAAY,CAAC;QACtB,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB,CAAC,CAAC;CA4BJ,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAC9B,QAAQ,UAAU,GAAG,SAAS,EAC9B,OAAO,MAAM,KACZ,OAiCF,CAAC;AAEF,eAAO,MAAM,yBAAyB,GACpC,eAAe,UAAU,GAAG,SAAS,EACrC,WAAW,UAAU,EACrB,QAAQ,UAAU,GAAG,QAAQ,KAC5B,UAqBF,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,KAAK,gBAAgB,EACrB,OAAO,UAAU,SAmBlB,CAAC"}