@tangle-network/agent-provider-cli-bridge 0.7.7 → 0.8.0

package/dist/retained-native.js

@@ -0,0 +1,204 @@
+import { AgentExactRunControlRefSchema, RequestedInteractionsSchema, canonicalCandidateDigest, } from "@tangle-network/agent-interface";
+import { CliBridgeRequestRejectedError } from "./retained-stream.js";
+import { requestHeaders, trimSlash, } from "./transport.js";
+import { inlineProfile, safeJson, resolveBridgeModel, toRetainedSessionBody, toRetainedTurnBody, } from "./wire.js";
+/** Interactions are valid only for the native retained Pi contract. */
+export function supportsCliBridgeNativeInteractions(capabilities, selectedBackend) {
+    const interactions = capabilities.interactions;
+    const retainedControl = capabilities.retainedControl;
+    return Boolean(selectedBackend === "pi" &&
+        piInteractionCapabilitiesMatch(interactions) &&
+        capabilities.streaming.live &&
+        capabilities.streaming.replay &&
+        capabilities.streaming.detach &&
+        capabilities.streaming.turnIdempotency &&
+        capabilities.sessions.continue &&
+        retainedControl?.exactRunIdentity &&
+        retainedControl.resultIdentity &&
+        retainedControl.eventIdentity &&
+        retainedControl.cancellationIdempotency);
+}
+/** Reject posture the selected environment did not advertise before transport use. */
+export function assertCliBridgeRequestedInteractions(capabilities, requested) {
+    if (requested === undefined)
+        return;
+    const parsed = RequestedInteractionsSchema.parse(requested);
+    const advertised = new Set(capabilities.interactions?.kinds ?? []);
+    const unsupported = Object.keys(parsed).filter((kind) => !advertised.has(kind));
+    if (unsupported.length > 0) {
+        throw new Error(`cli-bridge environment does not advertise requested interaction kind(s): ${unsupported.join(", ")}`);
+    }
+}
+/** Keep capability discovery and every native turn on one exact model route. */
+export function assertCliBridgeNativeTurnModel(options, environmentInput, turn, selectedModel) {
+    if (selectedModel === undefined) {
+        throw new Error("cli-bridge native interactions require an environment model");
+    }
+    const requestedModel = resolveBridgeModel(options, environmentInput, turn, inlineProfile(environmentInput.profile));
+    if (requestedModel !== selectedModel) {
+        throw new Error(`cli-bridge native environment model is ${JSON.stringify(selectedModel)}; create another environment for ${JSON.stringify(requestedModel)}`);
+    }
+}
+function piInteractionCapabilitiesMatch(interactions) {
+    return Boolean(interactions &&
+        interactions.kinds.includes("permission") &&
+        interactions.answerFieldTypes.includes("select") &&
+        interactions.responseScopes.includes("interaction") &&
+        interactions.secretAnswers === false &&
+        interactions.concurrentRequests === false &&
+        interactions.replay === true &&
+        interactions.responseIdempotency === true);
+}
+/**
+ * Create or reuse the server's retained native session for one external id.
+ *
+ * The cache stores the promise so concurrent first turns cannot create two
+ * native sessions for the same id.
+ */
+export async function ensureCliBridgeNativeSession(options, environmentInput, turn, sessionId, transport, sessions, signal) {
+    const profile = inlineProfile(environmentInput.profile);
+    const model = resolveBridgeModel(options, environmentInput, turn, profile);
+    const existing = sessions.get(sessionId);
+    if (existing) {
+        const session = await existing;
+        assertNativeSessionModel(session, model);
+        return session;
+    }
+    const pending = createCliBridgeNativeSession(options, environmentInput, profile, sessionId, model, transport, signal);
+    sessions.set(sessionId, pending);
+    try {
+        const session = await pending;
+        assertNativeSessionModel(session, model);
+        return session;
+    }
+    catch (error) {
+        if (sessions.get(sessionId) === pending)
+            sessions.delete(sessionId);
+        throw error;
+    }
+}
+async function createCliBridgeNativeSession(options, environmentInput, profile, sessionId, model, transport, signal) {
+    const body = toRetainedSessionBody(options, environmentInput, profile, sessionId, model);
+    const createRequestDigest = canonicalCandidateDigest(body);
+    const url = `${trimSlash(options.baseUrl)}/v1/sessions`;
+    const init = {
+        method: "POST",
+        headers: requestHeaders(options),
+        body: JSON.stringify(body),
+        ...(signal ? { signal } : {}),
+    };
+    const response = await transport.fetch(url, init);
+    if (response.status === 409) {
+        return recoverConflictingNativeSession(options, sessionId, model, createRequestDigest, transport, signal, response);
+    }
+    if (!response.ok) {
+        throw new CliBridgeRequestRejectedError(response.status, await response.text());
+    }
+    return parseNativeSessionView(await response.text(), sessionId, model, createRequestDigest);
+}
+async function recoverConflictingNativeSession(options, sessionId, model, createRequestDigest, transport, signal, conflictResponse) {
+    await conflictResponse.text();
+    const response = await transport.fetch(`${trimSlash(options.baseUrl)}/v1/sessions/${encodeURIComponent(sessionId)}`, {
+        method: "GET",
+        headers: requestHeaders(options),
+        ...(signal ? { signal } : {}),
+    });
+    if (!response.ok) {
+        throw new CliBridgeRequestRejectedError(response.status, `session ${JSON.stringify(sessionId)} could not be recovered: ${await response.text()}`);
+    }
+    return parseNativeSessionView(await response.text(), sessionId, model, createRequestDigest);
+}
+function parseNativeSessionView(value, expectedId, expectedModel, expectedCreateRequestDigest) {
+    const parsed = safeJson(value);
+    const id = parsed?.id;
+    const model = parsed?.model;
+    const digest = parsed?.create_request_digest;
+    const parsedDigest = AgentExactRunControlRefSchema.shape.requestDigest.safeParse(digest);
+    if (typeof id !== "string" ||
+        typeof model !== "string" ||
+        !parsedDigest.success) {
+        throw new Error("cli-bridge retained session returned an invalid session view");
+    }
+    if (id !== expectedId) {
+        throw new Error(`cli-bridge returned session ${JSON.stringify(id)} for requested session ${JSON.stringify(expectedId)}`);
+    }
+    if (model !== expectedModel) {
+        throw new Error(`cli-bridge retained session ${JSON.stringify(expectedId)} is bound to model ${JSON.stringify(model)}`);
+    }
+    if (parsedDigest.data !== expectedCreateRequestDigest) {
+        throw new Error(`cli-bridge retained session ${JSON.stringify(expectedId)} has a different creation request digest`);
+    }
+    return {
+        id,
+        model,
+        createRequestDigest: parsedDigest.data,
+    };
+}
+function assertNativeSessionModel(session, expectedModel) {
+    if (session.model !== expectedModel) {
+        throw new Error(`cli-bridge retained session ${JSON.stringify(session.id)} cannot change model from ${JSON.stringify(session.model)} to ${JSON.stringify(expectedModel)}`);
+    }
+}
+/** Admit one native retained turn and bind its server digest to the run. */
+export async function beginCliBridgeNativeTurn(options, providerName, environmentInput, turn, run, transport, sessions, signal, onAdmission) {
+    if (!run.sessionId) {
+        throw new Error("cli-bridge native retained turns require a session id");
+    }
+    const body = toRetainedTurnBody(turn, run, providerName);
+    const nativeSession = await ensureCliBridgeNativeSession(options, environmentInput, turn, run.sessionId, transport, sessions, signal);
+    const response = await transport.fetch(`${trimSlash(options.baseUrl)}/v1/sessions/${encodeURIComponent(run.sessionId)}/turns`, {
+        method: "POST",
+        headers: requestHeaders(options),
+        body: JSON.stringify(body),
+        ...(signal ? { signal } : {}),
+    });
+    if (!response.ok) {
+        throw new CliBridgeRequestRejectedError(response.status, await response.text());
+    }
+    onAdmission?.();
+    const parsed = safeJson(await response.text());
+    const responseSession = parsed?.session;
+    const responseRun = parsed?.run;
+    const responseSessionId = responseSession && typeof responseSession === "object"
+        ? responseSession.id
+        : undefined;
+    const responseSessionModel = responseSession && typeof responseSession === "object"
+        ? responseSession.model
+        : undefined;
+    const responseSessionDigest = responseSession && typeof responseSession === "object"
+        ? responseSession.create_request_digest
+        : undefined;
+    const parsedSessionDigest = AgentExactRunControlRefSchema.shape.requestDigest.safeParse(responseSessionDigest);
+    const runId = responseRun && typeof responseRun === "object"
+        ? responseRun.id
+        : undefined;
+    const responseSessionIdFromRun = responseRun && typeof responseRun === "object"
+        ? responseRun.sessionId
+        : undefined;
+    const executionId = responseRun && typeof responseRun === "object"
+        ? responseRun.executionId
+        : undefined;
+    const requestDigestValue = responseRun && typeof responseRun === "object"
+        ? responseRun.requestDigest
+        : undefined;
+    const requestDigest = AgentExactRunControlRefSchema.shape.requestDigest.safeParse(requestDigestValue);
+    if (!parsed ||
+        typeof responseSessionId !== "string" ||
+        responseSessionId !== run.sessionId ||
+        responseSessionModel !== nativeSession.model ||
+        !parsedSessionDigest.success ||
+        parsedSessionDigest.data !== nativeSession.createRequestDigest ||
+        typeof runId !== "string" ||
+        runId !== run.id ||
+        typeof responseSessionIdFromRun !== "string" ||
+        responseSessionIdFromRun !== run.sessionId ||
+        typeof executionId !== "string" ||
+        executionId !== run.executionId ||
+        !requestDigest.success) {
+        throw new Error("cli-bridge retained turn returned mismatched run coordinates");
+    }
+    if (run.requestDigest !== undefined && run.requestDigest !== requestDigest.data) {
+        throw new Error("cli-bridge retained turn changed the admitted request digest");
+    }
+    run.requestDigest = requestDigest.data;
+}

