@uncensoredcode/openbridge 0.1.0

package/README.md

@@ -0,0 +1,117 @@
+# uncensoredcode // openbridge
+
+Turn a glossy web-chat LLM into an agent-ready, tool-calling model.
+
+`openbridge` reuses authenticated browser chat sessions and exposes them through an OpenAI-compatible API so agents like `opencode`, `pi`, `OpenClaw`, `Hermes`, and anything else that can speak OpenAI-style chat completions can drive them like real tool-call models.
+
+This is not another chatbot wrapper. The point is to take the classic consumer web-chat experience, keep the auth session you already have, and bridge it into something agents can actually use.
+
+## What It Does
+
+- Reuses authenticated web sessions instead of forcing a separate API key flow.
+- Preserves provider conversation bindings so follow-up turns keep working.
+- Exposes an OpenAI-compatible `/v1/chat/completions` surface.
+- Supports generic transport profiles for `http-sse`, `http-json`, and `http-connect`.
+- Lets you run the same bridge against different upstream chat products without rewriting your agent stack every time.
+
+Most of the currently tested targets are the usual big chat LLM products. The actual goal is broader: make this bridge generic enough to sit in front of any OpenAI-compatible API or browser-backed chat transport we can model cleanly.
+
+## Critical Path: Session Extraction
+
+The critical path is session extraction. That is why the extension exists.
+
+Maintainer note: I personally believe users should be extremely careful with any extension that extracts auth sessions. That is powerful, invasive, and easy to misuse. If you do not want to trust an extension with that job, manually extract the session material yourself and install it through the session-package flow, or have an agent vibe-code a dedicated installer on top of this repo's formats and server endpoints.
+
+In other words: the extension is a convenience path, not a trust requirement.
+
+## Tested Targets
+
+Confirmed in the repo's transport/session-package test suite:
+
+- `chat.deepseek.com` with `deepseek-chat`
+- `chat.qwen.ai` with `qwen3.6-plus`
+- `chat.z.ai` with `glm-4.7`
+- `www.kimi.com` as a Kimi-style `http-connect` target
+
+Observed in checked-in bridge continuation state in this repo:
+
+- `chat.qwen.ai` with `qwen3-max` and `qwen3.6-plus`
+- `chat.deepseek.com` with `deepseek-chat`
+- `chat.z.ai` with `GLM-5-Turbo` and `glm-4.7`
+- `www.kimi.com` with `kimi-k2@instant`, `kimi-k2@no-thinking`, and `kimi-k2@thinking`
+
+That list should be read as "known working surfaces we have evidence for", not as a product boundary. The bridge is intended to be generic.
+
+## Package Surface
+
+- `@uncensoredcode/openbridge`: default server export.
+- `@uncensoredcode/openbridge/server`: Fastify HTTP API, provider/session-package storage, session vault, and standalone bridge server.
+- `@uncensoredcode/openbridge/runtime`: provider turn compilation, packet handling, tool execution, and runtime helpers.
+- `@uncensoredcode/openbridge/cli`: unified `openbridge` CLI for server control, health checks, and sending prompts to a running bridge server.
+
+## Quick Start
+
+```bash
+bun install
+bun run build
+bun run format:check
+bun run lint
+bun run test
+```
+
+Use the local CLI during development:
+
+```bash
+bun run ./bin/openbridge.js --help
+```
+
+Start the server in watch mode:
+
+```bash
+bun run dev:server
+```
+
+Or start the standalone server directly:
+
+```bash
+openbridge start
+```
+
+Check health:
+
+```bash
+openbridge health
+```
+
+Send a prompt through a bridge session:
+
+```bash
+openbridge --session demo "Read README.md"
+```
+
+Use the OpenAI-compatible endpoint directly:
+
+```bash
+curl http://127.0.0.1:4318/v1/chat/completions \
+  -H 'content-type: application/json' \
+  -d '{
+    "model": "chat-qwen-ai/qwen3-max",
+    "messages": [
+      { "role": "user", "content": "Reply with exactly OK." }
+    ]
+  }'
+```
+
+## Session Package Install Flow
+
+Captured session material is installed per provider through:
+
+```text
+PUT /v1/providers/:id/session-package
+```
+
+The server can infer provider transport details from captured browser requests and headers, then store the session package for later reuse.
+
+## Why This Exists
+
+The frontier labs keep shipping powerful models behind polished web apps. Agents want stable tool-calling APIs. `openbridge` is the splice point between those two worlds.

