@tangle-network/agent-provider-cli-bridge 0.2.26 → 0.2.28

package/README.md

@@ -11,3 +11,6 @@ const provider = createCliBridgeProvider({
   defaultModel: 'codex',
 })
 ```
+
+Response headers and streamed bodies have no transport timeout by default.
+For unattended runs, set `headersTimeoutMs`, `bodyTimeoutMs`, or an `AbortSignal` so an unresponsive bridge cannot wait forever.

package/dist/index.d.ts

@@ -13,6 +13,10 @@ export interface CliBridgeProviderOptions {
         capability?: string;
         ttlSeconds?: number;
     };
+    /** Maximum wait for response headers. Defaults to no timeout. */
+    headersTimeoutMs?: number;
+    /** Maximum idle time between response body chunks. Defaults to no timeout. */
+    bodyTimeoutMs?: number;
     fetch?: typeof fetch;
     name?: string;
     capabilities?: AgentEnvironmentCapabilities;

package/dist/index.js

@@ -1,29 +1,40 @@
+import { Agent, fetch as undiciFetch } from "undici";
 export function createCliBridgeProvider(options) {
-    const fetchImpl = options.fetch ?? globalThis.fetch;
-    if (!fetchImpl)
-        throw new Error("createCliBridgeProvider requires fetch");
+    assertTimeout(options.headersTimeoutMs, "headersTimeoutMs");
+    assertTimeout(options.bodyTimeoutMs, "bodyTimeoutMs");
     const name = options.name ?? "cli-bridge";
     return {
         name,
         capabilities: () => options.capabilities ?? defaultCliBridgeCapabilities(),
         async create(input) {
+            const transport = createTransport(options);
+            let destroyed = false;
+            let closePromise;
             return {
                 id: input.idempotencyKey ?? input.name ?? crypto.randomUUID(),
                 provider: name,
                 ...(input.name ? { name: input.name } : {}),
-                status: async () => "running",
-                stream: (turn) => streamCliBridgeTurn(fetchImpl, options, input, turn),
+                status: async () => (destroyed ? "stopped" : "running"),
+                stream: (turn) => {
+                    if (destroyed)
+                        throw new Error("cli-bridge environment is destroyed");
+                    return streamCliBridgeTurn(options, input, turn, transport);
+                },
                 placement: async () => ({
                     kind: options.defaultExecution?.kind === "sandbox" ? "sandbox" : "local",
                     providerMetadata: { baseUrl: options.baseUrl },
                 }),
-                destroy: async () => { },
+                destroy: () => {
+                    destroyed = true;
+                    closePromise ??= transport.close();
+                    return closePromise;
+                },
             };
         },
     };
 }
-async function* streamCliBridgeTurn(fetchImpl, options, environmentInput, turn) {
-    const response = await fetchImpl(`${trimSlash(options.baseUrl)}/v1/chat/completions`, {
+async function* streamCliBridgeTurn(options, environmentInput, turn, transport) {
+    const response = await transport.fetch(`${trimSlash(options.baseUrl)}/v1/chat/completions`, {
         method: "POST",
         headers: {
             "content-type": "application/json",
@@ -40,10 +51,13 @@ async function* streamCliBridgeTurn(fetchImpl, options, environmentInput, turn)
     if (!response.body)
         throw new Error("cli-bridge response body is empty");
     let text = "";
-    let usage;
+    const sessionId = turn.sessionId ?? environmentInput.idempotencyKey ?? environmentInput.name ?? "cli-bridge";
+    const messageId = turn.turnId ?? `${sessionId}:assistant`;
+    const emittedToolCalls = new Set();
+    let completed = false;
     for await (const event of parseSse(response.body)) {
         if (event === "[DONE]")
-            break;
+            continue;
         const parsed = safeJson(event);
         if (!parsed)
             continue;
@@ -51,35 +65,107 @@ async function* streamCliBridgeTurn(fetchImpl, options, environmentInput, turn)
             const error = parsed.error;
             const message = typeof error.message === "string" ? error.message : "cli-bridge error";
             yield { type: "status", data: { status: "failed", error: message } };
-            return;
+            throw new Error(`cli-bridge: ${message}`);
         }
         const choice = Array.isArray(parsed.choices) ? parsed.choices[0] : undefined;
         const delta = choice?.delta;
         const chunk = delta && typeof delta.content === "string" ? delta.content : "";
         const nextUsage = usageFromOpenAi(parsed.usage);
         if (nextUsage) {
-            usage = mergeUsage(usage, nextUsage);
-            yield { type: "usage", data: { usage: nextUsage }, usage: nextUsage };
+            yield { type: "usage", data: {}, usage: nextUsage };
         }
         if (chunk) {
             text += chunk;
+            const part = {
+                id: `${messageId}:text`,
+                sessionID: sessionId,
+                messageID: messageId,
+                type: "text",
+                text,
+            };
+            const normalized = {
+                type: "message.part.updated",
+                part,
+                delta: chunk,
+            };
+            yield {
+                type: "message.part.updated",
+                data: { part, delta: chunk },
+                normalized,
+            };
+        }
+        for (const toolCall of toolCallsFromDelta(delta)) {
+            const callId = toolCall.id ?? `${messageId}:tool:${toolCall.index}`;
+            if (!toolCall.name || emittedToolCalls.has(callId))
+                continue;
+            emittedToolCalls.add(callId);
+            const part = {
+                id: callId,
+                sessionID: sessionId,
+                messageID: messageId,
+                type: "tool",
+                callID: callId,
+                tool: toolCall.name,
+                state: { status: "pending", input: {} },
+            };
+            const normalized = {
+                type: "message.part.updated",
+                part,
+            };
             yield {
                 type: "message.part.updated",
-                data: { delta: chunk },
+                data: { part },
+                normalized,
             };
         }
         if (choice?.finish_reason) {
+            if (choice.finish_reason === "error") {
+                yield {
+                    type: "status",
+                    data: { status: "failed", error: "cli-bridge returned finish_reason=error" },
+                };
+                throw new Error("cli-bridge returned finish_reason=error");
+            }
+            completed = true;
             yield {
                 type: "result",
                 data: {
                     finalText: text,
                     finishReason: choice.finish_reason,
-                    status: choice.finish_reason === "error" ? "failed" : "completed",
+                    status: "completed",
                 },
-                ...(usage ? { usage } : {}),
             };
         }
     }
+    if (!completed)
+        throw new Error("cli-bridge stream ended without a terminal result");
+}
+function createTransport(options) {
+    if (options.fetch) {
+        const fetch = options.fetch;
+        return {
+            fetch: (input, init) => fetch(input, init),
+            close: async () => { },
+        };
+    }
+    const dispatcher = new Agent({
+        headersTimeout: options.headersTimeoutMs ?? 0,
+        bodyTimeout: options.bodyTimeoutMs ?? 0,
+    });
+    return {
+        fetch: (input, init) => undiciFetch(input, {
+            ...init,
+            dispatcher,
+        }),
+        close: async () => {
+            await dispatcher.close();
+        },
+    };
+}
+function assertTimeout(value, name) {
+    if (value !== undefined && (!Number.isInteger(value) || value < 0)) {
+        throw new Error(`createCliBridgeProvider ${name} must be a non-negative integer`);
+    }
 }
 function toChatCompletionsBody(options, environmentInput, turn) {
     const profile = inlineProfile(environmentInput.profile);
@@ -128,35 +214,35 @@ function executionFromInput(options, input) {
     };
 }
 async function* parseSse(body) {
-    const reader = body.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
-    try {
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            buffer += decoder.decode(value, { stream: true });
-            let boundary = buffer.indexOf("\n\n");
-            while (boundary !== -1) {
-                const frame = buffer.slice(0, boundary);
-                buffer = buffer.slice(boundary + 2);
-                const data = dataFromFrame(frame);
-                if (data !== undefined)
-                    yield data;
-                boundary = buffer.indexOf("\n\n");
-            }
-        }
-        if (buffer) {
-            const data = dataFromFrame(buffer);
+    for await (const value of body) {
+        buffer += decoder.decode(value, { stream: true });
+        let boundary = findFrameBoundary(buffer);
+        while (boundary) {
+            const frame = buffer.slice(0, boundary.index);
+            buffer = buffer.slice(boundary.index + boundary.length);
+            const data = dataFromFrame(frame);
             if (data !== undefined)
                 yield data;
+            boundary = findFrameBoundary(buffer);
         }
     }
-    finally {
-        reader.releaseLock();
+    if (buffer) {
+        const data = dataFromFrame(buffer);
+        if (data !== undefined)
+            yield data;
     }
 }
+function findFrameBoundary(value) {
+    const lf = value.indexOf("\n\n");
+    const crlf = value.indexOf("\r\n\r\n");
+    if (lf === -1 && crlf === -1)
+        return undefined;
+    if (crlf !== -1 && (lf === -1 || crlf < lf))
+        return { index: crlf, length: 4 };
+    return { index: lf, length: 2 };
+}
 function dataFromFrame(frame) {
     const lines = frame.split(/\r?\n/);
     const data = lines
@@ -165,6 +251,25 @@ function dataFromFrame(frame) {
         .join("\n");
     return data || undefined;
 }
+function toolCallsFromDelta(value) {
+    if (!value || typeof value !== "object")
+        return [];
+    const calls = value.tool_calls;
+    if (!Array.isArray(calls))
+        return [];
+    return calls.flatMap((call, position) => {
+        if (!call || typeof call !== "object")
+            return [];
+        const record = call;
+        const fn = record.function;
+        const name = fn && typeof fn === "object" && typeof fn.name === "string"
+            ? fn.name
+            : undefined;
+        const index = number(record.index) ?? position;
+        const id = typeof record.id === "string" ? record.id : undefined;
+        return [{ ...(id ? { id } : {}), index, ...(name ? { name } : {}) }];
+    });
+}
 function safeJson(value) {
     try {
         const parsed = JSON.parse(value);
@@ -182,15 +287,19 @@ function usageFromOpenAi(value) {
     const outputTokens = number(record.completion_tokens) ?? number(record.output_tokens);
     if (inputTokens === undefined && outputTokens === undefined)
         return undefined;
-    return { inputTokens: inputTokens ?? 0, outputTokens: outputTokens ?? 0 };
-}
-function mergeUsage(left, right) {
-    if (!left)
-        return right;
+    const totalTokens = number(record.total_tokens);
+    const cacheReadInputTokens = number(record.cache_read_input_tokens);
+    const cacheCreationInputTokens = number(record.cache_creation_input_tokens);
+    const reasoningTokens = number(record.reasoning_tokens);
+    const cost = number(record.cost);
     return {
-        inputTokens: left.inputTokens + right.inputTokens,
-        outputTokens: left.outputTokens + right.outputTokens,
-        ...(left.cost !== undefined || right.cost !== undefined ? { cost: (left.cost ?? 0) + (right.cost ?? 0) } : {}),
+        inputTokens: inputTokens ?? 0,
+        outputTokens: outputTokens ?? 0,
+        ...(totalTokens !== undefined ? { totalTokens } : {}),
+        ...(cacheReadInputTokens !== undefined ? { cacheReadInputTokens } : {}),
+        ...(cacheCreationInputTokens !== undefined ? { cacheCreationInputTokens } : {}),
+        ...(reasoningTokens !== undefined ? { reasoningTokens } : {}),
+        ...(cost !== undefined ? { cost } : {}),
     };
 }
 function number(value) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-provider-cli-bridge",
-  "version": "0.2.26",
+  "version": "0.2.28",
   "description": "AgentEnvironmentProvider adapter for cli-bridge /v1/chat/completions",
   "type": "module",
   "license": "MIT",
@@ -29,7 +29,8 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@tangle-network/agent-interface": "0.34.0"
+    "@tangle-network/agent-interface": "0.34.0",
+    "undici": "7.28.0"
   },
   "devDependencies": {
     "@types/node": "25.6.0",