@tangle-network/agent-provider-cli-bridge 0.7.0 → 0.7.2

package/README.md

@@ -49,6 +49,9 @@ Passing the same `sessionId` on later turns continues the same CLI conversation.
 `dispatch()` starts a bridge-owned durable run and returns after detaching its HTTP reader.
 The returned `AgentSession` exposes status, cursor-based event replay, the terminal result, continuation, and cancellation.
 Cancellation returns only after cli-bridge confirms the run is terminal.
+A direct stream treats a finish frame as provisional until cli-bridge returns the same run's aggregate result.
+A retained replay confirms its terminal state from the retained run endpoint.
+The provider rejects a terminal response when its run id or request digest does not match the accepted stream.
 Usage events and terminal result metadata include `modelRequests` only when the bridge measured an exact non-negative integer count.
 Missing, malformed, partial, or estimated request counts remain unknown.
 When `dispatch()` receives no `sessionId`, it creates one from that turn's stable run id and returns it.

package/dist/retained-execution.js

@@ -27,7 +27,7 @@ export async function* streamTrackedCliBridgeTurn(options, environmentInput, pre
     let drained = false;
     let threw = false;
     try {
-        for await (const event of streamCliBridgeTurn(options, turn, run.requestBody, transport, run.id, originalTurn.lastEventId, signal, (response) => captureCliBridgeRunIdentity(response, run, false))) {
+        for await (const event of streamCliBridgeTurn(options, turn, run.requestBody, transport, run.id, originalTurn.lastEventId, signal, (response) => captureCliBridgeRunIdentity(response, run, true), () => getCliBridgeRun(options, transport, run, 30_000, signal))) {
             yield event;
         }
         drained = true;
@@ -171,7 +171,7 @@ export async function* streamCliBridgeSessionEvents(options, environmentInput, r
             ...(run.sessionId ? { sessionId: run.sessionId } : {}),
             executionId: run.executionId,
             turnId: run.turnId,
-        }, undefined, transport, run.id, eventOptions?.since ?? "0", signal, (response) => captureCliBridgeRunIdentity(response, run, false));
+        }, undefined, transport, run.id, eventOptions?.since ?? "0", signal, (response) => captureCliBridgeRunIdentity(response, run, false), () => getCliBridgeRun(options, transport, run, 30_000, signal));
         drained = true;
         if (runs.get(run.id) === run)
             runs.delete(run.id);

package/dist/retained-stream.d.ts

@@ -1,8 +1,9 @@
 import type { AgentEnvironmentEvent, AgentTurnInput } from "@tangle-network/agent-interface/environment-provider";
 import type { CliBridgeProviderOptions } from "./provider-options.js";
+import type { CliBridgeRunSnapshot } from "./retained-run-state.js";
 import type { CliBridgeResponse, CliBridgeTransport } from "./transport.js";
 export declare class CliBridgeRequestRejectedError extends Error {
     readonly status: number;
     constructor(status: number, detail: string);
 }
-export declare function streamCliBridgeTurn(options: CliBridgeProviderOptions, turn: AgentTurnInput, requestBody: string | undefined, transport: CliBridgeTransport, runId: string, lastEventId?: string, signal?: AbortSignal, onAccepted?: (response: CliBridgeResponse) => void): AsyncIterable<AgentEnvironmentEvent>;
+export declare function streamCliBridgeTurn(options: CliBridgeProviderOptions, turn: AgentTurnInput, requestBody: string | undefined, transport: CliBridgeTransport, runId: string, lastEventId?: string, signal?: AbortSignal, onResponse?: (response: CliBridgeResponse) => void, readAuthoritativeRun?: () => Promise<CliBridgeRunSnapshot | null>): AsyncIterable<AgentEnvironmentEvent>;

package/dist/retained-stream.js

@@ -1,4 +1,5 @@
 import { retainedEventsWithIdentity, retainedReplayRequest, } from "./retained-event-cursor.js";
