@tangle-network/agent-provider-cli-bridge 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tangle Network
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,13 @@
+# @tangle-network/agent-provider-cli-bridge
+
+Wraps a running `cli-bridge` server as an `AgentEnvironmentProvider`.
+
+```ts
+import { createCliBridgeProvider } from '@tangle-network/agent-provider-cli-bridge'
+
+const provider = createCliBridgeProvider({
+  baseUrl: 'http://127.0.0.1:8787',
+  bearerToken: process.env.CLI_BRIDGE_TOKEN,
+  defaultModel: 'codex',
+})
+```

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+import type { AgentEnvironmentCapabilities, AgentEnvironmentProvider } from "@tangle-network/agent-interface/environment-provider";
+export interface CliBridgeProviderOptions {
+    baseUrl: string;
+    bearerToken?: string;
+    defaultModel?: string;
+    defaultMode?: "byob" | "hosted-safe" | "hosted-sandboxed";
+    defaultExecution?: {
+        kind: "host";
+    } | {
+        kind: "sandbox";
+        repoUrl?: string;
+        gitRef?: string;
+        capability?: string;
+        ttlSeconds?: number;
+    };
+    fetch?: typeof fetch;
+    name?: string;
+    capabilities?: AgentEnvironmentCapabilities;
+}
+export declare function createCliBridgeProvider(options: CliBridgeProviderOptions): AgentEnvironmentProvider;
+export declare function defaultCliBridgeCapabilities(): AgentEnvironmentCapabilities;

package/dist/index.js