package/bin/openbridge.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { bridgeCli } from "@uncensoredcode/openbridge/cli";
+
+const { runBridgeCli } = bridgeCli;
+const exitCode = await runBridgeCli({
+  argv: process.argv.slice(2)
+});
+if (exitCode !== 0) {
+  process.exitCode = exitCode;
+}

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@uncensoredcode/openbridge",
+  "version": "0.1.0",
+  "description": "OpenBridge runtime, server, and CLI for bridging AI providers through a unified interface.",
+  "packageManager": "bun@1.3.11",
+  "type": "module",
+  "author": "Linuz",
+  "license": "MIT",
+  "main": "./packages/server/dist/index.js",
+  "types": "./packages/server/dist/index.d.ts",
+  "files": [
+    "bin",
+    "packages/runtime/dist",
+    "packages/server/dist",
+    "packages/cli/dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/uncensoredcode/openbridge.git"
+  },
+  "homepage": "https://github.com/uncensoredcode/openbridge",
+  "bugs": {
+    "url": "https://github.com/uncensoredcode/openbridge/issues"
+  },
+  "bin": {
+    "openbridge": "bin/openbridge.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./packages/server/dist/index.d.ts",
+      "default": "./packages/server/dist/index.js"
+    },
+    "./server": {
+      "types": "./packages/server/dist/index.d.ts",
+      "default": "./packages/server/dist/index.js"
+    },
+    "./runtime": {
+      "types": "./packages/runtime/dist/index.d.ts",
+      "default": "./packages/runtime/dist/index.js"
+    },
+    "./cli": {
+      "types": "./packages/cli/dist/index.d.ts",
+      "default": "./packages/cli/dist/index.js"
+    }
+  },
+  "workspaces": [
+    "packages/runtime",
+    "packages/server",
+    "packages/cli"
+  ],
+  "scripts": {
+    "build": "cd packages/runtime && bun run build && cd ../server && bun run build && cd ../cli && bun run build && cd ../..",
+    "typecheck": "bun run build && cd packages/runtime && bun run typecheck && cd ../server && bun run typecheck && cd ../cli && bun run typecheck",
+    "test": "bun run build && bun run test:workspaces",
+    "test:workspaces": "cd packages/runtime && bun run test && cd ../server && bun run test && cd ../cli && bun run test",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "prepare": "husky",
+    "dev:runtime": "cd packages/runtime && bun run dev",
+    "dev:server": "cd packages/server && bun run dev",
+    "dev:cli": "cd packages/cli && bun run dev",
+    "clear-session-vault": "cd packages/server && bun run build && bun run clear-session-vault"
+  },
+  "dependencies": {
+    "commander": "*",
+    "fastify": "*",
+    "zod": "*"
+  },
+  "devDependencies": {
+    "@eslint/js": "9.39.1",
+    "eslint": "9.39.1",
+    "eslint-plugin-import": "2.32.0",
+    "eslint-plugin-simple-import-sort": "12.1.1",
+    "globals": "16.4.0",
+    "husky": "9.1.7",
+    "prettier": "3.6.2",
+    "typescript-eslint": "8.46.1"
+  }
+}

package/packages/cli/dist/args.d.ts

@@ -0,0 +1,30 @@
+import type { BridgeApiToolProfile } from "@uncensoredcode/openbridge/server";
+type BridgeCliCommand = {
+    kind: "help";
+} | {
+    kind: "health";
+    baseUrl: string;
+} | {
+    kind: "server";
+    argv: string[];
+} | {
+    kind: "send";
+    baseUrl: string;
+    sessionId: string;
+    input: string;
+    provider?: string;
+    model?: string;
+    metadata?: Record<string, unknown>;
+    toolProfile?: BridgeApiToolProfile;
+};
+type ParseBridgeCliArgsInput = {
+    argv: string[];
+    env?: NodeJS.ProcessEnv;
+};
+declare function parseBridgeCliArgs(input: ParseBridgeCliArgsInput): BridgeCliCommand;
+declare function getBridgeCliHelpText(): string;
+export declare const argsModule: {
+    parseBridgeCliArgs: typeof parseBridgeCliArgs;
+    getBridgeCliHelpText: typeof getBridgeCliHelpText;
+};
+export type { BridgeCliCommand, ParseBridgeCliArgsInput };

