@uncensoredcode/openbridge 0.1.0

package/packages/server/dist/client/index.d.ts

@@ -0,0 +1,11 @@
+export declare const clientModule: {
+    BridgeApiHttpError: typeof import("./bridge-api-client.ts").BridgeApiHttpError;
+    buildHealthUrl: (baseUrl: string) => string;
+    buildSessionMessageUrl: (baseUrl: string, sessionId: string) => string;
+    checkBridgeHealth: (input: import("./bridge-api-client.ts").CheckBridgeHealthInput) => Promise<import("../index.ts").BridgeHealthResponse>;
+    createBridgeChatCompletion: (input: import("./bridge-api-client.ts").CreateBridgeChatCompletionInput) => Promise<import("../index.ts").BridgeChatCompletionResponse>;
+    DEFAULT_BRIDGE_API_BASE_URL: string;
+    sendBridgeMessage: (input: import("./bridge-api-client.ts").SendBridgeMessageInput) => Promise<import("../index.ts").BridgeMessageResponse>;
+    streamBridgeChatCompletion: (input: import("./bridge-api-client.ts").StreamBridgeChatCompletionInput) => Promise<AsyncIterable<string>>;
+};
+export type { BridgeApiClientFetch, BridgeApiHttpError, CheckBridgeHealthInput, CreateBridgeChatCompletionInput, SendBridgeMessageInput, StreamBridgeChatCompletionInput } from "./bridge-api-client.ts";

package/packages/server/dist/client/index.js

@@ -0,0 +1,11 @@
+import { bridgeApiClientModule } from "./bridge-api-client.js";
+export const clientModule = {
+    BridgeApiHttpError: bridgeApiClientModule.BridgeApiHttpError,
+    buildHealthUrl: bridgeApiClientModule.buildHealthUrl,
+    buildSessionMessageUrl: bridgeApiClientModule.buildSessionMessageUrl,
+    checkBridgeHealth: bridgeApiClientModule.checkBridgeHealth,
+    createBridgeChatCompletion: bridgeApiClientModule.createBridgeChatCompletion,
+    DEFAULT_BRIDGE_API_BASE_URL: bridgeApiClientModule.DEFAULT_BRIDGE_API_BASE_URL,
+    sendBridgeMessage: bridgeApiClientModule.sendBridgeMessage,
+    streamBridgeChatCompletion: bridgeApiClientModule.streamBridgeChatCompletion
+};

package/packages/server/dist/config/bridge-server-config.d.ts

