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

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

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOpenResponsesEventPersistence = void 0;
+const asJsonValue = (value) => {
+    if (value === null || typeof value === "string" ||
+        typeof value === "number" || typeof value === "boolean") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => asJsonValue(entry));
+    }
+    if (value && typeof value === "object") {
+        const out = {};
+        for (const [key, entry] of Object.entries(value)) {
+            out[key] = asJsonValue(entry);
+        }
+        return out;
+    }
+    return String(value);
+};
+const hashStringFNV1a = (value) => {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < value.length; i += 1) {
+        hash ^= value.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193) >>> 0;
+    }
+    return hash.toString(16).padStart(8, "0");
+};
+const tracePayloadFingerprint = (payload) => hashStringFNV1a(JSON.stringify(asJsonValue(payload)));
+const messageContentFingerprint = (content) => hashStringFNV1a(JSON.stringify(asJsonValue(content)));
+const stringifyMessageContent = (content) => {
+    if (typeof content === "string")
+        return content;
+    if (content === null || content === undefined)
+        return "";
+    const normalized = asJsonValue(content);
+    if (typeof normalized === "string")
+        return normalized;
+    try {
+        return JSON.stringify(normalized);
+    }
+    catch {
+        return String(content);
+    }
+};
+const traceToRecord = (trace) => {
+    return !trace || typeof trace !== "object" || Array.isArray(trace)
+        ? {}
+        : trace;
+};
+const createOpenResponsesEventPersistence = (deps) => {
+    const persistOpenResponsesTraceEvent = (state, trace, fallbackRunId) => {
+        if (!state)
+            return;
+        const rawPayload = traceToRecord(trace);
+        const eventType = typeof rawPayload.type === "string"
+            ? rawPayload.type
+            : "";
+        if (!eventType.startsWith("response."))
+            return;
+        const runId = typeof rawPayload.runId === "string" &&
+            rawPayload.runId.length > 0
+            ? rawPayload.runId
+            : fallbackRunId;
+        if (!runId)
+            return;
+        const eventTs = typeof rawPayload.ts === "number" &&
+            Number.isFinite(rawPayload.ts)
+            ? rawPayload.ts
+            : Date.now();
+        const eventScope = typeof rawPayload.item_id === "string"
+            ? rawPayload.item_id
+            : typeof rawPayload.actionCallId === "string"
+                ? rawPayload.actionCallId
+                : typeof rawPayload.output_index === "number"
+                    ? String(rawPayload.output_index)
+                    : typeof rawPayload.sequence_number === "number"
+                        ? String(rawPayload.sequence_number)
+                        : "event";
+        const payload = deps.sanitizeJsonRecord(rawPayload);
+        const payloadFingerprint = tracePayloadFingerprint(payload);
+        void deps.appendOpenResponsesRunEvent(state, {
+            workspace_id: "",
+            run_id: runId,
+            event_type: eventType,
+            payload,
+            idempotency_key: `${runId}:${eventType}:${eventTs}:${eventScope}:${payloadFingerprint}`,
+            created_at: new Date(eventTs).toISOString(),
+        });
+    };
+    const persistCanonicalUserInputEvent = (args) => {
+        if (!args.state)
+            return;
+        const content = args.message.trim();
+        if (!content)
+            return;
+        const eventTs = Date.now();
+        void deps.appendOpenResponsesRunEvent(args.state, {
+            workspace_id: "",
+            run_id: args.runId,
+            event_type: "input.item",
+            payload: {
+                type: "input.item",
+                role: "user",
+                content: [{ type: "input_text", text: content }],
+                source: args.source,
+            },
+            idempotency_key: `${args.runId}:input.item:${args.source}:${eventTs}:${content.slice(0, 64)}`,
+            created_at: new Date(eventTs).toISOString(),
+        });
+    };
+    const persistCanonicalStateMessages = (args) => {
+        if (!args.state || !Array.isArray(args.state.messages))
+            return;
+        const refs = Array.isArray(args.state.messageRefs)
+            ? args.state.messageRefs
+            : [];
+        const startIndex = Math.max(0, args.startIndex ?? 0);
+        for (let index = startIndex; index < args.state.messages.length; index += 1) {
+            const message = args.state.messages[index];
+            if (!message || (message.role !== "user" && message.role !== "assistant")) {
+                continue;
+            }
+            const content = stringifyMessageContent(message.content).trim();
+            if (!content)
+                continue;
+            const ref = refs[index];
+            const messageRefId = typeof ref?.id === "string" && ref.id.trim().length > 0
+                ? ref.id.trim()
+                : undefined;
+            const fingerprint = messageContentFingerprint(message.content);
+            if (message.role === "user") {
+                void deps.appendOpenResponsesRunEvent(args.state, {
+                    workspace_id: "",
+                    run_id: args.runId,
+                    event_type: "input.item",
+                    payload: {
+                        type: "input.item",
+                        role: "user",
+                        content: [{ type: "input_text", text: content }],
+                        source: args.source,
+                        ...(messageRefId ? { message_id: messageRefId, messageRefId } : {}),
+                    },
+                    idempotency_key: `${args.runId}:input.item:canonical:${messageRefId ?? index}:${fingerprint}`,
+                    created_at: new Date().toISOString(),
+                });
+                continue;
+            }
+            void deps.appendOpenResponsesRunEvent(args.state, {
+                workspace_id: "",
+                run_id: args.runId,
+                event_type: "response.output_item.done",
+                payload: {
+                    type: "response.output_item.done",
+                    output_index: index,
+                    item: {
+                        type: "message",
+                        role: "assistant",
+                        content: [{ type: "output_text", text: content }],
+                        ...(messageRefId ? { messageRefId } : {}),
+                    },
+                },
+                idempotency_key: `${args.runId}:response.output_item.done:canonical:${messageRefId ?? index}:${fingerprint}`,
+                created_at: new Date().toISOString(),
+            });
+        }
+    };
+    const persistOpenResponsesTracesFromState = (state, fallbackRunId) => {
+        if (!state || !Array.isArray(state.traces))
+            return;
+        for (const trace of state.traces) {
+            persistOpenResponsesTraceEvent(state, trace, fallbackRunId);
+        }
+    };
+    return {
+        persistOpenResponsesTraceEvent,
+        persistCanonicalUserInputEvent,
+        persistCanonicalStateMessages,
+        persistOpenResponsesTracesFromState,
+    };
+};
+exports.createOpenResponsesEventPersistence = createOpenResponsesEventPersistence;

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

