@code-yeongyu/senpi-ai 2026.7.26 → 2026.7.28

package/dist/api/anthropic-messages.d.ts

@@ -1,5 +1,6 @@
 import Anthropic from "@anthropic-ai/sdk";
 import type { SimpleStreamOptions, StreamFunction, StreamOptions } from "../types.ts";
+export { getAnthropicCompat } from "../utils/prompt-cache-ttl.ts";
 export type AnthropicEffort = "low" | "medium" | "high" | "xhigh" | "max";
 export type AnthropicThinkingDisplay = "summarized" | "omitted";
 export interface AnthropicOptions extends StreamOptions {

package/dist/api/anthropic-messages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"anthropic-messages.d.ts","sourceRoot":"","sources":["../../src/api/anthropic-messages.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,mBAAmB,CAAC;AAU1C,OAAO,KAAK,EAYX,mBAAmB,EAEnB,cAAc,EACd,aAAa,EAOb,MAAM,aAAa,CAAC;AAiMrB,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,CAAC;AAE1E,MAAM,MAAM,wBAAwB,GAAG,YAAY,GAAG,SAAS,CAAC;AAoHhE,MAAM,WAAW,gBAAiB,SAAQ,aAAa;IACtD;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB;;;;;;;;;;;OAWG;IACH,eAAe,CAAC,EAAE,wBAAwB,CAAC;IAC3C;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACtE;;;;OAIG;IACH,MAAM,CAAC,EAAE,SAAS,CAAC;CACnB;AA+pBD,eAAO,MAAM,MAAM,EAAE,cAAc,CAAC,oBAAoB,EAAE,gBAAgB,CAoYzE,CAAC;AA0FF,eAAO,MAAM,YAAY,EAAE,cAAc,CAAC,oBAAoB,EAAE,mBAAmB,CA2ClF,CAAC"}
+{"version":3,"file":"anthropic-messages.d.ts","sourceRoot":"","sources":["../../src/api/anthropic-messages.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,mBAAmB,CAAC;AAU1C,OAAO,KAAK,EAWX,mBAAmB,EAEnB,cAAc,EACd,aAAa,EAOb,MAAM,aAAa,CAAC;AA+BrB,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AA6JlE,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,CAAC;AAE1E,MAAM,MAAM,wBAAwB,GAAG,YAAY,GAAG,SAAS,CAAC;AAoEhE,MAAM,WAAW,gBAAiB,SAAQ,aAAa;IACtD;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB;;;;;;;;;;;OAWG;IACH,eAAe,CAAC,EAAE,wBAAwB,CAAC;IAC3C;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACtE;;;;OAIG;IACH,MAAM,CAAC,EAAE,SAAS,CAAC;CACnB;AA8zBD,eAAO,MAAM,MAAM,EAAE,cAAc,CAAC,oBAAoB,EAAE,gBAAgB,CAqYzE,CAAC;AA0FF,eAAO,MAAM,YAAY,EAAE,cAAc,CAAC,oBAAoB,EAAE,mBAAmB,CA2ClF,CAAC"}

package/dist/api/anthropic-messages.js

@@ -6,6 +6,7 @@ import { splitDeferredTools } from "../utils/deferred-tools.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord, providerHeadersToRecord } from "../utils/headers.js";
 import { parseJsonWithRepair, parseStreamingJson } from "../utils/json-parse.js";
+import { getAnthropicCompat, isAnthropicApiBaseUrl } from "../utils/prompt-cache-ttl.js";
 import { getProviderEnvValue } from "../utils/provider-env.js";
 import { retryProviderRequest } from "../utils/provider-retry.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
@@ -17,6 +18,7 @@ import { resolveJsonSchemaStrictSampling } from "./constrained-sampling.js";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
 import { ANTHROPIC_RESERVED_BODY_KEYS, adjustMaxTokensForThinking, buildBaseOptions, clampMaxTokensToContext, } from "./simple-options.js";
 import { transformMessages } from "./transform-messages.js";
+export { getAnthropicCompat } from "../utils/prompt-cache-ttl.js";
 /**
  * Resolve cache retention preference.
  * Defaults to the provided fallback and uses PI_CACHE_RETENTION for backward compatibility.
@@ -33,14 +35,6 @@ function resolveCacheRetention(cacheRetention, env, fallback = "short") {
     }
     return fallback;
 }
-function isAnthropicApiBaseUrl(baseUrl) {
-    try {
-        return new URL(baseUrl).hostname === "api.anthropic.com";
-    }
-    catch {
-        return false;
-    }
-}
 function getCacheControl(model, cacheRetention, env) {
     const retention = resolveCacheRetention(cacheRetention, env, "long");
     if (retention === "none") {
@@ -168,7 +162,6 @@ const NATIVE_XHIGH_EFFORT_MODEL_MARKERS = [
  * gateway rows carry no generated compat, so the family fact has to live here as well.
  */
 const DISABLED_THINKING_REJECTING_MODEL_MARKERS = ["fable-5", "mythos-5"];
-const CLAUDE_FABLE_OR_MYTHOS_MODEL_ID = /^claude-(?:fable|mythos)(?:-|$)/i;
 const UNSUPPORTED_NATIVE_COMPUTER_TOOL_MODEL_MARKERS = [
     "opus-4-6",
     "opus-4.6",
@@ -191,47 +184,6 @@ function isInvalidUnsignedThinkingSignatureError(error) {
         error instanceof Error &&
         /Invalid signature in thinking block/i.test(error.message));
 }
-function getAnthropicCompat(model) {
-    // Auto-detect session affinity and cache control support from provider
-    const isFireworks = model.provider === "fireworks";
-    const isCloudflareAiGatewayAnthropic = model.provider === "cloudflare-ai-gateway" && model.baseUrl.includes("anthropic");
-    const isXiaomi = model.provider === "xiaomi" || model.provider.startsWith("xiaomi-token-plan-");
-    return {
-        supportsEagerToolInputStreaming: model.compat?.supportsEagerToolInputStreaming ?? !isFireworks,
-        supportsLongCacheRetention: model.compat?.supportsLongCacheRetention ?? !isFireworks,
-        sendSessionAffinityHeaders: model.compat?.sendSessionAffinityHeaders ?? !!(isFireworks || isCloudflareAiGatewayAnthropic),
-        supportsCacheControlOnTools: model.compat?.supportsCacheControlOnTools ?? !isFireworks,
-        supportsDisabledThinking: model.compat?.supportsDisabledThinking ?? !isXiaomi,
-        supportsTemperature: model.compat?.supportsTemperature ?? true,
-        supportsToolChoice: model.compat?.supportsToolChoice ?? true,
-        supportsForcedToolChoice: model.compat?.supportsForcedToolChoice ?? !CLAUDE_FABLE_OR_MYTHOS_MODEL_ID.test(model.id),
-        allowEmptySignature: model.compat?.allowEmptySignature ?? false,
-        unsignedThinkingReplay: model.compat?.unsignedThinkingReplay ?? (model.compat?.allowEmptySignature ? "empty-signature" : "text"),
-        supportsStrictTools: model.compat?.supportsStrictTools ?? false,
-        supportsToolReferences: model.compat?.supportsToolReferences ?? defaultSupportsToolReferences(model),
-        // Default: first-party Anthropic only. Anthropic-compatible providers
-        // (kimi-coding, fireworks, copilot, gateways) may execute the server-side
-        // search but reject the replayed server_tool_use / web_search_tool_result
-        // blocks on the next request (kimi-coding 400s with `tool_call_id is not
-        // found`).
-        supportsWebSearch: model.compat?.supportsWebSearch ?? isAnthropicApiBaseUrl(model.baseUrl),
-    };
-}
-/**
- * Default for `supportsToolReferences`: first-party Anthropic models except
- * Haiku (rejects client-side tool_reference blocks) and models that predate
- * tool search (Claude 3.x, Opus/Sonnet 4.0, Opus 4.1).
- */
-function defaultSupportsToolReferences(model) {
-    if (model.provider !== "anthropic" || model.id.includes("haiku"))
-        return false;
-    const version = model.id.match(/^claude-(?:opus|sonnet|fable)-(\d+)(?:-(\d+))?(?:-|$)/);
-    if (!version)
-        return false;
-    const major = Number(version[1]);
-    const minor = version[2] && version[2].length < 8 ? Number(version[2]) : 0;
-    return major > 4 || (major === 4 && minor >= 5);
-}
 function mergeHeaders(...headerSources) {
     const merged = {};
     for (const headers of headerSources) {
@@ -569,6 +521,164 @@ function sanitizeUnsupportedNativeTools(model, params) {
     }
     return changed ? sanitized : params;
 }
+/**
+ * Anthropic validates that every tool referenced by the message history is
+ * available in the same request — defined in `tools` or discovered through a
+ * `tool_reference` block — and rejects the whole request otherwise
+ * ("Tool reference '<name>' not found in available tools"). Sessions outlive
+ * their tools: an MCP server can be absent after a resume, an extension can
+ * stop registering a tool, or a payload hook can strip a definition while the
+ * history still carries the call. Demote those references to plain text so
+ * the turn can proceed; the matching tool_result is demoted in lockstep so no
+ * orphan pairing error replaces the original one.
+ */
+function demoteUnavailableToolReferences(params) {
+    const messages = params.messages;
+    if (!Array.isArray(messages) || messages.length === 0)
+        return params;
+    const definedNames = new Set();
+    if (Array.isArray(params.tools)) {
+        for (const tool of params.tools) {
+            if (isRecord(tool) && typeof tool.name === "string")
+                definedNames.add(tool.name);
+        }
+    }
+    // `tool_reference` blocks — emitted for deferred tools or replayed from a
+    // server-side tool search — make their targets available without a
+    // non-deferred definition.
+    const discoveredNames = new Set();
+    collectToolReferenceNames(messages, discoveredNames);
+    const demotedCallNames = new Map();
+    for (const message of messages) {
+        if (message.role !== "assistant" || !Array.isArray(message.content))
+            continue;
+        for (const block of message.content) {
+            if (isRecord(block) &&
+                block.type === "tool_use" &&
+                typeof block.name === "string" &&
+                !definedNames.has(block.name) &&
+                !discoveredNames.has(block.name)) {
+                demotedCallNames.set(block.id, block.name);
+            }
+        }
+    }
+    // A `tool_reference` without its definition 400s the same way.
+    const danglingReferenceNames = new Set();
+    for (const name of discoveredNames) {
+        if (!definedNames.has(name))
+            danglingReferenceNames.add(name);
+    }
+    if (demotedCallNames.size === 0 && danglingReferenceNames.size === 0)
+        return params;
+    let changed = false;
+    const rewrittenMessages = [];
+    for (const message of messages) {
+        if (!Array.isArray(message.content)) {
+            rewrittenMessages.push(message);
+            continue;
+        }
+        let messageChanged = false;
+        const content = [];
+        for (const block of message.content) {
+            if (message.role === "assistant" && isRecord(block) && block.type === "tool_use") {
+                const demotedName = demotedCallNames.get(block.id);
+                if (demotedName !== undefined) {
+                    messageChanged = true;
+                    content.push({ type: "text", text: demotedToolCallText(demotedName, block.input) });
+                    continue;
+                }
+            }
+            if (isRecord(block) && block.type === "tool_result") {
+                const demotedName = demotedCallNames.get(block.tool_use_id);
+                if (demotedName !== undefined) {
+                    messageChanged = true;
+                    content.push({ type: "text", text: demotedToolResultText(demotedName, block.content) });
+                    continue;
+                }
+                if (danglingReferenceNames.size > 0 && Array.isArray(block.content)) {
+                    const kept = [];
+                    const omitted = [];
+                    for (const item of block.content) {
+                        if (isRecord(item) &&
+                            item.type === "tool_reference" &&
+                            typeof item.tool_name === "string" &&
+                            danglingReferenceNames.has(item.tool_name)) {
+                            omitted.push(item.tool_name);
+                            continue;
+                        }
+                        kept.push(item);
+                    }
+                    if (omitted.length > 0) {
+                        messageChanged = true;
+                        const nextContent = kept.length > 0
+                            ? kept
+                            : [{ type: "text", text: `Tool reference unavailable: ${[...new Set(omitted)].join(", ")}` }];
+                        content.push({ ...block, content: nextContent });
+                        continue;
+                    }
+                }
+            }
+            content.push(block);
+        }
+        if (content.length === 0) {
+            changed = true;
+            continue;
+        }
+        if (messageChanged) {
+            changed = true;
+            rewrittenMessages.push({ ...message, content });
+            continue;
+        }
+        rewrittenMessages.push(message);
+    }
+    if (!changed)
+        return params;
+    return { ...params, messages: rewrittenMessages };
+}
+function collectToolReferenceNames(value, names) {
+    if (Array.isArray(value)) {
+        for (const item of value)
+            collectToolReferenceNames(item, names);
+        return;
+    }
+    if (!isRecord(value))
+        return;
+    if (value.type === "tool_reference" && typeof value.tool_name === "string")
+        names.add(value.tool_name);
+    for (const nested of Object.values(value))
+        collectToolReferenceNames(nested, names);
+}
+function demotedToolCallText(name, input) {
+    let serializedInput;
+    try {
+        serializedInput = JSON.stringify(input ?? {});
+    }
+    catch {
+        serializedInput = "{}";
+    }
+    return `[Called tool "${name}" (no longer available in this session) with input: ${serializedInput}]`;
+}
+function demotedToolResultText(name, content) {
+    return `[Result of unavailable tool "${name}": ${toolResultText(content)}]`;
+}
+function toolResultText(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        const parts = [];
+        for (const item of content) {
+            if (!isRecord(item))
+                continue;
+            if (item.type === "text" && typeof item.text === "string")
+                parts.push(item.text);
+            else if (typeof item.type === "string")
+                parts.push(`[${item.type}]`);
+        }
+        if (parts.length > 0)
+            return parts.join("\n");
+    }
+    return "Tool output unavailable.";
+}
 function sanitizeAdaptiveThinkingPayload(model, params, options) {
     if (!supportsAdaptiveThinking(model)) {
         return params;
@@ -817,6 +927,7 @@ export const stream = (model, context, options) => {
                 }
                 params = sanitizeAdaptiveThinkingPayload(model, params, options);
                 params = sanitizeUnsupportedNativeTools(model, params);
+                params = demoteUnavailableToolReferences(params);
                 const payloadRequestMetadata = extractPayloadRequestMetadata(params);
                 params = payloadRequestMetadata.params;
                 const requestOptions = {