@@ -0,0 +1,233 @@
+export function createCliBridgeProvider(options) {
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    if (!fetchImpl)
+        throw new Error("createCliBridgeProvider requires fetch");
+    const name = options.name ?? "cli-bridge";
+    return {
+        name,
+        capabilities: () => options.capabilities ?? defaultCliBridgeCapabilities(),
+        async create(input) {
+            return {
+                id: input.idempotencyKey ?? input.name ?? crypto.randomUUID(),
+                provider: name,
+                ...(input.name ? { name: input.name } : {}),
+                status: async () => "running",
+                stream: (turn) => streamCliBridgeTurn(fetchImpl, options, input, turn),
+                placement: async () => ({
+                    kind: options.defaultExecution?.kind === "sandbox" ? "sandbox" : "local",
+                    providerMetadata: { baseUrl: options.baseUrl },
+                }),
+                destroy: async () => { },
+            };
+        },
+    };
+}
+async function* streamCliBridgeTurn(fetchImpl, options, environmentInput, turn) {
+    const response = await fetchImpl(`${trimSlash(options.baseUrl)}/v1/chat/completions`, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            accept: "text/event-stream",
+            ...(options.bearerToken ? { authorization: `Bearer ${options.bearerToken}` } : {}),
+            ...(turn.sessionId ? { "x-session-id": turn.sessionId } : {}),
+        },
+        body: JSON.stringify(toChatCompletionsBody(options, environmentInput, turn)),
+        signal: turn.signal ?? environmentInput.signal,
+    });
+    if (!response.ok) {
+        throw new Error(`cli-bridge ${response.status}: ${await response.text()}`);
+    }
+    if (!response.body)
+        throw new Error("cli-bridge response body is empty");
+    let text = "";
+    let usage;
+    for await (const event of parseSse(response.body)) {
+        if (event === "[DONE]")
+            break;
+        const parsed = safeJson(event);
+        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 { type: "status", data: { status: "failed", error: message } };
+            return;
+        }
+        const choice = Array.isArray(parsed.choices) ? parsed.choices[0] : undefined;
+        const delta = choice?.delta;
+        const chunk = delta && typeof delta.content === "string" ? delta.content : "";
+        const nextUsage = usageFromOpenAi(parsed.usage);
+        if (nextUsage) {
+            usage = mergeUsage(usage, nextUsage);
+            yield { type: "usage", data: { usage: nextUsage }, usage: nextUsage };
+        }
+        if (chunk) {
+            text += chunk;
+            yield {
+                type: "message.part.updated",
+                data: { delta: chunk },
+            };
+        }
+        if (choice?.finish_reason) {
+            yield {
+                type: "result",
+                data: {
+                    finalText: text,
+                    finishReason: choice.finish_reason,
+                    status: choice.finish_reason === "error" ? "failed" : "completed",
+                },
+                ...(usage ? { usage } : {}),
+            };
+        }
+    }
+}
+function toChatCompletionsBody(options, environmentInput, turn) {
+    const profile = inlineProfile(environmentInput.profile);
+    return {
+        model: turn.model ?? environmentInput.backend ?? options.defaultModel ?? "opencode",
+        messages: messagesFromTurn(turn, profile),
+        stream: true,
+        ...(turn.sessionId ? { session_id: turn.sessionId } : {}),
+        ...(options.defaultMode ? { mode: options.defaultMode } : {}),
+        ...(profile ? { agent_profile: profile } : {}),
+        ...(environmentInput.env ? { env: environmentInput.env } : {}),
+        ...(environmentInput.workspace?.cwd ? { cwd: environmentInput.workspace.cwd } : {}),
+        ...(executionFromInput(options, environmentInput) ? { execution: executionFromInput(options, environmentInput) } : {}),
+        metadata: {
+            ...(environmentInput.metadata ?? {}),
+            ...(turn.context ?? {}),
+            ...(turn.providerOptions ?? {}),
+        },
+    };
+}
+function messagesFromTurn(turn, profile) {
+    const messages = [];
+    const systemPrompt = profile?.prompt?.systemPrompt;
+    if (systemPrompt)
+        messages.push({ role: "system", content: systemPrompt });
+    messages.push({ role: "user", content: contentFromTurn(turn) });
+    return messages;
+}
+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 } : {}),
+    };
+}
+async function* parseSse(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            let boundary = buffer.indexOf("\n\n");
+            while (boundary !== -1) {
+                const frame = buffer.slice(0, boundary);
+                buffer = buffer.slice(boundary + 2);
+                const data = dataFromFrame(frame);
+                if (data !== undefined)
+                    yield data;
+                boundary = buffer.indexOf("\n\n");
+            }
+        }
+        if (buffer) {
+            const data = dataFromFrame(buffer);
+            if (data !== undefined)
+                yield data;
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+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");
+    return data || undefined;
+}
+function safeJson(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === "object" ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function usageFromOpenAi(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const record = value;
+    const inputTokens = number(record.prompt_tokens) ?? number(record.input_tokens);
+    const outputTokens = number(record.completion_tokens) ?? number(record.output_tokens);
+    if (inputTokens === undefined && outputTokens === undefined)
+        return undefined;
+    return { inputTokens: inputTokens ?? 0, outputTokens: outputTokens ?? 0 };
+}
+function mergeUsage(left, right) {
+    if (!left)
+        return right;
+    return {
+        inputTokens: left.inputTokens + right.inputTokens,
+        outputTokens: left.outputTokens + right.outputTokens,
+        ...(left.cost !== undefined || right.cost !== undefined ? { cost: (left.cost ?? 0) + (right.cost ?? 0) } : {}),
+    };
+}
+function number(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function trimSlash(value) {
+    return value.replace(/\/+$/, "");
+}
+export function defaultCliBridgeCapabilities() {
+    return {
+        profile: {
+            namedProfiles: false,
+            systemPrompt: true,
+            instructions: true,
+            tools: true,
+            permissions: true,
+            mcp: true,
+            subagents: true,
+            resources: {
+                files: true,
+                instructions: true,
+                tools: true,
+                skills: true,
+                agents: true,
+                commands: true,
+            },
+            hooks: false,
+            modes: true,
+            runtimeUpdate: false,
+            validation: false,
+        },
+        streaming: { live: true, replay: false, detach: false, 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 },
+        placement: true,
+        usage: true,
+        confidential: false,
+    };
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@tangle-network/agent-provider-cli-bridge",
+  "version": "0.2.0",
+  "description": "AgentEnvironmentProvider adapter for cli-bridge /v1/chat/completions",
+  "type": "module",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tangle-network/agent-sdk.git",
+    "directory": "packages/agent-provider-cli-bridge"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "files": [
+    "dist/index.d.ts",
+    "dist/index.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@tangle-network/agent-interface": "0.14.0"
+  },
+  "devDependencies": {
+    "@types/node": "25.6.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "check-types": "tsc --noEmit",
+    "clean": "rm -rf dist",
+    "test": "vitest run"
+  }
+}