@@ -0,0 +1,52 @@
+import { z } from "zod";
+declare const bridgeServerConfigSchema: z.ZodObject<{
+    host: z.ZodString;
+    port: z.ZodCoercedNumber<unknown>;
+    stateRoot: z.ZodString;
+    runtimeRoot: z.ZodString;
+    sessionVaultPath: z.ZodOptional<z.ZodString>;
+    sessionVaultKeyPath: z.ZodOptional<z.ZodString>;
+    defaultProvider: z.ZodNullable<z.ZodString>;
+    defaultModel: z.ZodNullable<z.ZodString>;
+    maxSteps: z.ZodCoercedNumber<unknown>;
+    authToken: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    corsOrigins: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type BridgeServerConfig = z.infer<typeof bridgeServerConfigSchema>;
+type BridgeServerConfigOverrides = Partial<{
+    host: string;
+    port: number | string;
+    stateRoot: string;
+    runtimeRoot: string;
+    sessionVaultPath: string;
+    sessionVaultKeyPath: string;
+    defaultProvider: string | null;
+    defaultModel: string | null;
+    maxSteps: number | string;
+    authToken: string | null;
+    corsOrigins: string[] | string;
+}>;
+declare function loadBridgeServerConfig(env?: NodeJS.ProcessEnv, overrides?: BridgeServerConfigOverrides): BridgeServerConfig;
+declare function getBridgeServerStartupWarnings(config: BridgeServerConfig): string[];
+declare function isLocalBridgeHost(host: string): boolean;
+declare function isWildcardCorsOrigins(value: string[] | undefined): boolean;
+export declare const bridgeServerConfigModule: {
+    bridgeServerConfigSchema: z.ZodObject<{
+        host: z.ZodString;
+        port: z.ZodCoercedNumber<unknown>;
+        stateRoot: z.ZodString;
+        runtimeRoot: z.ZodString;
+        sessionVaultPath: z.ZodOptional<z.ZodString>;
+        sessionVaultKeyPath: z.ZodOptional<z.ZodString>;
+        defaultProvider: z.ZodNullable<z.ZodString>;
+        defaultModel: z.ZodNullable<z.ZodString>;
+        maxSteps: z.ZodCoercedNumber<unknown>;
+        authToken: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        corsOrigins: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    loadBridgeServerConfig: typeof loadBridgeServerConfig;
+    getBridgeServerStartupWarnings: typeof getBridgeServerStartupWarnings;
+    isLocalBridgeHost: typeof isLocalBridgeHost;
+    isWildcardCorsOrigins: typeof isWildcardCorsOrigins;
+};
+export type { BridgeServerConfig, BridgeServerConfigOverrides };

package/packages/server/dist/config/bridge-server-config.js

@@ -0,0 +1,118 @@
+import os from "node:os";
+import path from "node:path";
+import { z } from "zod";
+const DEFAULT_HOST = "127.0.0.1";
+const DEFAULT_PORT = 4318;
+const DEFAULT_MAX_STEPS = 8;
+const DEFAULT_APP_STATE_DIR_NAME = ".bridge";
+const DEFAULT_BRIDGE_APP_DIR_NAME = "server";
+const nonNegativeIntegerSchema = z.coerce.number().int().min(0);
+const positiveIntegerSchema = z.coerce.number().int().min(1);
+const bridgeServerConfigSchema = z.object({
+    host: z.string().trim().min(1),
+    port: nonNegativeIntegerSchema.max(65535),
+    stateRoot: z.string().trim().min(1),
+    runtimeRoot: z.string().trim().min(1),
+    sessionVaultPath: z.string().trim().min(1).optional(),
+    sessionVaultKeyPath: z.string().trim().min(1).optional(),
+    defaultProvider: z.string().trim().min(1).nullable(),
+    defaultModel: z.string().trim().min(1).nullable(),
+    maxSteps: positiveIntegerSchema,
+    authToken: z.string().trim().min(1).nullable().optional(),
+    corsOrigins: z.array(z.string().trim().min(1)).optional()
+});
+function loadBridgeServerConfig(env = process.env, overrides = {}) {
+    return bridgeServerConfigSchema.parse({
+        host: trimOrNull(overrides.host) ?? trimOrNull(env.BRIDGE_SERVER_HOST) ?? DEFAULT_HOST,
+        port: overrides.port ?? env.BRIDGE_SERVER_PORT ?? DEFAULT_PORT,
+        stateRoot: resolveStateRoot(env, overrides),
+        runtimeRoot: resolveRuntimeRoot(env, overrides),
+        sessionVaultPath: resolveSessionVaultPath(env, overrides),
+        sessionVaultKeyPath: resolveSessionVaultKeyPath(env, overrides),
+        defaultProvider: trimOrNull(overrides.defaultProvider ?? undefined) ?? trimOrNull(env.BRIDGE_PROVIDER),
+        defaultModel: trimOrNull(overrides.defaultModel ?? undefined) ?? trimOrNull(env.BRIDGE_MODEL),
+        maxSteps: overrides.maxSteps ?? env.BRIDGE_MAX_STEPS ?? DEFAULT_MAX_STEPS,
+        authToken: trimOrNull(overrides.authToken ?? undefined) ??
+            trimOrNull(env.BRIDGE_AUTH_TOKEN) ??
+            undefined,
+        corsOrigins: resolveCorsOrigins(overrides.corsOrigins ?? env.BRIDGE_CORS_ORIGINS)
+    });
+}
+function getBridgeServerStartupWarnings(config) {
+    const warnings = [];
+    if (!trimOrNull(config.authToken ?? undefined)) {
+        warnings.push("Bridge auth token is not configured; non-health endpoints accept unauthenticated local requests.");
+    }
+    if (!isLocalBridgeHost(config.host)) {
+        warnings.push(`Bridge is binding to non-local host '${config.host}'; this may expose the server beyond localhost.`);
+    }
+    if (isWildcardCorsOrigins(config.corsOrigins)) {
+        warnings.push("Bridge CORS is set to allow any origin; use wildcard CORS only when explicitly needed.");
+    }
+    return warnings;
+}
+function isLocalBridgeHost(host) {
+    const normalized = host.trim().toLowerCase();
+    return (normalized === "localhost" ||
+        normalized === "::1" ||
+        normalized === "[::1]" ||
+        normalized.endsWith(".localhost") ||
+        /^127(?:\.\d{1,3}){3}$/.test(normalized));
+}
+function isWildcardCorsOrigins(value) {
+    return Boolean(value?.includes("*"));
+}
+function resolveStateRoot(env, overrides) {
+    const explicit = trimOrNull(overrides.stateRoot) ?? trimOrNull(env.BRIDGE_STATE_ROOT);
+    if (explicit) {
+        return path.resolve(explicit);
+    }
+    return path.resolve(process.cwd(), ".bridge-server");
+}
+function resolveRuntimeRoot(env, overrides) {
+    return path.resolve(trimOrNull(overrides.runtimeRoot) ?? trimOrNull(env.BRIDGE_RUNTIME_ROOT) ?? process.cwd());
+}
+function resolveSessionVaultPath(env, overrides) {
+    const explicit = trimOrNull(overrides.sessionVaultPath) ?? trimOrNull(env.BRIDGE_SESSION_VAULT_PATH);
+    if (explicit) {
+        return path.resolve(explicit);
+    }
+    return path.join(resolveDefaultBridgeAppRoot(env), "session-vault");
+}
+function resolveSessionVaultKeyPath(env, overrides) {
+    const explicit = trimOrNull(overrides.sessionVaultKeyPath) ?? trimOrNull(env.BRIDGE_SESSION_VAULT_KEY_PATH);
+    if (explicit) {
+        return path.resolve(explicit);
+    }
+    return path.join(resolveDefaultBridgeAppRoot(env), "keys", "session-vault.key");
+}
+function resolveCorsOrigins(value) {
+    if (Array.isArray(value)) {
+        const normalized = value.map((entry) => entry.trim()).filter(Boolean);
+        return normalized.length > 0 ? normalized : undefined;
+    }
+    const raw = value?.trim();
+    if (!raw) {
+        return undefined;
+    }
+    const normalized = raw
+        .split(",")
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+    return normalized.length > 0 ? normalized : undefined;
+}
+function trimOrNull(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : null;
+}
+function resolveDefaultBridgeAppRoot(env) {
+    const homeDir = trimOrNull(env.HOME) ?? os.homedir();
+    return path.resolve(homeDir, DEFAULT_APP_STATE_DIR_NAME, DEFAULT_BRIDGE_APP_DIR_NAME);
+}
+export const bridgeServerConfigModule = {
+    bridgeServerConfigSchema,
+    loadBridgeServerConfig,
+    getBridgeServerStartupWarnings,
+    isLocalBridgeHost,
+    isWildcardCorsOrigins
+};

package/packages/server/dist/config/index.d.ts

@@ -0,0 +1,20 @@
+export declare const configModule: {
+    bridgeServerConfigSchema: import("zod").ZodObject<{
+        host: import("zod").ZodString;
+        port: import("zod").ZodCoercedNumber<unknown>;
+        stateRoot: import("zod").ZodString;
+        runtimeRoot: import("zod").ZodString;
+        sessionVaultPath: import("zod").ZodOptional<import("zod").ZodString>;
+        sessionVaultKeyPath: import("zod").ZodOptional<import("zod").ZodString>;
+        defaultProvider: import("zod").ZodNullable<import("zod").ZodString>;
+        defaultModel: import("zod").ZodNullable<import("zod").ZodString>;
+        maxSteps: import("zod").ZodCoercedNumber<unknown>;
+        authToken: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        corsOrigins: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    }, import("zod/v4/core").$strip>;
+    getBridgeServerStartupWarnings: (config: import("./bridge-server-config.ts").BridgeServerConfig) => string[];
+    isLocalBridgeHost: (host: string) => boolean;
+    isWildcardCorsOrigins: (value: string[] | undefined) => boolean;
+    loadBridgeServerConfig: (env?: NodeJS.ProcessEnv, overrides?: import("./bridge-server-config.ts").BridgeServerConfigOverrides) => import("./bridge-server-config.ts").BridgeServerConfig;
+};
+export type { BridgeServerConfig, BridgeServerConfigOverrides } from "./bridge-server-config.ts";

package/packages/server/dist/config/index.js

@@ -0,0 +1,8 @@
+import { bridgeServerConfigModule } from "./bridge-server-config.js";
+export const configModule = {
+    bridgeServerConfigSchema: bridgeServerConfigModule.bridgeServerConfigSchema,
+    getBridgeServerStartupWarnings: bridgeServerConfigModule.getBridgeServerStartupWarnings,
+    isLocalBridgeHost: bridgeServerConfigModule.isLocalBridgeHost,
+    isWildcardCorsOrigins: bridgeServerConfigModule.isWildcardCorsOrigins,
+    loadBridgeServerConfig: bridgeServerConfigModule.loadBridgeServerConfig
+};

package/packages/server/dist/http/bridge-api-route-context.d.ts

@@ -0,0 +1,14 @@
+import type { BridgeRuntimeService, ProviderStore, SessionPackageStore, SessionStore } from "../bridge/index.ts";
+import type { BridgeServerConfig } from "../config/index.ts";
+type BridgeApiRouteContext = {
+    config: BridgeServerConfig;
+    service: BridgeRuntimeService;
+    providerStore: ProviderStore;
+    sessionPackageStore: SessionPackageStore;
+    sessionStore: SessionStore;
+    onInternalError?: (error: unknown, request: {
+        method: string;
+        url: string;
+    }) => void;
+};
+export type { BridgeApiRouteContext };

package/packages/server/dist/http/bridge-api-route-context.js

@@ -0,0 +1 @@
+export {};

package/packages/server/dist/http/create-bridge-api-server.d.ts

@@ -0,0 +1,72 @@
+import type { Server } from "node:http";
+import type { BridgeServerConfig } from "../config/index.ts";
+declare const createBridgeRuntimeService: (dependencies: import("../bridge/bridge-runtime-service.ts").BridgeRuntimeServiceDependencies) => {
+    respond(request: import("../index.ts").BridgeMessageRequest, pathSessionId?: string): Promise<import("../index.ts").BridgeMessageResponse>;
+    execute(request: {
+        sessionId: string;
+        input: string;
+        providerId: string;
+        modelId: string;
+        metadata?: Record<string, unknown>;
+        toolProfile?: import("../index.ts").BridgeApiToolProfile;
+        sessionHistory?: import("@uncensoredcode/openbridge/runtime").BridgeSessionTurn[];
+        persistSession?: boolean;
+    }): Promise<import("../index.ts").BridgeMessageResponse>;
+    completeChatCompletionPacket(request: {
+        sessionId: string;
+        providerId: string;
+        modelId: string;
+        messages: import("@uncensoredcode/openbridge/runtime").CompiledProviderMessage[];
+        tools: import("../shared/api-schema.ts").BridgeChatCompletionTool[];
+        toolChoice?: import("../index.ts").BridgeChatCompletionRequest["tool_choice"];
+        continuation: boolean;
+        toolFollowUp: boolean;
+        metadata?: Record<string, unknown>;
+        persistSession?: boolean;
+    }): Promise<{
+        packet: import("@uncensoredcode/openbridge/runtime").AssistantResponse;
+        providerBindingReused: boolean;
+    }>;
+    streamChatCompletionPacket(request: {
+        sessionId: string;
+        providerId: string;
+        modelId: string;
+        messages: import("@uncensoredcode/openbridge/runtime").CompiledProviderMessage[];
+        tools: import("../shared/api-schema.ts").BridgeChatCompletionTool[];
+        toolChoice?: import("../index.ts").BridgeChatCompletionRequest["tool_choice"];
+        continuation: boolean;
+        toolFollowUp: boolean;
+        metadata?: Record<string, unknown>;
+        persistSession?: boolean;
+    }): Promise<{
+        content: AsyncIterable<import("../bridge/providers/provider-streams.ts").ProviderStreamFragment>;
+        packet: Promise<import("@uncensoredcode/openbridge/runtime").AssistantResponse>;
+        providerBindingReused: boolean;
+    }>;
+    streamChatCompletion(request: {
+        sessionId: string;
+        input: string;
+        providerId: string;
+        modelId: string;
+        metadata?: Record<string, unknown>;
+        toolProfile?: import("../index.ts").BridgeApiToolProfile;
+        sessionHistory?: import("@uncensoredcode/openbridge/runtime").BridgeSessionTurn[];
+        persistSession?: boolean;
+    }): Promise<AsyncIterable<string>>;
+};
+type BridgeApiServerLogger = {
+    warn(message: string): void;
+    error(message: string): void;
+};
+type BridgeApiServerOptions = {
+    config?: BridgeServerConfig;
+    service?: ReturnType<typeof createBridgeRuntimeService>;
+    logger?: BridgeApiServerLogger;
+};
+declare function createBridgeApiServer(options?: BridgeApiServerOptions): Server<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse>;
+declare function startBridgeApiServer(options?: BridgeApiServerOptions): Promise<Server<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse>>;
+export declare const createBridgeApiServerModule: {
+    createBridgeApiServer: typeof createBridgeApiServer;
+    startBridgeApiServer: typeof startBridgeApiServer;
+};
+export type { BridgeApiServerLogger, BridgeApiServerOptions };

package/packages/server/dist/http/create-bridge-api-server.js

@@ -0,0 +1,225 @@
+import path from "node:path";
+import Fastify from "fastify";
+import { bridgeModule } from "../bridge/index.js";
+import { providerTransportProfileModule } from "../bridge/providers/provider-transport-profile.js";
+import { localSessionPackageStoreModule } from "../bridge/stores/local-session-package-store.js";
+import { sessionBackedProviderStoreModule } from "../bridge/stores/session-backed-provider-store.js";
+import { configModule } from "../config/index.js";
+import { securityModule } from "../security/index.js";
+import { bridgeApiErrorModule } from "../shared/bridge-api-error.js";
+import { registerBridgeApiRoutesModule } from "./register-bridge-api-routes.js";
+const { createBridgeRuntimeService, createInMemorySessionStore } = bridgeModule;
+const { resolveProviderTransportProfile } = providerTransportProfileModule;
+const { createSessionBackedProviderStore } = sessionBackedProviderStoreModule;
+const { createLocalSessionPackageStore } = localSessionPackageStoreModule;
+const { loadBridgeServerConfig } = configModule;
+const { isBridgeApiError } = bridgeApiErrorModule;
+const { formatBridgeServerErrorLog, isAuthorizedBridgeRequest, requiresBridgeAuth, resolveCorsOrigin, sanitizeBridgeApiErrorPayload } = securityModule;
+const { registerBridgeApiRoutes } = registerBridgeApiRoutesModule;
+const BRIDGE_API_BODY_LIMIT_BYTES = 10 * 1024 * 1024;
+function createBridgeApiServer(options = {}) {
+    const { app, server } = createBridgeApiApp(options);
+    void app.ready((error) => {
+        if (error) {
+            const logger = options.logger ?? defaultBridgeApiServerLogger;
+            logger.error(formatBridgeServerErrorLog(error));
+        }
+    });
+    return server;
+}
+async function startBridgeApiServer(options = {}) {
+    const { app, config } = createBridgeApiApp(options);
+    await app.listen({
+        host: config.host,
+        port: config.port
+    });
+    return app.server;
+}
+function createBridgeApiApp(options = {}) {
+    const config = options.config ?? loadBridgeServerConfig();
+    const logger = options.logger ?? defaultBridgeApiServerLogger;
+    const sessionPackageStore = createLocalSessionPackageStore({
+        vaultPath: config.sessionVaultPath ?? path.join(config.stateRoot, "session-vault"),
+        keyPath: config.sessionVaultKeyPath ?? path.join(config.stateRoot, "keys", "session-vault.key")
+    });
+    const providerStore = createSessionBackedProviderStore(sessionPackageStore);
+    const sessionStore = createInMemorySessionStore();
+    const service = options.service ??
+        createBridgeRuntimeService({
+            config,
+            loadProvider(providerId) {
+                return providerStore.get(providerId);
+            },
+            sessionPackageStore
+        });
+    const app = Fastify({
+        logger: false,
+        bodyLimit: BRIDGE_API_BODY_LIMIT_BYTES
+    });
+    for (const warning of collectInstalledProviderWarnings(config, providerStore.list())) {
+        logger.warn(warning);
+    }
+    app.addHook("onRequest", async (request, reply) => {
+        setCorsHeaders(request, reply, config);
+        reply.header("Cache-Control", "no-store");
+        if (request.method === "OPTIONS" || !requiresBridgeAuth(request, config.authToken)) {
+            return;
+        }
+        if (isAuthorizedBridgeRequest(request.headers, config.authToken)) {
+            return;
+        }
+        reply.header("WWW-Authenticate", 'Bearer realm="bridge-server"');
+        await writeJson(reply, 401, {
+            error: {
+                code: "unauthorized",
+                message: "Bridge authorization failed."
+            }
+        });
+    });
+    app.options("*", async (_request, reply) => {
+        reply.code(204).send();
+    });
+    registerBridgeApiRoutes(app, {
+        config,
+        service,
+        providerStore,
+        sessionPackageStore,
+        sessionStore,
+        onInternalError(error, request) {
+            logger.error(formatBridgeServerErrorLog(error, {
+                method: request.method,
+                url: request.url
+            }));
+        }
+    });
+    app.setNotFoundHandler(async (_request, reply) => {
+        await writeJson(reply, 404, {
+            error: {
+                code: "not_found",
+                message: "Route not found."
+            }
+        });
+    });
+    app.setErrorHandler(async (error, _request, reply) => {
+        if (isBridgeApiError(error)) {
+            if (shouldLogBridgeApiError(error)) {
+                logger.warn(formatBridgeServerErrorLog(error, {
+                    method: _request.method,
+                    url: _request.url
+                }));
+            }
+            const safeError = sanitizeBridgeApiErrorPayload(error);
+            await writeJson(reply, error.statusCode, {
+                error: {
+                    code: safeError.code,
+                    message: safeError.message,
+                    details: safeError.details
+                }
+            });
+            return;
+        }
+        if (isInvalidJsonBodyError(error)) {
+            await writeJson(reply, 400, {
+                error: {
+                    code: "invalid_json",
+                    message: "Request body must contain valid JSON."
+                }
+            });
+            return;
+        }
+        if (isRequestBodyTooLargeError(error)) {
+            await writeJson(reply, 413, {
+                error: {
+                    code: "request_too_large",
+                    message: "Request body exceeds the bridge server upload limit."
+                }
+            });
+            return;
+        }
+        logger.error(formatBridgeServerErrorLog(error, {
+            method: _request.method,
+            url: _request.url
+        }));
+        await writeJson(reply, 500, {
+            error: {
+                code: "internal_error",
+                message: "Internal bridge server error."
+            }
+        });
+    });
+    return {
+        app,
+        config,
+        server: app.server
+    };
+}
+function setCorsHeaders(request, reply, config) {
+    const allowedOrigin = resolveCorsOrigin(request.headers.origin, config.corsOrigins);
+    if (!allowedOrigin) {
+        return;
+    }
+    if (allowedOrigin === "*") {
+        reply.header("Access-Control-Allow-Origin", "*");
+    }
+    else {
+        reply.header("Access-Control-Allow-Origin", allowedOrigin);
+        reply.header("Vary", "Origin");
+    }
+    reply.header("Access-Control-Allow-Headers", "Authorization, Content-Type, X-Bridge-Token");
+    reply.header("Access-Control-Allow-Methods", "GET,POST,PUT,PATCH,DELETE,OPTIONS");
+}
+async function writeJson(reply, statusCode, value) {
+    await reply.code(statusCode).send(value);
+}
+function isInvalidJsonBodyError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        (error.code === "FST_ERR_CTP_INVALID_JSON_BODY" || error.code === "FST_ERR_CTP_EMPTY_JSON_BODY"));
+}
+function isRequestBodyTooLargeError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "FST_ERR_CTP_BODY_TOO_LARGE");
+}
+const defaultBridgeApiServerLogger = {
+    warn(message) {
+        console.warn(message);
+    },
+    error(message) {
+        console.error(message);
+    }
+};
+function collectInstalledProviderWarnings(config, providers) {
+    const warnings = [];
+    const providersById = new Map(providers.map((provider) => [provider.id, provider]));
+    if (config.defaultProvider && providers.length > 0) {
+        const defaultProvider = providersById.get(config.defaultProvider);
+        if (!defaultProvider) {
+            warnings.push(`Bridge default provider '${config.defaultProvider}' is not installed.`);
+        }
+        else if (!resolveProviderTransportProfile(defaultProvider)) {
+            warnings.push(`Bridge default provider '${defaultProvider.id}' is not runnable; unsupported kind '${defaultProvider.kind}' or missing transport config.`);
+        }
+    }
+    for (const provider of providers) {
+        if (!provider.enabled) {
+            continue;
+        }
+        if (resolveProviderTransportProfile(provider)) {
+            continue;
+        }
+        warnings.push(`Provider '${provider.id}' is enabled but not runnable; unsupported kind '${provider.kind}' or missing transport config.`);
+    }
+    return warnings;
+}
+function shouldLogBridgeApiError(error) {
+    return (error.statusCode >= 500 ||
+        error.code.startsWith("provider_") ||
+        error.code === "provider_unavailable");
+}
+export const createBridgeApiServerModule = {
+    createBridgeApiServer,
+    startBridgeApiServer
+};

