@tangle-network/agent-provider-cli-bridge 0.4.2 → 0.5.0

package/README.md

@@ -17,6 +17,22 @@ const environment = await provider.create({
     model: { default: 'gpt-5' },
   },
 })
+
+const reference = await environment.dispatch({
+  prompt: 'inspect the repository',
+  sessionId: 'research-session',
+  executionId: 'research-turn-1',
+})
+const session = environment.session(reference.id)
+
+for await (const event of session.events({ since: '0' })) {
+  // Sequence-numbered bridge events, including normalized usage and result data.
+}
+
+await session.prompt({
+  prompt: 'change direction using the evidence already collected',
+  executionId: 'research-turn-2',
+})
 ```
 
 The bridge model is selected from run data in this order: the turn, the provider default, or the profile's `harness` plus `model.default`.
@@ -24,7 +40,13 @@ Execution fails before network use when none is present.
 
 Passing the same `sessionId` on later turns continues the same CLI conversation.
 `executionId` gives a turn stable bridge identity, and `lastEventId` reattaches after a reader failure.
-Stopping a reader or destroying the environment cancels every active bridge run and waits for terminal confirmation.
+`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.
+When `dispatch()` receives no `sessionId`, it creates one from that turn's stable run id and returns it.
+Replay and result reads fail loudly after cli-bridge's configured replay retention expires.
+Stopping a `session.events()` reader detaches only that replay observer.
+Stopping a direct `environment.stream()` reader or destroying the environment cancels its active bridge runs and waits for terminal confirmation.
 
 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.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { harnessSystemPromptIntents, } from "@tangle-network/agent-interface";