@@ -0,0 +1,23 @@
+import type { ModelProvider, SavedState } from "@bolt-foundry/gambit-core";
+export declare function stringifyOutput(output: unknown): string;
+export declare function resolveWorkerSandboxForSignalAwareRun(args: {
+    workerSandbox?: boolean;
+    signal?: AbortSignal;
+}): boolean | undefined;
+export declare function runDeckWithFallback(args: {
+    path: string;
+    input?: unknown;
+    inputProvided?: boolean;
+    modelProvider: ModelProvider;
+    state?: SavedState;
+    allowRootStringInput?: boolean;
+    initialUserMessage?: string;
+    onStateUpdate?: (state: SavedState) => void;
+    stream?: boolean;
+    onStreamText?: (chunk: string) => void;
+    responsesMode?: boolean;
+    workerSandbox?: boolean;
+    signal?: AbortSignal;
+    onCancel?: () => unknown | Promise<unknown>;
+}): Promise<unknown>;
+//# sourceMappingURL=run_deck.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"run_deck.d.ts","sourceRoot":"","sources":["../../../../src/src/server/workspace/run_deck.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAE3E,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAevD;AAUD,wBAAgB,qCAAqC,CAAC,IAAI,EAAE;IAC1D,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB,GAAG,OAAO,GAAG,SAAS,CAMtB;AAED,wBAAsB,mBAAmB,CAAC,IAAI,EAAE;IAC9C,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,aAAa,EAAE,aAAa,CAAC;IAC7B,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IAC5C,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC7C,GAAG,OAAO,CAAC,OAAO,CAAC,CA2CnB"}

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

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringifyOutput = stringifyOutput;
+exports.resolveWorkerSandboxForSignalAwareRun = resolveWorkerSandboxForSignalAwareRun;
+exports.runDeckWithFallback = runDeckWithFallback;
+const gambit_core_1 = require("@bolt-foundry/gambit-core");
+function stringifyOutput(output) {
+    if (output === null || output === undefined)
+        return "";
+    if (output &&
+        typeof output === "object" &&
+        "payload" in output) {
+        return stringifyOutput(output.payload);
+    }
+    if (typeof output === "string")
+        return output;
+    try {
+        return JSON.stringify(output);
+    }
+    catch {
+        return String(output);
+    }
+}
+function shouldRetryWithStringInput(error) {
+    if (!error)
+        return false;
+    if (error instanceof Error) {
+        return error.message.includes("Schema validation failed");
+    }
+    return false;
+}
+function resolveWorkerSandboxForSignalAwareRun(args) {
+    // gambit-core currently rejects worker sandbox runs when an AbortSignal is
+    // supplied. Simulator flows require signals for stop/reset cancellation, so
+    // force in-process execution for those runs.
+    if (args.signal)
+        return false;
+    return args.workerSandbox;
+}
+async function runDeckWithFallback(args) {
+    const workerSandbox = resolveWorkerSandboxForSignalAwareRun({
+        workerSandbox: args.workerSandbox,
+        signal: args.signal,
+    });
+    try {
+        return await (0, gambit_core_1.runDeck)({
+            path: args.path,
+            input: args.input,
+            inputProvided: args.inputProvided,
+            modelProvider: args.modelProvider,
+            state: args.state,
+            allowRootStringInput: args.allowRootStringInput,
+            initialUserMessage: args.initialUserMessage,
+            onStateUpdate: args.onStateUpdate,
+            stream: args.stream,
+            onStreamText: args.onStreamText,
+            responsesMode: args.responsesMode,
+            workerSandbox,
+            signal: args.signal,
+            onCancel: args.onCancel,
+        });
+    }
+    catch (error) {
+        if (args.input === undefined && shouldRetryWithStringInput(error)) {
+            return await (0, gambit_core_1.runDeck)({
+                path: args.path,
+                input: "",
+                inputProvided: true,
+                modelProvider: args.modelProvider,
+                state: args.state,
+                allowRootStringInput: args.allowRootStringInput,
+                initialUserMessage: args.initialUserMessage,
+                onStateUpdate: args.onStateUpdate,
+                stream: args.stream,
+                onStreamText: args.onStreamText,
+                responsesMode: args.responsesMode,
+                workerSandbox,
+                signal: args.signal,
+                onCancel: args.onCancel,
+            });
+        }
+        throw error;
+    }
+}

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