package/packages/server/dist/http/index.d.ts

@@ -0,0 +1,5 @@
+export declare const httpModule: {
+    createBridgeApiServer: (options?: import("./create-bridge-api-server.ts").BridgeApiServerOptions) => import("node:http").Server<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse>;
+    startBridgeApiServer: (options?: import("./create-bridge-api-server.ts").BridgeApiServerOptions) => Promise<import("node:http").Server<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse>>;
+};
+export type { BridgeApiServerLogger, BridgeApiServerOptions } from "./create-bridge-api-server.ts";

package/packages/server/dist/http/index.js

@@ -0,0 +1,5 @@
+import { createBridgeApiServerModule } from "./create-bridge-api-server.js";
+export const httpModule = {
+    createBridgeApiServer: createBridgeApiServerModule.createBridgeApiServer,
+    startBridgeApiServer: createBridgeApiServerModule.startBridgeApiServer
+};

package/packages/server/dist/http/parse-request.d.ts

@@ -0,0 +1,6 @@
+import { type z, type ZodTypeAny } from "zod";
+declare function parseRequest<TSchema extends ZodTypeAny>(schema: TSchema, value: unknown): z.output<TSchema>;
+export declare const parseRequestModule: {
+    parseRequest: typeof parseRequest;
+};
+export {};