package/packages/cli/dist/args.js

@@ -0,0 +1,160 @@
+const DEFAULT_BASE_URL = "http://127.0.0.1:4318";
+const SERVER_SUBCOMMANDS = new Set(["start", "chat", "live-canary", "clear-session-vault"]);
+function parseBridgeCliArgs(input) {
+    const env = input.env ?? process.env;
+    const args = [...input.argv];
+    const command = args[0];
+    if (args.length === 0) {
+        return {
+            kind: "help"
+        };
+    }
+    if (command && SERVER_SUBCOMMANDS.has(command)) {
+        return {
+            kind: "server",
+            argv: args
+        };
+    }
+    if (command === "help" ||
+        command === "--help" ||
+        command === "-h" ||
+        args.includes("--help") ||
+        args.includes("-h")) {
+        return {
+            kind: "help"
+        };
+    }
+    if (command === "health") {
+        const { options, positionals } = parseFlags(args.slice(1));
+        if (positionals.length > 0) {
+            throw new Error("health does not accept positional arguments.");
+        }
+        return {
+            kind: "health",
+            baseUrl: readBaseUrl(options.baseUrl, env)
+        };
+    }
+    const { options, positionals } = parseFlags(args);
+    const sessionId = requireNonEmptyString(options.session, "session");
+    const inputText = readInput(options.input, positionals);
+    const metadata = readMetadata(options.metadata);
+    const toolProfile = readToolProfile(options.toolProfile);
+    return {
+        kind: "send",
+        baseUrl: readBaseUrl(options.baseUrl, env),
+        sessionId,
+        input: inputText,
+        provider: optionalNonEmptyString(options.provider, "provider") ?? undefined,
+        model: optionalNonEmptyString(options.model, "model") ?? undefined,
+        metadata,
+        toolProfile
+    };
+}
+function getBridgeCliHelpText() {
+    return [
+        "openbridge",
+        "",
+        "Usage:",
+        "  openbridge start [--host <host>] [--port <port>] [--token <token>]",
+        "  openbridge health [--base-url <url>]",
+        "  openbridge --session <id> [--input <text>] [--base-url <url>] [--provider <id>] [--model <id>] [--metadata <json>]",
+        "  openbridge chat --model <id> --message <text> [--system <text>] [--base-url <url>] [--stream]",
+        "  openbridge live-canary [--state-root <path>] [--provider <id>] [--model <id>]",
+        "  openbridge clear-session-vault [--state-root <path>] [--session-vault-path <path>]",
+        "",
+        "Examples:",
+        "  openbridge start",
+        "  openbridge health",
+        '  openbridge --session demo "Read README.md"',
+        '  openbridge --base-url http://127.0.0.1:4318 --session s1 --input "Run git status"'
+    ].join("\n");
+}
+function parseFlags(argv) {
+    const options = {};
+    const positionals = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const value = argv[index] ?? "";
+        if (!value.startsWith("--")) {
+            positionals.push(value);
+            continue;
+        }
+        const key = value.slice(2);
+        const next = argv[index + 1];
+        if (!next || next.startsWith("--")) {
+            throw new Error(`Missing value for --${key}.`);
+        }
+        options[toOptionKey(key)] = next;
+        index += 1;
+    }
+    return {
+        options,
+        positionals
+    };
+}
+function toOptionKey(value) {
+    return value.replace(/-([a-z])/g, (_match, character) => character.toUpperCase());
+}
+function readBaseUrl(value, env) {
+    return (optionalNonEmptyString(value, "base-url") ??
+        optionalNonEmptyString(env.BRIDGE_API_BASE_URL, "BRIDGE_API_BASE_URL") ??
+        optionalNonEmptyString(env.BRIDGE_SERVER_BASE_URL, "BRIDGE_SERVER_BASE_URL") ??
+        DEFAULT_BASE_URL);
+}
+function readInput(flagValue, positionals) {
+    const flagInput = optionalNonEmptyString(flagValue, "input");
+    const positionalInput = positionals.length > 0 ? positionals.join(" ") : null;
+    if (flagInput && positionalInput && flagInput !== positionalInput) {
+        throw new Error("Provide input either with --input or as a positional argument, not both.");
+    }
+    const resolved = flagInput ?? positionalInput;
+    if (!resolved?.trim()) {
+        throw new Error("input is required.");
+    }
+    return resolved;
+}
+function readMetadata(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        throw new Error("metadata must be valid JSON.");
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error("metadata must be a JSON object.");
+    }
+    return parsed;
+}
+function readToolProfile(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "default" || value === "workspace") {
+        return value;
+    }
+    throw new Error('toolProfile must be either "default" or "workspace".');
+}
+function requireNonEmptyString(value, key) {
+    const normalized = optionalNonEmptyString(value, key);
+    if (!normalized) {
+        throw new Error(`${key} is required.`);
+    }
+    return normalized;
+}
+function optionalNonEmptyString(value, key) {
+    if (value === undefined) {
+        return null;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        throw new Error(`${key} must be a non-empty string.`);
+    }
+    return trimmed;
+}
+export const argsModule = {
+    parseBridgeCliArgs,
+    getBridgeCliHelpText
+};

