@code-yeongyu/senpi-ai 2026.10.10 → 2026.10.12

package/dist/api/anthropic-messages.js

@@ -27,8 +27,10 @@ import { normalizeToolCallId } from "../utils/tool-call-id.js";
 import { sendWithForcedToolChoiceFallback } from "../utils/tool-choice-fallback.js";
 import { resolveRootObjectSchema } from "../utils/tool-schema-compat.js";
 import { getCurrentTools, getDeclaredTools, getInitialSystemMessage, hasToolRedefinitions, normalizeContext, resolveTranscript, } from "../utils/transcript.js";
+import { isAnthropicWebSearchReplayBlock, isReplayableAnthropicProviderNativeBlock, } from "./anthropic-native-replay-blocks.js";
 import { sanitizeAnthropicToolPairs } from "./anthropic-tool-pairs.js";
 import { demoteToolReferenceReplay, demoteUnavailableToolReferences } from "./anthropic-tool-references.js";
+import { demoteExpiredWebSearchReplay, expiredWebSearchReplayIds, isExpiredWebSearchContentError, } from "./anthropic-web-search-expiry.js";
 import { resolveCloudflareBaseUrl } from "./cloudflare.js";
 import { getJsonSchemaToolParameters, resolveJsonSchemaStrictSampling, } from "./constrained-sampling.js";
 import { withGitHubCopilotFailureNote } from "./github-copilot-errors.js";