package/dist/retained-run-state.d.ts

@@ -20,7 +20,7 @@ export interface CliBridgeSessionState {
 export interface CliBridgeRunSnapshot {
     readonly id: string;
     readonly requestDigest?: Sha256Digest;
-    readonly status: "running" | "done" | "error" | "cancelled";
+    readonly status: "running" | "done" | "error" | "cancelled" | "unknown";
     readonly terminal: boolean;
 }
 export interface PreparedCliBridgeRun {

package/dist/retained-run-state.js

@@ -46,6 +46,10 @@ export function assertRunMatchesControlRef(run, controlRef) {
     run.controlRef = controlRef;
 }
 export function prepareCliBridgeRun(options, environmentInput, originalTurn, environmentId, requireSession) {
+    if (requireSession &&
+        (originalTurn.turnId === undefined || originalTurn.executionId === undefined)) {
+        throw new Error("cli-bridge native retained turns require stable turnId and executionId values");
+    }
     const turnId = originalTurn.turnId ?? crypto.randomUUID();
     const runId = cliBridgeRunId(environmentId, originalTurn, turnId);
     const sessionId = originalTurn.sessionId ?? (requireSession ? runId : undefined);

package/dist/retained-stream.d.ts

@@ -6,4 +6,4 @@ 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, onResponse?: (response: CliBridgeResponse) => void, readAuthoritativeRun?: () => Promise<CliBridgeRunSnapshot | null>): 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>, validateCanonicalEvent?: (event: AgentEnvironmentEvent) => void): AsyncIterable<AgentEnvironmentEvent>;

package/dist/retained-stream.js

@@ -1,4 +1,5 @@
 import { retainedEventsWithIdentity, retainedReplayRequest, } from "./retained-event-cursor.js";
+import { isTerminalCanonicalEvent, retainedCanonicalEvent, } from "./retained-canonical-event.js";
 import { detachCliBridgeReader } from "./retained-control.js";
 import { requestHeaders, trimSlash } from "./transport.js";
 import { modelRequestsFromOpenAi, parseSse, responseIdentityFromOpenAi, safeJson, toolCallsFromDelta, usageFromOpenAi, } from "./wire.js";
@@ -18,7 +19,7 @@ class CliBridgeRunCancelledError extends Error {
         this.name = "CliBridgeRunCancelledError";
     }
 }