package/packages/cli/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/packages/cli/dist/cli.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { bridgeCli } from "./index.js";
+const { runBridgeCli } = bridgeCli;
+const exitCode = await runBridgeCli({
+    argv: process.argv.slice(2)
+});
+if (exitCode !== 0) {
+    process.exitCode = exitCode;
+}

package/packages/cli/dist/index.d.ts

@@ -0,0 +1,26 @@
+import type { BridgeApiClientFetch, RunBridgeServerCliInput } from "@uncensoredcode/openbridge/server";
+declare const runBridgeServerCli: (input: import("../../server/dist/cli/run-bridge-server-cli.js").RunBridgeServerCliInput) => Promise<number>;
+type BridgeCliDependencies = {
+    argv: string[];
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: BridgeApiClientFetch;
+    stdout?: {
+        write(value: string): void;
+    };
+    stderr?: {
+        write(value: string): void;
+    };
+    stdin?: RunBridgeServerCliInput["stdin"];
+    startServer?: RunBridgeServerCliInput["startServer"];
+    onServerStarted?: RunBridgeServerCliInput["onServerStarted"];
+    runLiveCanary?: RunBridgeServerCliInput["runLiveCanary"];
+    promptForVaultKey?: RunBridgeServerCliInput["promptForVaultKey"];
+    runServerCli?: typeof runBridgeServerCli;
+};
+declare function runBridgeCli(dependencies: BridgeCliDependencies): Promise<number>;
+export declare const bridgeCli: {
+    getBridgeCliHelpText: () => string;
+    parseBridgeCliArgs: (input: import("./args.ts").ParseBridgeCliArgsInput) => import("./args.ts").BridgeCliCommand;
+    runBridgeCli: typeof runBridgeCli;
+};
+export type { BridgeCliCommand } from "./args.ts";

package/packages/cli/dist/index.js