@@ -71,7 +73,7 @@ function getCacheControl(model, cacheRetention, env) {
 // The bundled Claude Code version and the floor of the advertised `claude-cli/<version>`
 // (see utils/claude-code-version.ts). Keep this exact declaration: a downstream installer
 // (oh-my-openagent) rewrites it byte-for-byte in the installed dist and bundle.
-const claudeCodeVersion = "2.1.289";
+const claudeCodeVersion = "2.1.292";
 // Claude Code 2.x tool names (canonical casing)
 // Source: https://cchistory.mariozechner.at/data/prompts-2.1.11.md
 // To update: https://github.com/badlogic/cchistory
@@ -164,6 +166,7 @@ const ADAPTIVE_THINKING_MODEL_MARKERS = [
     "opus-5",
     "sonnet-4-6",
     "sonnet-5",
+    "haiku-5-5",
     "fable-5",
     "mythos-5",
 ];
@@ -176,14 +179,20 @@ const NATIVE_XHIGH_EFFORT_MODEL_MARKERS = [
     "opus-4-8",
     "opus-5",
     "sonnet-5",
+    "haiku-5-5",
     "fable-5",
     "mythos-5",
 ];
 /**
- * Adaptive families that reject `thinking: {type: "disabled"}` outright (verified 400:
- * `"thinking.type.disabled" is not supported for this model`). The generated catalog also encodes
- * this as `compat.supportsDisabledThinking: false`, but `models.json` entries and third-party
- * gateway rows carry no generated compat, so the family fact has to live here as well.
+ * Families senpi never sends `thinking: {type: "disabled"}` to. Fable 5, Opus 5.5 and Sonnet 5.5 reject it
+ * outright (verified live 400: `"thinking.type.disabled" is not supported for this model`); Mythos 5 is
+ * listed by family with Fable. Claude Haiku 5.5 is listed by choice, not because it rejects `disabled`: its
+ * effort docs accept `disabled` at effort `high` or below (400 only at `xhigh` / `max`) and reject a
+ * differing per-message effort while disabled, so a real thinking-off needs marker handling first
+ * (senpi#2927). Until then a thinking-off turn sends no `thinking` and effort `low`, which is valid on all of
+ * them. The generated catalog also encodes this as `compat.supportsDisabledThinking: false`, but
+ * `models.json` entries and third-party gateway rows carry no generated compat, so the family fact has to
+ * live here as well.
  */
 const DISABLED_THINKING_REJECTING_MODEL_MARKERS = [
     "fable-5",
@@ -192,6 +201,8 @@ const DISABLED_THINKING_REJECTING_MODEL_MARKERS = [
     "opus-5.5",
     "sonnet-5-5",
     "sonnet-5.5",
+    "haiku-5-5",
+    "haiku-5.5",
 ];
 const UNSUPPORTED_NATIVE_COMPUTER_TOOL_MODEL_MARKERS = [
     "opus-4-6",
@@ -234,6 +245,8 @@ function supportsMidConvoToolChanges(model) {
 const unsignedThinkingTextReplayFallbacks = new Set();
 // Endpoints that rejected a replayed tool_reference for one conversation (senpi #2568).
 const toolReferenceReplayFallbacks = new Set();
+// `${fallbackKey}\u0000${tool_use_id}` of web search results whose encrypted payload expired (senpi #3201).
+const expiredWebSearchReplays = new Set();
 registerSessionResourceCleanup((sessionId) => {
     // One small entry per (session, base URL, model) that ever hit the fallback;
     // drop the session's entries at teardown so long-lived hosts do not collect
@@ -241,10 +254,15 @@ registerSessionResourceCleanup((sessionId) => {
     if (sessionId === undefined) {
         unsignedThinkingTextReplayFallbacks.clear();
         toolReferenceReplayFallbacks.clear();
+        expiredWebSearchReplays.clear();
         return;
     }
     const prefix = `${sessionId}\u0000`;
-    for (const fallbacks of [unsignedThinkingTextReplayFallbacks, toolReferenceReplayFallbacks]) {
+    for (const fallbacks of [
+        unsignedThinkingTextReplayFallbacks,
+        toolReferenceReplayFallbacks,
+        expiredWebSearchReplays,
+    ]) {
         for (const key of fallbacks) {
             if (key.startsWith(prefix))
                 fallbacks.delete(key);
@@ -346,26 +364,6 @@ let federationClient;
 function isRecord(value) {
     return typeof value === "object" && value !== null;
 }
-const REPLAYABLE_ANTHROPIC_PROVIDER_NATIVE_TYPES = new Set([
-    "server_tool_use",
-    "web_search_tool_result",
-    "web_fetch_tool_result",
-    "code_execution_tool_result",
-    "bash_code_execution_tool_result",
-    "text_editor_code_execution_tool_result",
-    "tool_search_tool_result",
-    "container_upload",
-    // The server-side fallback marker (`fallback`, server-side-fallback-2026-06-01
-    // beta) is deliberately absent: the Messages API rejects it as an *input* tag
-    // ("Input tag 'fallback' found using 'type' does not match any of the expected
-    // tags"), so replaying it 400s every subsequent same-model request. The stored
-    // marker is audit metadata and still drives declined-attempt pruning in
-    // convertMessages (see lastAnthropicFallbackBoundary and
-    // collectDiscardedFallbackToolCallIds); blocks after it replay verbatim.
-]);
-function isReplayableAnthropicProviderNativeBlock(raw) {
-    return isRecord(raw) && typeof raw.type === "string" && REPLAYABLE_ANTHROPIC_PROVIDER_NATIVE_TYPES.has(raw.type);
-}
 function isSameAnthropicModel(message, model) {
     return message.provider === model.provider && message.api === model.api && message.model === model.id;
 }
@@ -399,17 +397,6 @@ function isAnthropicServerToolUseBlock(raw) {
 function isProviderNativeToolUseBlock(raw) {
     return isRecord(raw) && (raw.type === "server_tool_use" || raw.type === "mcp_tool_use");
 }
-// Endpoints without `supportsWebSearch` reject replayed web-search server-tool
-// blocks (kimi-coding 400s with `tool_call_id is not found`), wedging every
-// subsequent request of the session. Dropping the pair loses the searched
-// context but keeps the conversation usable.
-function isAnthropicWebSearchReplayBlock(raw) {
-    if (!isRecord(raw))
-        return false;
-    if (raw.type === "web_search_tool_result")
-        return true;
-    return raw.type === "server_tool_use" && raw.name === "web_search";
-}
 // The user turn a pending server tool can survive is one that carries only
 // tool results. Anything else the wire would emit — real text, an image —
 // closes the assistant turn (the API then 400s the still-open use). A blank
@@ -439,7 +426,7 @@ function collectProviderNativeToolPairing(messages, model, deferredToolNames, no
                 if (block.type !== "providerNative" || !isRecord(block.raw))
                     continue;
                 const raw = block.raw;
-                if (typeof raw.type !== "string" || !REPLAYABLE_ANTHROPIC_PROVIDER_NATIVE_TYPES.has(raw.type))
+                if (!isReplayableAnthropicProviderNativeBlock(raw))
                     continue;
                 if (isProviderNativeToolUseBlock(raw) && typeof raw.id === "string")
                     pendingUseIds.add(raw.id);
@@ -448,7 +435,7 @@ function collectProviderNativeToolPairing(messages, model, deferredToolNames, no
                 if (block.type !== "providerNative" || !isRecord(block.raw))
                     continue;
                 const raw = block.raw;
-                if (typeof raw.type !== "string" || !REPLAYABLE_ANTHROPIC_PROVIDER_NATIVE_TYPES.has(raw.type))
+                if (!isReplayableAnthropicProviderNativeBlock(raw))
                     continue;
                 const toolUseId = raw.tool_use_id;
                 if (typeof toolUseId !== "string")
@@ -922,7 +909,7 @@ export const stream = (model, context, options) => {
     const normalizedContext = resolveTranscript(context, supportsMidConvoSystemMessages(model));
     const currentTools = getCurrentTools(normalizedContext.messages);
     (async () => {
-        const providerThinkingLevel = model.compat?.supportsMidConvoEffort ? (options?.effort ?? "high") : undefined;
+        const providerThinkingLevel = managedEffortForRequest(model, options);
         const output = {
             role: "assistant",
             content: [],
@@ -972,7 +959,7 @@ export const stream = (model, context, options) => {
                 const cacheRetention = resolveCacheRetention(options?.cacheRetention ?? model.cacheRetention, options?.env, "short");
                 const cacheSessionId = cacheRetention === "none" ? undefined : options?.sessionId;
                 openClient = () => {
-                    const created = createClient(model, apiKey, options?.interleavedThinking ?? true, shouldUseFineGrainedToolStreamingBeta(model, normalizedContext), options?.refusalFallbacks !== undefined, optionsHeaders, options?.fetch, copilotDynamicHeaders, cacheSessionId, options?.env, federation);
+                    const created = createClient(model, apiKey, options?.interleavedThinking ?? true, shouldUseFineGrainedToolStreamingBeta(model, normalizedContext), options?.refusalFallbacks !== undefined && configuredBetaHeader(model, options) !== null, optionsHeaders, options?.fetch, copilotDynamicHeaders, cacheSessionId, options?.env, federation);
                     client = created.client;
                     isOAuth = created.isOAuthToken;
                     advertisedClaudeCodeVersion = created.claudeCodeVersion;
@@ -1007,6 +994,15 @@ export const stream = (model, context, options) => {
                 : getAnthropicCompat(model).unsignedThinkingReplay;
             let demoteReferenceReplay = fallbackKey !== undefined && toolReferenceReplayFallbacks.has(fallbackKey);
             let requestReplaysReferences = false;
+            const expiredSearchPrefix = fallbackKey === undefined ? undefined : `${fallbackKey}\u0000`;
+            const expiredSearchIds = new Set();
+            if (expiredSearchPrefix !== undefined) {
+                for (const key of expiredWebSearchReplays) {
+                    if (key.startsWith(expiredSearchPrefix))
+                        expiredSearchIds.add(key.slice(expiredSearchPrefix.length));
+                }
+            }
+            let lastSentParams;
             const createRequest = async () => {
                 let params = buildParams(model, normalizedContext, isOAuth, options, unsignedThinkingReplay);
                 const nextParams = await options?.onPayload?.(params, model);
@@ -1020,6 +1016,8 @@ export const stream = (model, context, options) => {
                 requestReplaysReferences = withoutReferenceReplay !== params;
                 if (demoteReferenceReplay)
                     params = withoutReferenceReplay;
+                params = demoteExpiredWebSearchReplay(params, expiredSearchIds);
+                lastSentParams = params;
                 params = sanitizeAnthropicToolPairs(params);
                 const payloadRequestMetadata = extractPayloadRequestMetadata(params);
                 params = payloadRequestMetadata.params;
@@ -1044,6 +1042,28 @@ export const stream = (model, context, options) => {
                 });
                 return { params: sent.params, response: sent.result };
             };
+            // True when the error names web search payloads this request had not demoted yet.
+            const markNewlyExpiredSearches = (error) => {
+                if (!isExpiredWebSearchContentError(error) || lastSentParams === undefined)
+                    return false;
+                const newlyExpired = expiredWebSearchReplayIds(lastSentParams, error).filter((id) => !expiredSearchIds.has(id));
+                for (const id of newlyExpired) {
+                    expiredSearchIds.add(id);
+                    if (expiredSearchPrefix !== undefined)
+                        expiredWebSearchReplays.add(expiredSearchPrefix + id);
+                }
+                return newlyExpired.length > 0;
+            };
+            const createRequestDemotingExpiredSearches = async () => {
+                try {
+                    return await createRequest();
+                }
+                catch (error) {
+                    if (markNewlyExpiredSearches(error))
+                        return createRequestDemotingExpiredSearches();
+                    throw error;
+                }
+            };
             let requestOutcome;
             try {
                 requestOutcome = await retryProviderRequest(async () => {
@@ -1063,6 +1083,8 @@ export const stream = (model, context, options) => {
                                 toolReferenceReplayFallbacks.add(fallbackKey);
                             return createRequest();
                         }
+                        if (markNewlyExpiredSearches(error))
+                            return createRequestDemotingExpiredSearches();
                         if (await retryWithNewerClaudeCode(error)) {
                             try {
                                 return await createRequest();
@@ -1459,6 +1481,25 @@ function cannotDisableThinking(model, compat) {
         return true;
     return matchesModelMarker(model, DISABLED_THINKING_REJECTING_MODEL_MARKERS);
 }
+/**
+ * Effort a per-message-effort request runs at, which is also the active marker and the level recorded
+ * on the reply: the caller's effort with thinking on, `low` for a thinking-off turn on a family that
+ * cannot disable thinking, and none when thinking is actually disabled (senpi#2912).
+ */
+function managedEffortForRequest(model, options) {
+    if (model.compat?.supportsMidConvoEffort !== true)
+        return undefined;
+    if (options?.thinkingEnabled === false) {
+        return cannotDisableThinking(model, getAnthropicCompat(model)) ? "low" : undefined;
+    }
+    return options?.effort ?? "high";
+}
+function isEffortMarker(message) {
+    return (message.role === "system" &&
+        Array.isArray(message.content) &&
+        message.content.length === 0 &&
+        message.output_config?.effort !== undefined);
+}
 function disableThinkingForRequest(params, model, compat) {
     // A degraded/disabled turn must not retain the caller's higher effort.
     delete params.output_config;
@@ -1470,6 +1511,8 @@ function disableThinkingForRequest(params, model, compat) {
         return;
     }
     params.thinking = { type: "disabled" };
+    // Per-message effort is rejected alongside disabled thinking (senpi#1399).
+    params.messages = params.messages.filter((message) => !isEffortMarker(message));
 }
 function supportsAdaptiveThinking(model) {
     if (model.compat?.forceAdaptiveThinking !== undefined) {
@@ -1665,27 +1708,46 @@ export function buildAnthropicWarmPromptCacheParams(model, context, options) {
         max_tokens: 0,
     });
 }
-function getBetaFeatures(model, context, isOAuthToken, nativeToolChanges, options) {
-    let configuredFeatures;
+function configuredBetaHeader(model, options) {
+    let configured;
     for (const headers of [model.headers, options?.headers]) {
         for (const [name, value] of Object.entries(headers ?? {})) {
             if (name.toLowerCase() === "anthropic-beta")
-                configuredFeatures = value;
+                configured = value;
         }
     }
-    if (configuredFeatures === null)
+    return configured;
+}
+function getBetaFeatures(model, context, isOAuthToken, shape, options) {
+    const configured = configuredBetaHeader(model, options);
+    if (configured === null)
         return [];
-    if (configuredFeatures !== undefined) {
-        return [
-            ...new Set(configuredFeatures
-                .split(",")
-                .map((feature) => feature.trim())
-                .filter(Boolean)),
-        ];
-    }
-    const features = [];
+    // Betas the request body depends on: the API rejects the request without them.
+    const required = [];
     if (isOAuthToken)
-        features.push("claude-code-20250219", "oauth-2025-04-20");
+        required.push("claude-code-20250219", "oauth-2025-04-20");
+    if (shape.midConvoEffort)
+        required.push(MID_CONVERSATION_OUTPUT_CONFIG_BETA);
+    if (shape.thinkingBinding)
+        required.push(THINKING_BINDING_CONTROLS_BETA);
+    if (shape.nativeToolChanges)
+        required.push(MID_CONVERSATION_TOOL_CHANGES_BETA);
+    if (shape.refusalFallbacks)
+        required.push(SERVER_SIDE_FALLBACK_BETA);
+    // A configured header owns the optional betas and is merged with the required ones, never replacing them: a
+    // proxy route's own header used to drop the effort beta, and Claude 5.5 models then 400ed (senpi#2957).
+    // Interleaved thinking is stripped on adaptive models here too, as it is from the client headers.
+    const optional = configured === undefined
+        ? defaultOptionalBetas(model, context, options)
+        : configured
+            .split(",")
+            .map((feature) => feature.trim())
+            .filter(Boolean)
+            .filter((feature) => !(feature === INTERLEAVED_THINKING_BETA && supportsAdaptiveThinking(model)));
+    return [...new Set([...optional, ...required])];
+}
+function defaultOptionalBetas(model, context, options) {
+    const features = [];
     if (shouldUseFineGrainedToolStreamingBeta(model, context))
         features.push(FINE_GRAINED_TOOL_STREAMING_BETA);
     if (model.reasoning &&
@@ -1696,12 +1758,7 @@ function getBetaFeatures(model, context, isOAuthToken, nativeToolChanges, option
     }
     if (shouldUseServerSideFallbackBeta(model))
         features.push(SERVER_SIDE_FALLBACK_BETA);
-    if (model.compat?.supportsMidConvoEffort === true) {
-        features.push(MID_CONVERSATION_OUTPUT_CONFIG_BETA, THINKING_BINDING_CONTROLS_BETA);
-    }
-    if (nativeToolChanges)
-        features.push(MID_CONVERSATION_TOOL_CHANGES_BETA);
-    return [...new Set(features)];
+    return features;
 }
 function buildParams(model, context, isOAuthToken, options, unsignedThinkingReplay = getAnthropicCompat(model).unsignedThinkingReplay) {
     const compat = getAnthropicCompat(model);
@@ -1718,7 +1775,16 @@ function buildParams(model, context, isOAuthToken, options, unsignedThinkingRepl
     // and Anthropic rejects a tool list where every tool is deferred, so there must be an
     // initial active tool to anchor the deferred ones. Otherwise the current tool list is sent.
     const initialTools = initialSystemMessage?.toolsAdded ?? [];
-    const nativeToolChanges = supportsMidConvoSystemMessages(model) &&
+    // A configured `anthropic-beta: null` asks for no betas at all, so the request takes a shape that needs none:
+    // the current tool list instead of native tool changes, top-level effort instead of per-message markers, and
+    // no server-side fallbacks (senpi#2957). OAuth still needs its identity betas; getBetaFeatures names them.
+    const betasSuppressed = configuredBetaHeader(model, options) === null;
+    if (betasSuppressed && isOAuthToken) {
+        throw new Error(`The anthropic-beta header is set to null, but ${model.provider}/${model.id} is called with an OAuth token, which needs the claude-code-20250219 and oauth-2025-04-20 betas. Remove the null, or list the betas you want instead; senpi adds the ones a request needs.`);
+    }
+    const midConvoEffort = model.compat?.supportsMidConvoEffort === true && !betasSuppressed;
+    const nativeToolChanges = !betasSuppressed &&
+        supportsMidConvoSystemMessages(model) &&
         supportsMidConvoToolChanges(model) &&
         initialTools.length > 0 &&
         !hasToolRedefinitions(context.messages);
@@ -1741,15 +1807,21 @@ function buildParams(model, context, isOAuthToken, options, unsignedThinkingRepl
         deferredTools = [];
     }
     const deferredToolNames = new Set(deferredTools.map((tool) => normalizeToolName(tool.name)));
-    const activeEffort = options?.effort ?? "high";
-    const betaFeatures = getBetaFeatures(model, context, isOAuthToken, nativeToolChanges, options);
-    const convertedMessages = convertMessages(conversationMessages, model, isOAuthToken, cacheControl, unsignedThinkingReplay, deferredToolNames, normalizeToolName, model.compat?.supportsMidConvoEffort === true ? model.provider : undefined, nativeToolChanges);
-    const messages = model.compat?.supportsMidConvoEffort === true
+    const activeEffort = managedEffortForRequest(model, options) ?? "high";
+    const sendFallbacks = options?.refusalFallbacks !== undefined && !betasSuppressed;
+    const betaFeatures = getBetaFeatures(model, context, isOAuthToken, {
+        midConvoEffort,
+        thinkingBinding: midConvoEffort && options?.thinkingEnabled !== false,
+        nativeToolChanges,
+        refusalFallbacks: sendFallbacks,
+    }, options);
+    const convertedMessages = convertMessages(conversationMessages, model, isOAuthToken, cacheControl, unsignedThinkingReplay, deferredToolNames, normalizeToolName, midConvoEffort ? model.provider : undefined, nativeToolChanges);
+    const messages = midConvoEffort
         ? insertThinkingLevelMessages(convertedMessages, activeEffort)
         : convertedMessages.messages;
     // Effort markers are appended after history; re-run the fork's final-user cache checkpoint
     // against the actual last user/tool-result message so the marker cannot displace cache_control.
-    if (model.compat?.supportsMidConvoEffort === true && cacheControl) {
+    if (midConvoEffort && cacheControl) {
         for (let index = messages.length - 1; index >= 0; index--) {
             const message = messages[index];
             // A native system update after the last turn already holds the checkpoint;
@@ -1826,9 +1898,10 @@ function buildParams(model, context, isOAuthToken, options, unsignedThinkingRepl
         ];
     }
     // Managed effort models always use adaptive thinking so prefix mismatches can
-    // be dropped instead of surfacing as persistent 400 responses. Thinking-off is
-    // handled before this managed branch because these models accept `disabled`.
-    if (model.compat?.supportsMidConvoEffort === true && options?.thinkingEnabled !== false) {
+    // be dropped instead of surfacing as persistent 400 responses. A thinking-off turn
+    // skips this branch: `disableThinkingForRequest` sends `disabled` where the family
+    // accepts it and pins effort `low` where it does not (Opus/Sonnet/Haiku 5.5, Fable, Mythos).
+    if (midConvoEffort && options?.thinkingEnabled !== false) {
         params.thinking = {
             type: "adaptive",
             display: options?.thinkingDisplay ?? "summarized",
@@ -1897,7 +1970,7 @@ function buildParams(model, context, isOAuthToken, options, unsignedThinkingRepl
         }
     }
     applyExtraBodyToAnthropicParams(params, options?.extraBody);
-    if (options?.refusalFallbacks !== undefined) {
+    if (sendFallbacks && options?.refusalFallbacks !== undefined) {
         // AnthropicRefusalFallback models a readonly list; the SDK's BetaFallbacksParam
         // is mutable, so copy rather than widen the fork's public type.
         params.fallbacks = options.refusalFallbacks === "default" ? "default" : [...options.refusalFallbacks];
@@ -2070,7 +2143,6 @@ function convertMessages(transformedMessages, model, isOAuthToken, cacheControl,
             }
         }
         else if (msg.role === "assistant") {
-            flushPendingSystemMessages();
             const blocks = [];
             const isSameModel = isSameAnthropicModel(msg, model);
             // Blocks before the final fallback marker are the declined attempt; the
@@ -2156,8 +2228,12 @@ function convertMessages(transformedMessages, model, isOAuthToken, cacheControl,
                     }
                 }
             }
+            // Pending system messages are emitted only in front of an assistant param that is actually sent: a reply
+            // that converts to no blocks is skipped, and flushing for it would leave a `system` param directly before
+            // the next `user` turn, which Anthropic rejects on every later request (senpi#2864).
             if (blocks.length === 0)
                 continue;
+            flushPendingSystemMessages();
             const messageIndex = params.length;
             params.push({
                 role: "assistant",

package/dist/api/anthropic-native-replay-blocks.d.ts

@@ -0,0 +1,4 @@
+import type { BetaContentBlockParam } from "@anthropic-ai/sdk/resources/beta/messages/messages.js";
+export declare function isReplayableAnthropicProviderNativeBlock(raw: unknown): raw is BetaContentBlockParam;
+export declare function isAnthropicWebSearchReplayBlock(raw: unknown): boolean;
+//# sourceMappingURL=anthropic-native-replay-blocks.d.ts.map

package/dist/api/anthropic-native-replay-blocks.js

@@ -0,0 +1,28 @@
+const replayableTypes = new Set([
+    "server_tool_use",
+    "web_search_tool_result",
+    // GLM's Anthropic-compatible coding endpoint returns this server-result shape.
+    // Pairing still requires a preceding same-model server_tool_use.
+    "tool_result",
+    "web_fetch_tool_result",
+    "code_execution_tool_result",
+    "bash_code_execution_tool_result",
+    "text_editor_code_execution_tool_result",
+    "tool_search_tool_result",
+    "container_upload",
+    // Stored fallback markers are audit metadata, not valid Messages input tags.
+]);
+function isRecord(value) {
+    return value !== null && typeof value === "object";
+}
+export function isReplayableAnthropicProviderNativeBlock(raw) {
+    return isRecord(raw) && typeof raw.type === "string" && replayableTypes.has(raw.type);
+}
+export function isAnthropicWebSearchReplayBlock(raw) {
+    if (!isRecord(raw))
+        return false;
+    if (raw.type === "web_search_tool_result" || raw.type === "tool_result")
+        return true;
+    return raw.type === "server_tool_use" && raw.name === "web_search";
+}
+//# sourceMappingURL=anthropic-native-replay-blocks.js.map

package/dist/api/anthropic-tool-references.js

@@ -73,6 +73,27 @@ export function demoteUnavailableToolReferences(params) {
     }
     let changed = false;
     const availableToolNames = [...available];
+    // A native search pair whose every reference stopped resolving is demoted as a
+    // unit: the result decides, and its `server_tool_use` follows. The pair can span
+    // two assistant messages (a deferred server tool resumes in the continuation), so
+    // the decision is collected over the whole request before any message is rewritten.
+    const droppedSearchUseIds = new Set();
+    const droppedSearchNames = new Map();
+    for (const message of messages) {
+        if (message.role !== "assistant" || !Array.isArray(message.content))
+            continue;
+        for (const block of message.content) {
+            if (!isNativeToolSearchResultBlock(block))
+                continue;
+            const names = block.content.tool_references
+                .filter((item) => isRecord(item) && item.type === "tool_reference")
+                .map((item) => (typeof item.tool_name === "string" ? item.tool_name : ""));
+            if (names.length > 0 && names.every((name) => resolve(name) === undefined)) {
+                droppedSearchUseIds.add(block.tool_use_id);
+                droppedSearchNames.set(block.tool_use_id, names);
+            }
+        }
+    }
     const seenDemotedCallNames = new Set();
     const rewrittenMessages = [];
     for (const message of messages) {
@@ -81,23 +102,6 @@ export function demoteUnavailableToolReferences(params) {
             continue;
         }
         let messageChanged = false;
-        // A native search pair whose every reference stopped resolving is demoted
-        // as a unit: the result decides, and its `server_tool_use` follows.
-        const droppedSearchUseIds = new Set();
-        const droppedSearchNames = new Map();
-        if (message.role === "assistant") {
-            for (const block of message.content) {
-                if (!isNativeToolSearchResultBlock(block))
-                    continue;
-                const names = block.content.tool_references
-                    .filter((item) => isRecord(item) && item.type === "tool_reference")
-                    .map((item) => (typeof item.tool_name === "string" ? item.tool_name : ""));
-                if (names.length > 0 && names.every((name) => resolve(name) === undefined)) {
-                    droppedSearchUseIds.add(block.tool_use_id);
-                    droppedSearchNames.set(block.tool_use_id, names);
-                }
-            }
-        }
         const content = [];
         for (const block of message.content) {
             if (message.role === "assistant" && isRecord(block) && block.type === "tool_use") {
@@ -168,7 +172,9 @@ export function demoteUnavailableToolReferences(params) {
             }
             content.push(block);
         }
-        if (content.length === 0) {
+        // Only a message this pass emptied is dropped; a message that arrived empty (a per-message
+        // effort marker carries `content: []` by design) passes through untouched (senpi#2912).
+        if (messageChanged && content.length === 0) {
             changed = true;
             continue;
         }

package/dist/api/anthropic-web-search-expiry.d.ts

@@ -0,0 +1,10 @@
+import type { MessageCreateParamsStreaming } from "@anthropic-ai/sdk/resources/beta/messages/messages.js";
+export declare function isExpiredWebSearchContentError(error: unknown): error is Error;
+/**
+ * The `tool_use_id`s of the web search results the rejected request replayed
+ * at or before the message the API named. Without a parsable index every
+ * replayed result counts as expired.
+ */
+export declare function expiredWebSearchReplayIds(params: MessageCreateParamsStreaming, error: Error): string[];
+export declare function demoteExpiredWebSearchReplay(params: MessageCreateParamsStreaming, expired: ReadonlySet<string>): MessageCreateParamsStreaming;
+//# sourceMappingURL=anthropic-web-search-expiry.d.ts.map

package/dist/api/anthropic-web-search-expiry.js

@@ -0,0 +1,104 @@
+/**
+ * The opaque `encrypted_content` of a native web search result is only valid
+ * for the account that ran the search (senpi #3201). Same-model replay keeps
+ * the payload byte-for-byte (#208), so once a request is served by another
+ * account (credential rotation, a multi-account gateway) every later request
+ * on that model fails with "messages.N.content.0: Invalid `encrypted_content` in
+ * `search_result` block" and the session only moves on through a model
+ * fallback. Stripping the field is not an option: the API requires it (#150).
+ *
+ * Recovery demotes expired search pairs to plain text: the `server_tool_use`
+ * becomes a note naming its query and the `web_search_tool_result` a list of
+ * the result titles and URLs. Only pairs whose result sits at or before the
+ * rejected message are demoted, because a search is never fresher than a
+ * later one; newer results keep replaying verbatim.
+ */
+const EXPIRED_SEARCH_CONTENT = /Invalid `encrypted_content` in `search_result` block/i;
+const REJECTED_MESSAGE_INDEX = /messages\.(\d+)\.content\.\d+: Invalid `encrypted_content`/i;
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+export function isExpiredWebSearchContentError(error) {
+    return (error instanceof Error &&
+        "status" in error &&
+        error.status === 400 &&
+        EXPIRED_SEARCH_CONTENT.test(error.message));
+}
+function webSearchResultIds(message) {
+    if (message.role !== "assistant" || !Array.isArray(message.content))
+        return [];
+    const ids = [];
+    for (const block of message.content) {
+        if (isRecord(block) && block.type === "web_search_tool_result" && typeof block.tool_use_id === "string") {
+            ids.push(block.tool_use_id);
+        }
+    }
+    return ids;
+}
+/**
+ * The `tool_use_id`s of the web search results the rejected request replayed
+ * at or before the message the API named. Without a parsable index every
+ * replayed result counts as expired.
+ */
+export function expiredWebSearchReplayIds(params, error) {
+    const match = REJECTED_MESSAGE_INDEX.exec(error.message);
+    const lastIndex = match?.[1] === undefined ? params.messages.length - 1 : Number(match[1]);
+    return params.messages.slice(0, lastIndex + 1).flatMap(webSearchResultIds);
+}
+function searchQuery(block) {
+    const input = block.input;
+    return isRecord(input) && typeof input.query === "string" ? input.query : undefined;
+}
+function demotedResultText(block) {
+    const results = Array.isArray(block.content) ? block.content : [];
+    const lines = [];
+    for (const result of results) {
+        if (!isRecord(result) || result.type !== "web_search_result")
+            continue;
+        const title = typeof result.title === "string" ? result.title : "";
+        const url = typeof result.url === "string" ? result.url : "";
+        lines.push(`- ${title} (${url})`);
+    }
+    if (lines.length === 0)
+        return "Web search returned no results.";
+    return ["Web search results (page contents no longer available):", ...lines].join("\n");
+}
+function demoteBlock(block, expired) {
+    if (!isRecord(block))
+        return undefined;
+    if (block.type === "server_tool_use" && block.name === "web_search" && typeof block.id === "string") {
+        if (!expired.has(block.id))
+            return undefined;
+        const query = searchQuery(block);
+        return { type: "text", text: query === undefined ? "Searched the web." : `Searched the web for: ${query}` };
+    }
+    if (block.type === "web_search_tool_result" && typeof block.tool_use_id === "string") {
+        if (!expired.has(block.tool_use_id))
+            return undefined;
+        return { type: "text", text: demotedResultText(block) };
+    }
+    return undefined;
+}
+export function demoteExpiredWebSearchReplay(params, expired) {
+    if (expired.size === 0)
+        return params;
+    let changed = false;
+    const messages = params.messages.map((message) => {
+        if (message.role !== "assistant" || !Array.isArray(message.content))
+            return message;
+        let messageChanged = false;
+        const content = message.content.map((block) => {
+            const demoted = demoteBlock(block, expired);
+            if (demoted === undefined)
+                return block;
+            messageChanged = true;
+            return demoted;
+        });
+        if (!messageChanged)
+            return message;
+        changed = true;
+        return { ...message, content };
+    });
+    return changed ? { ...params, messages } : params;
+}
+//# sourceMappingURL=anthropic-web-search-expiry.js.map