@code-yeongyu/senpi-ai 2026.10.1-3 → 2026.10.2

package/README.md

@@ -1626,10 +1626,10 @@ Browser compatibility notes:
 
 ## Bundling and Tree Shaking
 
-For small bundles, import only the providers you need:
+For small bundles and low-overhead unbundled scripts, import the model runtime and only the providers you need:
 
 ```typescript
-import { createModels } from '@earendil-works/pi-ai';
+import { createModels } from '@earendil-works/pi-ai/models';
 import { openaiProvider } from '@earendil-works/pi-ai/providers/openai';
 
 const models = createModels();
@@ -1638,7 +1638,8 @@ models.setProvider(openaiProvider());
 
 Rules:
 
-- `@earendil-works/pi-ai` is the core entrypoint and does not import built-in catalogs, provider factories, or SDK implementations.
+- `@earendil-works/pi-ai/models` exports the model runtime (`createModels`, `createProvider`, model helpers, and their types) without TypeBox, built-in catalogs, or SDK implementations. Other types can still use `import type` from the root.
+- `@earendil-works/pi-ai` is the core entrypoint and does not import built-in catalogs, real provider factories, or SDK implementations, but it eagerly imports TypeBox and schema validation. Unbundled Node scripts do not tree-shake its unused exports; prefer `./models`, `./providers/faux`, and specific `./utils/*` subpaths when those are all you need.
 - `@earendil-works/pi-ai/providers/<provider>` imports that provider's catalog and lazy API wrapper only.
 - `@earendil-works/pi-ai/providers/all` imports every built-in provider factory and all catalogs. Use it only when you want the full built-in set.
 - With code splitting, provider SDKs stay in lazy chunks and load on first request.

package/dist/api/anthropic-messages.js

@@ -1,4 +1,5 @@
 import Anthropic from "@anthropic-ai/sdk";
+import { ANTHROPIC_FEDERATION_RULE_ID_ENV, ANTHROPIC_IDENTITY_TOKEN_FILE_ENV, ANTHROPIC_ORGANIZATION_ID_ENV, ANTHROPIC_SERVICE_ACCOUNT_ID_ENV, ANTHROPIC_WORKSPACE_ID_ENV, } from "../env-api-keys.js";
 import { calculateCost } from "../models.js";
 import { readProviderDiagnostic } from "../provider-diagnostic.js";
 import { registerSessionResourceCleanup } from "../session-resources.js";
@@ -27,9 +28,9 @@ import { sendWithForcedToolChoiceFallback } from "../utils/tool-choice-fallback.
 import { resolveRootObjectSchema } from "../utils/tool-schema-compat.js";
 import { getCurrentTools, getDeclaredTools, getInitialSystemMessage, hasToolRedefinitions, normalizeContext, resolveTranscript, } from "../utils/transcript.js";
 import { sanitizeAnthropicToolPairs } from "./anthropic-tool-pairs.js";
-import { demoteUnavailableToolReferences } from "./anthropic-tool-references.js";
+import { demoteToolReferenceReplay, demoteUnavailableToolReferences } from "./anthropic-tool-references.js";
 import { resolveCloudflareBaseUrl } from "./cloudflare.js";
-import { getJsonSchemaToolParameters, resolveJsonSchemaStrictSampling } from "./constrained-sampling.js";
+import { getJsonSchemaToolParameters, resolveJsonSchemaStrictSampling, } from "./constrained-sampling.js";
 import { withGitHubCopilotFailureNote } from "./github-copilot-errors.js";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
 import { ANTHROPIC_RESERVED_BODY_KEYS, adjustMaxTokensForThinking, buildBaseOptions, clampMaxTokensToContext, } from "./simple-options.js";
@@ -231,18 +232,23 @@ function supportsMidConvoToolChanges(model) {
 // A provider can reject its own empty signatures. Learn that capability for one
 // conversation without changing the shared model definition used by other sessions.
 const unsignedThinkingTextReplayFallbacks = new Set();
+// Endpoints that rejected a replayed tool_reference for one conversation (senpi #2568).
+const toolReferenceReplayFallbacks = 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
     // them for every session that ever ran.
     if (sessionId === undefined) {
         unsignedThinkingTextReplayFallbacks.clear();
+        toolReferenceReplayFallbacks.clear();
         return;
     }
     const prefix = `${sessionId}\u0000`;
-    for (const key of unsignedThinkingTextReplayFallbacks) {
-        if (key.startsWith(prefix))
-            unsignedThinkingTextReplayFallbacks.delete(key);
+    for (const fallbacks of [unsignedThinkingTextReplayFallbacks, toolReferenceReplayFallbacks]) {
+        for (const key of fallbacks) {
+            if (key.startsWith(prefix))
+                fallbacks.delete(key);
+        }
     }
 });
 function unsignedThinkingFallbackKey(model, sessionId) {
@@ -256,6 +262,12 @@ function isInvalidUnsignedThinkingSignatureError(error) {
         error instanceof Error &&
         /Invalid signature in thinking block/i.test(error.message));
 }
+function isToolReferenceNotFoundError(error) {
+    return (error instanceof Error &&
+        "status" in error &&
+        error.status === 400 &&
+        /Tool reference '[^']*' not found in available tools/i.test(error.message));
+}
 function mergeHeaders(...headerSources) {
     const merged = {};
     for (const headers of headerSources) {
@@ -279,16 +291,58 @@ function hasHeader(headers, name) {
     }
     return false;
 }
-function assertRequestAuth(provider, apiKey, headers) {
-    if (apiKey)
-        return;
-    if (hasHeader(headers, "authorization") ||
+function hasRequestAuth(apiKey, headers) {
+    return (!!apiKey ||
+        hasHeader(headers, "authorization") ||
         hasHeader(headers, "x-api-key") ||
-        hasHeader(headers, "cf-aig-authorization")) {
-        return;
+        hasHeader(headers, "cf-aig-authorization"));
+}
+function assertRequestAuth(provider, apiKey, headers) {
+    if (!hasRequestAuth(apiKey, headers))
+        throw new Error(`No API key for provider: ${provider}`);
+}
+/**
+ * Anthropic SDK client that never runs the SDK's own credential chain
+ * (ANTHROPIC_PROFILE config files, federation env vars). Without this, every
+ * client built with `apiKey: null, authToken: null` for header-owned auth would
+ * also resolve and exchange SDK credentials behind pi's auth resolver.
+ */
+class PiAnthropic extends Anthropic {
+    _shouldResolveDefaultCredentials() {
+        return false;
     }
-    throw new Error(`No API key for provider: ${provider}`);
 }
