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

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,22 @@
+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;
+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,226 @@
+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);
+}
+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;
+}
+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.0",
   "description": "AgentEnvironmentProvider adapter for cli-bridge /v1/chat/completions",
   "type": "module",
   "license": "MIT",
@@ -25,6 +25,24 @@
   "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"
   ],