@wacry/codeks-bridge 0.0.1 → 0.0.4

package/NOTICE

@@ -11,3 +11,15 @@ licensed under the Apache License, Version 2.0:
 - catalog/*.json contains model metadata and prompts copied or adapted from:
   codex-rs/models-manager/models.json
   Each catalog entry records its source tag, commit, and changes.
+- benchmarks/compaction/prompts/ contains frozen or adapted compact prompts,
+  the summary prefix, and model instructions from OpenAI Codex, together with
+  user-supplied experiment prompts. File hashes and source notes are recorded
+  in benchmarks/compaction/prompts/manifest.json.
+- benchmarks/compaction/retention.py adapts the text-only user-message retention
+  and middle-truncation logic from codex-rs/core/src/compact_remote_v2.rs and
+  codex-rs/utils/string/src/truncate.rs at rust-v0.162.1.
+
+benchmarks/compaction/fixture.py adapts the product-defaults fixture generator
+from algal/pi-openai-server-compaction, Copyright (c) 2026 Alexis Gallagher,
+licensed under the MIT License. The source commit and complete license are
+included in that file.

package/README.md

@@ -30,7 +30,7 @@ codeks-bridge config-snippet --config /absolute/path/bridge.json
 
 - 上游错误保留原始详情交给客户端；bridge 不自动换端点、重试或更换压缩方式。
 - Reasoning 默认只回放给原目标。原生压缩与 reasoning 的跨目标复用分别配置，实际兼容性由上游决定。
-- GPT 默认使用 `compaction.mode: "native"`：先做原生加密压缩，需要文字表示时再向原来源复述并缓存。其他模型默认使用标准文字压缩，也可通过 [`compaction.model`](docs/config.md#压缩模式与执行模型) 委托 GPT 执行原生压缩。
+- GPT 默认使用 `compaction.mode: "native"`：先做原生加密压缩，需要文字表示时再向原来源复述并缓存。其他模型默认使用标准文字压缩，也可通过 [`compaction.model`](docs/config.md#压缩模式与执行模型) 委托常用 GPT 执行原生压缩，直接复用已有模型配置；见 [GPT＋Claude 双模型示例](examples/gpt-claude.json)。
 - 历史由 codeks 保存；按需复述的成功结果另存本地缓存。封装只是编码，文字 reasoning、摘要及复述配方可读。
 - Lark/regex 转为工具描述约束。图片理解由模型支持，客户端配置关闭网页搜索和图片生成。
 

package/dist/adapter-options.d.ts

@@ -0,0 +1,5 @@
+import type { AdapterId, ClaudeMessagesOptions, ResolvedModel } from "./types.ts";
+/** Validate bridge-owned settings; native options stay open to upstream extensions. */
+export declare function validateAdapterConfig(value: unknown, location: string, adapter?: AdapterId): void;
+/** Model leaves override connection leaves; neither is part of state provenance. */
+export declare function resolveClaudeOptions(route: Pick<ResolvedModel, "upstream" | "config">): ClaudeMessagesOptions;

package/dist/adapter-options.js

