@wacry/codeks-bridge 0.0.0-stage → 0.0.1

package/dist/compaction.js

@@ -0,0 +1,134 @@
+import { encodeCompaction } from "./carrier.js";
+import { splitCompactionPrefix } from "./compaction-history.js";
+import { BridgeError, ResponsesIncompleteError, ResponsesStreamError } from "./errors.js";
+import { newId } from "./ids.js";
+import { withCaptureLabel } from "./inspect/capture.js";
+import { HANDOFF_PROMPT, SUMMARIZATION_PROMPT } from "./prompts.js";
+import { ResponseWriter } from "./writer.js";
+export function isCompactionRequest(request) {
+    return Array.isArray(request.input) && request.input.some((item) => item.type === "compaction_trigger");
+}
+function compactionInput(request) {
+    if (!Array.isArray(request.input))
+        throw new BridgeError("Compaction requires an input array.");
+    const triggers = request.input.filter((item) => item.type === "compaction_trigger");
+    if (triggers.length !== 1 || request.input.at(-1)?.type !== "compaction_trigger") {
+        throw new BridgeError("Compaction requires exactly one trigger at the end of input.");
+    }
+    return request.input.slice(0, -1);
+}
+/** Keep the shared prefix intact, including tools and any signed reasoning. */
+export function summaryRequest(request) {
+    const input = compactionInput(request);
+    const result = {
+        ...request,
+        input: [...input, { type: "message", role: "user", content: [{ type: "input_text", text: SUMMARIZATION_PROMPT }] }],
+        stream: true,
+    };
+    // A conversation's structured output schema does not describe a handoff summary.
+    delete result.text;
+    return result;
+}
+function handoffRecipe(context, prefix) {
+    // The handoff rebuilds input and transport mode; a summary is not a structured answer.
+    const { input: _input, stream: _stream, text: _text, ...parameters } = context.request;
+    parameters.reasoning = { ...parameters.reasoning, effort: parameters.reasoning?.effort ?? context.route.profile.default_effort };
+    return structuredClone({ prefix, parameters, responsesLite: context.responsesLite === true });
+}
+/** Rephrase the checkpoint using the exact history retained by the client. */
+export function handoffRequest(recipe, retained, checkpoint) {
+    return {
+        ...recipe.parameters,
+        input: [...recipe.prefix, ...retained, checkpoint,
+            { type: "message", role: "user", content: [{ type: "input_text", text: HANDOFF_PROMPT }] }],
+        stream: true,
+    };
+}
+async function collect(context, backend) {
+    const writer = new ResponseWriter({ write() { } }, { model: context.request.model, showSummary: false });
+    let result;
+    try {
+        result = await backend(context, writer);
+    }
+    catch (cause) {
+        // Auxiliary output and usage must not become the client's replacement history.
+        if (cause instanceof ResponsesIncompleteError) {
+            throw new BridgeError(cause.message, "invalid_prompt", 400, undefined, { upstream: { body: cause.response }, cause });
+        }
+        if (cause instanceof ResponsesStreamError && cause.response) {
+            const { output: _output, usage: _usage, ...response } = cause.response;
+            throw new ResponsesStreamError(cause.error, { ...response, output: [] }, cause.event, cause.headers);
+        }
+        throw cause;
+    }
+    context.signal.throwIfAborted();
+    writer.complete(result.usage);
+    return { output: writer.outputItems, usage: result.usage, endTurn: result.endTurn };
+}
+function summaryText({ output, endTurn }) {
+    const parts = [];
+    for (const value of output) {
+        const item = value;
+        if (item.type === "function_call" || item.type === "custom_tool_call") {
+            throw new BridgeError("Compaction returned a tool call instead of a summary. No tools were executed.");
+        }
+        if (item.type !== "message" || item.role !== "assistant" || !Array.isArray(item.content))
+            continue;
+        for (const part of item.content) {
+            if (part.type === "refusal")
+                throw new BridgeError("Compaction was refused.");
+            if (part.type === "output_text" && typeof part.text === "string")
+                parts.push(part.text);
+        }
+    }
+    if (endTurn === false)
+        throw new BridgeError("Compaction did not finish its response.");
+    const summary = parts.join("\n").trim();
+    if (!summary)
+        throw new BridgeError("Compaction returned an empty summary.");
+    return summary;
+}
+export async function collectHandoff(context, backend) {
+    // Generating text from the source's own native state is independent of whether
+    // that route normally chooses to replay native checkpoints in ordinary turns.
+    const route = { ...context.route, compaction: { ...context.route.compaction, native_replay: true } };
+    const result = await withCaptureLabel("handoff", () => collect({ ...context, route, compacting: true }, backend));
+    return { summary: summaryText(result), usage: result.usage };
+}
+function nativeItem(output) {
+    const items = output.filter((value) => {
+        const item = value;
+        return item.type === "compaction" || item.type === "compaction_summary";
+    });
+    if (items.length !== 1 || typeof items[0]?.encrypted_content !== "string" || !items[0].encrypted_content) {
+        throw new BridgeError("Native compaction must return exactly one nonempty compaction item.");
+    }
+    return items[0];
+}
+/** Publish a complete native checkpoint or portable text summary. */
+export async function compact(context, backend) {
+    const input = compactionInput(context.request);
+    context.signal.throwIfAborted();
+    const item = (carrier) => ({
+        type: "compaction", id: newId("cmp"), encrypted_content: encodeCompaction(carrier),
+    });
+    if (context.route.compaction.mode === "summary") {
+        const result = await withCaptureLabel("summary", () => collect({
+            ...context, compacting: true, request: summaryRequest(context.request),
+        }, backend));
+        return { item: item({ summary: summaryText(result) }), usage: result.usage };
+    }
+    const native = await withCaptureLabel("native", () => collect({
+        ...context, compacting: true, request: { ...context.request, stream: true },
+    }, backend));
+    if (native.endTurn === false)
+        throw new BridgeError("Compaction did not finish its response.");
+    const { prefix } = splitCompactionPrefix(input);
+    return {
+        item: item({
+            native: { source: context.route.origin, format: context.route.profile.native_compaction_format, data: nativeItem(native.output) },
+            handoff: handoffRecipe(context, prefix),
+        }),
+        usage: native.usage,
+    };
+}

