@uncensoredcode/openbridge 0.1.0

package/packages/server/dist/cli/run-bridge-server-cli.js

@@ -0,0 +1,371 @@
+import crypto from "node:crypto";
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { createInterface } from "node:readline/promises";
+import { Command } from "commander";
+import { ZodError } from "zod";
+import { bridgeModule } from "../bridge/index.js";
+import { clientModule } from "../client/index.js";
+import { configModule } from "../config/index.js";
+import { httpModule } from "../http/index.js";
+import { securityModule } from "../security/index.js";
+const { createBridgeChatCompletion, DEFAULT_BRIDGE_API_BASE_URL, streamBridgeChatCompletion } = clientModule;
+const { getBridgeServerStartupWarnings, loadBridgeServerConfig } = configModule;
+const { clearLocalSessionVault, formatLiveProviderExtractionCanaryResult, runLiveProviderExtractionCanary } = bridgeModule;
+const { sanitizeSensitiveText } = securityModule;
+const { startBridgeApiServer } = httpModule;
+async function runBridgeServerCli(input) {
+    const stdout = input.stdout ?? process.stdout;
+    const stderr = input.stderr ?? process.stderr;
+    const stdin = input.stdin ?? process.stdin;
+    const startServer = input.startServer ?? startBridgeApiServer;
+    const runLiveCanary = input.runLiveCanary ?? runLiveProviderExtractionCanary;
+    let command;
+    try {
+        command = parseBridgeServerCliArgs({
+            argv: input.argv,
+            env: input.env
+        });
+    }
+    catch (error) {
+        stderr.write(`${formatCliError(error)}\n`);
+        return 1;
+    }
+    if (command.kind === "help") {
+        stdout.write(`${getBridgeServerCliHelpText()}\n`);
+        return 0;
+    }
+    try {
+        if (command.kind === "chat") {
+            const messages = [
+                command.system
+                    ? {
+                        role: "system",
+                        content: command.system
+                    }
+                    : null,
+                {
+                    role: "user",
+                    content: command.message
+                }
+            ].filter((message) => message !== null);
+            if (command.stream) {
+                const contentStream = await streamBridgeChatCompletion({
+                    baseUrl: command.baseUrl,
+                    model: command.model,
+                    messages,
+                    fetchImpl: input.fetchImpl
+                });
+                for await (const chunk of contentStream) {
+                    stdout.write(chunk);
+                }
+                stdout.write("\n");
+                return 0;
+            }
+            const response = await createBridgeChatCompletion({
+                baseUrl: command.baseUrl,
+                model: command.model,
+                messages,
+                fetchImpl: input.fetchImpl
+            });
+            const content = response.choices[0]?.message?.content;
+            if (typeof content !== "string") {
+                throw new Error("Bridge chat completion response did not include assistant text.");
+            }
+            stdout.write(`${content}\n`);
+            return 0;
+        }
+        if (command.kind === "live-canary") {
+            const result = await runLiveCanary(command);
+            const stream = result.ok ? stdout : stderr;
+            stream.write(`${formatLiveProviderExtractionCanaryResult(result)}\n`);
+            return result.ok ? 0 : 1;
+        }
+        if (command.kind === "clear-session-vault") {
+            const sessionVaultPath = requireConfigPath(command.config.sessionVaultPath, "sessionVaultPath");
+            clearLocalSessionVault({
+                vaultPath: sessionVaultPath
+            });
+            stdout.write(`Emptied session vault at ${sessionVaultPath}\n`);
+            return 0;
+        }
+        for (const warning of getBridgeServerStartupWarnings(command.config)) {
+            stderr.write(`Warning: ${warning}\n`);
+        }
+        if (command.kind === "serve") {
+            command = {
+                ...command,
+                config: await ensureCliVaultKey(command.config, {
+                    env: input.env ?? process.env,
+                    stdin,
+                    stdout,
+                    stderr,
+                    promptForVaultKey: input.promptForVaultKey
+                })
+            };
+        }
+        const server = await startServer({
+            config: command.config
+        });
+        input.onServerStarted?.(server);
+        const address = server.address();
+        if (typeof address === "object" && address) {
+            stdout.write(`Bridge server listening on http://${address.address}:${address.port}\n`);
+        }
+        return 0;
+    }
+    catch (error) {
+        stderr.write(`${formatCliError(error)}\n`);
+        return 1;
+    }
+}
+function parseBridgeServerCliArgs(input) {
+    const env = input.env ?? process.env;
+    const args = [...input.argv];
+    if (args.includes("--help") || args.includes("-h") || args[0] === "help") {
+        return {
+            kind: "help"
+        };
+    }
+    let parsedCommand = null;
+    const program = buildBridgeServerCliProgram(env, {
+        onStart(options) {
+            parsedCommand = {
+                kind: "serve",
+                config: loadBridgeServerConfig(env, {
+                    host: optionalNonEmptyString(options.host, "host") ?? undefined,
+                    port: options.port,
+                    authToken: optionalNonEmptyString(options.token, "token") ?? undefined
+                })
+            };
+        },
+        onChat(options) {
+            parsedCommand = {
+                kind: "chat",
+                baseUrl: optionalNonEmptyString(options.baseUrl, "base-url") ?? DEFAULT_BRIDGE_API_BASE_URL,
+                model: requireNonEmptyString(options.model, "model"),
+                message: requireNonEmptyString(options.message, "message"),
+                system: optionalNonEmptyString(options.system, "system") ?? undefined,
+                stream: options.stream === true
+            };
+        },
+        onLiveCanary(options) {
+            const providerId = optionalNonEmptyString(options.provider, "provider");
+            const modelId = optionalNonEmptyString(options.model, "model");
+            const prompt = optionalNonEmptyString(options.prompt, "prompt");
+            const expectedSubstring = optionalNonEmptyString(options.expectedSubstring, "expected-substring");
+            const config = loadBridgeServerConfig(env, {
+                stateRoot: optionalNonEmptyString(options.stateRoot, "state-root") ?? undefined,
+                defaultProvider: providerId ?? undefined,
+                defaultModel: modelId ?? undefined
+            });
+            parsedCommand = {
+                kind: "live-canary",
+                config,
+                stateRoot: config.stateRoot,
+                providerId: providerId ?? undefined,
+                modelId: modelId ?? undefined,
+                prompt: prompt ?? undefined,
+                expectedSubstring: expectedSubstring ?? undefined
+            };
+        },
+        onClearSessionVault(options) {
+            parsedCommand = {
+                kind: "clear-session-vault",
+                config: loadBridgeServerConfig(env, {
+                    stateRoot: optionalNonEmptyString(options.stateRoot, "state-root") ?? undefined,
+                    sessionVaultPath: optionalNonEmptyString(options.sessionVaultPath, "session-vault-path") ?? undefined
+                })
+            };
+        }
+    });
+    const normalizedArgv = args.length === 0 || args[0]?.startsWith("--") ? ["start", ...args] : args;
+    try {
+        program.parse(normalizedArgv, {
+            from: "user"
+        });
+    }
+    catch (error) {
+        throw normalizeCommanderError(error);
+    }
+    if (!parsedCommand) {
+        throw new Error("No openbridge command was selected.");
+    }
+    return parsedCommand;
+}
+function getBridgeServerCliHelpText() {
+    return buildBridgeServerCliProgram(process.env).helpInformation();
+}
+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;
+}
+function requireNonEmptyString(value, key) {
+    const normalized = optionalNonEmptyString(value, key);
+    if (!normalized) {
+        throw new Error(`${key} is required.`);
+    }
+    return normalized;
+}
+function formatCliError(error) {
+    if (error instanceof ZodError) {
+        return sanitizeSensitiveText(error.issues
+            .map((issue) => `${issue.path.join(".") || "config"}: ${issue.message}`)
+            .join("; "));
+    }
+    return sanitizeSensitiveText(error instanceof Error ? error.message : String(error));
+}
+function buildBridgeServerCliProgram(env, handlers = {}) {
+    const program = new Command();
+    program
+        .name("openbridge")
+        .description("Server-side openbridge commands.")
+        .showHelpAfterError()
+        .exitOverride()
+        .configureOutput({
+        writeOut() { },
+        writeErr() { }
+    });
+    program
+        .command("start")
+        .description("Start the standalone bridge HTTP server.")
+        .option("--host <host>", "Bind host", trimOrUndefined(env.BRIDGE_SERVER_HOST) ?? "127.0.0.1")
+        .option("--port <port>", "Bind port", trimOrUndefined(env.BRIDGE_SERVER_PORT))
+        .option("--token <token>", "Optional local bridge auth token", trimOrUndefined(env.BRIDGE_AUTH_TOKEN))
+        .action((options) => {
+        handlers.onStart?.(options);
+    });
+    program
+        .command("chat")
+        .description("Send a chat completion request through the standalone bridge HTTP API.")
+        .requiredOption("--model <id>", "Model id")
+        .requiredOption("--message <text>", "User message")
+        .option("--system <text>", "Optional system message")
+        .option("--base-url <url>", "Bridge base URL", trimOrUndefined(env.BRIDGE_API_BASE_URL) ??
+        trimOrUndefined(env.BRIDGE_SERVER_BASE_URL) ??
+        DEFAULT_BRIDGE_API_BASE_URL)
+        .option("--stream", "Stream assistant text deltas")
+        .action((options) => {
+        handlers.onChat?.(options);
+    });
+    program
+        .command("live-canary")
+        .description("Run the live provider extraction canary through the standalone bridge runtime.")
+        .option("--state-root <path>", "State root for bridge artifacts")
+        .option("--provider <id>", "Provider id")
+        .option("--model <id>", "Model id")
+        .option("--prompt <text>", "Prompt to send to the provider")
+        .option("--expected-substring <text>", "Substring expected in the extracted output")
+        .action((options) => {
+        handlers.onLiveCanary?.({
+            ...options,
+            stateRoot: options.stateRoot ? path.resolve(options.stateRoot) : undefined
+        });
+    });
+    program
+        .command("clear-session-vault")
+        .description("Remove all stored session packages from the local session vault.")
+        .option("--state-root <path>", "State root for bridge artifacts")
+        .option("--session-vault-path <path>", "Session vault path override")
+        .action((options) => {
+        handlers.onClearSessionVault?.({
+            ...options,
+            stateRoot: options.stateRoot ? path.resolve(options.stateRoot) : undefined,
+            sessionVaultPath: options.sessionVaultPath
+                ? path.resolve(options.sessionVaultPath)
+                : undefined
+        });
+    });
+    return program;
+}
+function normalizeCommanderError(error) {
+    if (error instanceof Error && "code" in error) {
+        const code = String(error.code);
+        if (code === "commander.helpDisplayed") {
+            return new Error(getBridgeServerCliHelpText());
+        }
+    }
+    return error;
+}
+function trimOrUndefined(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+async function ensureCliVaultKey(config, input) {
+    const sessionVaultKeyPath = requireConfigPath(config.sessionVaultKeyPath, "sessionVaultKeyPath");
+    if (trimOrUndefined(input.env.BRIDGE_SESSION_VAULT_KEY)) {
+        return config;
+    }
+    const existingKey = await readOptionalFile(sessionVaultKeyPath);
+    if (existingKey) {
+        return config;
+    }
+    if (!input.stdin.isTTY) {
+        throw new Error(`Session vault key is required. Set BRIDGE_SESSION_VAULT_KEY or place a base64 32-byte key at ${sessionVaultKeyPath}.`);
+    }
+    const promptForVaultKey = input.promptForVaultKey ?? defaultPromptForVaultKey;
+    const provided = (await promptForVaultKey({
+        keyPath: sessionVaultKeyPath,
+        stdin: input.stdin
+    })).trim();
+    if (provided) {
+        input.env.BRIDGE_SESSION_VAULT_KEY = provided;
+        process.env.BRIDGE_SESSION_VAULT_KEY = provided;
+        return loadBridgeServerConfig(input.env, config);
+    }
+    const generated = crypto.randomBytes(32).toString("base64");
+    await mkdir(path.dirname(sessionVaultKeyPath), {
+        recursive: true,
+        mode: 0o700
+    });
+    await writeFile(sessionVaultKeyPath, `${generated}\n`, {
+        encoding: "utf8",
+        mode: 0o600
+    });
+    await chmod(sessionVaultKeyPath, 0o600);
+    input.stderr.write(`Generated session vault key at ${sessionVaultKeyPath}\n`);
+    return config;
+}
+async function defaultPromptForVaultKey(input) {
+    const readline = createInterface({
+        input: input.stdin,
+        output: process.stdout,
+        terminal: true
+    });
+    try {
+        return await readline.question(`Session vault key is not configured.\nPaste a base64 32-byte key, or press Enter to generate one at ${input.keyPath}: `);
+    }
+    finally {
+        readline.close();
+    }
+}
+async function readOptionalFile(targetPath) {
+    try {
+        const value = (await readFile(targetPath, "utf8")).trim();
+        return value || null;
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}
+function requireConfigPath(value, key) {
+    if (!value) {
+        throw new Error(`${key} is required.`);
+    }
+    return value;
+}
+export const runBridgeServerCliModule = {
+    runBridgeServerCli,
+    parseBridgeServerCliArgs,
+    getBridgeServerCliHelpText
+};

package/packages/server/dist/client/bridge-api-client.d.ts

@@ -0,0 +1,61 @@
+import type { BridgeChatCompletionRequest, BridgeChatCompletionResponse, BridgeHealthResponse, BridgeMessageRequest, BridgeMessageResponse } from "../shared/api-schema.ts";
+declare class BridgeApiHttpError extends Error {
+    readonly statusCode: number;
+    readonly code: string;
+    readonly details: Record<string, unknown> | undefined;
+    constructor(input: {
+        statusCode: number;
+        code: string;
+        message: string;
+        details?: Record<string, unknown>;
+    });
+}
+declare class BridgeApiConnectionError extends Error {
+    readonly baseUrl: string;
+    constructor(input: {
+        baseUrl: string;
+        cause?: unknown;
+    });
+}
+type BridgeApiClientFetch = typeof fetch;
+type SendBridgeMessageInput = Omit<BridgeMessageRequest, "sessionId"> & {
+    baseUrl: string;
+    sessionId: string;
+    fetchImpl?: BridgeApiClientFetch;
+    signal?: AbortSignal;
+};
+type CreateBridgeChatCompletionInput = Omit<BridgeChatCompletionRequest, "stream"> & {
+    baseUrl: string;
+    fetchImpl?: BridgeApiClientFetch;
+    signal?: AbortSignal;
+};
+type StreamBridgeChatCompletionInput = Omit<BridgeChatCompletionRequest, "stream"> & {
+    baseUrl: string;
+    fetchImpl?: BridgeApiClientFetch;
+    signal?: AbortSignal;
+};
+type CheckBridgeHealthInput = {
+    baseUrl: string;
+    fetchImpl?: BridgeApiClientFetch;
+    signal?: AbortSignal;
+};
+declare function sendBridgeMessage(input: SendBridgeMessageInput): Promise<BridgeMessageResponse>;
+declare function checkBridgeHealth(input: CheckBridgeHealthInput): Promise<BridgeHealthResponse>;
+declare function createBridgeChatCompletion(input: CreateBridgeChatCompletionInput): Promise<BridgeChatCompletionResponse>;
+declare function streamBridgeChatCompletion(input: StreamBridgeChatCompletionInput): Promise<AsyncIterable<string>>;
+declare function buildSessionMessageUrl(baseUrl: string, sessionId: string): string;
+declare function buildHealthUrl(baseUrl: string): string;
+declare function buildChatCompletionsUrl(baseUrl: string): string;
+export declare const bridgeApiClientModule: {
+    DEFAULT_BRIDGE_API_BASE_URL: string;
+    BridgeApiHttpError: typeof BridgeApiHttpError;
+    BridgeApiConnectionError: typeof BridgeApiConnectionError;
+    sendBridgeMessage: typeof sendBridgeMessage;
+    checkBridgeHealth: typeof checkBridgeHealth;
+    createBridgeChatCompletion: typeof createBridgeChatCompletion;
+    streamBridgeChatCompletion: typeof streamBridgeChatCompletion;
+    buildSessionMessageUrl: typeof buildSessionMessageUrl;
+    buildHealthUrl: typeof buildHealthUrl;
+    buildChatCompletionsUrl: typeof buildChatCompletionsUrl;
+};
+export type { BridgeApiClientFetch, BridgeApiConnectionError, BridgeApiHttpError, CheckBridgeHealthInput, CreateBridgeChatCompletionInput, SendBridgeMessageInput, StreamBridgeChatCompletionInput };

package/packages/server/dist/client/bridge-api-client.js

@@ -0,0 +1,267 @@
+const DEFAULT_BRIDGE_API_BASE_URL = "http://127.0.0.1:4318";
+class BridgeApiHttpError extends Error {
+    statusCode;
+    code;
+    details;
+    constructor(input) {
+        super(input.message);
+        this.name = "BridgeApiHttpError";
+        this.statusCode = input.statusCode;
+        this.code = input.code;
+        this.details = input.details;
+    }
+}
+class BridgeApiConnectionError extends Error {
+    baseUrl;
+    constructor(input) {
+        const suffix = formatCauseMessage(input.cause);
+        super(`Failed to reach bridge server at ${input.baseUrl}.${suffix ? ` ${suffix}` : ""}`);
+        this.name = "BridgeApiConnectionError";
+        this.baseUrl = input.baseUrl;
+        this.cause = input.cause;
+    }
+}
+async function sendBridgeMessage(input) {
+    const response = await (input.fetchImpl ?? fetch)(buildSessionMessageUrl(input.baseUrl, input.sessionId), {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+            input: input.input,
+            message: input.message,
+            provider: input.provider,
+            model: input.model,
+            metadata: input.metadata,
+            toolProfile: input.toolProfile
+        }),
+        signal: input.signal
+    });
+    if (!response.ok) {
+        throw await readBridgeApiError(response);
+    }
+    return response.json();
+}
+async function checkBridgeHealth(input) {
+    const response = await (input.fetchImpl ?? fetch)(buildHealthUrl(input.baseUrl), {
+        method: "GET",
+        signal: input.signal
+    });
+    if (!response.ok) {
+        throw await readBridgeApiError(response);
+    }
+    return response.json();
+}
+async function createBridgeChatCompletion(input) {
+    const response = await fetchBridgeApi(input.baseUrl, input.fetchImpl, buildChatCompletionsUrl(input.baseUrl), {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+            model: input.model,
+            messages: input.messages,
+            metadata: input.metadata
+        }),
+        signal: input.signal
+    });
+    if (!response.ok) {
+        throw await readBridgeApiError(response);
+    }
+    return response.json();
+}
+async function streamBridgeChatCompletion(input) {
+    const response = await fetchBridgeApi(input.baseUrl, input.fetchImpl, buildChatCompletionsUrl(input.baseUrl), {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+            model: input.model,
+            messages: input.messages,
+            stream: true,
+            metadata: input.metadata
+        }),
+        signal: input.signal
+    });
+    if (!response.ok) {
+        throw await readBridgeApiError(response);
+    }
+    return readChatCompletionStream(response);
+}
+function buildSessionMessageUrl(baseUrl, sessionId) {
+    return new URL(`/v1/sessions/${encodeURIComponent(sessionId)}/messages`, ensureBaseUrl(baseUrl)).toString();
+}
+function buildHealthUrl(baseUrl) {
+    return new URL("/health", ensureBaseUrl(baseUrl)).toString();
+}
+function buildChatCompletionsUrl(baseUrl) {
+    return new URL("/v1/chat/completions", ensureBaseUrl(baseUrl)).toString();
+}
+async function readBridgeApiError(response) {
+    let payload = null;
+    try {
+        payload = (await response.json());
+    }
+    catch {
+        payload = null;
+    }
+    return new BridgeApiHttpError({
+        statusCode: response.status,
+        code: payload?.error.code ?? "http_error",
+        message: payload?.error.message ?? `Bridge API request failed with status ${response.status}.`,
+        details: payload?.error.details
+    });
+}
+function ensureBaseUrl(value) {
+    const trimmed = value.trim();
+    return trimmed.endsWith("/") ? trimmed : `${trimmed}/`;
+}
+async function fetchBridgeApi(baseUrl, fetchImpl, url, init) {
+    try {
+        return await (fetchImpl ?? fetch)(url, init);
+    }
+    catch (error) {
+        throw new BridgeApiConnectionError({
+            baseUrl,
+            cause: error
+        });
+    }
+}
+async function* readChatCompletionStream(response) {
+    const stream = response.body;
+    if (!stream) {
+        throw new Error("Bridge chat stream did not include a response body.");
+    }
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let sawDone = false;
+    try {
+        while (true) {
+            const result = await reader.read();
+            if (result.done) {
+                break;
+            }
+            buffer += decoder.decode(result.value, {
+                stream: true
+            });
+            for (const line of consumeSseLines(() => buffer, (value) => {
+                buffer = value;
+            })) {
+                const data = readSseDataLine(line);
+                if (data === null) {
+                    continue;
+                }
+                if (data === "[DONE]") {
+                    sawDone = true;
+                    return;
+                }
+                const chunk = parseChatCompletionChunk(data);
+                const content = chunk.choices[0]?.delta?.content;
+                if (typeof content === "string" && content.length > 0) {
+                    yield content;
+                }
+            }
+        }
+        buffer += decoder.decode();
+        for (const line of consumeSseLines(() => buffer, (value) => {
+            buffer = value;
+        })) {
+            const data = readSseDataLine(line);
+            if (data === null) {
+                continue;
+            }
+            if (data === "[DONE]") {
+                sawDone = true;
+                return;
+            }
+            const chunk = parseChatCompletionChunk(data);
+            const content = chunk.choices[0]?.delta?.content;
+            if (typeof content === "string" && content.length > 0) {
+                yield content;
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    if (buffer.trim().length > 0) {
+        throw new Error("Bridge chat stream ended with an incomplete SSE frame.");
+    }
+    if (!sawDone) {
+        throw new Error("Bridge chat stream ended before [DONE].");
+    }
+}
+function* consumeSseLines(readBuffer, writeBuffer) {
+    while (true) {
+        const buffer = readBuffer();
+        const newlineIndex = buffer.indexOf("\n");
+        if (newlineIndex < 0) {
+            return;
+        }
+        const line = buffer.slice(0, newlineIndex).replace(/\r$/, "");
+        writeBuffer(buffer.slice(newlineIndex + 1));
+        yield line;
+    }
+}
+function readSseDataLine(line) {
+    if (!line.startsWith("data:")) {
+        return null;
+    }
+    const value = line.slice(5).trimStart();
+    return value.length > 0 ? value : null;
+}
+function parseChatCompletionChunk(data) {
+    let payload;
+    try {
+        payload = JSON.parse(data);
+    }
+    catch {
+        throw new Error("Bridge chat stream contained invalid JSON.");
+    }
+    if (typeof payload !== "object" || payload === null) {
+        throw new Error("Bridge chat stream contained a malformed chunk.");
+    }
+    const chunk = payload;
+    const choices = chunk.choices;
+    if (chunk.object !== "chat.completion.chunk" || !Array.isArray(choices) || choices.length === 0) {
+        throw new Error("Bridge chat stream contained a malformed chunk.");
+    }
+    const choice = choices[0];
+    if (!choice || typeof choice !== "object") {
+        throw new Error("Bridge chat stream contained a malformed chunk.");
+    }
+    if (choice.delta !== undefined &&
+        (typeof choice.delta !== "object" || choice.delta === null || Array.isArray(choice.delta))) {
+        throw new Error("Bridge chat stream contained a malformed chunk.");
+    }
+    if (choice.delta &&
+        "content" in choice.delta &&
+        choice.delta.content !== undefined &&
+        typeof choice.delta.content !== "string") {
+        throw new Error("Bridge chat stream contained a malformed chunk.");
+    }
+    return {
+        object: "chat.completion.chunk",
+        choices
+    };
+}
+function formatCauseMessage(error) {
+    if (!(error instanceof Error)) {
+        return "";
+    }
+    return error.message.trim();
+}
+export const bridgeApiClientModule = {
+    DEFAULT_BRIDGE_API_BASE_URL,
+    BridgeApiHttpError,
+    BridgeApiConnectionError,
+    sendBridgeMessage,
+    checkBridgeHealth,
+    createBridgeChatCompletion,
+    streamBridgeChatCompletion,
+    buildSessionMessageUrl,
+    buildHealthUrl,
+    buildChatCompletionsUrl
+};