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

package/dist/retained-stream.js

@@ -0,0 +1,276 @@
+import { retainedEventsWithIdentity, retainedReplayRequest, } from "./retained-event-cursor.js";
+import { requestHeaders, trimSlash } from "./transport.js";
+import { modelRequestsFromOpenAi, parseSse, responseIdentityFromOpenAi, safeJson, toolCallsFromDelta, usageFromOpenAi, } from "./wire.js";
+export class CliBridgeRequestRejectedError extends Error {
+    status;
+    constructor(status, detail) {
+        super(`cli-bridge ${status}: ${detail}`);
+        this.status = status;
+        this.name = "CliBridgeRequestRejectedError";
+    }
+}
+export async function* streamCliBridgeTurn(options, turn, requestBody, transport, runId, lastEventId, signal, onAccepted) {
+    const reconnect = requestBody === undefined;
+    const replay = retainedReplayRequest(lastEventId);
+    const response = await transport.fetch(reconnect
+        ? `${trimSlash(options.baseUrl)}/v1/runs/${encodeURIComponent(runId)}/events`
+        : `${trimSlash(options.baseUrl)}/v1/chat/completions`, {
+        method: reconnect ? "GET" : "POST",
+        headers: {
+            ...requestHeaders(options),
+            accept: "text/event-stream",
+            ...(!reconnect && turn.sessionId ? { "x-session-id": turn.sessionId } : {}),
+            ...(replay.serverCursor === undefined
+                ? {}
+                : { "last-event-id": replay.serverCursor }),
+        },
+        ...(requestBody === undefined ? {} : { body: 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);
+    }
+    onAccepted?.(response);
+    if (!response.body)
+        throw new Error("cli-bridge response body is empty");
+    let text = "";
+    const sessionId = turn.sessionId ?? runId;
+    const messageId = turn.turnId ?? `${sessionId}:assistant`;
+    const emittedToolCalls = new Set();
+    let completed = false;
+    let sawUsage = false;
+    let observedModelRequests = 0;
+    let modelRequestsKnown = false;
+    let servedModel;
+    let systemFingerprint;
+    let textBoundaryPending = false;
+    let terminalCursor;
+    let sawProtocolEnd = false;
+    for await (const frame of parseSse(response.body)) {
+        if (frame.data === "[DONE]") {
+            sawProtocolEnd = true;
+            continue;
+        }
+        const parsed = safeJson(frame.data);
+        if (!parsed)
+            continue;
+        if (parsed.error && typeof parsed.error === "object") {
+            const error = parsed.error;
+            const message = typeof error.message === "string" ? error.message : "cli-bridge error";
+            yield* retainedEventsWithIdentity([{
+                    type: "status",
+                    data: { status: "failed", error: message },
+                    normalized: { type: "status", status: "failed", detail: message },
+                }], frame.id, runId, sessionId, turn.executionId, replay.anchor);
+            throw new Error(`cli-bridge: ${message}`);
+        }
+        const choice = Array.isArray(parsed.choices) ? parsed.choices[0] : undefined;
+        const delta = choice?.delta;
+        const responseIdentity = responseIdentityFromOpenAi(parsed);
+        if (responseIdentity?.model !== undefined)
+            servedModel = responseIdentity.model;
+        if (responseIdentity?.system_fingerprint !== undefined) {
+            systemFingerprint = responseIdentity.system_fingerprint;
+        }
+        const identityData = {
+            ...(servedModel === undefined ? {} : { model: servedModel }),
+            ...(systemFingerprint === undefined ? {} : { system_fingerprint: systemFingerprint }),
+        };
+        const toolCallDeltas = toolCallsFromDelta(delta);
+        const rawChunk = delta && typeof delta.content === "string" ? delta.content : "";
+        const chunk = rawChunk &&
+            textBoundaryPending &&
+            toolCallDeltas.length === 0 &&
+            text.length > 0 &&
+            !/\s$/u.test(text) &&
+            !/^\s/u.test(rawChunk)
+            ? `\n\n${rawChunk}`
+            : rawChunk;
+        if (rawChunk && toolCallDeltas.length === 0)
+            textBoundaryPending = false;
+        const nextUsage = usageFromOpenAi(parsed.usage);
+        const nextModelRequests = modelRequestsFromOpenAi(parsed.usage);
+        const frameEvents = [];
+        if (nextUsage || nextModelRequests !== undefined) {
+            if (nextUsage)
+                sawUsage = true;
+            if (nextModelRequests !== undefined) {
+                observedModelRequests += nextModelRequests;
+                modelRequestsKnown = true;
+            }
+            frameEvents.push({
+                type: "usage",
+                data: {
+                    ...identityData,
+                    ...(nextModelRequests === undefined ? {} : { modelRequests: nextModelRequests }),
+                },
+                ...(nextUsage ? { 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,
+            };
+            frameEvents.push({
+                type: "message.part.updated",
+                data: { ...identityData, part, delta: chunk },
+                normalized,
+            });
+        }
+        for (const toolCall of toolCallDeltas) {
+            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,
+            };
+            frameEvents.push({
+                type: "message.part.updated",
+                data: { part },
+                normalized,
+            });
+        }
+        if (toolCallDeltas.length > 0)
+            textBoundaryPending = true;
+        if (choice?.finish_reason) {
+            if (choice.finish_reason === "error") {
+                frameEvents.push({
+                    type: "status",
+                    data: { status: "failed", error: "cli-bridge returned finish_reason=error" },
+                    normalized: {
+                        type: "status",
+                        status: "failed",
+                        detail: "cli-bridge returned finish_reason=error",
+                    },
+                });
+                yield* retainedEventsWithIdentity(frameEvents, frame.id, runId, sessionId, turn.executionId, replay.anchor);
+                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 } : {}),
+                    },
+                });
+            }
+        }
+        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 (!completed && lastEventId === undefined) {
+        throw new Error("cli-bridge stream ended without a terminal result");
+    }
+    if (lastEventId && requestBody !== undefined) {
+        const result = await readFullCliBridgeResult(options, requestBody, transport, signal, onAccepted);
+        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 }),
+        };
+    }
+}
+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");
+    const response = await transport.fetch(`${trimSlash(options.baseUrl)}/v1/chat/completions`, {
+        method: "POST",
+        headers: requestHeaders(options),
+        body: JSON.stringify({ ...body, stream: false }),
+        ...(signal ? { 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;
+        const message = typeof error.message === "string" ? error.message : "cli-bridge replay failed";
+        throw new Error(`cli-bridge replay result failed: ${message}`);
+    }
+    const choice = Array.isArray(parsed?.choices) ? parsed.choices[0] : undefined;
+    const message = choice?.message && typeof choice.message === "object"
+        ? choice.message
+        : undefined;
+    if (typeof message?.content !== "string" ||
+        typeof choice?.finish_reason !== "string") {
+        throw new Error("cli-bridge replay result returned an invalid completion");
+    }
+    if (choice.finish_reason === "error" || choice.finish_reason === "timeout") {
+        throw new Error(`cli-bridge replay result ended ${choice.finish_reason}`);
+    }
+    const usage = usageFromOpenAi(parsed?.usage);
+    const modelRequests = modelRequestsFromOpenAi(parsed?.usage);
+    const responseIdentity = responseIdentityFromOpenAi(parsed);
+    return {
+        text: message.content,
+        finishReason: choice.finish_reason,
+        ...(usage ? { usage } : {}),
+        ...(modelRequests === undefined ? {} : { modelRequests }),
+        ...(responseIdentity?.model === undefined ? {} : { model: responseIdentity.model }),
+        ...(responseIdentity?.system_fingerprint === undefined
+            ? {}
+            : { system_fingerprint: responseIdentity.system_fingerprint }),
+    };
+}

package/dist/transport.d.ts

@@ -0,0 +1,23 @@
+import type { CliBridgeProviderOptions } from "./provider-options.js";
+export interface CliBridgeTransport {
+    fetch(input: string, init: CliBridgeRequest): Promise<CliBridgeResponse>;
+    close(): Promise<void>;
+}
+export interface CliBridgeRequest {
+    method: "GET" | "POST";
+    headers: Record<string, string>;
+    body?: string;
+    signal?: AbortSignal;
+}
+export interface CliBridgeResponse {
+    readonly ok: boolean;
+    readonly status: number;
+    readonly body: AsyncIterable<Uint8Array> | null;
+    readonly headers: {
+        get(name: string): string | null;
+    };
+    text(): Promise<string>;
+}
+export declare function createCliBridgeTransport(options: CliBridgeProviderOptions): CliBridgeTransport;
+export declare function requestHeaders(options: CliBridgeProviderOptions): Record<string, string>;
+export declare function trimSlash(value: string): string;

package/dist/transport.js

@@ -0,0 +1,32 @@
+import { Agent, fetch as undiciFetch } from "undici";
+export function createCliBridgeTransport(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();
+        },
+    };
+}
+export function requestHeaders(options) {
+    return {
+        "content-type": "application/json",
+        ...(options.bearerToken ? { authorization: `Bearer ${options.bearerToken}` } : {}),
+    };
+}
+export function trimSlash(value) {
+    return value.replace(/\/+$/, "");
+}