package/dist/config.d.ts

@@ -0,0 +1,6 @@
+import type { BridgeConfig, ResolvedModel } from "./types.ts";
+export declare function validateConfig(value: unknown): BridgeConfig;
+export declare function loadConfig(path: string): Promise<BridgeConfig>;
+export declare function resolveModel(config: BridgeConfig, slug: string): ResolvedModel;
+/** Select one executor; the caller owns the generation mode, the executor owns replay. */
+export declare function resolveCompactionModel(config: BridgeConfig, caller: ResolvedModel): ResolvedModel;

package/dist/config.js

@@ -0,0 +1,167 @@
+import { readFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { modelProfile } from "./profiles.js";
+import { getCatalogEntry } from "./model-catalog.js";
+import { BridgeError } from "./errors.js";
+function object(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function fail(message) { throw new BridgeError(`Invalid configuration: ${message}`); }
+function strings(value) {
+    return Array.isArray(value) && value.every(v => typeof v === "string" && v.length > 0);
+}
+const hash = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
+/** Record provenance, never policy or credentials, in portable history. */
+function origin(config, model) {
+    const connection = hash([model.upstream, config.upstreams[model.upstream].base_url.replace(/\/+$/, "")]);
+    const { adapter } = getCatalogEntry(model.catalog);
+    return { connection, model: model.model, adapter, id: hash([connection, adapter, model.model]) };
+}
+export function validateConfig(value) {
+    if (!object(value) || !object(value.upstreams) || !object(value.models))
+        fail("upstreams and models must be objects");
+    if (!Object.keys(value.models).length)
+        fail("at least one model is required");
+    if (value.host !== undefined && (typeof value.host !== "string" || !value.host))
+        fail("host must be a string");
+    if (value.port !== undefined && (!Number.isInteger(value.port) || value.port < 0 || value.port > 65535))
+        fail("port must be 0..65535");
+    if (value.token_env !== undefined && (typeof value.token_env !== "string" || !value.token_env))
+        fail("token_env must name an environment variable");
+    if (value.compaction_cache_dir !== undefined && (typeof value.compaction_cache_dir !== "string" || !value.compaction_cache_dir.trim()))
+        fail("compaction_cache_dir must be a nonempty path");
+    if (value.inspect !== undefined) {
+        const inspect = value.inspect;
+        if (!object(inspect))
+            fail("inspect must be an object");
+        if (inspect.capture !== undefined && typeof inspect.capture !== "boolean")
+            fail("inspect.capture must be boolean");
+        if (inspect.max_mib !== undefined && (!Number.isSafeInteger(inspect.max_mib) || inspect.max_mib <= 0))
+            fail("inspect.max_mib must be a positive integer");
+    }
+    for (const [name, up] of Object.entries(value.upstreams)) {
+        if (!object(up))
+            fail(`upstream ${name}: expected a connection object`);
+        let url;
+        try {
+            url = new URL(up.base_url);
+        }
+        catch {
+            fail(`upstream ${name}: invalid base_url`);
+        }
+        if (!["https:", "http:"].includes(url.protocol) || url.username || url.password || url.search || url.hash)
+            fail(`upstream ${name}: base_url must be an HTTP(S) URL without credentials, query, or fragment`);
+        if (up.api_key_env !== undefined && (typeof up.api_key_env !== "string" || !up.api_key_env))
+            fail(`upstream ${name}: invalid api_key_env`);
+        if (up.api_key_env && up.api_key_command)
+            fail(`upstream ${name}: choose api_key_env or api_key_command`);
+        if (up.api_key_command !== undefined && (!Array.isArray(up.api_key_command) || !up.api_key_command.length || up.api_key_command.some((arg) => typeof arg !== "string")))
+            fail(`upstream ${name}: api_key_command must be a nonempty argv array`);
+        if (up.stream_idle_timeout_ms !== undefined && (!Number.isSafeInteger(up.stream_idle_timeout_ms) || up.stream_idle_timeout_ms <= 0))
+            fail(`upstream ${name}: invalid stream_idle_timeout_ms`);
+        if (up.auth_header !== undefined && (typeof up.auth_header !== "string" || !/^[\w-]+$/.test(up.auth_header)))
+            fail(`upstream ${name}: invalid auth_header`);
+        if (up.headers !== undefined && (!object(up.headers) || Object.values(up.headers).some(v => typeof v !== "string" || /[\r\n]/.test(v))))
+            fail(`upstream ${name}: invalid headers`);
+        if (up.options !== undefined && !object(up.options))
+            fail(`upstream ${name}: options must be an object`);
+    }
+    for (const [slug, model] of Object.entries(value.models)) {
+        if (!slug || !object(model) || typeof model.model !== "string" || !model.model || typeof model.upstream !== "string" || !Object.hasOwn(value.upstreams, model.upstream))
+            fail(`model ${slug}: model and an existing upstream are required`);
+        if (typeof model.catalog !== "string" || !model.catalog)
+            fail(`model ${slug}: catalog is required`);
+        if (model.expose !== undefined && typeof model.expose !== "boolean")
+            fail(`model ${slug}: expose must be boolean`);
+        for (const field of ["context_window", "max_output_tokens"]) {
+            if (model[field] !== undefined && (!Number.isSafeInteger(model[field]) || model[field] <= 0))
+                fail(`model ${slug}: ${field} must be a positive integer`);
+        }
+        if (model.options !== undefined && !object(model.options))
+            fail(`model ${slug}: options must be an object`);
+        if (model.input_modalities !== undefined && (!strings(model.input_modalities) || !model.input_modalities.length || model.input_modalities.some((m) => !["text", "image"].includes(m))))
+            fail(`model ${slug}: input_modalities must contain text or image`);
+        if (model.reasoning !== undefined) {
+            const r = model.reasoning;
+            if (!object(r))
+                fail(`model ${slug}: reasoning must be an object`);
+            if (r.default_effort !== undefined && (typeof r.default_effort !== "string" || !r.default_effort))
+                fail(`model ${slug}: invalid default_effort`);
+            if (r.effort_map !== undefined && (!object(r.effort_map) || !Object.keys(r.effort_map).length || Object.entries(r.effort_map).some(([key, native]) => !key || typeof native !== "string" || !native)))
+                fail(`model ${slug}: effort_map must map effort names to upstream values`);
+        }
+        const profile = modelProfile(model);
+        if (Object.hasOwn(profile.effort_map, "ultra") && !profile.multi_agent_effort)
+            fail(`model ${slug}: ultra must map to the same upstream effort as an ordinary level`);
+        if (!Object.hasOwn(profile.effort_map, profile.default_effort))
+            fail(`model ${slug}: default_effort must appear in effort_map`);
+        if (model.replay !== undefined) {
+            if (!object(model.replay))
+                fail(`model ${slug}: replay must be an object`);
+            for (const field of ["reasoning_from", "native_compaction_from"]) {
+                if (model.replay[field] !== undefined && !strings(model.replay[field]))
+                    fail(`model ${slug}: ${field} must list source model aliases`);
+            }
+        }
+        if (model.compaction !== undefined) {
+            const c = model.compaction;
+            if (!object(c))
+                fail(`model ${slug}: compaction must be an object`);
+            if (c.mode !== undefined && !["summary", "native"].includes(c.mode))
+                fail(`model ${slug}: compaction.mode must be summary or native`);
+            if (c.model !== undefined && (typeof c.model !== "string" || !Object.hasOwn(value.models, c.model)))
+                fail(`model ${slug}: compaction.model must name an existing model alias`);
+            if (c.native_replay !== undefined && typeof c.native_replay !== "boolean")
+                fail(`model ${slug}: compaction.native_replay must be boolean`);
+            if (!profile.native_compaction_format && c.native_replay === true)
+                fail(`model ${slug}: adapter has no native compaction representation for replay`);
+        }
+    }
+    // References are directional. Validate decodability, not provider compatibility.
+    const config = value;
+    for (const [slug, model] of Object.entries(config.models)) {
+        const target = modelProfile(model);
+        for (const [field, format] of [["reasoning_from", "reasoning_format"], ["native_compaction_from", "native_compaction_format"]]) {
+            for (const name of model.replay?.[field] ?? []) {
+                if (!Object.hasOwn(config.models, name))
+                    fail(`model ${slug}: unknown replay source ${name}`);
+                const source = modelProfile(config.models[name]);
+                if (!target[format] || source[format] !== target[format])
+                    fail(`model ${slug}: cannot decode ${field} source ${name}`);
+            }
+        }
+    }
+    for (const slug of Object.keys(config.models)) {
+        const executor = resolveCompactionModel(config, resolveModel(config, slug));
+        if (executor.compaction.mode === "native" && !executor.profile.native_compaction_format)
+            fail(`model ${slug}: compaction model ${executor.slug} has no native compaction representation`);
+    }
+    return config;
+}
+export async function loadConfig(path) {
+    return validateConfig(JSON.parse(await readFile(path, "utf8")));
+}
+export function resolveModel(config, slug) {
+    if (typeof slug !== "string" || !Object.hasOwn(config.models, slug))
+        throw new BridgeError("Unknown model. Use GET /v1/models to list exposed models.");
+    const model = config.models[slug];
+    const profile = modelProfile(model);
+    const source = origin(config, model);
+    const allowed = (names = []) => new Set([source.id, ...names.map(name => origin(config, config.models[name]).id)]);
+    return {
+        slug, config: model, upstream: config.upstreams[model.upstream], profile, origin: source,
+        replay: { reasoning: allowed(model.replay?.reasoning_from), native_compaction: allowed(model.replay?.native_compaction_from) },
+        compaction: {
+            mode: model.compaction?.mode ?? (profile.native_compaction_format ? "native" : "summary"),
+            native_replay: model.compaction?.native_replay ?? !!profile.native_compaction_format,
+        },
+    };
+}
+/** Select one executor; the caller owns the generation mode, the executor owns replay. */
+export function resolveCompactionModel(config, caller) {
+    const slug = caller.config.compaction?.model;
+    if (slug === undefined || slug === caller.slug)
+        return caller;
+    const executor = resolveModel(config, slug);
+    return { ...executor, compaction: { ...executor.compaction, mode: caller.compaction.mode } };
+}

package/dist/errors.d.ts

@@ -0,0 +1,43 @@
+import { type HeaderRecord } from "./headers.ts";
+export interface UpstreamFailure {
+    status?: number;
+    body: unknown;
+}
+/** Native Responses HTTP failures retain their transport-level meaning. */
+export declare class UpstreamHttpError extends Error {
+    readonly status: number;
+    readonly body: string;
+    readonly headers: Headers;
+    constructor(status: number, body: string, headers: Headers);
+}
+/** A Responses failure belongs to the SSE protocol, not HTTP classification. */
+export declare class ResponsesStreamError extends Error {
+    readonly error: Record<string, unknown>;
+    readonly response?: Record<string, any>;
+    readonly event?: Record<string, any>;
+    readonly headers?: Headers;
+    constructor(error: Record<string, unknown>, response?: Record<string, any>, event?: Record<string, any>, headers?: Headers);
+}
+/** An incomplete response has its own client termination and usage semantics. */
+export declare class ResponsesIncompleteError extends Error {
+    readonly response: Record<string, any>;
+    readonly event?: Record<string, any>;
+    constructor(response: Record<string, any>, event?: Record<string, any>);
+}
+/** Client retry classification is separate from the unmodified upstream failure. */
+export declare class BridgeError extends Error {
+    readonly code: string;
+    readonly status: number;
+    readonly headers?: HeaderRecord;
+    readonly upstream?: UpstreamFailure;
+    constructor(message: string, code?: string, status?: number, headers?: HeaderRecord, options?: {
+        upstream?: UpstreamFailure;
+        cause?: unknown;
+    });
+}
+/** Keep native fields; only supplement missing retry advice from HTTP headers. */
+export declare function responsesStreamError(payload: unknown, headers?: Headers, event?: Record<string, any>): ResponsesStreamError;
+/** Translate non-Responses protocols into errors understood by the client. */
+export declare function upstreamError(status: number | undefined, payload: unknown, headers?: Headers): BridgeError;
+/** Pick only diagnostics; fetch options and credential-command output must not escape. */
+export declare function transportError(cause: unknown): BridgeError;

package/dist/errors.js

@@ -0,0 +1,141 @@
+import { forwardResponseHeaders } from "./headers.js";
+/** Native Responses HTTP failures retain their transport-level meaning. */
+export class UpstreamHttpError extends Error {
+    status;
+    body;
+    headers;
+    constructor(status, body, headers) {
+        super(`Upstream returned HTTP ${status}`);
+        this.name = "UpstreamHttpError";
+        this.status = status;
+        this.body = body;
+        this.headers = headers;
+    }
+}
+/** A Responses failure belongs to the SSE protocol, not HTTP classification. */
+export class ResponsesStreamError extends Error {
+    error;
+    response;
+    event;
+    headers;
+    constructor(error, response, event, headers) {
+        super(typeof error.message === "string" ? error.message : "The upstream response failed");
+        this.name = "ResponsesStreamError";
+        this.error = error;
+        this.response = response;
+        this.event = event;
+        this.headers = headers;
+    }
+}
+/** An incomplete response has its own client termination and usage semantics. */
+export class ResponsesIncompleteError extends Error {
+    response;
+    event;
+    constructor(response, event) {
+        super(`The upstream response is incomplete: ${String(response.incomplete_details?.reason ?? "unknown")}`);
+        this.name = "ResponsesIncompleteError";
+        this.response = response;
+        this.event = event;
+    }
+}
+/** Client retry classification is separate from the unmodified upstream failure. */
+export class BridgeError extends Error {
+    code;
+    status;
+    headers;
+    upstream;
+    constructor(message, code = "invalid_prompt", status = 400, headers, options) {
+        super(message, options);
+        this.name = "BridgeError";
+        this.code = code;
+        this.status = status;
+        this.headers = headers;
+        this.upstream = options?.upstream;
+    }
+}
+function record(value) {
+    return value !== null && typeof value === "object" ? value : undefined;
+}
+function retryAfter(value) {
+    if (value instanceof Headers)
+        return value.get("retry-after") ?? undefined;
+    for (const [name, content] of Object.entries(record(value) ?? {})) {
+        if (name.toLowerCase() === "retry-after" && (typeof content === "string" || typeof content === "number"))
+            return String(content);
+    }
+    return undefined;
+}
+/** Keep native fields; only supplement missing retry advice from HTTP headers. */
+export function responsesStreamError(payload, headers, event) {
+    const envelope = record(payload);
+    const response = envelope?.error !== undefined && (envelope.object === "response" || typeof envelope.status === "string" ||
+        (event?.type === "response.failed" && event.response !== undefined)) ? envelope : undefined;
+    let error = record(envelope?.error ?? payload) ?? {};
+    const delay = retryAfter(headers);
+    if (delay !== undefined && retryAfter(error.headers) === undefined) {
+        error = { ...error, headers: { ...record(error.headers), "retry-after": delay } };
+    }
+    return new ResponsesStreamError(error, response ? { ...response, error } : undefined, event, headers);
+}
+/** Translate non-Responses protocols into errors understood by the client. */
+export function upstreamError(status, payload, headers) {
+    const envelope = record(payload);
+    const raw = envelope?.error ?? payload;
+    const error = record(raw);
+    const message = typeof error?.message === "string" ? error.message
+        : typeof raw === "string" && raw.length ? raw
+            : status !== undefined ? `Upstream returned HTTP ${status}` : "The upstream response failed";
+    const kind = [error?.code, error?.type].filter((value) => typeof value === "string").join(" ");
+    let code;
+    if (/context_length|too_many_tokens/.test(kind) || /prompt is too long|maximum context length|too many tokens/i.test(message))
+        code = "context_length_exceeded";
+    else if (/quota|billing|credit|balance/.test(kind) || /insufficient (quota|credit|balance)/i.test(message))
+        code = "insufficient_quota";
+    else if (status === 429 || /rate_limit|slow_down/.test(kind))
+        code = "rate_limit_exceeded";
+    else if (status === 503 || status === 529 || /overload/.test(kind))
+        code = "server_is_overloaded";
+    else if (/stream_error/.test(kind))
+        code = "stream_error";
+    else if (/invalid|authentication|permission|not_found/.test(kind))
+        code = "invalid_prompt";
+    else
+        code = status !== undefined && status < 500 ? "invalid_prompt" : "upstream_error";
+    const mappedStatus = code === "rate_limit_exceeded" || code === "insufficient_quota" ? 429
+        : code === "server_is_overloaded" ? 503
+            : code === "invalid_prompt" || code === "context_length_exceeded" ? 400 : 502;
+    const delay = retryAfter(headers) ?? retryAfter(error?.headers) ?? retryAfter(envelope?.headers);
+    const forwarded = headers ? forwardResponseHeaders(headers) : {};
+    if (delay !== undefined)
+        forwarded["retry-after"] = delay;
+    return new BridgeError(message, code, status ?? mappedStatus, Object.keys(forwarded).length ? forwarded : undefined, {
+        upstream: { ...(status !== undefined ? { status } : {}), body: payload },
+    });
+}
+function transportFailure(value, seen = new Set()) {
+    const error = record(value);
+    const result = { message: typeof error?.message === "string" ? error.message : typeof value === "string" ? value : "Upstream request failed" };
+    if (seen.has(value))
+        return result;
+    seen.add(value);
+    if (typeof error?.name === "string")
+        result.name = error.name;
+    if (typeof error?.code === "string")
+        result.code = error.code;
+    if (error?.cause !== undefined)
+        result.cause = transportFailure(error.cause, seen);
+    if (Array.isArray(error?.errors))
+        result.errors = error.errors.map((cause) => transportFailure(cause, seen));
+    return result;
+}
+function transportMessage(error) {
+    const own = error.code ? `${error.message} (${error.code})` : error.message;
+    return [own, ...(error.cause ? [transportMessage(error.cause)] : []), ...(error.errors?.map(transportMessage) ?? [])].filter(Boolean).join(": ");
+}
+/** Pick only diagnostics; fetch options and credential-command output must not escape. */
+export function transportError(cause) {
+    if (cause instanceof BridgeError)
+        return cause;
+    const failure = transportFailure(cause);
+    return new BridgeError(transportMessage(failure), "upstream_error", 502, undefined, { cause: failure });
+}

package/dist/headers.d.ts

@@ -0,0 +1,6 @@
+import type { IncomingHttpHeaders } from "node:http";
+export type HeaderRecord = Record<string, string | string[]>;
+export declare function incomingHeaders(input: IncomingHttpHeaders): Headers;
+/** Credentials belong to the selected upstream, never to the bridge client. */
+export declare function forwardRequestHeaders(input?: Headers, authHeader?: string): Headers;
+export declare function forwardResponseHeaders(input: Headers, rewritten?: boolean): HeaderRecord;

package/dist/headers.js

@@ -0,0 +1,39 @@
+const HOP_BY_HOP = ["connection", "keep-alive", "proxy-authenticate", "proxy-authorization", "proxy-connection", "te", "trailer", "transfer-encoding", "upgrade"];
+/** Each HTTP leg owns its framing; metadata is forwarded unless it conflicts. */
+function withoutTransportHeaders(input) {
+    const headers = new Headers(input);
+    const connection = (headers.get("connection") ?? "").split(",").map(name => name.trim()).filter(Boolean);
+    for (const name of [...connection, ...HOP_BY_HOP, "content-length", "content-encoding", "content-md5", "digest", "content-digest", "repr-digest"])
+        headers.delete(name);
+    return headers;
+}
+export function incomingHeaders(input) {
+    const headers = new Headers();
+    for (const [name, value] of Object.entries(input)) {
+        for (const item of Array.isArray(value) ? value : value === undefined ? [] : [value])
+            headers.append(name, item);
+    }
+    return headers;
+}
+/** Credentials belong to the selected upstream, never to the bridge client. */
+export function forwardRequestHeaders(input, authHeader) {
+    const headers = withoutTransportHeaders(input);
+    for (const name of ["host", "accept-encoding", "authorization", "x-api-key", "api-key", "cookie", ...(authHeader ? [authHeader] : [])])
+        headers.delete(name);
+    return headers;
+}
+export function forwardResponseHeaders(input, rewritten = true) {
+    const headers = withoutTransportHeaders(input);
+    // The catalog belongs to the bridge even when the selected upstream also
+    // serves Codex. Rewritten bodies need their own content type.
+    headers.delete("x-models-etag");
+    if (rewritten) {
+        headers.delete("content-type");
+        headers.delete("etag");
+    }
+    const result = Object.fromEntries(headers);
+    const cookies = headers.getSetCookie();
+    if (cookies.length)
+        result["set-cookie"] = cookies;
+    return result;
+}

package/dist/history.d.ts

@@ -0,0 +1,7 @@
+import { type CompactionCarrier, type StatePayload } from "./carrier.ts";
+import type { ResolvedModel, ResponsesRequest } from "./types.ts";
+/** Replay policy for decoded state. The inspector reports the same decisions. */
+export declare function replaysReasoning(carrier: StatePayload, route: ResolvedModel): boolean;
+export declare function restoresNativeCompaction(carrier: CompactionCarrier, route: ResolvedModel): boolean;
+/** Selects model-specific opaque state without changing the stored history. */
+export declare function prepareHistory(input: ResponsesRequest["input"], route: ResolvedModel): Record<string, any>[];

package/dist/history.js

@@ -0,0 +1,85 @@
+import { decodeCompaction, decodeReasoning } from "./carrier.js";
+import { BridgeError } from "./errors.js";
+import { SUMMARY_PREFIX } from "./prompts.js";
+import { translateToolHistory } from "./tool-history.js";
+/** Replay policy for decoded state. The inspector reports the same decisions. */
+export function replaysReasoning(carrier, route) {
+    return route.replay.reasoning.has(carrier.source.id) && carrier.format === route.profile.reasoning_format;
+}
+export function restoresNativeCompaction(carrier, route) {
+    return !!carrier.native && route.compaction.native_replay &&
+        route.replay.native_compaction.has(carrier.native.source.id) &&
+        carrier.native.format === route.profile.native_compaction_format;
+}
+/** Selects model-specific opaque state without changing the stored history. */
+export function prepareHistory(input, route) {
+    if (typeof input === "string") {
+        return [{ type: "message", role: "user", content: [{ type: "input_text", text: input }] }];
+    }
+    if (input === undefined)
+        return [];
+    if (!Array.isArray(input))
+        throw new BridgeError("input must be a string or an array of items");
+    const result = [];
+    for (const original of input) {
+        if (!original || typeof original !== "object" || Array.isArray(original)) {
+            throw new BridgeError("Each input item must be an object");
+        }
+        const item = structuredClone(original);
+        if (item.type === "bridge_reasoning") {
+            throw new BridgeError("Internal reasoning items cannot be supplied as request history");
+        }
+        if (item.type === "item_reference") {
+            throw new BridgeError("Stored item references are unsupported; send the complete conversation items");
+        }
+        if (item.type === "reasoning") {
+            const carrier = decodeReasoning(item.encrypted_content);
+            if (carrier && replaysReasoning(carrier, route)) {
+                result.push({ type: "bridge_reasoning", state: carrier, summary: item.summary ?? [] });
+            }
+            continue;
+        }
+        if (item.type === "agent_message" && route.profile.api !== "responses") {
+            if (typeof item.author !== "string" || typeof item.recipient !== "string" || !Array.isArray(item.content)) {
+                throw new BridgeError("An agent message requires author, recipient, and content");
+            }
+            if (item.encrypted_content || item.content.some((part) => part?.type === "encrypted_content")) {
+                throw new BridgeError("Encrypted agent messages are unsupported on this backend; use plaintext agent messages");
+            }
+            for (const part of item.content) {
+                if (!["input_text", "input_image"].includes(part?.type)) {
+                    throw new BridgeError(`Unsupported agent message content: ${String(part?.type)}`);
+                }
+            }
+            result.push({
+                type: "message", role: "user",
+                content: [
+                    { type: "input_text", text: `Agent message from ${JSON.stringify(item.author)} to ${JSON.stringify(item.recipient)}:\n` },
+                    ...item.content,
+                ],
+            });
+            continue;
+        }
+        if (item.type === "compaction" || item.type === "compaction_summary") {
+            const carrier = decodeCompaction(item.encrypted_content);
+            if (!carrier) {
+                throw new BridgeError("This compaction item has no portable summary or handoff recipe; use history created through this bridge");
+            }
+            if (restoresNativeCompaction(carrier, route)) {
+                result.push(carrier.native.data);
+            }
+            else {
+                if (!carrier.summary)
+                    throw new BridgeError("Deferred compaction summary has not been materialized");
+                result.push({
+                    type: "message",
+                    role: "user",
+                    content: [{ type: "input_text", text: `${SUMMARY_PREFIX}\n\n${carrier.summary}` }],
+                });
+            }
+            continue;
+        }
+        result.push(item);
+    }
+    return route.profile.api === "responses" ? result : translateToolHistory(result);
+}

package/dist/ids.d.ts

@@ -0,0 +1 @@
+export declare function newId(prefix: string): string;

package/dist/ids.js

@@ -0,0 +1,4 @@
+import { randomBytes } from "node:crypto";
+export function newId(prefix) {
+    return `${prefix}_${randomBytes(12).toString("hex")}`;
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { createBridgeServer } from "./server.ts";
+export { loadConfig, validateConfig, resolveModel } from "./config.ts";
+export { buildCatalog, configSnippet } from "./catalog.ts";
+export { BridgeError } from "./errors.ts";
+export type { BridgeConfig, UpstreamConfig, ModelConfig } from "./types.ts";

package/dist/index.js

@@ -0,0 +1,4 @@
+export { createBridgeServer } from "./server.js";
+export { loadConfig, validateConfig, resolveModel } from "./config.js";
+export { buildCatalog, configSnippet } from "./catalog.js";
+export { BridgeError } from "./errors.js";