@@ -0,0 +1,41 @@
+import { BridgeError } from "./errors.js";
+function object(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+/** Validate bridge-owned settings; native options stay open to upstream extensions. */
+export function validateAdapterConfig(value, location, adapter) {
+    if (value === undefined)
+        return;
+    function fail(message) {
+        throw new BridgeError(`Invalid configuration: ${location}.adapters: ${message}`);
+    }
+    if (!object(value))
+        fail("must be an object");
+    for (const [name, settings] of Object.entries(value)) {
+        if (name !== "claude-messages")
+            fail(`unknown adapter settings ${name}`);
+        if (adapter !== undefined && name !== adapter)
+            fail(`${name} does not match the model adapter ${adapter}`);
+        if (!object(settings))
+            fail(`${name} must be an object`);
+        for (const field of Object.keys(settings)) {
+            if (field !== "tool_updates" && field !== "thinking_mismatch")
+                fail(`unknown ${name} setting ${field}`);
+        }
+        if (settings.tool_updates !== undefined && !["inline", "top_level"].includes(settings.tool_updates)) {
+            fail(`${name}.tool_updates must be inline or top_level`);
+        }
+        if (settings.thinking_mismatch !== undefined && !["drop_block", "error", "upstream_default"].includes(settings.thinking_mismatch)) {
+            fail(`${name}.thinking_mismatch must be drop_block, error, or upstream_default`);
+        }
+    }
+}
+/** Model leaves override connection leaves; neither is part of state provenance. */
+export function resolveClaudeOptions(route) {
+    const upstream = route.upstream.adapters?.["claude-messages"];
+    const model = route.config.adapters?.["claude-messages"];
+    return {
+        tool_updates: model?.tool_updates ?? upstream?.tool_updates ?? "inline",
+        thinking_mismatch: model?.thinking_mismatch ?? upstream?.thinking_mismatch ?? "drop_block",
+    };
+}

package/dist/backends/anthropic-tools.d.ts

@@ -0,0 +1,14 @@
+import { type ToolSet } from "../tools.ts";
+import type { ResponsesRequest } from "../types.ts";
+export interface AnthropicToolDefinition {
+    name: string;
+    description: string;
+    input_schema: Record<string, unknown>;
+    strict?: boolean;
+}
+/** Keep later definitions at their original conversation boundary. */
+export declare function buildAnthropicTools(request: ResponsesRequest, mode: "inline" | "top_level"): {
+    tools: ToolSet;
+    definitions: AnthropicToolDefinition[];
+    input: ResponsesRequest["input"];
+};

package/dist/backends/anthropic-tools.js

@@ -0,0 +1,44 @@
+import { BridgeError } from "../errors.js";
+import { buildToolSet, normalizeToolDeclarations } from "../tools.js";
+function definition(tool) {
+    return {
+        name: tool.flatName, description: tool.description, input_schema: tool.parameters,
+        ...(tool.strict === undefined ? {} : { strict: tool.strict }),
+    };
+}
+/** Keep later definitions at their original conversation boundary. */
+export function buildAnthropicTools(request, mode) {
+    if (mode === "top_level") {
+        const normalized = normalizeToolDeclarations(request);
+        const tools = buildToolSet(normalized.tools);
+        return { tools, definitions: tools.entries.map(definition), input: normalized.input };
+    }
+    const tools = buildToolSet(request.tools);
+    const initial = new Map(tools.entries.map((tool) => [tool.flatName, definition(tool)]));
+    if (!Array.isArray(request.input)) {
+        return { tools, definitions: [...initial.values()], input: request.input };
+    }
+    const input = [];
+    let prefix = true;
+    for (const item of request.input) {
+        if (item?.type === "additional_tools") {
+            if (!Array.isArray(item.tools))
+                throw new BridgeError("additional_tools requires a tools array.");
+            const definitions = tools.add(item.tools).map(definition);
+            if (prefix) {
+                for (const tool of definitions)
+                    initial.set(tool.name, tool);
+            }
+            else if (definitions.length) {
+                input.push({ ...item, tools: definitions });
+            }
+        }
+        else {
+            input.push(item);
+            if (!item || !["system", "developer"].includes(item.role) ||
+                (item.type !== undefined && item.type !== "message"))
+                prefix = false;
+        }
+    }
+    return { tools, definitions: [...initial.values()], input };
+}

package/dist/backends/anthropic.d.ts

@@ -4,5 +4,7 @@ import type { Backend, BackendContext } from "../types.ts";
 export declare function buildAnthropicRequest(context: BackendContext): {
     body: Record<string, any>;
     tools: ToolSet;
+    betas: string[];
+    continuationBefore?: string;
 };
 export declare const runAnthropic: Backend;

package/dist/backends/anthropic.js

@@ -1,10 +1,14 @@
 import { encodeReasoning } from "../carrier.js";
+import { resolveClaudeOptions } from "../adapter-options.js";
 import { BridgeError, upstreamError } from "../errors.js";
 import { prepareHistory } from "../history.js";
 import { reasoningEffort, reasoningSummaryRequested } from "../profiles.js";
 import { parseJsonSse } from "../sse.js";
-import { buildToolSet, normalizeToolDeclarations, safeCallId } from "../tools.js";
+import { safeCallId } from "../tools.js";
 import { upstreamFetch } from "../upstream.js";
+import { buildAnthropicTools } from "./anthropic-tools.js";
+const THINKING_BINDING_BETA = "thinking-binding-controls-2026-08-01";
+const INLINE_TOOLS_BETA = "inline-tools-2026-09-15";
 function contentBlocks(content) {
     if (typeof content === "string")
         return content ? [{ type: "text", text: content }] : [];
@@ -64,25 +68,64 @@ function toolChoice(value, tools) {
 /** Convert only request-owned copies; stored history remains unchanged. */
 export function buildAnthropicRequest(context) {
     const { route } = context;
-    const request = normalizeToolDeclarations(context.request);
-    const tools = buildToolSet(request.tools);
+    const request = context.request;
+    const settings = resolveClaudeOptions(route);
+    const { tools, definitions, input } = buildAnthropicTools(request, settings.tool_updates);
     const system = request.instructions ? [{ type: "text", text: request.instructions }] : [];
     const messages = [];
+    let additions = [];
+    let hasInlineTools = false;
+    const continueAssistant = () => {
+        const tail = messages.at(-1);
+        if (tail?.role === "assistant" && !tail.content.some(block => block.type === "tool_use")) {
+            const text = "Continue.";
+            messages.push({ role: "user", content: [{ type: "text", text }] });
+            return text;
+        }
+    };
+    const flushAdditions = () => {
+        if (!additions.length)
+            return;
+        // A persisted declaration also anchors this boundary on later replays.
+        continueAssistant();
+        if (messages.at(-1)?.role !== "user") {
+            throw new BridgeError("Inline tool declarations require a user or completed tool-result boundary.");
+        }
+        messages.push({ role: "system", content: additions });
+        additions = [];
+        hasInlineTools = true;
+    };
     const append = (role, blocks) => {
         if (!blocks.length)
             return;
+        // Several reminders/results may share a user turn. Tool declarations take
+        // effect after that complete boundary, before the next assistant step.
+        if (role === "assistant")
+            flushAdditions();
         const last = messages.at(-1);
         if (last?.role === role)
             last.content.push(...blocks);
         else
             messages.push({ role, content: blocks });
     };
-    for (const item of prepareHistory(request.input, route)) {
-        if (item.type === "bridge_reasoning") {
+    for (const item of prepareHistory(input, route)) {
+        if (item.type === "additional_tools") {
+            additions.push(...item.tools.map((definition) => ({
+                type: "tool_addition", tool: { type: "tool_definition", definition },
+            })));
+        }
+        else if (item.type === "bridge_reasoning") {
             const block = item.state.data;
             if (!block || !["thinking", "redacted_thinking"].includes(block.type)) {
                 throw new BridgeError("Invalid Messages reasoning carrier.");
             }
+            const continuation = item.state.continuation_before;
+            if (continuation !== undefined) {
+                if (typeof continuation !== "string" || !continuation.length) {
+                    throw new BridgeError("Invalid Messages reasoning continuation boundary.");
+                }
+                append("user", [{ type: "text", text: continuation }]);
+            }
             append("assistant", [block]);
         }
         else if (item.type === "function_call" || item.type === "custom_tool_call") {
@@ -117,9 +160,11 @@ export function buildAnthropicRequest(context) {
         else
             throw new BridgeError(`Unsupported Messages history item: ${String(item.type)}.`);
     }
-    const definitions = tools.entries.map((tool) => ({
-        name: tool.flatName, description: tool.description, input_schema: tool.parameters,
-    }));
+    // A failed response can leave a complete thinking/text item in codeks history.
+    // Claude requires a user boundary to resume. Do not mask a missing tool result.
+    // Pending declarations already persist their own continuation boundary.
+    const continuationBefore = additions.length ? undefined : continueAssistant();
+    flushAdditions();
     // Keep stable prefixes at 1h. The one-off compaction suffix uses 5m.
     const cache = (block, ttl = "1h") => {
         if (block)
@@ -158,6 +203,18 @@ export function buildAnthropicRequest(context) {
     Object.assign(body, route.upstream.options, route.config.options, {
         model: route.config.model, messages, stream: true,
     });
+    // Native options remain authoritative. Modes such as between_tools do not
+    // support binding controls; do not change the caller's chosen thinking mode.
+    if (["adaptive", "enabled"].includes(body.thinking?.type) &&
+        settings.thinking_mismatch !== "upstream_default") {
+        body.thinking = {
+            ...body.thinking,
+            block_binding: {
+                prefix_mismatch_behavior: settings.thinking_mismatch,
+                ...body.thinking.block_binding,
+            },
+        };
+    }
     if (system.length)
         body.system = system;
     else
@@ -172,7 +229,7 @@ export function buildAnthropicRequest(context) {
             delete body.output_config.format;
         }
     }
-    return { body, tools };
+    return { body, tools, betas: [THINKING_BINDING_BETA, ...(hasInlineTools ? [INLINE_TOOLS_BETA] : [])], continuationBefore };
 }
 function tokenCount(value) {
     if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
@@ -191,16 +248,18 @@ function validateUsage(value, required) {
         tokenCount(value.output_tokens_details.thinking_tokens);
 }
 export const runAnthropic = async (context, writer) => {
-    const { body, tools } = buildAnthropicRequest(context);
-    const response = await upstreamFetch(context.route, "/messages", body, context.signal, context.requestHeaders);
+    const { body, tools, betas, continuationBefore } = buildAnthropicRequest(context);
+    const response = await upstreamFetch(context.route, "/messages", body, context.signal, context.requestHeaders, { "anthropic-beta": betas });
     context.onAccepted?.(response.headers);
     if (!response.body)
         throw new BridgeError("Messages returned an empty stream.", "upstream_error", 502);
     const blocks = new Map();
+    let pendingContinuation = continuationBefore;
     let rawUsage = {};
     let started = false;
     let finalUsage = false;
     let stopReason;
+    let stopEvent;
     let stopped = false;
     for await (const { json: event } of parseJsonSse(response.body)) {
         if (event.type === "error")
@@ -219,7 +278,9 @@ export const runAnthropic = async (context, writer) => {
             if (!["text", "thinking", "redacted_thinking", "tool_use"].includes(value.type)) {
                 throw new BridgeError(`Unsupported Messages output block: ${String(value.type)}.`);
             }
-            blocks.set(event.index, { value, json: "" });
+            // Only the first native block can anchor the response's leading boundary.
+            blocks.set(event.index, { value, json: "", continuationBefore: pendingContinuation });
+            pendingContinuation = undefined;
             if (value.type === "text" && value.text)
                 writer.textDelta(value.text);
             if (value.type === "thinking")
@@ -251,7 +312,13 @@ export const runAnthropic = async (context, writer) => {
             if (!block)
                 throw new BridgeError("Messages stopped an unknown block.", "upstream_error", 502);
             if (block.value.type === "thinking" || block.value.type === "redacted_thinking") {
-                writer.endReasoning(encodeReasoning({ source: context.route.origin, format: context.route.profile.reasoning_format, data: block.value }));
+                const state = {
+                    source: context.route.origin,
+                    format: context.route.profile.reasoning_format,
+                    data: block.value,
+                    ...(block.continuationBefore !== undefined ? { continuation_before: block.continuationBefore } : {}),
+                };
+                writer.endReasoning(encodeReasoning(state));
             }
             else if (block.value.type === "tool_use") {
                 if (block.json)
@@ -273,7 +340,10 @@ export const runAnthropic = async (context, writer) => {
             blocks.delete(event.index);
         }
         else if (event.type === "message_delta") {
-            stopReason = event.delta?.stop_reason ?? stopReason;
+            if (event.delta?.stop_reason != null) {
+                stopReason = event.delta.stop_reason;
+                stopEvent = event;
+            }
             validateUsage(event.usage, ["output_tokens"]);
             finalUsage = true;
             rawUsage = { ...rawUsage, ...event.usage };
@@ -287,8 +357,14 @@ export const runAnthropic = async (context, writer) => {
     if (stopReason === "model_context_window_exceeded") {
         throw new BridgeError("Messages reached the model context window before completing the response.", "context_length_exceeded");
     }
-    if (stopReason === "max_tokens" || stopReason === "refusal") {
-        throw new BridgeError(stopReason === "max_tokens" ? "Messages reached max_tokens before completing the response." : "Messages refused the request.");
+    if (stopReason === "refusal") {
+        const details = stopEvent?.delta?.stop_details;
+        const diagnostic = [details?.category, details?.explanation]
+            .filter((value) => typeof value === "string" && value.trim().length > 0);
+        throw new BridgeError(`Messages refused the request.${diagnostic.length ? ` ${diagnostic.join(": ")}` : ""}`, "invalid_prompt", 400, undefined, { upstream: { body: stopEvent } });
+    }
+    if (stopReason === "max_tokens") {
+        throw new BridgeError("Messages reached max_tokens before completing the response.");
     }
     if (!["end_turn", "stop_sequence", "tool_use", "pause_turn"].includes(stopReason)) {
         throw new BridgeError(`Unsupported Messages stop reason: ${stopReason}.`);

package/dist/backends/chat.js

@@ -159,7 +159,10 @@ export function buildChatRequest(context, dialect) {
     body.stream_options = { ...body.stream_options, include_usage: true };
     if (tools.entries.length)
         body.tools = tools.entries.map((tool) => ({
-            type: "function", function: { name: tool.flatName, description: tool.description, parameters: tool.parameters },
+            type: "function", function: {
+                name: tool.flatName, description: tool.description, parameters: tool.parameters,
+                ...(tool.strict === undefined ? {} : { strict: tool.strict }),
+            },
         }));
     else
         delete body.tools;

package/dist/backends/responses.js

@@ -51,16 +51,41 @@ function usageFrom(value) {
         }
         return value;
     };
-    const cached = value?.input_tokens_details?.cached_tokens;
-    const reasoning = value?.output_tokens_details?.reasoning_tokens;
+    // These fields are required by codeks when their enclosing objects exist.
+    count(value?.total_tokens, "total_tokens");
+    const cached = value?.input_tokens_details == null ? undefined
+        : count(value.input_tokens_details.cached_tokens, "input_tokens_details.cached_tokens");
+    const reasoning = value?.output_tokens_details == null ? undefined
+        : count(value.output_tokens_details.reasoning_tokens, "output_tokens_details.reasoning_tokens");
     const cacheWrite = value?.input_tokens_details?.cache_write_tokens;
+    if (value?.codex_rollout_budget_units != null && !Number.isFinite(value.codex_rollout_budget_units)) {
+        throw new BridgeError("Invalid Responses usage field: codex_rollout_budget_units", "upstream_error", 502);
+    }
     return {
         input_tokens: count(value?.input_tokens, "input_tokens"),
         output_tokens: count(value?.output_tokens, "output_tokens"),
-        ...(cached !== undefined ? { cached_tokens: count(cached, "input_tokens_details.cached_tokens") } : {}),
+        ...(cached !== undefined ? { cached_tokens: cached } : {}),
         ...(cacheWrite !== undefined ? { cache_write_tokens: count(cacheWrite, "input_tokens_details.cache_write_tokens") } : {}),
-        ...(reasoning !== undefined ? { reasoning_tokens: count(reasoning, "output_tokens_details.reasoning_tokens") } : {}),
+        ...(reasoning !== undefined ? { reasoning_tokens: reasoning } : {}),
+    };
+}
+/** Validate the client terminal contract before any buffered tools can run. */
+function completedUsage(response) {
+    const invalid = (field) => {
+        throw new BridgeError(`Missing or invalid Responses completed field: ${field}`, "upstream_error", 502);
     };
+    if (typeof response.id !== "string")
+        invalid("id");
+    if (response.end_turn != null && typeof response.end_turn !== "boolean")
+        invalid("end_turn");
+    const metadata = response.usage_metadata;
+    if (metadata != null) {
+        if (typeof metadata !== "object" || Array.isArray(metadata))
+            invalid("usage_metadata");
+        if (metadata.amount != null && typeof metadata.amount !== "string")
+            invalid("usage_metadata.amount");
+    }
+    return usageFrom(response.usage);
 }
 /** Transform only bridge-owned fields; native events keep their original shape. */
 export const runResponses = async (context, writer) => {
@@ -136,6 +161,14 @@ export const runResponses = async (context, writer) => {
         states.set(index, state);
         emit({ ...event, item });
     }
+    function reconcileOutput(result) {
+        // codeks persists item events, not the terminal response.output. This also
+        // applies to partial history returned only by an incomplete terminal event.
+        for (const [index, item] of (result.output ?? []).entries()) {
+            if (!states.get(index)?.done)
+                outputEvent({ type: "response.output_item.done", output_index: index, item });
+        }
+    }
     function terminal(event) {
         const result = event.response;
         if (event.type === "response.failed" || result?.status === "failed" || result?.error) {
@@ -143,19 +176,15 @@ export const runResponses = async (context, writer) => {
             throw responsesStreamError(responseFor(result), response.headers, event);
         }
         if (event.type === "response.incomplete" || result?.status === "incomplete") {
+            reconcileOutput(result);
             releasePhase();
             throw new ResponsesIncompleteError(responseFor(result), event);
         }
         if (result?.status !== "completed") {
             throw new BridgeError("The upstream did not return a completed response", "stream_error", 502);
         }
-        const usage = usageFrom(result.usage);
-        // A whole JSON response, or a terminal-only stream, still needs item events
-        // because codeks persists the history from output_item.done.
-        for (const [index, item] of (result.output ?? []).entries()) {
-            if (!states.get(index)?.done)
-                outputEvent({ type: "response.output_item.done", output_index: index, item });
-        }
+        const usage = completedUsage(result);
+        reconcileOutput(result);
         for (const state of states.values()) {
             if (!state.done)
                 throw new BridgeError("The upstream completed with an unfinished output item", "stream_error", 502);
@@ -173,13 +202,6 @@ export const runResponses = async (context, writer) => {
         if (result.status === "completed" || result.status === "incomplete") {
             writer.nativeEvent({ type: "response.created", response: { ...result, model: context.request.model, status: "in_progress", output: [] } });
         }
-        if (result.status === "incomplete") {
-            // An interrupted whole response has no earlier item events. Publish its
-            // partial history before the terminal event, still withholding any tool suffix.
-            for (const [index, item] of (result.output ?? []).entries()) {
-                outputEvent({ type: "response.output_item.done", output_index: index, item });
-            }
-        }
         return terminal({ type: result.status === "incomplete" ? "response.incomplete" : "response.completed", response: result });
     }
     if (!response.body)

package/dist/config.js

@@ -3,6 +3,7 @@ import { createHash } from "node:crypto";
 import { modelProfile } from "./profiles.js";
 import { getCatalogEntry } from "./model-catalog.js";
 import { BridgeError } from "./errors.js";
+import { validateAdapterConfig } from "./adapter-options.js";
 function object(value) {
     return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -28,6 +29,8 @@ export function validateConfig(value) {
         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.request_max_mib !== undefined && (!Number.isSafeInteger(value.request_max_mib) || value.request_max_mib <= 0 || !Number.isSafeInteger(value.request_max_mib * 1024 * 1024)))
+        fail("request_max_mib must be a positive integer with a safe byte count");
     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) {
@@ -65,6 +68,7 @@ export function validateConfig(value) {
             fail(`upstream ${name}: invalid headers`);
         if (up.options !== undefined && !object(up.options))
             fail(`upstream ${name}: options must be an object`);
+        validateAdapterConfig(up.adapters, `upstream ${name}`);
     }
     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))
@@ -91,6 +95,7 @@ export function validateConfig(value) {
                 fail(`model ${slug}: effort_map must map effort names to upstream values`);
         }
         const profile = modelProfile(model);
+        validateAdapterConfig(model.adapters, `model ${slug}`, profile.id);
         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))

package/dist/inspect/view.d.ts

@@ -23,7 +23,7 @@ export interface Annotation {
     decoded: unknown;
 }
 /** Splits timed text into SSE events. An event takes the time of the part that completed it. */
-export declare function sseEvents(parts: readonly Part[]): SseRecord[];
+export declare function sseEvents(parts: readonly Part[], finished?: boolean): SseRecord[];
 export declare function summary(exchange: Exchange): {
     id: string;
     seq: number;

package/dist/inspect/view.js

@@ -2,7 +2,7 @@ import { decodeCompaction, decodeReasoning } from "../carrier.js";
 import { resolveModel } from "../config.js";
 import { replaysReasoning, restoresNativeCompaction } from "../history.js";
 /** Splits timed text into SSE events. An event takes the time of the part that completed it. */
-export function sseEvents(parts) {
+export function sseEvents(parts, finished = true) {
     const events = [];
     let event = null;
     let data = [];
@@ -43,11 +43,13 @@ export function sseEvents(parts) {
         }
         buffer = buffer.slice(start);
     }
-    if (buffer.endsWith("\r"))
-        buffer = buffer.slice(0, -1);
-    if (buffer)
-        line(buffer, t);
-    line("", t);
+    if (finished) {
+        if (buffer.endsWith("\r"))
+            buffer = buffer.slice(0, -1);
+        if (buffer)
+            line(buffer, t);
+        line("", t);
+    }
     return events;
 }
 function isSse(message) {
@@ -210,7 +212,7 @@ function messageView(message) {
         end: message.end,
         error: message.error ?? null,
         body: { text: message.text(), bytes: message.bytes },
-        events: isSse(message) ? sseEvents(message.parts) : null,
+        events: isSse(message) ? sseEvents(message.parts, message.end !== "active") : null,
     };
 }
 function reasoningInput(inspector, route, item, pointer) {

package/dist/server.js

@@ -14,7 +14,6 @@ import { Inspector } from "./inspect/capture.js";
 import { isInspectorPath, serveInspector } from "./inspect/http.js";
 import { forwardResponseHeaders, incomingHeaders } from "./headers.js";
 const BACKENDS = { "gpt-responses": runResponses, "claude-messages": runAnthropic, "deepseek-chat": runDeepSeek };
-const MAX_BODY_BYTES = 64 * 1024 * 1024;
 function json(res, status, body, headers = {}) {
     for (const [name, value] of Object.entries(headers))
         res.setHeader(name, value);
@@ -27,13 +26,15 @@ function upstreamHttpFailure(res, error) {
     res.writeHead(error.status, forwardResponseHeaders(error.headers, false));
     res.end(error.body);
 }
-async function readRequest(req, exchange) {
+async function readRequest(req, maxMiB, exchange) {
+    const maxBytes = maxMiB * 1024 * 1024;
     let size = 0;
     const chunks = [];
-    for await (const chunk of req) {
+    // Keep the socket alive long enough to deliver HTTP 413, then close it.
+    for await (const chunk of req.iterator({ destroyOnReturn: false })) {
         size += chunk.length;
-        if (size > MAX_BODY_BYTES)
-            throw new BridgeError("Request exceeds 64 MiB", "invalid_prompt", 413);
+        if (size > maxBytes)
+            throw new BridgeError(`Request exceeds ${maxMiB} MiB`, "invalid_prompt", 413, { connection: "close" });
         chunks.push(chunk);
     }
     const text = Buffer.concat(chunks).toString("utf8");
@@ -123,7 +124,7 @@ export function createBridgeServer(value) {
             }
             res.setHeader("x-models-etag", catalogEtag);
             const exchange = inspector.begin(req, res);
-            const request = await readRequest(req, exchange);
+            const request = await readRequest(req, config.request_max_mib ?? 512, exchange);
             const caller = resolveModel(config, request.model);
             const compacting = isCompactionRequest(request);
             // Restore history for the actual consumer before materializing any handoffs.

package/dist/tool-history.js

@@ -1,7 +1,8 @@
 import { BridgeError } from "./errors.js";
 const isCall = (item) => ["function_call", "custom_tool_call"].includes(item.type);
 const isResult = (item) => ["function_call_output", "custom_tool_call_output"].includes(item.type);
-const isReminder = (item) => (item.type === "message" || !item.type) && ["user", "developer", "system"].includes(item.role);
+const isReminder = (item) => item.type === "additional_tools" ||
+    ((item.type === "message" || !item.type) && ["user", "developer", "system"].includes(item.role));
 function toolName(item) {
     return JSON.stringify({ ...(item.namespace ? { namespace: item.namespace } : {}), name: item.name });
 }

package/dist/tools.d.ts

@@ -8,9 +8,12 @@ export interface ToolEntry {
     namespace?: string;
     description: string;
     parameters: Record<string, unknown>;
+    strict?: boolean;
 }
 export interface ToolSet {
     entries: ToolEntry[];
+    /** Applies a declaration batch and returns detached snapshots of its definitions. */
+    add(tools: unknown[]): ToolEntry[];
     /** Upstream name -> tool. */
     byFlat: Map<string, ToolEntry>;
     /** Upstream name for a call found in history. */