@wacry/codeks-bridge 0.0.3 → 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/dist/backends/anthropic-tools.d.ts

@@ -4,6 +4,7 @@ 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"): {

package/dist/backends/anthropic-tools.js

@@ -1,7 +1,10 @@
 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 };
+    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) {

package/dist/backends/anthropic.d.ts

@@ -5,5 +5,6 @@ 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

@@ -78,7 +78,9 @@ export function buildAnthropicRequest(context) {
     const continueAssistant = () => {
         const tail = messages.at(-1);
         if (tail?.role === "assistant" && !tail.content.some(block => block.type === "tool_use")) {
-            messages.push({ role: "user", content: [{ type: "text", text: "Continue." }] });
+            const text = "Continue.";
+            messages.push({ role: "user", content: [{ type: "text", text }] });
+            return text;
         }
     };
     const flushAdditions = () => {
@@ -117,6 +119,13 @@ export function buildAnthropicRequest(context) {
             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") {
@@ -153,7 +162,8 @@ export function buildAnthropicRequest(context) {
     }
     // 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.
-    continueAssistant();
+    // 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") => {
@@ -219,7 +229,7 @@ export function buildAnthropicRequest(context) {
             delete body.output_config.format;
         }
     }
-    return { body, tools, betas: [THINKING_BINDING_BETA, ...(hasInlineTools ? [INLINE_TOOLS_BETA] : [])] };
+    return { body, tools, betas: [THINKING_BINDING_BETA, ...(hasInlineTools ? [INLINE_TOOLS_BETA] : [])], continuationBefore };
 }
 function tokenCount(value) {
     if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
@@ -238,16 +248,18 @@ function validateUsage(value, required) {
         tokenCount(value.output_tokens_details.thinking_tokens);
 }
 export const runAnthropic = async (context, writer) => {
-    const { body, tools, betas } = buildAnthropicRequest(context);
+    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")
@@ -266,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")
@@ -298,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)
@@ -320,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 };
@@ -334,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/config.js

@@ -29,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) {

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/tools.d.ts

@@ -8,6 +8,7 @@ export interface ToolEntry {
     namespace?: string;
     description: string;
     parameters: Record<string, unknown>;
+    strict?: boolean;
 }
 export interface ToolSet {
     entries: ToolEntry[];

package/dist/tools.js

@@ -116,6 +116,8 @@ export function buildToolSet(tools) {
             // Lite updates contain only changed members. Replace that definition
             // without losing siblings or changing its established upstream name.
             Object.assign(previous, entry);
+            if (entry.strict === undefined)
+                delete previous.strict;
             return previous;
         }
         let flatName = baseFlatName(entry.namespace, entry.name);
@@ -140,6 +142,7 @@ export function buildToolSet(tools) {
                     namespace,
                     description: String(tool.description ?? ""),
                     parameters: objectSchema(tool.parameters),
+                    ...(typeof tool.strict === "boolean" ? { strict: tool.strict } : {}),
                 })];
         }
         else if (tool.type === "custom") {

package/dist/types.d.ts

@@ -49,6 +49,7 @@ export interface BridgeConfig {
     host?: string;
     port?: number;
     token_env?: string;
+    request_max_mib?: number;
     compaction_cache_dir?: string;
     /** Debug capture for the /inspect/ page. */
     inspect?: {

package/docs/backends-anthropic.md

@@ -40,20 +40,27 @@ Opus / Sonnet 5.5 目录的默认及最大上下文窗口为 `1000000`，Message
 
 所有 Messages 请求都附带 `thinking-binding-controls-2026-08-01` beta，与现有 beta header 合并，以取得 `input_transformations` 诊断；声明诊断 beta 本身不等于选择某种失配策略。服务端报告与实际支持取决于端点，未知能力或请求错误直接返回，不自动更换策略。[官方 preserved thinking 规则](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking)
 
-流式响应可能已交付完整 thinking 或文字项，随后才过载或断流。codeks 保存这些已完成项并负责重试，因此重试历史可能以 assistant 结束。若最后的 assistant 不含 `tool_use`，bridge 仅在本次出站请求追加 user `Continue.`，提供合法续接边界；含工具调用时不补这一句，以免掩盖缺失工具结果。
+流式响应可能已交付完整 thinking 或文字项，随后才过载或断流。codeks 保存这些已完成项并负责重试，因此重试历史可能以 assistant 结束。若最后的 assistant 不含 `tool_use`，bridge 在出站请求追加 user `Continue.`，提供合法续接边界；含工具调用时不补这一句，以免掩盖缺失工具结果。
 
 若这个 assistant 后紧跟持久化的增量工具声明，同样在声明前补续接边界；后续回放时，声明的位置让 bridge 能重新构造相同边界，不需要另存隐藏会话状态。
 
-这句合成提示不写入 codeks 历史。假设失败前已保存 T1，重试生成 T2，下一轮历史会出现以下差别：
+对于没有增量工具声明锚定的尾部 `Continue.`，若本次响应的第一个原生内容块是 `thinking` 或 `redacted_thinking`，bridge 在该块的 `cxbr1:` 外层记录可选字段 `continuation_before`，值为实际补入的文本。原生 thinking、签名和隐藏数据保持不变；字段随原 reasoning item 的 `output_item.done` 进入 codeks 历史，不产生独立的控制项或用户消息。
+
+以后恢复这块 reasoning 时，先在同一位置补回记录的 user 文本。假设失败前已保存 T1，重试的首块为 T2：
 
 ```text
-重试请求：H → assistant[T1] → user[Continue.] → assistant[T2, 正文]
-下一轮：  H → assistant[T1, T2, 正文] → user[新问题]
+重试请求：H → assistant[T1] → user[Continue.]
+重试输出：T2{continuation_before: "Continue."} → 正文
+下轮请求：H → assistant[T1] → user[Continue.] → assistant[T2, 正文] → user[新问题]
 ```
 
-因此 T2 的签名前缀可能不再匹配；默认 `drop_block` 让服务端在该轮报告并丢弃失配块。只保证 Continue 那次请求成功并不够，后续回放也需要考虑这个变化。`error` 或 `upstream_default` 下，服务端仍可能拒绝后续请求。
+这样 T2 不会仅因续接边界消失而失配。同一响应只标记首块，后续 thinking、正文和工具继续保持原顺序；如果 T2 完整交付后又发生故障，这个边界已随 T2 保存，下一次重试可恢复它并记录新的续接边界。首块尚未完整交付时没有新载荷，下次仍按已有历史重试。字段跟随 reasoning 的来源与格式筛选：本次不恢复该载荷时，也不恢复其中的边界；以后允许恢复时，两者一起生效。
+
+覆盖范围按实际输出顺序决定。Adaptive thinking 不保证第一个内容块就是 thinking；若先输出正文或工具，再输出 thinking，bridge 不给后来的块添加这个字段，否则会把 `Continue.` 恢复到错误的位置。这类响应及没有字段的既有历史仍沿用当前失配策略；没有 thinking 的响应则没有新签名需要通过这个字段保护。由增量工具声明锚定的边界不重复记录。[官方 thinking 规则](https://platform.claude.com/docs/en/build-with-claude/thinking)
 
-选择这种恢复方式是为了保留正常 thinking、正文的流式显示，不让每轮正文都等待整个响应成功，也不引入隐藏会话状态。工具调用仍按现有规则等完整成功后交付。失配块及依赖该前缀的后续 thinking 都可能被丢弃，造成推理上下文损失或增加重新推理成本；这不是质量不变的承诺，也不能修复损坏签名或其他所有非法输入。具体发生了什么以[检查器中的服务端报告](inspect.md#claude-服务端输入处理)为准。
+用户选择保留正常 thinking、正文的流式显示，并用少量自包含状态恢复边界。因此只记录位置确定的首块，不缓存整轮正文，也不引入会话索引、独立控制载荷或向前查找历史位置的规则。工具调用仍按现有规则等完整成功后交付。`continuation_before` 记录已发生的请求事实，不改变来源复用配置，也不替代 `thinking_mismatch`。
+
+工具定义等其他前缀变化仍可能导致失配，未覆盖的续接次序也可能丢失 thinking。默认 `drop_block` 让服务端报告并丢弃失配块；`error` 或 `upstream_default` 下，服务端仍可能拒绝请求。丢失推理上下文可能影响质量或增加重新推理成本，不能把边界恢复视为所有签名和输入均可接受的保证。具体发生了什么以[检查器中的服务端报告](inspect.md#claude-服务端输入处理)为准。
 
 一次失配不会令今后生成的 thinking 永久失效。后续请求保持前缀稳定时，新生成的块仍可正常复用；原始历史里的旧失配块可能在多轮请求中被重复报告，重复报告不代表每轮都丢弃新的 thinking。实际保留与丢弃以各次上游报告为准。
 
@@ -85,4 +92,6 @@ input 为 `input_tokens + cache_read_input_tokens + cache_creation_input_tokens`
 
 HTTP 与流内错误经共享层分类，同时保留上游原始错误体；未完整结束的流返回错误。bridge 不改参数重试，容量与限流退避由 codeks 决定。[错误结构](responses-stream.md)
 
+`stop_reason: "refusal"` 保持不可重试的 `invalid_prompt`。若上游提供 `stop_details.category` 或 `explanation`，错误消息附上这些原文，便于直接在 codeks 看到拒绝原因；未提供时保留通用提示，不猜测分类。完整的终止 `message_delta` 放入 `error.upstream.body`，包含未知字段及上游 usage，便于诊断，不计入普通成功响应的 usage。工具后缀仍整体丢弃，不因保留详情而交付工具或自动重试。
+
 实现与测试：[`src/backends/anthropic.ts`](https://github.com/WAcry/codeks-bridge/blob/main/src/backends/anthropic.ts)、[`test/anthropic.test.ts`](https://github.com/WAcry/codeks-bridge/blob/main/test/anthropic.test.ts)。协议参考：[thinking](https://platform.claude.com/docs/en/build-with-claude/thinking)、[结构化输出](https://platform.claude.com/docs/en/build-with-claude/structured-outputs)、[缓存](https://platform.claude.com/docs/en/build-with-claude/prompt-caching)。

package/docs/config.md

@@ -46,12 +46,15 @@
 | `host` | 默认 `127.0.0.1` |
 | `port` | 默认 `8787`；程序集成测试可用 `0` 分配端口 |
 | `token_env` | 保存 bridge 入口 Bearer token 的环境变量名称 |
+| `request_max_mib` | `POST /v1/responses` 请求体上限，单位 MiB，默认 `512`；必须是正整数且换算后的字节数可安全表示 |
 | `compaction_cache_dir` | 按需复述缓存目录；默认 `$XDG_CACHE_HOME/codeks-bridge/compaction`，未设置 XDG 时为 `~/.cache/codeks-bridge/compaction` |
 | `upstreams` | 上游连接配置表 |
 | `models` | 模型别名表，是否进入客户端目录由各自的 `expose` 控制 |
 | `inspect` | 可选；`capture` 决定启动时是否捕获，`max_mib` 是内存软上限，见[调试检查器](inspect.md) |
 
-监听非 loopback 地址时必须配置 `token_env`，客户端也要设置同一个变量。它是 bridge 入口鉴权，不是上游 API key。HTTP 请求体最多 64 MiB，包含所有图片编码；入口没有 CORS。携带 `Origin` 的请求必须使用配置好的 bridge token，即使监听 loopback 也一样，避免网页的简单 POST 在无法读取响应时仍触发上游调用。没有 `Origin` 的 codeks 请求保持原行为。`GET /health`、`GET /v1/models` 和 `POST /v1/responses` 使用同一鉴权。`/inspect/` 页面与接口使用[自己的规则](inspect.md#访问与鉴权)。
+监听非 loopback 地址时必须配置 `token_env`，客户端也要设置同一个变量。它是 bridge 入口鉴权，不是上游 API key。入口没有 CORS。携带 `Origin` 的请求必须使用配置好的 bridge token，即使监听 loopback 也一样，避免网页的简单 POST 在无法读取响应时仍触发上游调用。没有 `Origin` 的 codeks 请求保持原行为。`GET /health`、`GET /v1/models` 和 `POST /v1/responses` 使用同一鉴权。`/inspect/` 页面与接口使用[自己的规则](inspect.md#访问与鉴权)。
+
+请求体上限按实际收到的字节计算，包含 JSON 和图片编码，不按字符数或声明的 `Content-Length` 判断。恰好达到上限的请求可接受，超限立即返回 HTTP 413 并关闭连接，不调用上游。默认 `512` MiB 为长截图历史留出空间；可按会话需要及可用内存调高或调低。保留上限是为了约束完整缓冲、JSON 解析和转换的内存开销，启用检查器时还会保留捕获副本；它不是进程总内存上限，也不等于模型 token 窗口。
 
 ## 上游连接
 

package/docs/inspect.md

@@ -59,6 +59,16 @@ codeks-bridge serve --config /absolute/path/bridge.json --capture
 
 “概要”给出实际执行模型的路由配置、每个调用的时间线和上游调用表；客户端模型字段仍保留用户请求的工作别名。“标注”列出全部回放决定，点击可定位到对应项。“对比”选择任意两次交换的任意一段做结构比较，常用的是和同一线程上一轮的客户端请求或上游请求比较；数组按类型和角色对齐，新增、删除的项单独标出。
 
+概要中的“流式内容延迟”直接从已有 SSE 捕获派生，不增加请求或修改原始记录：
+
+- 每条 `main`、`native`、`summary`、`handoff` 从该次上游调用开始计时。`bridge → codeks` 从客户端请求开始计时，包含必要的前置 handoff 和 bridge 缓冲时间。
+- “首内容”是首次实际文字、reasoning 或工具内容；“首文字”“首 reasoning”“首工具”分别记录各类首次到达。工具以首次出现名称或非空参数为准，不表示工具已经执行。空 delta、响应头、created、keepalive、签名更新和压缩密文不算内容。
+- 上游 reasoning 可以是文字或不透明载荷；写回 codeks 一侧只计可展示的 reasoning 摘要，不把隐藏载荷当成可见输出。这里测量 bridge 收到或写出的时刻，不是模型内部生成时间或 codeks TUI 实际渲染时间。
+- SSE 事件按完成该事件的数据块计时；若上游只在终止事件里交付完整 output，就记该事件到达时刻。仍未结束的事件不会提前计入。
+- `—` 表示尚未观测到该类内容或无法测量，不等于零延迟。JSON 响应、未完成的 JSON 事件及缺少时间戳的导入记录不估算首 token 时间；原生压缩只有密文而没有上述内容时，这些指标也为空。已观测的延迟不代表整条响应成功，需同时看调用状态。
+
+时间线中的“响应头”保留其独立含义，不作为首内容时间。选择逐调用记录，是为了区分上游等待与客户端实际等待，避免把辅助压缩的时间混成普通模型的首 token 延迟。
+
 “导出全部”和详情里的“导出此条”下载导出文件。“导入”（或把文件拖到页面上）离线查看导出文件，“返回实时”回到 bridge 的记录。浏览器不允许从本地文件加载页面脚本，离线查看也要通过 HTTP 打开页面，例如任意运行中的 bridge 的 `/inspect/`。
 
 ## 记录规则

package/docs/reasoning.md

@@ -39,6 +39,8 @@ JSON 的结构如下，示例指纹为占位值：
 
 一个 carrier 对应一项 reasoning；格式可以保存字符串或结构化数据，不限于可见文字。外层只是编码，不是加密。GPT 密文本身不变；Claude 可见 thinking 和 DeepSeek 文本仍可解码。
 
+Claude 的外层还可包含 `continuation_before: "Continue."`，记录生成该块前实际补入的 user 续接边界。它只用于响应首块为 thinking/redacted 的情况，原生 `data` 和签名不变，前缀仍为 `cxbr1:`。字段随载荷保存、筛选和恢复，不改变复用策略；具体时序与覆盖范围见 [Claude 故障续接](backends-anthropic.md#失配策略与故障续接)。
+
 codeks 会再次发送 `encrypted_content`，因此载荷可以跨请求、会话恢复、服务重启和子代理 fork 保留。只放在 reasoning 的可见 `content` 中不足以完成这种回放。
 
 ## 来源身份

package/docs/testing.md

@@ -29,6 +29,12 @@ npm run check
 
 这些测试检查协议和客户端行为；假上游不会验证模型是否理解提示词，也不会验证真实服务的缓存命中率、容量和区域之间的密文兼容性。
 
+压缩后的信息保留与 handoff 质量另有[手动 benchmark](../benchmarks/compaction/README.md)：使用公开合成材料，对比两种文字 prompt、原生压缩和原生压缩后 handoff。它独立于 CI，提供复跑方法、输入、产物和逐题结果；真实模型请求需要显式执行。
+
+Claude 续接边界的回归同时检查生成和下一轮回放：首块 thinking/redacted 的 `continuation_before` 只记录一次，原生载荷不变；连续失败、多个 thinking、关闭摘要显示时仍保持顺序；来源过滤与切回按同一载荷生效；增量工具声明已有边界时不重复插入。正文或工具先于 thinking、没有 thinking，以及没有该字段的既有载荷，继续使用原有失配策略。`test/claude-continuation.test.ts` 检查转换，`test/claude-recovery-e2e.test.ts` 使用真实 codeks 和假上游检查持久化与重试；签名是否被真实上游接受须另行验证，不能由合成签名测试推断。
+
+2026-10-20（America/Los_Angeles），以 `@wacry/codeks@0.163.0-codeks.5` 启用全部客户端测试，286 项通过、0 跳过，类型检查、构建和私有内容检查通过。续接场景覆盖 overload、EOF、连续两次失败及进程重启后的 resume。另复用真实 T1/T2 签名直接请求官方 Sonnet 5.5：恢复原位 `user: Continue.` 后返回 HTTP 200，`input_transformations` 明确为空数组。这验证边界恢复的协议依据；carrier 的生成、保存与重放由真实客户端加本地假上游验证，两类证据分别成立。
+
 `test/delegated-compaction-e2e.test.ts` 通过 bridge 的真实 HTTP 入口连接本地假上游，覆盖 GPT 原生续聊 → Claude 按需复述 → Claude 委托 GPT 再压缩 → Claude 复述新检查点 → GPT 恢复新检查点。另检查 native 失败不交付部分检查点、handoff 失败不调用工作模型、工作模型失败后跨服务重启复用成功缓存，以及 inspector 的独立 handoff usage 不进入客户端响应。它不启动 codeks，也不调用真实模型；委托压缩的质量与成本不由这些测试推断。
 
 ## 使用真实 codeks 二进制

package/docs/tools.md

@@ -49,6 +49,10 @@ Messages 对不符合端点格式的 call ID 采用确定性映射，并添加
 
 根 schema 的 `$ref`、`$defs`、`allOf`、`anyOf`、`oneOf` 及其他约束均保留；缺少根 `type` 时补为 `object`，已有类型不覆盖，由上游判断是否支持。codeks 可以发送没有根 `type` 的引用或组合 schema，不能因此把参数清空。未提供参数 schema 时使用空对象定义；显式提供非对象 schema 值则报错，不在 bridge 内解析引用或删减约束。
 
+普通函数显式给出的 `strict: true` 或 `strict: false` 原样保留：Messages 放在工具定义顶层，Chat 放在 `function` 内；省略时不添加默认值。Lite 同名更新替换完整定义，因此新定义省略 `strict` 时也不继承旧值；Claude inline 的早先版本保持不变。custom 工具的 JSON 外壳不因此自动启用 strict。
+
+[Claude strict tool use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/strict-tool-use) 与 [DeepSeek strict mode](https://api-docs.deepseek.com/guides/tool_calls/#strict-mode-beta) 各有支持的 schema 范围；DeepSeek 官方文档还要求 beta 端点及所有函数都设为 `strict: true`。bridge 只转换调用方明确提供的字段，不切换端点、不改其他工具或删减 schema 来满足 strict。需要该能力时由用户配置支持的端点，上游不接受则保留错误。
+
 codeks V2 多代理工具的 task/message 是明文，历史中的 `agent_message` 对 Messages/Chat 转成 user 消息，保留 author、recipient 和内容顺序。它不会成为模型 reasoning。不能解密的工具或 agent message 会明确报错。
 
 ## 结果与范围

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wacry/codeks-bridge",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "Configurable local Responses API bridge for codeks with GPT, Claude Messages, and DeepSeek Chat adapters.",
   "license": "Apache-2.0",
   "author": "David Zhang",

package/ui/detail.js

@@ -8,6 +8,7 @@ import { diffView } from './diff.js';
 import { annChip, annDetail, annIndex, callLabel, decisionClass, decisionText, END_LABEL, INPUT_TRANSFORMATION_LABEL, KIND_LABEL, KIND_TEXT, OUTCOME_LABEL, reasonText, sourceText } from './labels.js';
 import { OUTCOME_CLASS, threadKey, byNewest } from './list.js';
 import { exportDoc } from './api.js';
+import { responseLatency } from './latency.js';
 
 const RAW_LIMIT = 200_000;
 const VIEW_STATES = 80;
@@ -402,7 +403,7 @@ export class DetailView {
       else {
         put(out, h('span', { class: `chip ${respClass(r)}` }, `${r.status ?? '–'} ${r.status_text ?? ''}`.trim()),
           h('span', { class: `chip ${r.end === 'active' ? 'info' : 'dim'}`, title: `end: ${r.end}` }, END_LABEL[r.end] ?? r.end ?? '–'),
-          r.headers_ms != null ? h('span', { class: 'dim', title: '自请求开始到响应头的时间' }, `首包 ${fmtDur(r.headers_ms)}`) : null,
+          r.headers_ms != null ? h('span', { class: 'dim', title: '自请求开始到响应头的时间' }, `响应头 ${fmtDur(r.headers_ms)}`) : null,
           r.ended_ms != null ? h('span', { class: 'dim', title: '自请求开始到结束的时间' }, `结束 ${fmtDur(r.ended_ms)}`) : null,
           r.events ? h('span', { class: 'dim' }, `${fmtInt(r.events.length)} 事件`) : h('span', { class: 'dim' }, '非 SSE'),
           r.error ? h('span', { class: 'chip bad', title: r.error }, oneLine(`错误：${r.error}`, 80)) : null);
@@ -476,10 +477,11 @@ export class DetailView {
     const box = h('div', { class: 'overview' });
     put(box, h('h4', null, '路由'), d.route ? fieldsTable(d.route, ROUTE_HINTS) : h('div', { class: 'dim' }, '没有路由信息（请求无法解析或路由失败）'));
     put(box, h('h4', null, '时间线'), this.timeline());
+    put(box, h('h4', null, '流式内容延迟'), this.latency());
     const keys = callKeys(d.upstream);
     if (d.upstream?.length) {
       put(box, h('h4', null, `上游调用（${d.upstream.length}）`), h('table', { class: 'calls' },
-        h('thead', null, h('tr', null, ['标签', '请求', '状态', '结束', '开始', '首包', '结束于', '请求大小', '响应大小', '错误'].map((x) => h('th', null, x)))),
+        h('thead', null, h('tr', null, ['标签', '请求', '状态', '结束', '开始', '响应头于', '结束于', '请求大小', '响应大小', '错误'].map((x) => h('th', null, x)))),
         h('tbody', null, d.upstream.map((c, i) => {
           const r = c.response;
           const tr = h('tr', { class: 'clickable', title: '打开该调用的上游响应', onclick: () => this.open(`upres:${keys[i]}`) },
@@ -525,13 +527,30 @@ export class DetailView {
       const bar = h('span', { class: `tl-bar ${r.cls}` });
       bar.style.left = pct(r.start);
       bar.style.width = pct(Math.max(end - r.start, total / 400));
-      const mark = r.head != null ? h('span', { class: 'tl-head', title: `首包 ${fmtDur(r.head)}` }) : null;
+      const mark = r.head != null ? h('span', { class: 'tl-head', title: `响应头 ${fmtDur(r.head)}` }) : null;
       if (mark) mark.style.left = pct(r.head);
       return h('div', { class: 'tl-row clickable', onclick: () => this.open(r.key) },
         h('span', { class: 'tl-label' }, r.label),
         h('span', { class: 'tl-track' }, bar, mark),
         h('span', { class: 'tl-num mono' }, `${fmtDur(r.start)} → ${r.head != null ? fmtDur(r.head) : '–'} → ${r.end != null ? fmtDur(r.end) : d.active ? '…' : '–'}`));
-    }), h('div', { class: 'dim tl-axis' }, `0 → ${fmtDur(total)}（开始 → 首包 → 结束，相对请求开始）`));
+    }), h('div', { class: 'dim tl-axis' }, `0 → ${fmtDur(total)}（开始 → 响应头 → 结束，相对请求开始）`));
+  }
+
+  latency() {
+    const d = this.detail;
+    const rows = (d.upstream ?? []).map(c => ({
+      label: `${callLabel(c.label)} → bridge`,
+      value: responseLatency(c.response, c.started_ms),
+    }));
+    rows.push({ label: 'bridge → codeks', value: responseLatency(d.client?.response, 0, true) });
+    return h('div', null,
+      h('div', { class: 'note' }, '上游从各自调用开始计时；写回 codeks 从客户端请求开始计时，包含前置 handoff。只计文字、reasoning 或工具内容，响应头和 keepalive 不计。这里是到达或写出时间，不是模型生成或 TUI 渲染时间。'),
+      h('table', { class: 'calls' },
+        h('thead', null, h('tr', null, ['方向', '首内容', '首文字', '首 reasoning', '首工具'].map(x => h('th', null, x)))),
+        h('tbody', null, rows.map(({ label, value }) => h('tr', null,
+          h('td', null, label),
+          ['content_ms', 'text_ms', 'reasoning_ms', 'tool_ms'].map(key => h('td', { class: 'mono' }, value?.[key] != null ? fmtDur(value[key]) : '—')))))),
+      h('div', { class: 'dim' }, '— 表示未观测到或无法测量；JSON 响应和缺少时间戳的导入不估算。上游 reasoning 可包含不透明载荷；写回 codeks 仅计可见摘要。工具以首次名称或参数为准，压缩密文不计入这些指标。'));
   }
 
   // ---------- annotations ----------

package/ui/latency.js

@@ -0,0 +1,88 @@
+// Delivery times derived from captured SSE events, never from headers or usage.
+const present = (value) => typeof value === 'string' && value.length > 0;
+const array = (value) => Array.isArray(value) ? value : [];
+
+function contentKinds(block, visibleOnly) {
+  if (!block || typeof block !== 'object') return [];
+  switch (block.type) {
+    case 'text': case 'output_text': case 'refusal':
+      return present(block.text ?? block.refusal) ? ['text'] : [];
+    case 'thinking':
+      return present(block.thinking) ? ['reasoning'] : [];
+    case 'summary_text': case 'reasoning_text':
+      return present(block.text) ? ['reasoning'] : [];
+    case 'redacted_thinking':
+      return !visibleOnly && present(block.data) ? ['reasoning'] : [];
+    case 'reasoning':
+      return [
+        ...array(block.summary).flatMap(part => contentKinds(part, visibleOnly)),
+        ...array(block.content).flatMap(part => contentKinds(part, visibleOnly)),
+        ...(!visibleOnly && present(block.encrypted_content) ? ['reasoning'] : []),
+      ];
+    case 'message':
+      return Array.isArray(block.content) ? block.content.flatMap(part => contentKinds(part, visibleOnly)) : [];
+    case 'function_call': case 'custom_tool_call': case 'tool_use':
+      return present(block.name) || present(block.arguments) || present(block.input) ? ['tool'] : [];
+    default: return [];
+  }
+}
+
+function eventKinds(data, visibleOnly) {
+  switch (data?.type) {
+    case 'response.output_text.delta': case 'response.output_text.done':
+      return present(data.delta ?? data.text) ? ['text'] : [];
+    case 'response.refusal.delta': case 'response.refusal.done':
+      return present(data.delta ?? data.refusal) ? ['text'] : [];
+    case 'response.reasoning_summary_text.delta': case 'response.reasoning_summary_text.done':
+    case 'response.reasoning_text.delta': case 'response.reasoning_text.done':
+      return present(data.delta ?? data.text) ? ['reasoning'] : [];
+    case 'response.function_call_arguments.delta': case 'response.function_call_arguments.done':
+    case 'response.custom_tool_call_input.delta': case 'response.custom_tool_call_input.done':
+      return present(data.delta ?? data.arguments ?? data.input) ? ['tool'] : [];
+    case 'response.output_item.added': case 'response.output_item.done':
+      return contentKinds(data.item, visibleOnly);
+    case 'response.content_part.added': case 'response.content_part.done':
+    case 'response.reasoning_summary_part.added': case 'response.reasoning_summary_part.done':
+      return contentKinds(data.part, visibleOnly);
+    case 'response.completed': case 'response.incomplete': case 'response.failed':
+      return array(data.response?.output).flatMap(item => contentKinds(item, visibleOnly));
+    case 'message_start':
+      return array(data.message?.content).flatMap(item => contentKinds(item, visibleOnly));
+    case 'content_block_start':
+      return contentKinds(data.content_block, visibleOnly);
+    case 'content_block_delta':
+      switch (data.delta?.type) {
+        case 'text_delta': return present(data.delta.text) ? ['text'] : [];
+        case 'thinking_delta': return present(data.delta.thinking) ? ['reasoning'] : [];
+        case 'input_json_delta': return present(data.delta.partial_json) ? ['tool'] : [];
+        default: return [];
+      }
+    default:
+      return array(data?.choices).flatMap(choice => {
+        const delta = choice?.delta ?? choice?.message;
+        if (!delta) return [];
+        return [
+          ...(present(delta.content) || present(delta.refusal) ? ['text'] : []),
+          ...(present(delta.reasoning_content) ? ['reasoning'] : []),
+          ...(array(delta.tool_calls).some(call => present(call.function?.name) || present(call.function?.arguments)) ? ['tool'] : []),
+        ];
+      });
+  }
+}
+
+/** Null means no timed SSE capture; individual null fields mean not observed. */
+export function responseLatency(response, startedMs, visibleOnly = false) {
+  if (!Array.isArray(response?.events) || !Number.isFinite(startedMs)) return null;
+  const first = { content_ms: null, text_ms: null, reasoning_ms: null, tool_ms: null };
+  for (const event of response.events) {
+    if (!Number.isFinite(event.t) || event.t < startedMs) continue;
+    let data;
+    try { data = JSON.parse(event.data); } catch { continue; }
+    for (const kind of eventKinds(data, visibleOnly)) {
+      const elapsed = Math.round((event.t - startedMs) * 10) / 10;
+      first.content_ms ??= elapsed;
+      first[`${kind}_ms`] ??= elapsed;
+    }
+  }
+  return first;
+}