package/dist/wire.d.ts

@@ -0,0 +1,27 @@
+import type { 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";
+export declare function toChatCompletionsBody(options: CliBridgeProviderOptions, environmentInput: CreateAgentEnvironmentInput, turn: AgentTurnInput, runId: string): Record<string, unknown>;
+export interface CliBridgeSseFrame {
+    readonly data: string;
+    readonly id?: string;
+}
+export declare function parseSse(body: AsyncIterable<Uint8Array>): AsyncIterable<CliBridgeSseFrame>;
+export declare function toolCallsFromDelta(value: unknown): Array<{
+    id?: string;
+    index: number;
+    name?: string;
+}>;
+export declare function safeJson(value: string): Record<string, unknown> | null;
+export declare function usageFromOpenAi(value: unknown): TokenUsage | undefined;
+export declare function modelRequestsFromOpenAi(value: unknown): number | undefined;
+/** Preserve the provider identity that cli-bridge returns on each completion frame. */
+export declare function responseIdentityFromOpenAi(value: unknown): {
+    model?: string;
+    system_fingerprint?: string;
+} | undefined;
+export declare function modelRequestCount(value: unknown): number | undefined;
+export declare function cliBridgeRunId(environmentId: string, turn: AgentTurnInput, turnId: string): string;
+export declare function runSnapshot(value: string): CliBridgeRunSnapshot;
+export declare function cancelSnapshot(value: string): CliBridgeRunSnapshot;

package/dist/wire.js

@@ -0,0 +1,243 @@
+import { createHash } from "node:crypto";
+import { AgentExactRunControlRefSchema } from "@tangle-network/agent-interface";
+export function toChatCompletionsBody(options, environmentInput, turn, runId) {
+    const profile = inlineProfile(environmentInput.profile);
+    const execution = executionFromInput(options, environmentInput);
+    return {
+        model: resolveBridgeModel(options, environmentInput, turn, profile),
+        messages: messagesFromTurn(turn),
+        stream: true,
+        ...(turn.sessionId ? { session_id: turn.sessionId } : {}),
+        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 } : {}),
+        ...(execution ? { execution } : {}),
+        metadata: {
+            ...(environmentInput.metadata ?? {}),
+            ...(turn.context ?? {}),
+            ...(turn.providerOptions ?? {}),
+        },
+    };
+}
+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;
+    if (!harness) {
+        if (model)
+            return model;
+        throw new Error("createCliBridgeProvider requires an explicit bridge model or a profile/backend harness");
+    }
+    if (!model || model === harness)
+        return harness;
+    if (model.startsWith(`${harness}/`))
+        return model;
+    if (model.includes("/"))
+        return `${harness}/${model}`;
+    if (provider)
+        return `${harness}/${provider}/${model}`;
+    return `${harness}/${model}`;
+}
+/** Keep task messages separate from the profile's harness-owned prompt controls. */
+function messagesFromTurn(turn) {
+    return [{ role: "user", content: contentFromTurn(turn) }];
+}
+function contentFromTurn(turn) {
+    if (turn.parts)
+        return turn.parts;
+    return turn.prompt ?? "";
+}
+function inlineProfile(profile) {
+    return typeof profile === "string" ? undefined : profile;
+}
+function executionFromInput(options, input) {
+    if (options.defaultExecution)
+        return options.defaultExecution;
+    if (!input.workspace?.repoUrl)
+        return undefined;
+    return {
+        kind: "sandbox",
+        repoUrl: input.workspace.repoUrl,
+        ...(input.workspace.gitRef ? { gitRef: input.workspace.gitRef } : {}),
+    };
+}
+export async function* parseSse(body) {
+    const decoder = new TextDecoder();
+    let 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)
+                yield data;
+            boundary = findFrameBoundary(buffer);
+        }
+    }
+    buffer += decoder.decode();
+    if (buffer) {
+        const data = dataFromFrame(buffer);
+        if (data)
+            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
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.slice("data:".length).trimStart())
+        .join("\n");
+    if (!data)
+        return undefined;
+    const id = lines.find((line) => line.startsWith("id:"))?.slice("id:".length).trim();
+    return { data, ...(id ? { id } : {}) };
+}
+export 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 = nonNegativeSafeInteger(record.index) ?? position;
+        const id = typeof record.id === "string" ? record.id : undefined;
+        return [{ ...(id ? { id } : {}), index, ...(name ? { name } : {}) }];
+    });
+}
+export function safeJson(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === "object" ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function usageFromOpenAi(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const record = value;
+    const inputTokens = nonNegativeSafeInteger(record.prompt_tokens) ??
+        nonNegativeSafeInteger(record.input_tokens);
+    const outputTokens = nonNegativeSafeInteger(record.completion_tokens) ??
+        nonNegativeSafeInteger(record.output_tokens);
+    if (inputTokens === undefined || outputTokens === undefined)
+        return undefined;
+    const totalTokens = nonNegativeSafeInteger(record.total_tokens);
+    const cacheReadInputTokens = nonNegativeSafeInteger(record.cache_read_input_tokens);
+    const cacheCreationInputTokens = nonNegativeSafeInteger(record.cache_creation_input_tokens);
+    const reasoningTokens = nonNegativeSafeInteger(record.reasoning_tokens);
+    const cost = finiteNonNegativeNumber(record.cost);
+    return {
+        inputTokens,
+        outputTokens,
+        ...(totalTokens !== undefined ? { totalTokens } : {}),
+        ...(cacheReadInputTokens !== undefined ? { cacheReadInputTokens } : {}),
+        ...(cacheCreationInputTokens !== undefined ? { cacheCreationInputTokens } : {}),
+        ...(reasoningTokens !== undefined ? { reasoningTokens } : {}),
+        ...(cost !== undefined ? { cost } : {}),
+    };
+}
+export function modelRequestsFromOpenAi(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    return modelRequestCount(value.model_requests);
+}
+/** Preserve the provider identity that cli-bridge returns on each completion frame. */
+export function responseIdentityFromOpenAi(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const record = value;
+    const model = nonEmptyString(record.model);
+    const systemFingerprint = nonEmptyString(record.system_fingerprint);
+    if (model === undefined && systemFingerprint === undefined)
+        return undefined;
+    return {
+        ...(model === undefined ? {} : { model }),
+        ...(systemFingerprint === undefined ? {} : { system_fingerprint: systemFingerprint }),
+    };
+}
+export function modelRequestCount(value) {
+    return nonNegativeSafeInteger(value);
+}
+function nonNegativeSafeInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0
+        ? value
+        : undefined;
+}
+function finiteNonNegativeNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0
+        ? value
+        : undefined;
+}
+function nonEmptyString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+export function cliBridgeRunId(environmentId, turn, turnId) {
+    if (turn.executionId &&
+        turn.executionId.length <= 128 &&
+        /^[A-Za-z0-9][A-Za-z0-9._:-]*$/u.test(turn.executionId)) {
+        return turn.executionId;
+    }
+    const digest = createHash("sha256")
+        .update(environmentId)
+        .update("\0")
+        .update(turn.sessionId ?? "")
+        .update("\0")
+        .update(turn.executionId ?? turnId)
+        .digest("hex");
+    return `agent-${digest}`;
+}
+export function runSnapshot(value) {
+    const parsed = safeJson(value);
+    if (!parsed)
+        throw new Error("cli-bridge run status returned invalid JSON");
+    const id = parsed.id;
+    const requestDigest = parsed.requestDigest === undefined
+        ? undefined
+        : AgentExactRunControlRefSchema.shape.requestDigest.safeParse(parsed.requestDigest);
+    const status = parsed.status;
+    const terminal = parsed.terminal;
+    if (typeof id !== "string" ||
+        (requestDigest !== undefined && !requestDigest.success) ||
+        !["running", "done", "error", "cancelled"].includes(String(status)) ||
+        typeof terminal !== "boolean") {
+        throw new Error("cli-bridge run status returned an invalid snapshot");
+    }
+    return {
+        id,
+        ...(requestDigest?.success ? { requestDigest: requestDigest.data } : {}),
+        status: status,
+        terminal,
+    };
+}
+export function cancelSnapshot(value) {
+    const parsed = safeJson(value);
+    if (!parsed || !parsed.run || typeof parsed.run !== "object") {
+        throw new Error("cli-bridge cancel returned an invalid snapshot");
+    }
+    return runSnapshot(JSON.stringify(parsed.run));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-provider-cli-bridge",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "AgentEnvironmentProvider adapter for cli-bridge /v1/chat/completions",
   "type": "module",
   "license": "MIT",
@@ -25,12 +25,30 @@
   "files": [
     "dist/index.d.ts",
     "dist/index.js",
+    "dist/provider-options.d.ts",
+    "dist/provider-options.js",
+    "dist/retained-control.d.ts",
+    "dist/retained-control.js",
+    "dist/retained-environment.d.ts",
+    "dist/retained-environment.js",
+    "dist/retained-event-cursor.d.ts",
+    "dist/retained-event-cursor.js",
+    "dist/retained-execution.d.ts",
+    "dist/retained-execution.js",
+    "dist/retained-run-state.d.ts",
+    "dist/retained-run-state.js",
+    "dist/retained-stream.d.ts",
+    "dist/retained-stream.js",
+    "dist/transport.d.ts",
+    "dist/transport.js",
+    "dist/wire.d.ts",
+    "dist/wire.js",
     "README.md",
     "LICENSE"
   ],
   "dependencies": {
-    "@tangle-network/agent-interface": "0.47.0",
-    "undici": "7.28.0"
+    "@tangle-network/agent-interface": "0.48.0",
+    "undici": "7.29.0"
   },
   "devDependencies": {
     "@types/node": "25.6.0",