@@ -0,0 +1,8 @@
+import type { SavedState } from "@bolt-foundry/gambit-core";
+import type { TestBotRunStatus } from "./types.js";
+export declare const readPersistedTestRunStatusById: (sessionState: SavedState, workspaceId: string, requestedRunId: string) => TestBotRunStatus | null;
+export declare const listPersistedTestRunStatuses: (sessionState: SavedState, workspaceId: string) => Array<TestBotRunStatus>;
+export declare const listScenarioRunStatusesFromStateMeta: (sessionState: SavedState, workspaceId: string) => Array<TestBotRunStatus>;
+export declare const isFeedbackEligibleMessageRef: (state: SavedState, messageRefId: string) => boolean;
+export declare const isFeedbackEligiblePersistedTestRunMessageRef: (state: SavedState, runId: string, messageRefId: string) => boolean;
+//# sourceMappingURL=scenario_history.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scenario_history.d.ts","sourceRoot":"","sources":["../../../../src/src/server/workspace/scenario_history.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEV,UAAU,EAEX,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAwDnD,eAAO,MAAM,8BAA8B,GACzC,cAAc,UAAU,EACxB,aAAa,MAAM,EACnB,gBAAgB,MAAM,KACrB,gBAAgB,GAAG,IAiCrB,CAAC;AAEF,eAAO,MAAM,4BAA4B,GACvC,cAAc,UAAU,EACxB,aAAa,MAAM,KAClB,KAAK,CAAC,gBAAgB,CAiCxB,CAAC;AAEF,eAAO,MAAM,oCAAoC,GAC/C,cAAc,UAAU,EACxB,aAAa,MAAM,KAClB,KAAK,CAAC,gBAAgB,CAyExB,CAAC;AAgBF,eAAO,MAAM,4BAA4B,GACvC,OAAO,UAAU,EACjB,cAAc,MAAM,KACnB,OAMF,CAAC;AAEF,eAAO,MAAM,4CAA4C,GACvD,OAAO,UAAU,EACjB,OAAO,MAAM,EACb,cAAc,MAAM,KACnB,OAgDF,CAAC"}

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