+import { detachCliBridgeReader } from "./retained-control.js";
 import { requestHeaders, trimSlash } from "./transport.js";
 import { modelRequestsFromOpenAi, parseSse, responseIdentityFromOpenAi, safeJson, toolCallsFromDelta, usageFromOpenAi, } from "./wire.js";
 export class CliBridgeRequestRejectedError extends Error {
@@ -17,7 +18,7 @@ class CliBridgeRunCancelledError extends Error {
         this.name = "CliBridgeRunCancelledError";
     }
 }
-export async function* streamCliBridgeTurn(options, turn, requestBody, transport, runId, lastEventId, signal, onAccepted) {
+export async function* streamCliBridgeTurn(options, turn, requestBody, transport, runId, lastEventId, signal, onResponse, readAuthoritativeRun) {
     const reconnect = requestBody === undefined;
     const replay = retainedReplayRequest(lastEventId);
     const response = await transport.fetch(reconnect
@@ -45,9 +46,20 @@ export async function* streamCliBridgeTurn(options, turn, requestBody, transport
         }
         throw new CliBridgeRequestRejectedError(response.status, detail);
     }
-    onAccepted?.(response);
     if (!response.body)
         throw new Error("cli-bridge response body is empty");
+    try {
+        onResponse?.(response);
+    }
+    catch (error) {
+        try {
+            await detachCliBridgeReader(response.body);
+        }
+        catch (detachError) {
+            throw new AggregateError([error, detachError], `cli-bridge rejected response identity for run "${runId}" and could not detach its reader`);
+        }
+        throw error;
+    }
     let text = "";
     const sessionId = turn.sessionId ?? runId;
     const messageId = turn.turnId ?? `${sessionId}:assistant`;
@@ -59,10 +71,10 @@ export async function* streamCliBridgeTurn(options, turn, requestBody, transport
     let servedModel;
     let systemFingerprint;
     let textBoundaryPending = false;
-    let terminalCursor;
     let sawProtocolEnd = false;
     let terminalFrameSeen = false;
     let cancelledTerminalSeen = false;
+    let terminalFrame;
     for await (const frame of parseSse(response.body)) {
         if (frame.data === "[DONE]") {
             sawProtocolEnd = true;
@@ -198,95 +210,160 @@ export async function* streamCliBridgeTurn(options, turn, requestBody, transport
                 throw new Error("cli-bridge returned finish_reason=error");
             }
             completed = true;
-            if (lastEventId && requestBody !== undefined) {
-                terminalCursor = frame.id === undefined
-                    ? undefined
-                    : `${frame.id}:${frameEvents.length}`;
-            }
-            else {
-                frameEvents.push({
-                    type: "result",
-                    data: {
-                        finalText: text,
-                        finishReason: choice.finish_reason,
-                        status: "completed",
-                        ...identityData,
-                        ...(modelRequestsKnown ? { modelRequests: observedModelRequests } : {}),
-                    },
-                });
-            }
+            terminalFrame = {
+                ...(frame.id === undefined ? {} : { id: frame.id }),
+                events: frameEvents,
+                finishReason: choice.finish_reason,
+            };
+            continue;
         }
         yield* retainedEventsWithIdentity(frameEvents, frame.id, runId, sessionId, turn.executionId, replay.anchor);
     }
     if (!sawProtocolEnd) {
         throw new Error("cli-bridge stream ended without the [DONE] protocol marker");
     }
+    if (cancelledTerminalSeen)
+        return;
     if (!completed && lastEventId === undefined) {
+        let snapshot;
+        try {
+            snapshot = await terminalRunSnapshot(runId, readAuthoritativeRun);
+        }
+        catch (error) {
+            throw new Error("cli-bridge stream ended without a terminal result", {
+                cause: error,
+            });
+        }
+        if (snapshot.status === "cancelled") {
+            const event = cancelledEvent(`cli-bridge run "${runId}" was cancelled`);
+            yield {
+                ...event,
+                data: {
+                    ...event.data,
+                    runId,
+                    sessionId,
+                    ...(turn.executionId === undefined
+                        ? {}
+                        : { executionId: turn.executionId }),
+                },
+            };
+            return;
+        }
         throw new Error("cli-bridge stream ended without a terminal result");
     }
-    if (lastEventId && requestBody !== undefined && !cancelledTerminalSeen) {
+    if (!terminalFrame) {
+        if (requestBody !== undefined && lastEventId !== undefined) {
+            try {
+                await readFullCliBridgeResult(options, requestBody, transport, signal, onResponse);
+            }
+            catch (error) {
+                if (error instanceof CliBridgeRunCancelledError)
+                    return;
+                throw error;
+            }
+        }
+        else if (requestBody === undefined) {
+            await terminalRunSnapshot(runId, readAuthoritativeRun);
+        }
+        return;
+    }
+    let terminalEvent;
+    let terminalFailure;
+    if (requestBody !== undefined) {
         let result;
         try {
-            result = await readFullCliBridgeResult(options, requestBody, transport, signal, onAccepted);
+            result = await readFullCliBridgeResult(options, requestBody, transport, signal, onResponse);
         }
         catch (error) {
             if (error instanceof CliBridgeRunCancelledError) {
-                // A normal finish frame can race with the bridge's authoritative
-                // cancelled state. Replace the withheld result at the same cursor.
-                if (terminalCursor !== undefined) {
-                    yield {
-                        type: "status",
-                        data: {
-                            status: "cancelled",
-                            error: error.detail,
-                            runId,
-                            sessionId,
-                            ...(turn.executionId === undefined
-                                ? {}
-                                : { executionId: turn.executionId }),
-                            cursor: terminalCursor,
-                        },
-                        normalized: {
-                            type: "status",
-                            status: "cancelled",
-                            detail: error.detail,
-                        },
-                        id: terminalCursor,
-                    };
-                }
-                // If no new terminal frame followed the requested cursor, the caller
-                // already consumed the cancellation event. Do not duplicate it.
-                return;
+                terminalEvent = cancelledEvent(error.detail);
+            }
+            else {
+                throw error;
             }
-            throw error;
         }
-        const finalModelRequests = result.modelRequests ??
-            (modelRequestsKnown ? observedModelRequests : undefined);
-        const finalCursor = terminalCursor ?? lastEventId;
-        yield {
-            type: "result",
-            data: {
-                finalText: result.text,
-                finishReason: result.finishReason,
-                status: "completed",
-                ...(result.model === undefined ? {} : { model: result.model }),
-                ...(result.system_fingerprint === undefined
-                    ? {}
-                    : { system_fingerprint: result.system_fingerprint }),
-                runId,
-                sessionId,
-                ...(turn.executionId === undefined ? {} : { executionId: turn.executionId }),
-                ...(finalCursor === undefined ? {} : { cursor: finalCursor }),
-                ...(finalModelRequests === undefined
-                    ? {}
-                    : { modelRequests: finalModelRequests }),
-            },
-            ...(result.usage && !sawUsage ? { usage: result.usage } : {}),
-            ...(finalCursor === undefined ? {} : { id: finalCursor }),
-        };
+        if (result !== undefined) {
+            const finalModelRequests = result.modelRequests ??
+                (modelRequestsKnown ? observedModelRequests : undefined);
+            terminalEvent = {
+                type: "result",
+                data: {
+                    finalText: lastEventId === undefined ? text : result.text,
+                    finishReason: lastEventId === undefined ? terminalFrame.finishReason : result.finishReason,
+                    status: "completed",
+                    ...(result.model === undefined ? {} : { model: result.model }),
+                    ...(result.system_fingerprint === undefined
+                        ? {}
+                        : { system_fingerprint: result.system_fingerprint }),
+                    ...(finalModelRequests === undefined
+                        ? {}
+                        : { modelRequests: finalModelRequests }),
+                },
+                ...(result.usage && !sawUsage ? { usage: result.usage } : {}),
+            };
+        }
+    }
+    else {
+        const snapshot = await terminalRunSnapshot(runId, readAuthoritativeRun);
+        if (snapshot.status === "cancelled") {
+            terminalEvent = cancelledEvent(`cli-bridge run "${runId}" was cancelled`);
+        }
+        else if (snapshot.status === "error") {
+            const detail = `cli-bridge run "${runId}" ended with an error`;
+            terminalEvent = failedEvent(detail);
+            terminalFailure = new Error(detail);
+        }
+        else {
+            terminalEvent = {
+                type: "result",
+                data: {
+                    finalText: text,
+                    finishReason: terminalFrame.finishReason,
+                    status: "completed",
+                    ...(servedModel === undefined ? {} : { model: servedModel }),
+                    ...(systemFingerprint === undefined
+                        ? {}
+                        : { system_fingerprint: systemFingerprint }),
+                    ...(modelRequestsKnown ? { modelRequests: observedModelRequests } : {}),
+                },
+            };
+        }
+    }
+    if (!terminalEvent) {
+        throw new Error("cli-bridge terminal state did not produce a terminal event");
+    }
+    terminalFrame.events.push(terminalEvent);
+    yield* retainedEventsWithIdentity(terminalFrame.events, terminalFrame.id, runId, sessionId, turn.executionId, replay.anchor);
+    if (terminalFailure)
+        throw terminalFailure;
+}
+async function terminalRunSnapshot(runId, readAuthoritativeRun) {
+    if (!readAuthoritativeRun) {
+        throw new Error("cli-bridge retained stream omitted authoritative run status");
+    }
+    const snapshot = await readAuthoritativeRun();
+    if (!snapshot)
+        throw new Error(`cli-bridge lost run "${runId}" before terminal replay`);
+    if (!snapshot.terminal || snapshot.status === "running") {
+        throw new Error(`cli-bridge run "${runId}" remained active after its stream ended`);
     }
+    return snapshot;
+}
+function cancelledEvent(detail) {
+    return {
+        type: "status",
+        data: { status: "cancelled", error: detail },
+        normalized: { type: "status", status: "cancelled", detail },
+    };
+}
+function failedEvent(detail) {
+    return {
+        type: "status",
+        data: { status: "failed", error: detail },
+        normalized: { type: "status", status: "failed", detail },
+    };
 }
-async function readFullCliBridgeResult(options, requestBody, transport, signal, onAccepted) {
+async function readFullCliBridgeResult(options, requestBody, transport, signal, onResponse) {
     const body = safeJson(requestBody);
     if (!body)
         throw new Error("cli-bridge replay request is not valid JSON");
@@ -296,16 +373,16 @@ async function readFullCliBridgeResult(options, requestBody, transport, signal,
         body: JSON.stringify({ ...body, stream: false }),
         ...(signal ? { signal } : {}),
     });
+    const responseText = await response.text();
+    onResponse?.(response);
     if (!response.ok) {
-        const responseText = await response.text();
         const error = cliBridgeError(safeJson(responseText));
         if (error?.type === "run_cancelled") {
             throw new CliBridgeRunCancelledError(cliBridgeErrorMessage(error));
         }
         throw new Error(`cli-bridge replay result ${response.status}: ${responseText}`);
     }
-    onAccepted?.(response);
-    const parsed = safeJson(await response.text());
+    const parsed = safeJson(responseText);
     const error = cliBridgeError(parsed);
     if (error) {
         if (error.type === "run_cancelled") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-provider-cli-bridge",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "AgentEnvironmentProvider adapter for cli-bridge /v1/chat/completions",
   "type": "module",
   "license": "MIT",
@@ -49,7 +49,7 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@tangle-network/agent-interface": "0.52.0",
+    "@tangle-network/agent-interface": "0.53.0",
     "undici": "7.29.0"
   },
   "devDependencies": {