-export async function* streamCliBridgeTurn(options, turn, requestBody, transport, runId, lastEventId, signal, onResponse, readAuthoritativeRun) {
+export async function* streamCliBridgeTurn(options, turn, requestBody, transport, runId, lastEventId, signal, onResponse, readAuthoritativeRun, validateCanonicalEvent) {
     const reconnect = requestBody === undefined;
     const replay = retainedReplayRequest(lastEventId);
     const response = await transport.fetch(reconnect
@@ -72,14 +73,53 @@ export async function* streamCliBridgeTurn(options, turn, requestBody, transport
     let systemFingerprint;
     let textBoundaryPending = false;
     let sawProtocolEnd = false;
+    let protocol = "unknown";
+    let canonicalTerminalStatus;
+    let canonicalTerminalEvent;
     let terminalFrameSeen = false;
     let cancelledTerminalSeen = false;
     let terminalFrame;
     for await (const frame of parseSse(response.body)) {
         if (frame.data === "[DONE]") {
+            if (protocol === "canonical") {
+                throw new Error("cli-bridge mixed canonical and OpenAI stream formats");
+            }
+            protocol = "openai";
             sawProtocolEnd = true;
             continue;
         }
+        if (frame.event !== undefined) {
+            if (protocol === "openai") {
+                throw new Error("cli-bridge mixed canonical and OpenAI stream formats");
+            }
+            protocol = "canonical";
+            if (canonicalTerminalStatus !== undefined) {
+                throw new Error("cli-bridge emitted an event after canonical terminal status");
+            }
+            const event = retainedCanonicalEvent(frame, {
+                runId,
+                sessionId,
+                ...(turn.executionId === undefined
+                    ? {}
+                    : { executionId: turn.executionId }),
+            });
+            if (!event) {
+                throw new Error("cli-bridge emitted an empty canonical event");
+            }
+            validateCanonicalEvent?.(event);
+            if (isTerminalCanonicalEvent(event)) {
+                canonicalTerminalStatus = event.normalized.status;
+                canonicalTerminalEvent = event;
+            }
+            else {
+                yield event;
+            }
+            continue;
+        }
+        if (protocol === "canonical") {
+            throw new Error("cli-bridge mixed canonical and OpenAI stream formats");
+        }
+        protocol = "openai";
         if (terminalFrameSeen)
             continue;
         const parsed = safeJson(frame.data);
@@ -219,6 +259,32 @@ export async function* streamCliBridgeTurn(options, turn, requestBody, transport
         }
         yield* retainedEventsWithIdentity(frameEvents, frame.id, runId, sessionId, turn.executionId, replay.anchor);
     }
+    if (protocol === "canonical") {
+        if (canonicalTerminalStatus === undefined) {
+            throw new Error("cli-bridge canonical stream ended without terminal status");
+        }
+        const snapshot = await terminalRunSnapshot(runId, readAuthoritativeRun);
+        const expectedStatus = canonicalTerminalStatus === "completed"
+            ? "done"
+            : canonicalTerminalStatus === "failed"
+                ? "error"
+                : "cancelled";
+        if (snapshot.status !== expectedStatus) {
+            throw new Error(`cli-bridge canonical terminal status ${JSON.stringify(canonicalTerminalStatus)} contradicts retained run status ${JSON.stringify(snapshot.status)}`);
+        }
+        if (!canonicalTerminalEvent) {
+            throw new Error("cli-bridge canonical terminal event was not retained");
+        }
+        yield canonicalTerminalEvent;
+        return;
+    }
+    if (!sawProtocolEnd &&
+        reconnect &&
+        lastEventId !== undefined &&
+        protocol === "unknown") {
+        await terminalRunSnapshot(runId, readAuthoritativeRun);
+        return;
+    }
     if (!sawProtocolEnd) {
         throw new Error("cli-bridge stream ended without the [DONE] protocol marker");
     }

package/dist/wire.d.ts

@@ -1,11 +1,17 @@
-import type { TokenUsage } from "@tangle-network/agent-interface";
+import type { AgentProfile, AgentProfileRef, TokenUsage } from "@tangle-network/agent-interface";
 import type { AgentTurnInput, CreateAgentEnvironmentInput } from "@tangle-network/agent-interface/environment-provider";
 import type { CliBridgeProviderOptions } from "./provider-options.js";
-import type { CliBridgeRunSnapshot } from "./retained-run-state.js";
+import type { CliBridgeRun, CliBridgeRunSnapshot } from "./retained-run-state.js";
 export declare function toChatCompletionsBody(options: CliBridgeProviderOptions, environmentInput: CreateAgentEnvironmentInput, turn: AgentTurnInput, runId: string): Record<string, unknown>;
+export declare function resolveBridgeModel(options: CliBridgeProviderOptions, environmentInput: CreateAgentEnvironmentInput, turn: AgentTurnInput, profile: AgentProfile | undefined): string;
+export declare function toRetainedSessionBody(options: CliBridgeProviderOptions, environmentInput: CreateAgentEnvironmentInput, profile: AgentProfile | undefined, sessionId: string, model: string): Record<string, unknown>;
+/** Encode the exact retained turn contract without moving posture into metadata. */
+export declare function toRetainedTurnBody(turn: AgentTurnInput, run: CliBridgeRun, providerName: string): Record<string, unknown>;
+export declare function inlineProfile(profile: AgentProfileRef): AgentProfile | undefined;
 export interface CliBridgeSseFrame {
     readonly data: string;
     readonly id?: string;
+    readonly event?: string;
 }
 export declare function parseSse(body: AsyncIterable<Uint8Array>): AsyncIterable<CliBridgeSseFrame>;
 export declare function toolCallsFromDelta(value: unknown): Array<{

package/dist/wire.js

@@ -1,8 +1,11 @@
 import { createHash } from "node:crypto";
-import { AgentExactRunControlRefSchema } from "@tangle-network/agent-interface";
+import { AgentExactRunControlRefSchema, RequestedInteractionsSchema, } from "@tangle-network/agent-interface";
 export function toChatCompletionsBody(options, environmentInput, turn, runId) {
     const profile = inlineProfile(environmentInput.profile);
     const execution = executionFromInput(options, environmentInput);
+    const interactions = turn.interactions === undefined
+        ? undefined
+        : RequestedInteractionsSchema.parse(turn.interactions);
     return {
         model: resolveBridgeModel(options, environmentInput, turn, profile),
         messages: messagesFromTurn(turn),
@@ -17,6 +20,7 @@ export function toChatCompletionsBody(options, environmentInput, turn, runId) {
         ...(environmentInput.env ? { env: environmentInput.env } : {}),
         ...(environmentInput.workspace?.cwd ? { cwd: environmentInput.workspace.cwd } : {}),
         ...(execution ? { execution } : {}),
+        ...(interactions === undefined ? {} : { interactions }),
         metadata: {
             ...(environmentInput.metadata ?? {}),
             ...(turn.context ?? {}),
@@ -24,7 +28,7 @@ export function toChatCompletionsBody(options, environmentInput, turn, runId) {
         },
     };
 }
-function resolveBridgeModel(options, environmentInput, turn, profile) {
+export function resolveBridgeModel(options, environmentInput, turn, profile) {
     const harness = environmentInput.backend ?? profile?.harness;
     const model = turn.model ?? options.defaultModel ?? profile?.model?.default;
     const provider = profile?.model?.provider;
@@ -43,6 +47,77 @@ function resolveBridgeModel(options, environmentInput, turn, profile) {
         return `${harness}/${provider}/${model}`;
     return `${harness}/${model}`;
 }
+export function toRetainedSessionBody(options, environmentInput, profile, sessionId, model) {
+    const execution = retainedExecutionFromInput(options, environmentInput);
+    return {
+        id: sessionId,
+        model,
+        interaction_policy: "interactive",
+        ...(options.defaultMode ? { mode: options.defaultMode } : {}),
+        ...(environmentInput.workspace?.cwd !== undefined
+            ? { cwd: environmentInput.workspace.cwd }
+            : {}),
+        ...(execution !== undefined ? { execution } : {}),
+        ...(profile ? { agent_profile: profile } : {}),
+        ...(environmentInput.env !== undefined ? { env: environmentInput.env } : {}),
+        ...(environmentInput.metadata !== undefined
+            ? { metadata: environmentInput.metadata }
+            : {}),
+        ...(environmentInput.providerOptions !== undefined
+            ? { provider_options: environmentInput.providerOptions }
+            : {}),
+    };
+}
+/** Encode the exact retained turn contract without moving posture into metadata. */
+export function toRetainedTurnBody(turn, run, providerName) {
+    assertRetainedTurnInputSupported(turn);
+    const interactions = RequestedInteractionsSchema.parse(turn.interactions ?? {});
+    const content = {};
+    if (turn.prompt !== undefined) {
+        if (turn.prompt.length === 0) {
+            throw new Error("cli-bridge retained sessions require a non-empty message");
+        }
+        content.message = turn.prompt;
+    }
+    if (turn.parts !== undefined) {
+        if (turn.parts.length === 0) {
+            throw new Error("cli-bridge retained sessions require non-empty input parts");
+        }
+        content.parts = turn.parts;
+    }
+    if (turn.prompt === undefined && turn.parts === undefined) {
+        throw new Error("cli-bridge retained sessions require a non-empty message or input parts");
+    }
+    return {
+        ...content,
+        turn_id: run.turnId,
+        execution_id: run.executionId,
+        run_id: run.id,
+        provider: providerName,
+        environment_id: run.environmentId,
+        ...(turn.interactions === undefined ? {} : { interactions }),
+        ...(turn.context !== undefined ? { context: turn.context } : {}),
+        ...(turn.providerOptions !== undefined
+            ? { provider_options: turn.providerOptions }
+            : {}),
+    };
+}
+function assertRetainedTurnInputSupported(turn) {
+    const unsupported = [];
+    if (turn.timeoutMs !== undefined)
+        unsupported.push("timeoutMs");
+    if (turn.controlRef !== undefined)
+        unsupported.push("controlRef");
+    if (turn.contextTransfer !== undefined)
+        unsupported.push("contextTransfer");
+    if (turn.nativeContinuation !== undefined)
+        unsupported.push("nativeContinuation");
+    if (turn.detach === true)
+        unsupported.push("detach");
+    if (unsupported.length > 0) {
+        throw new Error(`cli-bridge retained turns cannot represent ${unsupported.join(", ")}`);
+    }
+}
 /** Keep task messages separate from the profile's harness-owned prompt controls. */
 function messagesFromTurn(turn) {
     return [{ role: "user", content: contentFromTurn(turn) }];
@@ -52,7 +127,7 @@ function contentFromTurn(turn) {
         return turn.parts;
     return turn.prompt ?? "";
 }
-function inlineProfile(profile) {
+export function inlineProfile(profile) {
     return typeof profile === "string" ? undefined : profile;
 }
 function executionFromInput(options, input) {
@@ -66,6 +141,34 @@ function executionFromInput(options, input) {
         ...(input.workspace.gitRef ? { gitRef: input.workspace.gitRef } : {}),
     };
 }
+function retainedExecutionFromInput(options, input) {
+    const unsupported = [];
+    if (typeof input.profile === "string")
+        unsupported.push("named profile");
+    if (input.workspace?.environment !== undefined)
+        unsupported.push("workspace.environment");
+    if (input.workspace?.image !== undefined)
+        unsupported.push("workspace.image");
+    if (input.workspace?.repoUrl !== undefined)
+        unsupported.push("workspace.repoUrl");
+    if (input.workspace?.gitRef !== undefined)
+        unsupported.push("workspace.gitRef");
+    if (input.workspace?.providerOptions !== undefined) {
+        unsupported.push("workspace.providerOptions");
+    }
+    if (input.resources !== undefined)
+        unsupported.push("resources");
+    if (input.secrets !== undefined)
+        unsupported.push("secrets");
+    if (unsupported.length > 0) {
+        throw new Error(`cli-bridge retained sessions cannot represent ${unsupported.join(", ")}`);
+    }
+    const execution = executionFromInput(options, input);
+    if (execution?.kind === "sandbox") {
+        throw new Error("cli-bridge retained sessions cannot execute in a sandbox; use one-shot execution");
+    }
+    return execution;
+}
 export async function* parseSse(body) {
     const decoder = new TextDecoder();
     let buffer = "";
@@ -106,7 +209,11 @@ function dataFromFrame(frame) {
     if (!data)
         return undefined;
     const id = lines.find((line) => line.startsWith("id:"))?.slice("id:".length).trim();
-    return { data, ...(id ? { id } : {}) };
+    const event = lines
+        .find((line) => line.startsWith("event:"))
+        ?.slice("event:".length)
+        .trim();
+    return { data, ...(id ? { id } : {}), ...(event ? { event } : {}) };
 }
 export function toolCallsFromDelta(value) {
     if (!value || typeof value !== "object")
@@ -223,7 +330,7 @@ export function runSnapshot(value) {
     const terminal = parsed.terminal;
     if (typeof id !== "string" ||
         (requestDigest !== undefined && !requestDigest.success) ||
-        !["running", "done", "error", "cancelled"].includes(String(status)) ||
+        !["running", "done", "error", "cancelled", "unknown"].includes(String(status)) ||
         typeof terminal !== "boolean") {
         throw new Error("cli-bridge run status returned an invalid snapshot");
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tangle-network/agent-provider-cli-bridge",
-  "version": "0.7.7",
-  "description": "AgentEnvironmentProvider adapter for cli-bridge /v1/chat/completions",
+  "version": "0.8.0",
+  "description": "AgentEnvironmentProvider adapter for cli-bridge retained sessions and one-shot turns",
   "type": "module",
   "license": "MIT",
   "main": "./dist/index.js",
@@ -25,10 +25,18 @@
   "files": [
     "dist/index.d.ts",
     "dist/index.js",
+    "dist/environment-identity.d.ts",
+    "dist/environment-identity.js",
+    "dist/capability-discovery.d.ts",
+    "dist/capability-discovery.js",
+    "dist/interaction-response.d.ts",
+    "dist/interaction-response.js",
     "dist/observation.d.ts",
     "dist/observation.js",
     "dist/provider-options.d.ts",
     "dist/provider-options.js",
+    "dist/retained-canonical-event.d.ts",
+    "dist/retained-canonical-event.js",
     "dist/retained-control.d.ts",
     "dist/retained-control.js",
     "dist/retained-environment.d.ts",
@@ -37,6 +45,8 @@
     "dist/retained-event-cursor.js",
     "dist/retained-execution.d.ts",
     "dist/retained-execution.js",
+    "dist/retained-native.d.ts",
+    "dist/retained-native.js",
     "dist/retained-run-state.d.ts",
     "dist/retained-run-state.js",
     "dist/retained-stream.d.ts",
@@ -58,9 +68,10 @@
     "vitest": "^4.1.5"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "pnpm run clean && tsc -p tsconfig.build.json",
     "check-types": "tsc --noEmit",
     "clean": "rm -rf dist",
-    "test": "vitest run"
+    "test": "vitest run src",
+    "test:integration": "test -n \"$CLI_BRIDGE_INTEGRATION_ROOT\" || { echo 'CLI_BRIDGE_INTEGRATION_ROOT is required; see README' >&2; exit 1; }; vitest run tests/cli-bridge.integration.test.ts"
   }
 }