+/**
+ * Workload identity federation config from the ANTHROPIC_* variables the
+ * Anthropic SDK documents; the SDK performs the token exchange and refresh.
+ * Only for the anthropic provider, since the exchange is an Anthropic API
+ * endpoint, and only when no key or auth header was resolved.
+ */
+function getAnthropicFederation(model, apiKey, headers, env) {
+    if (model.provider !== "anthropic" || hasRequestAuth(apiKey, headers))
+        return undefined;
+    const federationRuleId = getProviderEnvValue(ANTHROPIC_FEDERATION_RULE_ID_ENV, env);
+    const organizationId = getProviderEnvValue(ANTHROPIC_ORGANIZATION_ID_ENV, env);
+    const identityTokenFile = getProviderEnvValue(ANTHROPIC_IDENTITY_TOKEN_FILE_ENV, env);
+    if (!federationRuleId || !organizationId || !identityTokenFile)
+        return undefined;
+    return {
+        organization_id: organizationId,
+        workspace_id: getProviderEnvValue(ANTHROPIC_WORKSPACE_ID_ENV, env),
+        authentication: {
+            type: "oidc_federation",
+            federation_rule_id: federationRuleId,
+            service_account_id: getProviderEnvValue(ANTHROPIC_SERVICE_ACCOUNT_ID_ENV, env),
+            identity_token: { source: "file", path: identityTokenFile },
+        },
+    };
+}
+/**
+ * The SDK caches the federated access token per client, but pi creates a client
+ * per request. Keep one client for the current federation config and fetch, and
+ * clone it per request with `withOptions()`, which shares the token cache.
+ */
+let federationClient;
 function isRecord(value) {
     return typeof value === "object" && value !== null;
 }
