@bolt-foundry/gambit 0.6.8 → 0.8.0

package/script/src/server.js

@@ -98,6 +98,87 @@ function randomId(prefix) {
     const suffix = crypto.randomUUID().replace(/-/g, "").slice(0, 24);
     return `${prefix}-${suffix}`;
 }
+async function parseOpenResponseRequest(req) {
+    try {
+        return await req.json();
+    }
+    catch {
+        return null;
+    }
+}
+function formatOpenResponseSseEvent(event) {
+    return `event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`;
+}
+function formatOpenResponseDoneEvent() {
+    return "data: [DONE]\n\n";
+}
+function createOpenResponseStream(req, provider, payload) {
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+        start(controller) {
+            let closed = false;
+            let completed = false;
+            const close = () => {
+                if (closed)
+                    return;
+                closed = true;
+                controller.close();
+            };
+            const send = (chunk) => {
+                if (closed)
+                    return;
+                controller.enqueue(encoder.encode(chunk));
+            };
+            const sendDone = () => {
+                if (closed)
+                    return;
+                send(formatOpenResponseDoneEvent());
+                close();
+            };
+            const sendEvent = (event) => {
+                if (closed)
+                    return;
+                send(formatOpenResponseSseEvent(event));
+                if (event.type === "response.completed") {
+                    completed = true;
+                    sendDone();
+                }
+            };
+            req.signal.addEventListener("abort", () => {
+                close();
+            });
+            (async () => {
+                try {
+                    const response = await provider.responses({
+                        ...payload,
+                        stream: true,
+                        onStreamEvent: sendEvent,
+                    });
+                    if (!completed) {
+                        sendEvent({ type: "response.completed", response });
+                        sendDone();
+                    }
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    sendEvent({
+                        type: "error",
+                        error: { code: "server_error", message },
+                    });
+                    sendDone();
+                }
+            })();
+        },
+    });
+    return new Response(stream, {
+        status: 200,
+        headers: {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+        },
+    });
+}
 function resolveDefaultValue(raw) {
     if (typeof raw === "function") {
         try {
@@ -565,6 +646,12 @@ function startWebSocketSimulator(opts) {
             return "";
         if (typeof value === "string")
             return value;
+        if (Array.isArray(value)) {
+            return value
+                .map((part) => typeof part === "string" ? part : part.text ??
+                "")
+                .join("");
+        }
         try {
             return JSON.stringify(value);
         }
@@ -624,7 +711,8 @@ function startWebSocketSimulator(opts) {
         const fallbackToolInserts = [];
         for (let i = 0; i < rawMessages.length; i++) {
             const msg = rawMessages[i];
-            if (msg?.role === "assistant" || msg?.role === "user") {
+            if (msg?.type === "message" &&
+                (msg.role === "assistant" || msg.role === "user")) {
                 const content = stringifyContent(msg.content).trim();
                 if (!content)
                     continue;
@@ -637,7 +725,7 @@ function startWebSocketSimulator(opts) {
                 });
                 continue;
             }
-            if (msg?.role === "tool") {
+            if (msg?.type === "message" && msg.role === "tool") {
                 const actionCallId = typeof msg.tool_call_id === "string"
                     ? msg.tool_call_id
                     : undefined;
@@ -773,7 +861,7 @@ function startWebSocketSimulator(opts) {
         const getLastAssistantMessage = (history) => {
             for (let i = history.length - 1; i >= 0; i--) {
                 const msg = history[i];
-                if (msg?.role === "assistant") {
+                if (msg?.type === "message" && msg.role === "assistant") {
                     return stringifyContent(msg.content);
                 }
             }
@@ -1036,6 +1124,43 @@ function startWebSocketSimulator(opts) {
     }
     const server = dntShim.Deno.serve({ port, signal: opts.signal, onListen: () => { } }, async (req) => {
         const url = new URL(req.url);
+        if (url.pathname === "/v1/responses") {
+            if (req.method !== "POST") {
+                return new Response("Method not allowed", { status: 405 });
+            }
+            const payload = await parseOpenResponseRequest(req);
+            if (!payload) {
+                return new Response("Invalid JSON payload", { status: 400 });
+            }
+            const model = payload.model ?? opts.model;
+            if (!model) {
+                return new Response("Missing model", { status: 400 });
+            }
+            const requestPayload = {
+                ...payload,
+                model,
+                input: payload.input ?? null,
+            };
+            if (payload.stream) {
+                return createOpenResponseStream(req, opts.modelProvider, requestPayload);
+            }
+            try {
+                const response = await opts.modelProvider.responses({
+                    ...requestPayload,
+                    stream: false,
+                });
+                return new Response(JSON.stringify(response), {
+                    headers: { "content-type": "application/json" },
+                });
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return new Response(JSON.stringify({ error: message }), {
+                    status: 500,
+                    headers: { "content-type": "application/json" },
+                });
+            }
+        }
         if (url.pathname.startsWith("/api/durable-streams/stream/")) {
             return (0, durable_streams_js_1.handleDurableStreamRequest)(req);
         }
@@ -1086,7 +1211,9 @@ function startWebSocketSimulator(opts) {
                 })();
                 const sessionPayload = {
                     messages: Array.isArray(sessionState.messages)
-                        ? sessionState.messages.map((msg) => ({
+                        ? sessionState.messages
+                            .filter((msg) => msg.type === "message")
+                            .map((msg) => ({
                             role: msg.role,
                             content: msg.content,
                             name: msg.name,
@@ -1241,6 +1368,124 @@ function startWebSocketSimulator(opts) {
                 }), { status: 400, headers: { "content-type": "application/json" } });
             }
         }
+        if (url.pathname === "/api/calibrate/flag") {
+            if (req.method !== "POST") {
+                return new Response("Method not allowed", { status: 405 });
+            }
+            try {
+                const body = await req.json();
+                if (!body.sessionId || !body.refId) {
+                    throw new Error("Missing sessionId or refId");
+                }
+                const state = readSessionState(body.sessionId);
+                if (!state) {
+                    throw new Error("Session not found");
+                }
+                const meta = (state.meta && typeof state.meta === "object")
+                    ? { ...state.meta }
+                    : {};
+                const existingFlags = Array.isArray(meta.gradingFlags)
+                    ? (meta.gradingFlags)
+                    : [];
+                const flagIndex = existingFlags.findIndex((flag) => flag?.refId === body.refId);
+                let nextFlags;
+                let flagged = false;
+                if (flagIndex >= 0) {
+                    nextFlags = existingFlags.filter((_, idx) => idx !== flagIndex);
+                    flagged = false;
+                }
+                else {
+                    const now = new Date().toISOString();
+                    nextFlags = [
+                        ...existingFlags,
+                        {
+                            id: randomId("flag"),
+                            refId: body.refId,
+                            runId: body.runId,
+                            turnIndex: body.turnIndex,
+                            reason: body.reason?.trim() || undefined,
+                            createdAt: now,
+                        },
+                    ];
+                    flagged = true;
+                }
+                const updated = persistSessionState({
+                    ...state,
+                    meta: {
+                        ...meta,
+                        gradingFlags: nextFlags,
+                    },
+                });
+                const sessionMeta = buildSessionMeta(body.sessionId, updated);
+                (0, durable_streams_js_1.appendDurableStreamEvent)(CALIBRATE_STREAM_ID, {
+                    type: "calibrateSession",
+                    sessionId: body.sessionId,
+                    session: sessionMeta,
+                });
+                return new Response(JSON.stringify({
+                    sessionId: body.sessionId,
+                    flagged,
+                    flags: nextFlags,
+                }), { headers: { "content-type": "application/json" } });
+            }
+            catch (err) {
+                return new Response(JSON.stringify({
+                    error: err instanceof Error ? err.message : String(err),
+                }), { status: 400, headers: { "content-type": "application/json" } });
+            }
+        }
+        if (url.pathname === "/api/calibrate/flag/reason") {
+            if (req.method !== "POST") {
+                return new Response("Method not allowed", { status: 405 });
+            }
+            try {
+                const body = await req.json();
+                if (!body.sessionId || !body.refId) {
+                    throw new Error("Missing sessionId or refId");
+                }
+                const state = readSessionState(body.sessionId);
+                if (!state) {
+                    throw new Error("Session not found");
+                }
+                const meta = (state.meta && typeof state.meta === "object")
+                    ? { ...state.meta }
+                    : {};
+                const existingFlags = Array.isArray(meta.gradingFlags)
+                    ? (meta.gradingFlags)
+                    : [];
+                const flagIndex = existingFlags.findIndex((flag) => flag?.refId === body.refId);
+                if (flagIndex < 0) {
+                    throw new Error("Flag not found");
+                }
+                const updatedFlag = {
+                    ...existingFlags[flagIndex],
+                    reason: body.reason?.trim() || undefined,
+                };
+                const nextFlags = existingFlags.map((flag, idx) => idx === flagIndex ? updatedFlag : flag);
+                const updated = persistSessionState({
+                    ...state,
+                    meta: {
+                        ...meta,
+                        gradingFlags: nextFlags,
+                    },
+                });
+                const sessionMeta = buildSessionMeta(body.sessionId, updated);
+                (0, durable_streams_js_1.appendDurableStreamEvent)(CALIBRATE_STREAM_ID, {
+                    type: "calibrateSession",
+                    sessionId: body.sessionId,
+                    session: sessionMeta,
+                });
+                return new Response(JSON.stringify({
+                    sessionId: body.sessionId,
+                    flags: nextFlags,
+                }), { headers: { "content-type": "application/json" } });
+            }
+            catch (err) {
+                return new Response(JSON.stringify({
+                    error: err instanceof Error ? err.message : String(err),
+                }), { status: 400, headers: { "content-type": "application/json" } });
+            }
+        }
         if (url.pathname === "/api/grading/reference") {
             if (req.method !== "POST") {
                 return new Response("Method not allowed", { status: 405 });
@@ -1385,7 +1630,10 @@ function startWebSocketSimulator(opts) {
                 if (typeof body.maxTurns === "number" && Number.isFinite(body.maxTurns)) {
                     maxTurnsOverride = body.maxTurns;
                 }
-                deckInput = body.init;
+                deckInput = body.context ?? body.init;
+                if (body.init !== undefined && body.context === undefined) {
+                    logger.warn('[gambit] Received deprecated "init" field in test-bot API; use "context" instead.');
+                }
                 botInput = body.botInput;
                 await deckLoadPromise.catch(() => null);
                 if (typeof body.botDeckPath === "string") {
@@ -1829,6 +2077,7 @@ function startWebSocketSimulator(opts) {
                 sessionId,
                 messages: state.messages,
                 messageRefs: state.messageRefs,
+                feedback: state.feedback,
                 traces: state.traces,
                 notes: state.notes,
                 meta: state.meta,
@@ -1992,7 +2241,13 @@ function startWebSocketSimulator(opts) {
                             Array.isArray(state.messages)) {
                             const idx = state.messageRefs.findIndex((ref) => ref?.id === messageRefId);
                             if (idx >= 0) {
-                                messageContent = state.messages[idx]?.content;
+                                const item = state.messages[idx];
+                                if (item?.type === "message") {
+                                    messageContent = stringifyContent(item.content);
+                                }
+                                else {
+                                    messageContent = undefined;
+                                }
                             }
                         }
                         items.push({

package/script/src/trace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trace.d.ts","sourceRoot":"","sources":["../../src/src/trace.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAI5D,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAQ7E;AAED,wBAAgB,iBAAiB,IAAI,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAmI/D"}
+{"version":3,"file":"trace.d.ts","sourceRoot":"","sources":["../../src/src/trace.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAI5D,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAQ7E;AAED,wBAAgB,iBAAiB,IAAI,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAsI/D"}

package/script/src/trace.js

@@ -68,7 +68,10 @@ function makeConsoleTracer() {
                 break;
             }
             case "message.user": {
-                logger.log(`[trace] message.user runId=${event.runId} actionCallId=${event.actionCallId} deck=${event.deckPath} content=${JSON.stringify(event.message?.content ?? "")}`);
+                const messageContent = event.message?.type === "message"
+                    ? event.message.content
+                    : event.message;
+                logger.log(`[trace] message.user runId=${event.runId} actionCallId=${event.actionCallId} deck=${event.deckPath} content=${JSON.stringify(messageContent ?? "")}`);
                 break;
             }
             case "deck.start":