@@ -0,0 +1,76 @@
+import { bridgeServer } from "@uncensoredcode/openbridge/server";
+import { argsModule } from "./args.js";
+const { BridgeApiHttpError, checkBridgeHealth, runBridgeServerCli, sendBridgeMessage } = bridgeServer;
+const { getBridgeCliHelpText, parseBridgeCliArgs } = argsModule;
+async function runBridgeCli(dependencies) {
+    const stdout = dependencies.stdout ?? process.stdout;
+    const stderr = dependencies.stderr ?? process.stderr;
+    const stdin = dependencies.stdin ?? process.stdin;
+    const delegatedRunBridgeServerCli = dependencies.runServerCli ?? runBridgeServerCli;
+    let command;
+    try {
+        command = parseBridgeCliArgs({
+            argv: dependencies.argv,
+            env: dependencies.env
+        });
+    }
+    catch (error) {
+        stderr.write(`${formatCliError(error)}\n`);
+        return 1;
+    }
+    if (command.kind === "help") {
+        stdout.write(`${getBridgeCliHelpText()}\n`);
+        return 0;
+    }
+    if (command.kind === "server") {
+        return delegatedRunBridgeServerCli({
+            argv: command.argv,
+            env: dependencies.env,
+            stdout,
+            stderr,
+            stdin,
+            startServer: dependencies.startServer,
+            onServerStarted: dependencies.onServerStarted,
+            runLiveCanary: dependencies.runLiveCanary,
+            fetchImpl: dependencies.fetchImpl,
+            promptForVaultKey: dependencies.promptForVaultKey
+        });
+    }
+    try {
+        if (command.kind === "health") {
+            const health = await checkBridgeHealth({
+                baseUrl: command.baseUrl,
+                fetchImpl: dependencies.fetchImpl
+            });
+            stdout.write(`${health.ok ? "ok" : "unhealthy"}\n`);
+            return health.ok ? 0 : 1;
+        }
+        const response = await sendBridgeMessage({
+            baseUrl: command.baseUrl,
+            sessionId: command.sessionId,
+            input: command.input,
+            provider: command.provider,
+            model: command.model,
+            metadata: command.metadata,
+            toolProfile: command.toolProfile,
+            fetchImpl: dependencies.fetchImpl
+        });
+        stdout.write(`${response.output}\n`);
+        return 0;
+    }
+    catch (error) {
+        stderr.write(`${formatCliError(error)}\n`);
+        return 1;
+    }
+}
+function formatCliError(error) {
+    if (error instanceof BridgeApiHttpError) {
+        return `${error.code}: ${error.message}`;
+    }
+    return error instanceof Error ? error.message : String(error);
+}
+export const bridgeCli = {
+    getBridgeCliHelpText: argsModule.getBridgeCliHelpText,
+    parseBridgeCliArgs: argsModule.parseBridgeCliArgs,
+    runBridgeCli
+};

package/packages/runtime/dist/assistant-protocol.d.ts

@@ -0,0 +1,34 @@
+import type { ToolDefinition } from "./execution/types.ts";
+type AssistantToolCall = {
+    id?: string;
+    name: string;
+    arguments: Record<string, unknown>;
+};
+type AssistantFinalResponse = {
+    type: "final";
+    message: string;
+};
+type AssistantToolResponse = {
+    type: "tool";
+    toolCall: AssistantToolCall;
+};
+type AssistantResponse = AssistantFinalResponse | AssistantToolResponse;
+declare class AssistantProtocolError extends Error {
+    constructor(message: string);
+}
+declare function parseAssistantResponse(rawText: string): AssistantResponse;
+declare function validateAssistantResponse(response: AssistantResponse, availableTools: ToolDefinition[]): AssistantFinalResponse | AssistantToolResponse;
+declare function parseAndValidateAssistantResponse(rawText: string, availableTools: ToolDefinition[]): AssistantFinalResponse | AssistantToolResponse;
+declare function createFinalResponse(message: string): string;
+declare function createToolResponse(toolCall: AssistantToolCall): string;
+declare function serializeAssistantResponse(response: AssistantResponse): string;
+export declare const assistantProtocolModule: {
+    AssistantProtocolError: typeof AssistantProtocolError;
+    parseAssistantResponse: typeof parseAssistantResponse;
+    validateAssistantResponse: typeof validateAssistantResponse;
+    parseAndValidateAssistantResponse: typeof parseAndValidateAssistantResponse;
+    createFinalResponse: typeof createFinalResponse;
+    createToolResponse: typeof createToolResponse;
+    serializeAssistantResponse: typeof serializeAssistantResponse;
+};
+export type { AssistantFinalResponse, AssistantProtocolError, AssistantResponse, AssistantToolCall, AssistantToolResponse };

package/packages/runtime/dist/assistant-protocol.js