package/packages/server/dist/http/parse-request.js

@@ -0,0 +1,27 @@
+import { ZodError } from "zod";
+import { bridgeApiErrorModule } from "../shared/bridge-api-error.js";
+const { BridgeApiError } = bridgeApiErrorModule;
+function parseRequest(schema, value) {
+    try {
+        return schema.parse(value);
+    }
+    catch (error) {
+        if (error instanceof ZodError) {
+            throw new BridgeApiError({
+                statusCode: 400,
+                code: "invalid_request",
+                message: "Request validation failed.",
+                details: {
+                    issues: error.issues.map((issue) => ({
+                        path: issue.path.length > 0 ? issue.path.join(".") : "$",
+                        message: issue.message
+                    }))
+                }
+            });
+        }
+        throw error;
+    }
+}
+export const parseRequestModule = {
+    parseRequest
+};

package/packages/server/dist/http/register-bridge-api-routes.d.ts

@@ -0,0 +1,7 @@
+import type { FastifyInstance } from "fastify";
+import type { BridgeApiRouteContext } from "./bridge-api-route-context.ts";
+declare function registerBridgeApiRoutes(app: FastifyInstance, context: BridgeApiRouteContext): void;
+export declare const registerBridgeApiRoutesModule: {
+    registerBridgeApiRoutes: typeof registerBridgeApiRoutes;
+};
+export {};