+import { harnessSystemPromptIntents, snapshotAgentProfile, } from "@tangle-network/agent-interface";
 import { Agent, fetch as undiciFetch } from "undici";
 export function createCliBridgeProvider(options) {
     assertTimeout(options.headersTimeoutMs, "headersTimeoutMs");
@@ -10,16 +10,25 @@ export function createCliBridgeProvider(options) {
         name,
         capabilities: () => options.capabilities ?? defaultCliBridgeCapabilities(),
         async create(input) {
+            if (typeof input.profile === "string") {
+                throw new Error(`createCliBridgeProvider requires an inline AgentProfile; named profile "${input.profile}" is unsupported`);
+            }
+            const environmentInput = {
+                ...input,
+                profile: snapshotAgentProfile(input.profile),
+            };
             const transport = createTransport(options);
             const environmentId = input.idempotencyKey ?? crypto.randomUUID();
             const runs = new Map();
+            const sessions = new Map();
             const readers = new Set();
             let destroyed = false;
             let closePromise;
             const stream = async function* (turn) {
                 if (destroyed)
                     throw new Error("cli-bridge environment is destroyed");
-                yield* streamTrackedCliBridgeTurn(options, input, turn, transport, environmentId, runs, readers);
+                const prepared = prepareCliBridgeRun(options, environmentInput, turn, environmentId, false);
+                yield* streamTrackedCliBridgeTurn(options, environmentInput, prepared, transport, runs, sessions, readers);
             };
             const environment = {
                 id: environmentId,
@@ -27,6 +36,26 @@ export function createCliBridgeProvider(options) {
                 ...(input.name ? { name: input.name } : {}),
                 status: async () => (destroyed ? "stopped" : "running"),
                 stream,
+                async dispatch(turn) {
+                    if (destroyed)
+                        throw new Error("cli-bridge environment is destroyed");
+                    const prepared = prepareCliBridgeRun(options, environmentInput, turn, environmentId, true);
+                    return dispatchCliBridgeTurn(options, environmentInput, prepared, transport, name, runs, sessions);
+                },
+                session(id) {
+                    return createCliBridgeSession({
+                        id,
+                        providerName: name,
+                        options,
+                        environmentInput,
+                        environmentId,
+                        transport,
+                        runs,
+                        sessions,
+                        readers,
+                        isDestroyed: () => destroyed,
+                    });
+                },
                 placement: async () => ({
                     kind: options.defaultExecution?.kind === "sandbox" ? "sandbox" : "local",
                     providerMetadata: { baseUrl: options.baseUrl },
@@ -54,6 +83,7 @@ export function createCliBridgeProvider(options) {
                             reader.abort(new DOMException("cli-bridge environment was destroyed", "AbortError"));
                         }
                         await transport.close();
+                        sessions.clear();
                     })();
                     closePromise = attempt;
                     try {
@@ -71,13 +101,63 @@ export function createCliBridgeProvider(options) {
         },
     };
 }
-async function* streamTrackedCliBridgeTurn(options, environmentInput, originalTurn, transport, environmentId, runs, readers) {
+function prepareCliBridgeRun(options, environmentInput, originalTurn, environmentId, requireSession) {
+    const turnId = originalTurn.turnId ?? crypto.randomUUID();
+    const runId = cliBridgeRunId(environmentId, originalTurn, turnId);
+    const sessionId = originalTurn.sessionId ?? (requireSession ? runId : undefined);
+    const turn = {
+        ...originalTurn,
+        turnId,
+        ...(sessionId ? { sessionId } : {}),
+    };
+    return {
+        turn,
+        run: {
+            id: runId,
+            ...(sessionId ? { sessionId } : {}),
+            turnId,
+            requestBody: JSON.stringify(toChatCompletionsBody(options, environmentInput, turn, runId)),
+            readers: new Set(),
+        },
+    };
+}
+function bindCliBridgeRun(prepared, runs) {
+    const previous = runs.get(prepared.id);
+    runs.set(prepared.id, prepared);
+    return previous;
+}
+function restoreCliBridgeRun(run, previous, runs) {
+    if (runs.get(run.id) !== run)
+        return;
+    if (previous) {
+        runs.set(run.id, previous);
+    }
+    else {
+        runs.delete(run.id);
+    }
+}
+function bindCliBridgeSession(run, sessions) {
+    if (!run.sessionId)
+        return undefined;
+    const previous = sessions.get(run.sessionId)?.current;
+    sessions.set(run.sessionId, { id: run.sessionId, current: run });
+    return previous;
+}
+function restoreCliBridgeSession(run, previous, sessions) {
+    if (!run.sessionId || sessions.get(run.sessionId)?.current !== run)
+        return;
+    if (previous) {
+        sessions.set(run.sessionId, { id: run.sessionId, current: previous });
+    }
+    else {
+        sessions.delete(run.sessionId);
+    }
+}
+async function* streamTrackedCliBridgeTurn(options, environmentInput, prepared, transport, runs, sessions, readers) {
+    const originalTurn = prepared.turn;
     if (originalTurn.detach) {
         throw new Error("cli-bridge provider does not support detached turns");
     }
-    const sessionId = originalTurn.sessionId;
-    const turnId = originalTurn.turnId ?? crypto.randomUUID();
-    const runId = cliBridgeRunId(environmentId, originalTurn, turnId);
     const controller = new AbortController();
     const signals = [
         originalTurn.signal,
@@ -86,21 +166,17 @@ async function* streamTrackedCliBridgeTurn(options, environmentInput, originalTu
     ].filter((signal) => signal !== undefined);
     const turn = {
         ...originalTurn,
-        turnId,
         ...(signals.length > 0 ? { signal: AbortSignal.any(signals) } : {}),
     };
-    const requestBody = JSON.stringify(toChatCompletionsBody(options, environmentInput, turn, runId));
-    const run = runs.get(runId) ?? {
-        id: runId,
-        readers: new Set(),
-    };
+    const run = prepared.run;
+    const previousRun = bindCliBridgeRun(run, runs);
+    const previousSessionRun = bindCliBridgeSession(run, sessions);
     run.readers.add(controller);
     readers.add(controller);
-    runs.set(runId, run);
     let drained = false;
     let threw = false;
     try {
-        for await (const event of streamCliBridgeTurn(options, turn, requestBody, transport, runId, originalTurn.lastEventId, signals.length > 0 ? AbortSignal.any(signals) : undefined)) {
+        for await (const event of streamCliBridgeTurn(options, turn, run.requestBody, transport, run.id, originalTurn.lastEventId, signals.length > 0 ? AbortSignal.any(signals) : undefined, (response) => captureCliBridgeRunIdentity(response, run, false))) {
             yield event;
         }
         drained = true;
@@ -110,8 +186,8 @@ async function* streamTrackedCliBridgeTurn(options, environmentInput, originalTu
     catch (error) {
         threw = true;
         if (error instanceof CliBridgeRequestRejectedError) {
-            if (runs.get(run.id) === run)
-                runs.delete(run.id);
+            restoreCliBridgeRun(run, previousRun, runs);
+            restoreCliBridgeSession(run, previousSessionRun, sessions);
             throw error;
         }
         let snapshot;
@@ -141,6 +217,299 @@ async function* streamTrackedCliBridgeTurn(options, environmentInput, originalTu
         readers.delete(controller);
     }
 }
+async function dispatchCliBridgeTurn(options, environmentInput, prepared, transport, providerName, runs, sessions) {
+    const run = prepared.run;
+    const previousRun = bindCliBridgeRun(run, runs);
+    const previousSessionRun = bindCliBridgeSession(run, sessions);
+    const signals = [
+        prepared.turn.signal,
+        environmentInput.signal,
+    ].filter((signal) => signal !== undefined);
+    const signal = signals.length > 0 ? AbortSignal.any(signals) : undefined;
+    let accepted = false;
+    let responseBody;
+    try {
+        const response = await transport.fetch(`${trimSlash(options.baseUrl)}/v1/chat/completions`, {
+            method: "POST",
+            headers: {
+                ...requestHeaders(options),
+                accept: "text/event-stream",
+                ...(run.sessionId ? { "x-session-id": run.sessionId } : {}),
+            },
+            body: run.requestBody,
+            ...(signal ? { signal } : {}),
+        });
+        if (!response.ok) {
+            let detail = "request rejected";
+            try {
+                detail = await response.text();
+            }
+            catch {
+                // The HTTP status already proves this request was rejected.
+            }
+            throw new CliBridgeRequestRejectedError(response.status, detail);
+        }
+        accepted = true;
+        if (!response.body)
+            throw new Error("cli-bridge response body is empty");
+        responseBody = response.body;
+        captureCliBridgeRunIdentity(response, run, true);
+        await detachCliBridgeReader(responseBody);
+        responseBody = undefined;
+        return {
+            id: run.sessionId,
+            provider: providerName,
+            metadata: {
+                runId: run.id,
+                requestDigest: run.requestDigest,
+            },
+        };
+    }
+    catch (error) {
+        let failure = error;
+        if (responseBody) {
+            try {
+                await detachCliBridgeReader(responseBody);
+            }
+            catch (detachError) {
+                failure = new AggregateError([failure, detachError], `cli-bridge dispatch "${run.id}" failed and its reader did not detach`);
+            }
+        }
+        if (failure instanceof CliBridgeRequestRejectedError) {
+            restoreCliBridgeRun(run, previousRun, runs);
+            restoreCliBridgeSession(run, previousSessionRun, sessions);
+            throw failure;
+        }
+        if (accepted || signal?.aborted) {
+            try {
+                await cancelCliBridgeRun(options, transport, run);
+                if (runs.get(run.id) === run)
+                    runs.delete(run.id);
+            }
+            catch (cancellationError) {
+                throw new AggregateError([failure, cancellationError], `cli-bridge dispatch "${run.id}" failed and cancellation was not confirmed`);
+            }
+        }
+        else {
+            restoreCliBridgeRun(run, previousRun, runs);
+        }
+        restoreCliBridgeSession(run, previousSessionRun, sessions);
+        throw failure;
+    }
+}
+function createCliBridgeSession(args) {
+    const currentRun = () => {
+        if (args.isDestroyed())
+            throw new Error("cli-bridge environment is destroyed");
+        return args.sessions.get(args.id)?.current;
+    };
+    const requireCurrentRun = () => {
+        const run = currentRun();
+        if (!run)
+            throw new Error(`cli-bridge session "${args.id}" has no run`);
+        return run;
+    };
+    return {
+        id: args.id,
+        async status() {
+            const run = currentRun();
+            if (!run)
+                return null;
+            const snapshot = await getCliBridgeRun(args.options, args.transport, run.id);
+            if (!snapshot)
+                return null;
+            if (snapshot.terminal && args.runs.get(run.id) === run) {
+                args.runs.delete(run.id);
+            }
+            return agentSessionStatusFromRun(snapshot);
+        },
+        async *events(options) {
+            const run = requireCurrentRun();
+            yield* streamCliBridgeSessionEvents(args.options, args.environmentInput, run, args.transport, args.runs, args.readers, options);
+        },
+        async result() {
+            const run = requireCurrentRun();
+            return collectCliBridgeTurnResult(streamCliBridgeSessionEvents(args.options, args.environmentInput, run, args.transport, args.runs, args.readers, { since: "0" }), run, args.options, args.transport);
+        },
+        async prompt(input) {
+            if (input.sessionId && input.sessionId !== args.id) {
+                throw new Error(`cli-bridge session "${args.id}" cannot prompt session "${input.sessionId}"`);
+            }
+            const prepared = prepareCliBridgeRun(args.options, args.environmentInput, {
+                ...input,
+                sessionId: args.id,
+            }, args.environmentId, false);
+            const result = await collectCliBridgeTurnResult(streamTrackedCliBridgeTurn(args.options, args.environmentInput, prepared, args.transport, args.runs, args.sessions, args.readers), prepared.run, args.options, args.transport);
+            return { ...result, sessionId: args.id };
+        },
+        async cancel() {
+            const run = requireCurrentRun();
+            await cancelCliBridgeRun(args.options, args.transport, run);
+            if (args.runs.get(run.id) === run)
+                args.runs.delete(run.id);
+        },
+    };
+}
+async function* streamCliBridgeSessionEvents(options, environmentInput, run, transport, runs, readers, eventOptions) {
+    const controller = new AbortController();
+    const signals = [
+        eventOptions?.signal,
+        environmentInput.signal,
+        controller.signal,
+    ].filter((signal) => signal !== undefined);
+    const signal = signals.length > 0 ? AbortSignal.any(signals) : undefined;
+    run.readers.add(controller);
+    readers.add(controller);
+    let drained = false;
+    try {
+        yield* streamCliBridgeTurn(options, {
+            ...(run.sessionId ? { sessionId: run.sessionId } : {}),
+            turnId: run.turnId,
+        }, run.requestBody, transport, run.id, eventOptions?.since ?? "0", signal, (response) => captureCliBridgeRunIdentity(response, run, false));
+        drained = true;
+        if (runs.get(run.id) === run)
+            runs.delete(run.id);
+    }
+    finally {
+        if (!drained) {
+            controller.abort(new DOMException("cli-bridge session event reader detached", "AbortError"));
+        }
+        run.readers.delete(controller);
+        readers.delete(controller);
+    }
+}
+async function collectCliBridgeTurnResult(source, run, options, transport) {
+    const events = [];
+    let text = "";
+    let usage;
+    let streamError;
+    try {
+        for await (const event of source) {
+            events.push(event);
+            const finalText = event.data.finalText;
+            if (typeof finalText === "string") {
+                text = finalText;
+            }
+            else if (typeof event.data.delta === "string") {
+                text += event.data.delta;
+            }
+            usage = addTokenUsage(usage, event.usage);
+        }
+    }
+    catch (error) {
+        streamError = error;
+    }
+    const snapshot = await getCliBridgeRun(options, transport, run.id);
+    if (!snapshot) {
+        if (streamError)
+            throw streamError;
+        throw new Error(`cli-bridge lost run "${run.id}" before reading its result`);
+    }
+    if (!snapshot.terminal) {
+        if (streamError)
+            throw streamError;
+        throw new Error(`cli-bridge run "${run.id}" has no terminal result`);
+    }
+    const success = snapshot.status === "done" && streamError === undefined;
+    return {
+        text,
+        success,
+        ...(!success
+            ? {
+                error: streamError instanceof Error
+                    ? streamError.message
+                    : `cli-bridge run ended ${snapshot.status}`,
+            }
+            : {}),
+        ...(run.sessionId ? { sessionId: run.sessionId } : {}),
+        ...(usage ? { usage } : {}),
+        metadata: {
+            runId: run.id,
+            status: snapshot.status,
+            ...(run.requestDigest ? { requestDigest: run.requestDigest } : {}),
+        },
+        events,
+    };
+}
+function agentSessionStatusFromRun(snapshot) {
+    if (snapshot.status === "done")
+        return "completed";
+    if (snapshot.status === "error")
+        return "failed";
+    if (snapshot.status === "cancelled")
+        return "cancelled";
+    return "running";
+}
+function addTokenUsage(current, next) {
+    if (!next)
+        return current;
+    if (!current)
+        return { ...next };
+    return {
+        inputTokens: current.inputTokens + next.inputTokens,
+        outputTokens: current.outputTokens + next.outputTokens,
+        ...(current.totalTokens !== undefined || next.totalTokens !== undefined
+            ? { totalTokens: (current.totalTokens ?? 0) + (next.totalTokens ?? 0) }
+            : {}),
+        ...(current.cacheReadInputTokens !== undefined ||
+            next.cacheReadInputTokens !== undefined
+            ? {
+                cacheReadInputTokens: (current.cacheReadInputTokens ?? 0) +
+                    (next.cacheReadInputTokens ?? 0),
+            }
+            : {}),
+        ...(current.cacheCreationInputTokens !== undefined ||
+            next.cacheCreationInputTokens !== undefined
+            ? {
+                cacheCreationInputTokens: (current.cacheCreationInputTokens ?? 0) +
+                    (next.cacheCreationInputTokens ?? 0),
+            }
+            : {}),
+        ...(current.reasoningTokens !== undefined || next.reasoningTokens !== undefined
+            ? {
+                reasoningTokens: (current.reasoningTokens ?? 0) + (next.reasoningTokens ?? 0),
+            }
+            : {}),
+        ...(current.cost !== undefined || next.cost !== undefined
+            ? { cost: (current.cost ?? 0) + (next.cost ?? 0) }
+            : {}),
+    };
+}
+function captureCliBridgeRunIdentity(response, run, required) {
+    const responseRunId = response.headers.get("x-run-id");
+    const requestDigest = response.headers.get("x-run-request-digest");
+    if (responseRunId !== null && responseRunId !== run.id) {
+        throw new Error(`cli-bridge accepted run "${responseRunId}" for requested run "${run.id}"`);
+    }
+    if ((required || run.requestDigest !== undefined) && responseRunId === null) {
+        throw new Error("cli-bridge response omitted X-Run-Id");
+    }
+    if (required && requestDigest === null) {
+        throw new Error("cli-bridge dispatch response omitted X-Run-Request-Digest");
+    }
+    if (requestDigest !== null &&
+        run.requestDigest !== undefined &&
+        requestDigest !== run.requestDigest) {
+        throw new Error(`cli-bridge changed request digest for run "${run.id}" from "${run.requestDigest}" to "${requestDigest}"`);
+    }
+    if (run.requestDigest !== undefined && requestDigest === null) {
+        throw new Error(`cli-bridge replay response omitted X-Run-Request-Digest for run "${run.id}"`);
+    }
+    if (requestDigest !== null)
+        run.requestDigest = requestDigest;
+}
+async function detachCliBridgeReader(body) {
+    const cancellable = body;
+    if (cancellable.cancel) {
+        await cancellable.cancel();
+        return;
+    }
+    const iterator = body[Symbol.asyncIterator]();
+    if (!iterator.return) {
+        throw new Error("cli-bridge response body cannot detach its reader");
+    }
+    await iterator.return();
+}
 async function cancelCliBridgeRun(options, transport, run) {
     if (run.cancellation)
         return run.cancellation;
@@ -154,6 +523,7 @@ async function cancelCliBridgeRun(options, transport, run) {
             throw new Error(`cli-bridge cancel ${response.status}: ${await response.text()}`);
         }
         let snapshot = cancelSnapshot(await response.text());
+        assertCliBridgeRunSnapshotIdentity(snapshot, run.id);
         const waitBudgetMs = options.cancelWaitMs ?? 30_000;
         const deadline = Date.now() + waitBudgetMs;
         while (!snapshot.terminal) {
@@ -191,9 +561,16 @@ async function getCliBridgeRun(options, transport, runId, waitMs) {
     if (!response.ok) {
         throw new Error(`cli-bridge run status ${response.status}: ${await response.text()}`);
     }
-    return runSnapshot(await response.text());
+    const snapshot = runSnapshot(await response.text());
+    assertCliBridgeRunSnapshotIdentity(snapshot, runId);
+    return snapshot;
+}
+function assertCliBridgeRunSnapshotIdentity(snapshot, expectedRunId) {
+    if (snapshot.id !== expectedRunId) {
+        throw new Error(`cli-bridge returned run "${snapshot.id}" for requested run "${expectedRunId}"`);
+    }
 }
-async function* streamCliBridgeTurn(options, turn, requestBody, transport, runId, lastEventId, signal) {
+async function* streamCliBridgeTurn(options, turn, requestBody, transport, runId, lastEventId, signal, onAccepted) {
     const response = await transport.fetch(`${trimSlash(options.baseUrl)}/v1/chat/completions`, {
         method: "POST",
         headers: {
@@ -215,6 +592,7 @@ async function* streamCliBridgeTurn(options, turn, requestBody, transport, runId
         }
         throw new CliBridgeRequestRejectedError(response.status, detail);
     }
+    onAccepted?.(response);
     if (!response.body)
         throw new Error("cli-bridge response body is empty");
     let text = "";
@@ -222,6 +600,7 @@ async function* streamCliBridgeTurn(options, turn, requestBody, transport, runId
     const messageId = turn.turnId ?? `${sessionId}:assistant`;
     const emittedToolCalls = new Set();
     let completed = false;
+    let sawUsage = false;
     let terminalCursor;
     for await (const frame of parseSse(response.body)) {
         if (frame.data === "[DONE]")
@@ -245,6 +624,7 @@ async function* streamCliBridgeTurn(options, turn, requestBody, transport, runId
         const nextUsage = usageFromOpenAi(parsed.usage);
         const frameEvents = [];
         if (nextUsage) {
+            sawUsage = true;
             frameEvents.push({ type: "usage", data: {}, usage: nextUsage });
         }
         if (chunk) {
@@ -321,7 +701,10 @@ async function* streamCliBridgeTurn(options, turn, requestBody, transport, runId
         throw new Error("cli-bridge stream ended without a terminal result");
     }
     if (lastEventId) {
-        const result = await readFullCliBridgeResult(options, requestBody, transport, signal);
+        const result = await readFullCliBridgeResult(options, requestBody, transport, signal, onAccepted);
+        if (result.usage && !sawUsage) {
+            yield { type: "usage", data: {}, usage: result.usage };
+        }
         yield {
             type: "result",
             data: {
@@ -341,7 +724,7 @@ class CliBridgeRequestRejectedError extends Error {
         this.name = "CliBridgeRequestRejectedError";
     }
 }
-async function readFullCliBridgeResult(options, requestBody, transport, signal) {
+async function readFullCliBridgeResult(options, requestBody, transport, signal, onAccepted) {
     const body = safeJson(requestBody);
     if (!body)
         throw new Error("cli-bridge replay request is not valid JSON");
@@ -354,6 +737,7 @@ async function readFullCliBridgeResult(options, requestBody, transport, signal)
     if (!response.ok) {
         throw new Error(`cli-bridge replay result ${response.status}: ${await response.text()}`);
     }
+    onAccepted?.(response);
     const parsed = safeJson(await response.text());
     if (parsed?.error && typeof parsed.error === "object") {
         const error = parsed.error;
@@ -371,7 +755,12 @@ async function readFullCliBridgeResult(options, requestBody, transport, signal)
     if (choice.finish_reason === "error" || choice.finish_reason === "timeout") {
         throw new Error(`cli-bridge replay result ended ${choice.finish_reason}`);
     }
-    return { text: message.content, finishReason: choice.finish_reason };
+    const usage = usageFromOpenAi(parsed?.usage);
+    return {
+        text: message.content,
+        finishReason: choice.finish_reason,
+        ...(usage ? { usage } : {}),
+    };
 }
 function createTransport(options) {
     if (options.fetch) {
@@ -410,6 +799,9 @@ function toChatCompletionsBody(options, environmentInput, turn, runId) {
         run_id: runId,
         ...(options.defaultMode ? { mode: options.defaultMode } : {}),
         ...(profile ? { agent_profile: profile } : {}),
+        ...(profile?.model?.reasoningEffort
+            ? { effort: profile.model.reasoningEffort }
+            : {}),
         ...(environmentInput.env ? { env: environmentInput.env } : {}),
         ...(environmentInput.workspace?.cwd ? { cwd: environmentInput.workspace.cwd } : {}),
         ...(executionFromInput(options, environmentInput) ? { execution: executionFromInput(options, environmentInput) } : {}),
@@ -649,7 +1041,7 @@ export function defaultCliBridgeCapabilities(harness) {
             runtimeUpdate: false,
             validation: false,
         },
-        streaming: { live: true, replay: true, detach: false, turnIdempotency: true },
+        streaming: { live: true, replay: true, detach: true, turnIdempotency: true },
         sessions: { continue: true, list: false, messages: false },
         workspace: { read: false, write: false, exec: false, git: false, upload: false, download: false },
         branching: { checkpoint: false, fork: false },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-provider-cli-bridge",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "AgentEnvironmentProvider adapter for cli-bridge /v1/chat/completions",
   "type": "module",
   "license": "MIT",
@@ -29,7 +29,7 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@tangle-network/agent-interface": "0.46.0",
+    "@tangle-network/agent-interface": "0.47.0",
     "undici": "7.28.0"
   },
   "devDependencies": {