@@ -0,0 +1,310 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFeedbackEligiblePersistedTestRunMessageRef = exports.isFeedbackEligibleMessageRef = exports.listScenarioRunStatusesFromStateMeta = exports.listPersistedTestRunStatuses = exports.readPersistedTestRunStatusById = void 0;
+const dntShim = __importStar(require("../../../_dnt.shims.js"));
+const helpers_js_1 = require("./helpers.js");
+const extractPersistedWorkspacePayload = (record) => {
+    const type = record.type;
+    if (type !== "build" && type !== "test" && type !== "grade" &&
+        type !== "session") {
+        return record;
+    }
+    const nested = record.data;
+    if (!nested || typeof nested !== "object" || Array.isArray(nested)) {
+        return record;
+    }
+    return nested;
+};
+const normalizePersistedTestRunStatus = (value, workspaceId) => {
+    if (!value || typeof value !== "object")
+        return null;
+    const raw = value;
+    const id = typeof raw.id === "string" ? raw.id : "";
+    if (!id)
+        return null;
+    const rawStatus = raw.status;
+    const status = rawStatus === "running" || rawStatus === "completed" ||
+        rawStatus === "error" || rawStatus === "canceled"
+        ? rawStatus
+        : "idle";
+    return {
+        id,
+        status,
+        workspaceId: typeof raw.workspaceId === "string"
+            ? raw.workspaceId
+            : workspaceId,
+        sessionId: typeof raw.sessionId === "string" ? raw.sessionId : workspaceId,
+        error: typeof raw.error === "string" ? raw.error : undefined,
+        startedAt: typeof raw.startedAt === "string" ? raw.startedAt : undefined,
+        finishedAt: typeof raw.finishedAt === "string" ? raw.finishedAt : undefined,
+        maxTurns: typeof raw.maxTurns === "number" && Number.isFinite(raw.maxTurns)
+            ? raw.maxTurns
+            : undefined,
+        messages: Array.isArray(raw.messages)
+            ? raw.messages
+            : [],
+        traces: Array.isArray(raw.traces) ? raw.traces : [],
+        toolInserts: Array.isArray(raw.toolInserts)
+            ? raw.toolInserts
+            : [],
+    };
+};
+const readPersistedTestRunStatusById = (sessionState, workspaceId, requestedRunId) => {
+    const eventsPath = typeof sessionState.meta?.sessionEventsPath === "string"
+        ? sessionState.meta.sessionEventsPath
+        : undefined;
+    if (!eventsPath)
+        return null;
+    try {
+        const text = dntShim.Deno.readTextFileSync(eventsPath);
+        let latest = null;
+        for (const line of text.split("\n")) {
+            if (!line.trim())
+                continue;
+            let parsed = null;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!parsed || typeof parsed !== "object")
+                continue;
+            const payload = extractPersistedWorkspacePayload(parsed);
+            if (payload.type !== "testBotStatus" &&
+                payload.type !== "gambit.test.status")
+                continue;
+            const normalized = normalizePersistedTestRunStatus(payload.run, workspaceId);
+            if (!normalized || normalized.id !== requestedRunId)
+                continue;
+            latest = normalized;
+        }
+        return latest;
+    }
+    catch {
+        return null;
+    }
+};
+exports.readPersistedTestRunStatusById = readPersistedTestRunStatusById;
+const listPersistedTestRunStatuses = (sessionState, workspaceId) => {
+    const eventsPath = typeof sessionState.meta?.sessionEventsPath === "string"
+        ? sessionState.meta.sessionEventsPath
+        : undefined;
+    if (!eventsPath)
+        return [];
+    try {
+        const text = dntShim.Deno.readTextFileSync(eventsPath);
+        const latestByRunId = new Map();
+        for (const line of text.split("\n")) {
+            if (!line.trim())
+                continue;
+            let parsed = null;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!parsed || typeof parsed !== "object")
+                continue;
+            const payload = extractPersistedWorkspacePayload(parsed);
+            if (payload.type !== "testBotStatus" &&
+                payload.type !== "gambit.test.status")
+                continue;
+            const normalized = normalizePersistedTestRunStatus(payload.run, workspaceId);
+            if (!normalized || !normalized.id)
+                continue;
+            latestByRunId.set(normalized.id, normalized);
+        }
+        return [...latestByRunId.values()];
+    }
+    catch {
+        return [];
+    }
+};
+exports.listPersistedTestRunStatuses = listPersistedTestRunStatuses;
+const listScenarioRunStatusesFromStateMeta = (sessionState, workspaceId) => {
+    const meta = sessionState.meta && typeof sessionState.meta === "object"
+        ? sessionState.meta
+        : null;
+    if (!meta)
+        return [];
+    const runsById = new Map();
+    const upsertPlaceholder = (runId, updatedAt) => {
+        if (!runId || runsById.has(runId))
+            return;
+        runsById.set(runId, {
+            id: runId,
+            status: "completed",
+            workspaceId,
+            sessionId: workspaceId,
+            startedAt: updatedAt,
+            finishedAt: updatedAt,
+            messages: [],
+            traces: [],
+            toolInserts: [],
+        });
+    };
+    const primaryRunId = typeof meta.scenarioRunId === "string" &&
+        meta.scenarioRunId.trim().length > 0
+        ? meta.scenarioRunId.trim()
+        : typeof meta.testBotRunId === "string" &&
+            meta.testBotRunId.trim().length > 0
+            ? meta.testBotRunId.trim()
+            : null;
+    if (primaryRunId) {
+        const primary = {
+            id: primaryRunId,
+            status: "idle",
+            workspaceId,
+            sessionId: workspaceId,
+            startedAt: typeof meta.startedAt === "string"
+                ? meta.startedAt
+                : undefined,
+            finishedAt: typeof meta.finishedAt === "string"
+                ? meta.finishedAt
+                : undefined,
+            messages: [],
+            traces: [],
+            toolInserts: [],
+        };
+        (0, helpers_js_1.syncTestBotRunFromState)(primary, sessionState);
+        if (primary.messages.length > 0 && primary.status === "idle") {
+            primary.status = "completed";
+        }
+        runsById.set(primary.id, primary);
+    }
+    const summaryValues = [
+        meta.scenarioRunSummary,
+        ...(Array.isArray(meta.scenarioRunSummaries)
+            ? meta.scenarioRunSummaries
+            : []),
+    ];
+    for (const value of summaryValues) {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            continue;
+        const summary = value;
+        const summaryRunId = typeof summary.scenarioRunId === "string" &&
+            summary.scenarioRunId.trim().length > 0
+            ? summary.scenarioRunId.trim()
+            : null;
+        if (!summaryRunId)
+            continue;
+        const updatedAt = typeof summary.updatedAt === "string"
+            ? summary.updatedAt
+            : undefined;
+        upsertPlaceholder(summaryRunId, updatedAt);
+    }
+    return [...runsById.values()];
+};
+exports.listScenarioRunStatusesFromStateMeta = listScenarioRunStatusesFromStateMeta;
+const resolveMessageByRef = (state, messageRefId) => {
+    const refs = Array.isArray(state.messageRefs) ? state.messageRefs : [];
+    const messages = Array.isArray(state.messages) ? state.messages : [];
+    const idx = refs.findIndex((ref) => ref?.id === messageRefId);
+    if (idx < 0)
+        return {};
+    return {
+        message: messages[idx],
+        ref: refs[idx],
+    };
+};
+const isFeedbackEligibleMessageRef = (state, messageRefId) => {
+    const { message, ref } = resolveMessageByRef(state, messageRefId);
+    if (!message)
+        return false;
+    if (message.role === "assistant")
+        return true;
+    if (message.role === "user" && ref?.source === "scenario")
+        return true;
+    return (0, helpers_js_1.summarizeRespondCall)(message) !== null;
+};
+exports.isFeedbackEligibleMessageRef = isFeedbackEligibleMessageRef;
+const isFeedbackEligiblePersistedTestRunMessageRef = (state, runId, messageRefId) => {
+    const eventsPath = typeof state.meta?.sessionEventsPath === "string"
+        ? state.meta.sessionEventsPath
+        : undefined;
+    if (!eventsPath)
+        return false;
+    try {
+        const text = dntShim.Deno.readTextFileSync(eventsPath);
+        for (const line of text.split("\n")) {
+            if (!line.trim())
+                continue;
+            let parsed = null;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!parsed || typeof parsed !== "object")
+                continue;
+            const payload = extractPersistedWorkspacePayload(parsed);
+            if (payload.type !== "testBotStatus" &&
+                payload.type !== "gambit.test.status") {
+                continue;
+            }
+            const run = payload.run;
+            if (!run || typeof run !== "object")
+                continue;
+            const runRecord = run;
+            if (typeof runRecord.id !== "string" || runRecord.id !== runId) {
+                continue;
+            }
+            if (!Array.isArray(runRecord.messages))
+                continue;
+            const found = runRecord.messages.some((entry) => {
+                if (!entry || typeof entry !== "object")
+                    return false;
+                const message = entry;
+                if (message.messageRefId !== messageRefId)
+                    return false;
+                if (message.role === "assistant")
+                    return true;
+                return message.role === "user" &&
+                    message.messageSource === "scenario";
+            });
+            if (found)
+                return true;
+        }
+    }
+    catch {
+        return false;
+    }
+    return false;
+};
+exports.isFeedbackEligiblePersistedTestRunMessageRef = isFeedbackEligiblePersistedTestRunMessageRef;