package/packages/server/dist/http/register-bridge-api-routes.js

@@ -0,0 +1,17 @@
+import { adminRoutesModule } from "./routes/admin-routes.js";
+import { chatCompletionsRouteModule } from "./routes/chat-completions-route.js";
+import { healthRoutesModule } from "./routes/health-routes.js";
+import { messageRoutesModule } from "./routes/message-routes.js";
+const { registerAdminRoutes } = adminRoutesModule;
+const { registerChatCompletionRoute } = chatCompletionsRouteModule;
+const { registerHealthRoutes } = healthRoutesModule;
+const { registerMessageRoutes } = messageRoutesModule;
+function registerBridgeApiRoutes(app, context) {
+    registerHealthRoutes(app);
+    registerAdminRoutes(app, context);
+    registerChatCompletionRoute(app, context);
+    registerMessageRoutes(app, context);
+}
+export const registerBridgeApiRoutesModule = {
+    registerBridgeApiRoutes
+};

package/packages/server/dist/http/routes/admin-routes.d.ts

@@ -0,0 +1,7 @@
+import type { FastifyInstance } from "fastify";
+import type { BridgeApiRouteContext } from "../bridge-api-route-context.ts";
+declare function registerAdminRoutes(app: FastifyInstance, context: BridgeApiRouteContext): void;
+export declare const adminRoutesModule: {
+    registerAdminRoutes: typeof registerAdminRoutes;
+};
+export {};