@@ -904,7 +958,9 @@ export const stream = (model, context, options) => {
             else {
                 const apiKey = options?.apiKey;
                 const optionsHeaders = providerHeadersToRecord(options?.headers);
-                assertRequestAuth(model.provider, apiKey, optionsHeaders);
+                const federation = getAnthropicFederation(model, apiKey, optionsHeaders, options?.env);
+                if (!federation)
+                    assertRequestAuth(model.provider, apiKey, optionsHeaders);
                 let copilotDynamicHeaders;
                 if (model.provider === "github-copilot") {
                     const hasImages = hasCopilotVisionInput(normalizedContext.messages);
@@ -916,7 +972,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);
+                    const created = createClient(model, apiKey, options?.interleavedThinking ?? true, shouldUseFineGrainedToolStreamingBeta(model, normalizedContext), options?.refusalFallbacks !== undefined, optionsHeaders, options?.fetch, copilotDynamicHeaders, cacheSessionId, options?.env, federation);
                     client = created.client;
                     isOAuth = created.isOAuthToken;
                     advertisedClaudeCodeVersion = created.claudeCodeVersion;
@@ -949,6 +1005,8 @@ export const stream = (model, context, options) => {
             let unsignedThinkingReplay = fallbackKey && unsignedThinkingTextReplayFallbacks.has(fallbackKey)
                 ? "text"
                 : getAnthropicCompat(model).unsignedThinkingReplay;
+            let demoteReferenceReplay = fallbackKey !== undefined && toolReferenceReplayFallbacks.has(fallbackKey);
+            let requestReplaysReferences = false;
             const createRequest = async () => {
                 let params = buildParams(model, normalizedContext, isOAuth, options, unsignedThinkingReplay);
                 const nextParams = await options?.onPayload?.(params, model);
@@ -957,7 +1015,12 @@ export const stream = (model, context, options) => {
                 }
                 params = sanitizeAdaptiveThinkingPayload(model, params, options);
                 params = sanitizeUnsupportedNativeTools(model, params);
-                params = sanitizeAnthropicToolPairs(demoteUnavailableToolReferences(params));
+                params = demoteUnavailableToolReferences(params);
+                const withoutReferenceReplay = demoteToolReferenceReplay(params);
+                requestReplaysReferences = withoutReferenceReplay !== params;
+                if (demoteReferenceReplay)
+                    params = withoutReferenceReplay;
+                params = sanitizeAnthropicToolPairs(params);
                 const payloadRequestMetadata = extractPayloadRequestMetadata(params);
                 params = payloadRequestMetadata.params;
                 const limitedTools = limitGitHubCopilotTools(model.provider, params.tools, params.tool_choice);
@@ -994,6 +1057,12 @@ export const stream = (model, context, options) => {
                                 unsignedThinkingTextReplayFallbacks.add(fallbackKey);
                             return createRequest();
                         }
+                        if (!demoteReferenceReplay && requestReplaysReferences && isToolReferenceNotFoundError(error)) {
+                            demoteReferenceReplay = true;
+                            if (fallbackKey)
+                                toolReferenceReplayFallbacks.add(fallbackKey);
+                            return createRequest();
+                        }
                         if (await retryWithNewerClaudeCode(error)) {
                             try {
                                 return await createRequest();
@@ -1437,7 +1506,10 @@ function mapThinkingLevelToEffort(model, level) {
 }
 export const streamSimple = (model, context, options) => {
     const apiKey = options?.apiKey;
-    assertRequestAuth(model.provider, apiKey, providerHeadersToRecord(options?.headers));
+    const optionsHeaders = providerHeadersToRecord(options?.headers);
+    if (!getAnthropicFederation(model, apiKey, optionsHeaders, options?.env)) {
+        assertRequestAuth(model.provider, apiKey, optionsHeaders);
+    }
     const base = {
         ...buildBaseOptions(model, context, options, options?.apiKey),
         toolChoice: options?.toolChoice,
@@ -1472,7 +1544,7 @@ export const streamSimple = (model, context, options) => {
 function isOAuthToken(apiKey) {
     return apiKey.includes("sk-ant-oat");
 }
-function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStreamingBeta, useServerSideFallbackBeta, optionsHeaders, fetch, dynamicHeaders, sessionId, env) {
+function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStreamingBeta, useServerSideFallbackBeta, optionsHeaders, fetch, dynamicHeaders, sessionId, env, federation) {
     // Adaptive thinking models have interleaved thinking built in, so skip the beta header.
     const needsInterleavedBeta = interleavedThinking && !supportsAdaptiveThinking(model);
     const betaFeatures = [];
@@ -1486,7 +1558,7 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
         betaFeatures.push(SERVER_SIDE_FALLBACK_BETA);
     }
     if (model.provider === "cloudflare-ai-gateway") {
-        const client = new Anthropic({
+        const client = new PiAnthropic({
             apiKey: null,
             authToken: null,
             baseURL: resolveCloudflareBaseUrl(model, env),
@@ -1505,7 +1577,7 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
     }
     // Copilot: Bearer auth, selective betas.
     if (model.provider === "github-copilot") {
-        const client = new Anthropic({
+        const client = new PiAnthropic({
             apiKey: null,
             authToken: apiKey,
             baseURL: model.baseUrl,
@@ -1522,7 +1594,7 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
     // OAuth: Bearer auth, Claude Code identity headers
     if (apiKey && isOAuthToken(apiKey)) {
         const advertisedClaudeCodeVersion = getClaudeCodeVersion(claudeCodeVersion, env);
-        const client = new Anthropic({
+        const client = new PiAnthropic({
             apiKey: null,
             authToken: apiKey,
             baseURL: model.baseUrl,
@@ -1538,7 +1610,7 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
         });
         return { client, isOAuthToken: true, claudeCodeVersion: advertisedClaudeCodeVersion };
     }
-    // API key auth
+    // API key, header-owned auth, or workload identity federation.
     const affinityCompat = getAnthropicCompat(model);
     const sessionAffinityHeaders = {};
     if (sessionId && affinityCompat.sendSessionAffinityHeaders) {
@@ -1547,17 +1619,33 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
         const header = affinityCompat.sessionAffinityFormat === "openrouter" ? "x-session-id" : "x-session-affinity";
         sessionAffinityHeaders[header] = sessionId;
     }
-    const client = new Anthropic({
+    const defaultHeaders = sanitizeAdaptiveThinkingHeaders(model, mergeClientHeaders(model, {
+        accept: "application/json",
+        "anthropic-dangerous-direct-browser-access": "true",
+        ...(betaFeatures.length > 0 ? { "anthropic-beta": betaFeatures.join(",") } : {}),
+    }, sessionAffinityHeaders, model.headers, optionsHeaders));
+    if (federation) {
+        const key = JSON.stringify([model.baseUrl, federation]);
+        if (federationClient?.key !== key || federationClient.fetch !== fetch) {
+            const client = new PiAnthropic({
+                apiKey: null,
+                authToken: null,
+                config: federation,
+                baseURL: model.baseUrl,
+                dangerouslyAllowBrowser: true,
+                fetch,
+            });
+            federationClient = { key, fetch, client };
+        }
+        return { client: federationClient.client.withOptions({ defaultHeaders }), isOAuthToken: false };
+    }
+    const client = new PiAnthropic({
         apiKey: apiKey ?? null,
         authToken: null,
         baseURL: model.baseUrl,
         dangerouslyAllowBrowser: true,
         fetch,
-        defaultHeaders: sanitizeAdaptiveThinkingHeaders(model, mergeClientHeaders(model, {
-            accept: "application/json",
-            "anthropic-dangerous-direct-browser-access": "true",
-            ...(betaFeatures.length > 0 ? { "anthropic-beta": betaFeatures.join(",") } : {}),
-        }, sessionAffinityHeaders, model.headers, optionsHeaders)),
+        defaultHeaders,
     });
     return { client, isOAuthToken: false };
 }
@@ -2142,11 +2230,47 @@ function insertThinkingLevelMessages(converted, activeEffort) {
 function shouldUseFineGrainedToolStreamingBeta(model, context) {
     return getCurrentTools(context.messages).length > 0 && !getAnthropicCompat(model).supportsEagerToolInputStreaming;
 }
+// Keywords Anthropic strict tool use rejects with a 400 for the whole request.
+// https://platform.claude.com/docs/en/build-with-claude/structured-outputs#json-schema-limitations
+const ANTHROPIC_STRICT_UNSUPPORTED_KEYWORDS = new Set([
+    "minimum",
+    "maximum",
+    "exclusiveMinimum",
+    "exclusiveMaximum",
+    "multipleOf",
+    "maxItems",
+    "uniqueItems",
+    "minContains",
+    "maxContains",
+    "minProperties",
+    "maxProperties",
+]);
+const ANTHROPIC_STRICT_STRING_FORMATS = new Set([
+    "date-time",
+    "time",
+    "date",
+    "duration",
+    "email",
+    "hostname",
+    "uri",
+    "ipv4",
+    "ipv6",
+    "uuid",
+]);
+const isAnthropicStrictUnsupportedKeyword = (key, value) => {
+    if (ANTHROPIC_STRICT_UNSUPPORTED_KEYWORDS.has(key))
+        return true;
+    if (key === "minItems")
+        return value !== 0 && value !== 1;
+    if (key === "format")
+        return typeof value !== "string" || !ANTHROPIC_STRICT_STRING_FORMATS.has(value);
+    return false;
+};
 function convertTools(tools, isOAuthToken, supportsEagerToolInputStreaming, supportsStrictTools, cacheControl, deferLoading = false) {
     if (!tools)
         return [];
     return tools.map((tool, index) => {
-        const strict = resolveJsonSchemaStrictSampling(tool, supportsStrictTools);
+        const strict = resolveJsonSchemaStrictSampling(tool, supportsStrictTools, isAnthropicStrictUnsupportedKeyword);
         const parameters = getJsonSchemaToolParameters(tool, strict);
         // A root union carries no top-level properties, so reading them directly
         // would advertise the tool to the model as taking no arguments at all.

package/dist/api/anthropic-tool-references.d.ts

@@ -1,3 +1,17 @@
 import type { MessageCreateParamsStreaming } from "@anthropic-ai/sdk/resources/beta/messages/messages.js";
 export declare function demoteUnavailableToolReferences(params: MessageCreateParamsStreaming): MessageCreateParamsStreaming;
+/**
+ * Some Anthropic-compatible endpoints run a native tool search inside one request
+ * but reject every `tool_reference` replayed from history once the request
+ * carries more than a handful of tools: "Tool reference '<name>' not found in
+ * available tools" even though `tools` defines the name (senpi #2568). The
+ * request is then retried with the replay demoted to text: a native search pair
+ * (`server_tool_use` plus its `tool_search_tool_result`, which may sit in a later
+ * assistant message) becomes a note naming the tools it found, and
+ * `tool_reference` items inside a client `tool_result` become one text item.
+ * A deferred tool is loaded only by a replayed reference, so every tool the demoted
+ * references named is sent without `defer_loading`: it stays callable without another
+ * search. Returns `params` unchanged when the history replays no reference.
+ */
+export declare function demoteToolReferenceReplay(params: MessageCreateParamsStreaming): MessageCreateParamsStreaming;
 //# sourceMappingURL=anthropic-tool-references.d.ts.map

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

@@ -183,6 +183,113 @@ export function demoteUnavailableToolReferences(params) {
         return params;
     return { ...params, messages: rewrittenMessages };
 }
+/**
+ * Some Anthropic-compatible endpoints run a native tool search inside one request
+ * but reject every `tool_reference` replayed from history once the request
+ * carries more than a handful of tools: "Tool reference '<name>' not found in
+ * available tools" even though `tools` defines the name (senpi #2568). The
+ * request is then retried with the replay demoted to text: a native search pair
+ * (`server_tool_use` plus its `tool_search_tool_result`, which may sit in a later
+ * assistant message) becomes a note naming the tools it found, and
+ * `tool_reference` items inside a client `tool_result` become one text item.
+ * A deferred tool is loaded only by a replayed reference, so every tool the demoted
+ * references named is sent without `defer_loading`: it stays callable without another
+ * search. Returns `params` unchanged when the history replays no reference.
+ */
+export function demoteToolReferenceReplay(params) {
+    const messages = params.messages;
+    if (!Array.isArray(messages) || messages.length === 0)
+        return params;
+    const searchUseIds = new Set();
+    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_search_tool_result" && typeof block.tool_use_id === "string") {
+                searchUseIds.add(block.tool_use_id);
+            }
+        }
+    }
+    let changed = false;
+    const demotedNames = new Set();
+    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)) {
+                if (block.type === "server_tool_use" && typeof block.id === "string" && searchUseIds.has(block.id)) {
+                    messageChanged = true;
+                    continue;
+                }
+                if (block.type === "tool_search_tool_result") {
+                    messageChanged = true;
+                    const names = isNativeToolSearchResultBlock(block)
+                        ? toolReferenceNames(block.content.tool_references)
+                        : [];
+                    for (const name of names)
+                        demotedNames.add(name);
+                    content.push({
+                        type: "text",
+                        text: names.length > 0 ? `Tool search found: ${names.join(", ")}` : "Tool search found no tools.",
+                    });
+                    continue;
+                }
+            }
+            if (isRecord(block) && block.type === "tool_result" && Array.isArray(block.content)) {
+                const names = toolReferenceNames(block.content);
+                if (names.length > 0) {
+                    messageChanged = true;
+                    for (const name of names)
+                        demotedNames.add(name);
+                    const kept = block.content.filter((item) => !(isRecord(item) && item.type === "tool_reference"));
+                    content.push({
+                        ...block,
+                        content: [...kept, { type: "text", text: `Tools loaded: ${names.join(", ")}` }],
+                    });
+                    continue;
+                }
+            }
+            content.push(block);
+        }
+        if (!messageChanged) {
+            rewrittenMessages.push(message);
+            continue;
+        }
+        changed = true;
+        if (content.length > 0)
+            rewrittenMessages.push({ ...message, content });
+    }
+    if (!changed)
+        return params;
+    return { ...params, messages: rewrittenMessages, ...residentTools(params.tools, demotedNames) };
+}
+/** Drops `defer_loading` from the tools a demoted reference named; the rest keep their deferral. */
+function residentTools(tools, names) {
+    if (!Array.isArray(tools) || names.size === 0)
+        return {};
+    let changed = false;
+    const rewritten = tools.map((tool) => {
+        if (!isRecord(tool) || tool.defer_loading !== true || typeof tool.name !== "string" || !names.has(tool.name))
+            return tool;
+        changed = true;
+        const { defer_loading: _deferLoading, ...resident } = tool;
+        return resident;
+    });
+    return changed ? { tools: rewritten } : {};
+}
+function toolReferenceNames(items) {
+    const names = new Set();
+    for (const item of items) {
+        if (isRecord(item) && item.type === "tool_reference" && typeof item.tool_name === "string")
+            names.add(item.tool_name);
+    }
+    return [...names];
+}
 /**
  * Folds every `tool_reference` item in `items` onto the request's own tool
  * name and drops the ones that still do not resolve. Returns undefined when

package/dist/api/constrained-sampling.d.ts

@@ -1,6 +1,8 @@
 import type { Tool } from "../types.ts";
+/** Returns true when a provider's strict mode rejects this schema keyword with this value. */
+export type UnsupportedStrictSchemaKeywordCheck = (key: string, value: unknown) => boolean;
 /** Convert a tool schema to the strict subset expected by provider constrained sampling. */
-export declare function makeStrictJsonSchema(schema: Tool["parameters"]): Record<string, unknown>;
+export declare function makeStrictJsonSchema(schema: Tool["parameters"], isUnsupportedKeyword?: UnsupportedStrictSchemaKeywordCheck): Record<string, unknown>;
 export declare function getJsonSchemaToolParameters(tool: Tool, strict: boolean | undefined): Tool["parameters"];
 export interface GrammarConstrainedSampling {
     format: "lark" | "regex";
@@ -14,7 +16,11 @@ export interface GrammarToolInputJsonBuffer {
 }
 export declare function getGrammarToolInput(toolName: string, arguments_: Record<string, unknown>, inputProperty: string): string;
 export declare function appendGrammarToolInputJsonDelta(buffer: GrammarToolInputJsonBuffer, inputProperty: string, nextInput: string, close: boolean): string | undefined;
-export declare function resolveJsonSchemaStrictSampling(tool: Tool, supportsStrictMode: boolean): boolean | undefined;
+/**
+ * Decide whether a JSON-schema tool is sent in strict mode. `isUnsupportedKeyword` lets a provider
+ * reject extra keywords its strict mode does not accept, so "prefer" tools fall back to non-strict.
+ */
+export declare function resolveJsonSchemaStrictSampling(tool: Tool, supportsStrictMode: boolean, isUnsupportedKeyword?: UnsupportedStrictSchemaKeywordCheck): boolean | undefined;
 export declare function resolveGrammarConstrainedSampling(tool: Tool, supportsOpenAIGrammarTools: boolean): GrammarConstrainedSampling | undefined;
 export declare function createGrammarToolInputProperties(tools: Tool[] | undefined, supportsOpenAIGrammarTools: boolean): ReadonlyMap<string, string>;
 //# sourceMappingURL=constrained-sampling.d.ts.map

package/dist/api/constrained-sampling.js

@@ -39,7 +39,7 @@ function schemaAllowsNull(schema) {
         return true;
     return Array.isArray(schema.anyOf) && schema.anyOf.some((variant) => schemaAllowsNull(variant));
 }
-function makeJsonSchemaNodeStrict(schema) {
+function makeJsonSchemaNodeStrict(schema, isUnsupportedKeyword) {
     if (!isJsonSchemaObject(schema)) {
         throw new UnsupportedStrictJsonSchemaError("boolean schemas are unsupported");
     }
@@ -48,6 +48,13 @@ function makeJsonSchemaNodeStrict(schema) {
             throw new UnsupportedStrictJsonSchemaError(`${key} schemas are unsupported`);
         }
     }
+    if (isUnsupportedKeyword) {
+        for (const [key, value] of Object.entries(schema)) {
+            if (isUnsupportedKeyword(key, value)) {
+                throw new UnsupportedStrictJsonSchemaError(`${key}: ${JSON.stringify(value)} is unsupported`);
+            }
+        }
+    }
     if (schema.anyOf !== undefined) {
         if (!Array.isArray(schema.anyOf) || schema.anyOf.length === 0) {
             throw new UnsupportedStrictJsonSchemaError("anyOf must contain at least one schema");
@@ -56,14 +63,14 @@ function makeJsonSchemaNodeStrict(schema) {
             if (isStructuredSchema(variant)) {
                 throw new UnsupportedStrictJsonSchemaError("object and array unions are unsupported");
             }
-            makeJsonSchemaNodeStrict(variant);
+            makeJsonSchemaNodeStrict(variant, isUnsupportedKeyword);
         }
     }
     if (schema.items !== undefined) {
         if (Array.isArray(schema.items)) {
             throw new UnsupportedStrictJsonSchemaError("tuple schemas are unsupported");
         }
-        makeJsonSchemaNodeStrict(schema.items);
+        makeJsonSchemaNodeStrict(schema.items, isUnsupportedKeyword);
     }
     const isObjectSchema = schema.type === "object";
     if (schema.properties !== undefined && !isObjectSchema) {
@@ -88,7 +95,7 @@ function makeJsonSchemaNodeStrict(schema) {
         throw new UnsupportedStrictJsonSchemaError("required contains an unknown property");
     }
     for (const [key, property] of Object.entries(properties)) {
-        makeJsonSchemaNodeStrict(property);
+        makeJsonSchemaNodeStrict(property, isUnsupportedKeyword);
         if (!required.has(key) && !schemaAllowsNull(property)) {
             properties[key] = { anyOf: [property, { type: "null" }] };
         }
@@ -97,12 +104,12 @@ function makeJsonSchemaNodeStrict(schema) {
     schema.additionalProperties = false;
 }
 /** Convert a tool schema to the strict subset expected by provider constrained sampling. */
-export function makeStrictJsonSchema(schema) {
+export function makeStrictJsonSchema(schema, isUnsupportedKeyword) {
     const cloned = structuredClone(schema);
     if (!isJsonSchemaObject(cloned)) {
         throw new UnsupportedStrictJsonSchemaError("root schema must have type object");
     }
-    makeJsonSchemaNodeStrict(cloned);
+    makeJsonSchemaNodeStrict(cloned, isUnsupportedKeyword);
     if (cloned.type !== "object") {
         throw new UnsupportedStrictJsonSchemaError("root schema must have type object");
     }
@@ -160,13 +167,17 @@ function inferGrammarInputProperty(tool) {
     }
     return inputProperty;
 }
-export function resolveJsonSchemaStrictSampling(tool, supportsStrictMode) {
+/**
+ * Decide whether a JSON-schema tool is sent in strict mode. `isUnsupportedKeyword` lets a provider
+ * reject extra keywords its strict mode does not accept, so "prefer" tools fall back to non-strict.
+ */
+export function resolveJsonSchemaStrictSampling(tool, supportsStrictMode, isUnsupportedKeyword) {
     const config = tool.constrainedSampling;
     if (config === false || config?.type !== "json_schema")
         return undefined;
     if (supportsStrictMode) {
         try {
-            makeStrictJsonSchema(tool.parameters);
+            makeStrictJsonSchema(tool.parameters, isUnsupportedKeyword);
             return true;
         }
         catch (error) {

package/dist/api/openai-responses-shared.js

@@ -337,12 +337,14 @@ export function convertResponsesMessages(model, context, allowedToolCallProvider
                     // An active grammar declaration wins over sentinel recovery below: its
                     // named input property is richer than the persisted freeform fallback.
                     // For different-model messages, set id to undefined to avoid pairing validation.
-                    // OpenAI tracks which fc_xxx IDs were paired with rs_xxx reasoning items.
+                    // OpenAI tracks which item IDs were paired with rs_xxx reasoning items.
                     // By omitting the id, we avoid triggering that validation (like cross-provider does).
-                    // Function-call item ids must begin with fc_ while freeform calls can replay
-                    // without the local <call_id>|custom sentinel.
-                    if ((isDifferentModel && itemId?.startsWith("fc_")) ||
-                        (!isFreeform && customInputProperty === undefined && !itemId?.startsWith("fc_"))) {
+                    // Also drop ids that do not match the replayed item type: function_call ids must be fc_*
+                    // and custom_tool_call ids must be ctc_*. Foreign tool call ids are normalized to fc_*, and
+                    // a call can switch between the two types when grammar tool support differs. Freeform
+                    // calls replay without an item id and without the local <call_id>|custom sentinel.
+                    const itemIdPrefix = customInputProperty === undefined ? "fc_" : "ctc_";
+                    if (isDifferentModel || !itemId?.startsWith(itemIdPrefix)) {
                         itemId = undefined;
                     }
                     const canReplayNamespace = isSameModel || toolPlacement.deferred.has(toolCall.name);

package/dist/api-registry.d.ts

@@ -14,6 +14,8 @@ export interface ApiProviderInternal {
 export type RegisteredApiProvider = {
     provider: ApiProviderInternal;
     sourceId?: string;
+    /** Kept by `clearApiProviders()`; removed only through `unregisterApiProviders(sourceId)`. */
+    survivesClear?: boolean;
 };
 /** Browser-neutral shape installed by the node-only provider-scope subpath. */
 export interface ProviderScopeAccess {
@@ -23,7 +25,9 @@ export interface ProviderScopeAccess {
 /** Installs the optional node-only scope lookup without importing node APIs here. */
 export declare function installProviderScopeAccessor(accessor: () => ProviderScopeAccess | undefined): void;
 export declare function setProviderScopeStrictMode(enabled: boolean): void;
-export declare function registerApiProvider<TApi extends Api, TOptions extends StreamOptions>(provider: ApiProvider<TApi, TOptions>, sourceId?: string): void;
+export declare function registerApiProvider<TApi extends Api, TOptions extends StreamOptions>(provider: ApiProvider<TApi, TOptions>, sourceId?: string, options?: {
+    survivesClear?: boolean;
+}): void;
 /** Registers a builtin once, retaining its immutable identity for active scopes. */
 export declare function registerBuiltinApiProvider<TApi extends Api, TOptions extends StreamOptions>(provider: ApiProvider<TApi, TOptions>): void;
 export declare function getBuiltinApiProvider(api: Api): ApiProviderInternal | undefined;