@@ -0,0 +1,121 @@
+class AssistantProtocolError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "AssistantProtocolError";
+    }
+}
+function parseAssistantResponse(rawText) {
+    const trimmed = rawText.trim();
+    const finalMatch = trimmed.match(/^<final>([\s\S]*?)<\/final>$/);
+    if (finalMatch) {
+        const message = finalMatch[1] ?? "";
+        if (!message.trim()) {
+            throw new AssistantProtocolError("<final> block must not be empty.");
+        }
+        return {
+            type: "final",
+            message
+        };
+    }
+    const toolMatch = trimmed.match(/^<tool>([\s\S]*?)<\/tool>$/);
+    if (toolMatch) {
+        return {
+            type: "tool",
+            toolCall: parseToolPayload(toolMatch[1] ?? "")
+        };
+    }
+    throw new AssistantProtocolError('Assistant output must be exactly one <final>...</final> block or one <tool>{"name":"...","arguments":{...}}</tool> block.');
+}
+function validateAssistantResponse(response, availableTools) {
+    if (response.type !== "tool") {
+        return response;
+    }
+    const tool = availableTools.find((candidate) => candidate.name === response.toolCall.name);
+    if (!tool) {
+        throw new AssistantProtocolError(`Tool "${response.toolCall.name}" is not registered.`);
+    }
+    const schema = tool.inputSchema;
+    const argumentsRecord = response.toolCall.arguments;
+    const propertyNames = Object.keys(schema.properties);
+    const allowedProperties = new Set(propertyNames);
+    for (const name of Object.keys(argumentsRecord)) {
+        if (!allowedProperties.has(name)) {
+            throw new AssistantProtocolError(`Tool "${tool.name}" received unknown argument "${name}".`);
+        }
+    }
+    for (const requiredName of schema.required) {
+        if (!(requiredName in argumentsRecord)) {
+            throw new AssistantProtocolError(`Tool "${tool.name}" is missing required argument "${requiredName}".`);
+        }
+    }
+    for (const propertyName of propertyNames) {
+        if (!(propertyName in argumentsRecord)) {
+            continue;
+        }
+        const property = schema.properties[propertyName];
+        const value = argumentsRecord[propertyName];
+        if (property.type === "string" && typeof value !== "string") {
+            throw new AssistantProtocolError(`Tool "${tool.name}" argument "${propertyName}" must be a string.`);
+        }
+        if (property.type === "boolean" && typeof value !== "boolean") {
+            throw new AssistantProtocolError(`Tool "${tool.name}" argument "${propertyName}" must be a boolean.`);
+        }
+    }
+    return response;
+}
+function parseAndValidateAssistantResponse(rawText, availableTools) {
+    return validateAssistantResponse(parseAssistantResponse(rawText), availableTools);
+}
+function createFinalResponse(message) {
+    return `<final>${message}</final>`;
+}
+function createToolResponse(toolCall) {
+    return `<tool>${JSON.stringify({
+        name: toolCall.name,
+        arguments: toolCall.arguments
+    })}</tool>`;
+}
+function serializeAssistantResponse(response) {
+    return response.type === "final"
+        ? createFinalResponse(response.message)
+        : createToolResponse(response.toolCall);
+}
+function parseToolPayload(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw.trim());
+    }
+    catch {
+        throw new AssistantProtocolError("<tool> payload must contain valid JSON.");
+    }
+    if (!isRecord(parsed)) {
+        throw new AssistantProtocolError("<tool> payload must decode to an object.");
+    }
+    const keys = Object.keys(parsed).sort();
+    if (keys.length !== 2 || keys[0] !== "arguments" || keys[1] !== "name") {
+        throw new AssistantProtocolError('<tool> JSON must contain only "name" and "arguments".');
+    }
+    const name = typeof parsed.name === "string" ? parsed.name.trim() : "";
+    if (!name) {
+        throw new AssistantProtocolError('<tool> JSON field "name" must be a non-empty string.');
+    }
+    if (!isRecord(parsed.arguments)) {
+        throw new AssistantProtocolError('<tool> JSON field "arguments" must be an object.');
+    }
+    return {
+        name,
+        arguments: parsed.arguments
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export const assistantProtocolModule = {
+    AssistantProtocolError,
+    parseAssistantResponse,
+    validateAssistantResponse,
+    parseAndValidateAssistantResponse,
+    createFinalResponse,
+    createToolResponse,
+    serializeAssistantResponse
+};