@code-yeongyu/senpi-ai 2026.10.31-1 → 2026.11.2-1

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

@@ -1,9 +1,7 @@
 import Anthropic from "@anthropic-ai/sdk";
 import type { MessageCreateParamsNonStreaming } from "@anthropic-ai/sdk/resources/beta/messages/messages.js";
-import type { AnthropicRefusalFallback, Context, Model, SimpleStreamOptions, StreamFunction, StreamOptions, Tool } from "../types.ts";
+import type { AnthropicRefusalFallback, Context, Model, SimpleStreamOptions, StreamFunction, StreamOptions } from "../types.ts";
 export { getAnthropicCompat } from "../utils/prompt-cache-ttl.ts";
-export declare const toClaudeCodeName: (name: string) => string;
-export declare const fromClaudeCodeName: (name: string, tools?: Tool[]) => string;
 export type AnthropicEffort = "low" | "medium" | "high" | "xhigh" | "max";
 export type AnthropicThinkingDisplay = "summarized" | "omitted";
 export interface AnthropicOptions extends StreamOptions {
@@ -72,6 +70,18 @@ export interface AnthropicOptions extends StreamOptions {
      */
     client?: Anthropic;
 }
+/**
+ * A Claude OAuth token (`sk-ant-oat...`) offered as an API key. senpi no longer sends such a token
+ * to the Messages API while presenting itself as Claude Code (senpi#5131); the subscription path is
+ * the `anthropic-subscription` provider, which runs the official Claude Code CLI.
+ */
+export declare class ClaudeOAuthTokenRefusedError extends Error {
+    readonly code = "claude_oauth_token_refused";
+    readonly provider: string;
+    readonly modelId: string;
+    constructor(provider: string, modelId: string);
+}
+export declare function isClaudeOAuthTokenRefusedError(error: unknown): error is ClaudeOAuthTokenRefusedError;
 export declare const stream: StreamFunction<"anthropic-messages", AnthropicOptions>;
 export declare const streamSimple: StreamFunction<"anthropic-messages", SimpleStreamOptions>;
 export declare function buildAnthropicWarmPromptCacheParams(model: Model<"anthropic-messages">, context: Context, options?: AnthropicOptions): MessageCreateParamsNonStreaming;

package/dist/api/anthropic-messages.js

@@ -6,7 +6,6 @@ import { registerSessionResourceCleanup } from "../session-resources.js";
 import { isVideoMimeType } from "../types.js";
 import { combineAbortSignals } from "../utils/abort-signals.js";
 import { pushAssistantProgress } from "../utils/assistant-capture.js";
-import { claudeCodeVersionTooOldHint, getClaudeCodeVersion, isClaudeCodeVersionTooOldError, recoverClaudeCodeVersion, } from "../utils/claude-code-version.js";
 import { splitDeferredTools } from "../utils/deferred-tools.js";
 import { appendAssistantMessageDiagnostic } from "../utils/diagnostics.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
@@ -73,49 +72,6 @@ function getCacheControl(model, cacheRetention, env) {
         cacheControl: { type: "ephemeral", ...(ttl && { ttl }) },
     };
 }
-// Stealth mode: Mimic Claude Code's identity and tool naming exactly.
-// 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.306";
-// 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
-const claudeCodeTools = [
-    "Read",
-    "Write",
-    "Edit",
-    "Bash",
-    "Grep",
-    "Glob",
-    "AskUserQuestion",
-    "EnterPlanMode",
-    "ExitPlanMode",
-    "KillShell",
-    "NotebookEdit",
-    "Skill",
-    "Task",
-    "TaskOutput",
-    "TodoWrite",
-    "WebFetch",
-    "WebSearch",
-];
-const ccToolLookup = new Map(claudeCodeTools.map((t) => [t.toLowerCase(), t]));
-const ccToolAliases = new Map([["ask_user_question", "AskUserQuestion"]]);
-// Convert tool name to CC canonical casing if it matches (case-insensitive)
-export const toClaudeCodeName = (name) => ccToolAliases.get(name) ?? ccToolLookup.get(name.toLowerCase()) ?? name;
-export const fromClaudeCodeName = (name, tools) => {
-    if (tools && tools.length > 0) {
-        const alias = [...ccToolAliases].find(([, wireName]) => wireName === name);
-        if (alias && tools.some((tool) => tool.name === alias[0]))
-            return alias[0];
-        const lowerName = name.toLowerCase();
-        const matchedTool = tools.find((tool) => tool.name.toLowerCase() === lowerName);
-        if (matchedTool)
-            return matchedTool.name;
-    }
-    return name;
-};
 function convertContentBlocks(content) {
     // If only text blocks, return as concatenated string for simplicity
     const hasImages = content.some((c) => c.type === "image");
@@ -323,6 +279,28 @@ function assertRequestAuth(provider, apiKey, headers) {
     if (!hasRequestAuth(apiKey, headers))
         throw new Error(`No API key for provider: ${provider}`);
 }
+const CLAUDE_OAUTH_TOKEN_MARKER = "sk-ant-oat";
+/**
+ * A Claude OAuth token (`sk-ant-oat...`) offered as an API key. senpi no longer sends such a token
+ * to the Messages API while presenting itself as Claude Code (senpi#5131); the subscription path is
+ * the `anthropic-subscription` provider, which runs the official Claude Code CLI.
+ */
+export class ClaudeOAuthTokenRefusedError extends Error {
+    constructor(provider, modelId) {
+        super(`${provider}/${modelId}: a Claude OAuth token (${CLAUDE_OAUTH_TOKEN_MARKER}...) is not accepted as an API key; senpi does not send Claude subscription tokens to the Anthropic API directly. For a Claude Pro/Max subscription sign in with /login anthropic-subscription (or set CLAUDE_CODE_OAUTH_TOKEN) and use anthropic-subscription/${modelId}; otherwise use an Anthropic API key.`);
+        this.code = "claude_oauth_token_refused";
+        this.name = "ClaudeOAuthTokenRefusedError";
+        this.provider = provider;
+        this.modelId = modelId;
+    }
+}
+export function isClaudeOAuthTokenRefusedError(error) {
+    return error instanceof ClaudeOAuthTokenRefusedError;
+}
+function assertNotClaudeOAuthToken(model, apiKey) {
+    if (apiKey?.includes(CLAUDE_OAUTH_TOKEN_MARKER))
+        throw new ClaudeOAuthTokenRefusedError(model.provider, model.id);
+}
 /**
  * Anthropic SDK client that never runs the SDK's own credential chain
  * (ANTHROPIC_PROFILE config files, federation env vars). Without this, every
@@ -410,7 +388,7 @@ function userMessageClosesServerTurn(message) {
         return message.content.trim().length > 0;
     return message.content.some((block) => (block.type === "text" && block.text.trim().length > 0) || block.type === "image");
 }
-function collectProviderNativeToolPairing(messages, model, deferredToolNames, normalizeToolName, discardedFallbackToolCallIds) {
+function collectProviderNativeToolPairing(messages, model, deferredToolNames, discardedFallbackToolCallIds) {
     const resolvedUseIds = new Set();
     const validResultIds = new Set();
     // Uses whose turn can still be resumed. A same-model assistant resets the
@@ -462,10 +440,9 @@ function collectProviderNativeToolPairing(messages, model, deferredToolNames, no
             // and the pending use resumable.
             let emitsReferences = false;
             for (const name of message.addedToolNames ?? []) {
-                const normalizedName = normalizeToolName(name);
-                if (!deferredToolNames.has(normalizedName) || loadedReferenceNames.has(normalizedName))
+                if (!deferredToolNames.has(name) || loadedReferenceNames.has(name))
                     continue;
-                loadedReferenceNames.add(normalizedName);
+                loadedReferenceNames.add(name);
                 emitsReferences = true;
             }
             if (emitsReferences)
@@ -926,7 +903,6 @@ async function* iterateAnthropicEvents(response, signal, onTransportActivity) {
 export const stream = (model, context, options) => {
     const stream = new AssistantMessageEventStream({ captureBlocks: true });
     const normalizedContext = resolveTranscript(context, supportsMidConvoSystemMessages(model));
-    const currentTools = getCurrentTools(normalizedContext.messages);
     (async () => {
         const providerThinkingLevel = managedEffortForRequest(model, options);
         const output = {
@@ -953,8 +929,6 @@ export const stream = (model, context, options) => {
         const requestSignal = combinedAbort.signal;
         try {
             let client;
-            let isOAuth = false;
-            let advertisedClaudeCodeVersion;
             let usageModel = model;
             let inputTransformations;
             let openClient;
@@ -967,6 +941,7 @@ export const stream = (model, context, options) => {
                 const federation = getAnthropicFederation(model, apiKey, optionsHeaders, options?.env);
                 if (!federation)
                     assertRequestAuth(model.provider, apiKey, optionsHeaders);
+                assertNotClaudeOAuthToken(model, apiKey);
                 let copilotDynamicHeaders;
                 if (model.provider === "github-copilot") {
                     const hasImages = hasCopilotVisionInput(normalizedContext.messages);
@@ -978,37 +953,12 @@ 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 && configuredBetaHeader(model, options) !== null, optionsHeaders, getAnthropicCompat(model).supportsGzipRequestBody
+                    client = createClient(model, apiKey, options?.interleavedThinking ?? true, shouldUseFineGrainedToolStreamingBeta(model, normalizedContext), options?.refusalFallbacks !== undefined && configuredBetaHeader(model, options) !== null, optionsHeaders, getAnthropicCompat(model).supportsGzipRequestBody
                         ? withGzipRequestBodies(options?.fetch)
                         : options?.fetch, copilotDynamicHeaders, cacheSessionId, options?.env, federation);
-                    client = created.client;
-                    isOAuth = created.isOAuthToken;
-                    advertisedClaudeCodeVersion = created.claudeCodeVersion;
                 };
                 openClient();
             }
-            // One retry per request: a `claude_code_version_too_old` 400 names the version Anthropic
-            // wants, so the fingerprint is raised and the same request goes out again with it.
-            let claudeCodeVersionRetried = false;
-            const retryWithNewerClaudeCode = async (error) => {
-                if (claudeCodeVersionRetried ||
-                    openClient === undefined ||
-                    advertisedClaudeCodeVersion === undefined ||
-                    !isClaudeCodeVersionTooOldError(error)) {
-                    return false;
-                }
-                const next = await recoverClaudeCodeVersion(error, claudeCodeVersion, advertisedClaudeCodeVersion, options?.env);
-                if (next === undefined)
-                    return false;
-                claudeCodeVersionRetried = true;
-                openClient();
-                return true;
-            };
-            const noteTooOldClaudeCode = (error) => {
-                if (advertisedClaudeCodeVersion !== undefined && isClaudeCodeVersionTooOldError(error)) {
-                    error.message = `${error.message}\n${claudeCodeVersionTooOldHint(advertisedClaudeCodeVersion)}`;
-                }
-            };
             const fallbackKey = unsignedThinkingFallbackKey(model, options?.sessionId);
             let unsignedThinkingReplay = fallbackKey && unsignedThinkingTextReplayFallbacks.has(fallbackKey)
                 ? "text"
@@ -1025,7 +975,7 @@ export const stream = (model, context, options) => {
             }
             let lastSentParams;
             const createRequest = async () => {
-                let params = buildParams(model, normalizedContext, isOAuth, options, unsignedThinkingReplay);
+                let params = buildParams(model, normalizedContext, options, unsignedThinkingReplay);
                 const nextParams = await options?.onPayload?.(params, model);
                 if (nextParams !== undefined) {
                     params = nextParams;
@@ -1110,16 +1060,6 @@ export const stream = (model, context, options) => {
                         }
                         if (markNewlyExpiredSearches(error))
                             return createRequestDemotingExpiredSearches();
-                        if (await retryWithNewerClaudeCode(error)) {
-                            try {
-                                return await createRequest();
-                            }
-                            catch (retryError) {
-                                noteTooOldClaudeCode(retryError);
-                                throw retryError;
-                            }
-                        }
-                        noteTooOldClaudeCode(error);
                         throw error;
                     }
                 }, {
@@ -1232,9 +1172,7 @@ export const stream = (model, context, options) => {
                         const block = {
                             type: "toolCall",
                             id: event.content_block.id,
-                            name: isOAuth
-                                ? fromClaudeCodeName(event.content_block.name, currentTools)
-                                : event.content_block.name,
+                            name: event.content_block.name,
                             arguments: isRecord(event.content_block.input)
                                 ? event.content_block.input
                                 : {},
@@ -1594,6 +1532,7 @@ export const streamSimple = (model, context, options) => {
     if (!getAnthropicFederation(model, apiKey, optionsHeaders, options?.env)) {
         assertRequestAuth(model.provider, apiKey, optionsHeaders);
     }
+    assertNotClaudeOAuthToken(model, apiKey);
     const base = {
         ...buildBaseOptions(model, context, options, options?.apiKey),
         toolChoice: options?.toolChoice,
@@ -1625,9 +1564,6 @@ export const streamSimple = (model, context, options) => {
         thinkingBudgetTokens: Math.min(adjusted.thinkingBudget, Math.max(0, maxTokens - 1024)),
     });
 };
-function isOAuthToken(apiKey) {
-    return apiKey.includes("sk-ant-oat");
-}
 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);
@@ -1657,7 +1593,7 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
                 ...(betaFeatures.length > 0 ? { "anthropic-beta": betaFeatures.join(",") } : {}),
             }, model.headers, optionsHeaders)),
         });
-        return { client, isOAuthToken: false };
+        return client;
     }
     // Copilot: Bearer auth, selective betas.
     if (model.provider === "github-copilot") {
@@ -1673,26 +1609,7 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
                 ...(betaFeatures.length > 0 ? { "anthropic-beta": betaFeatures.join(",") } : {}),
             }, model.headers, dynamicHeaders, optionsHeaders)),
         });
-        return { client, isOAuthToken: false };
-    }
-    // OAuth: Bearer auth, Claude Code identity headers
-    if (apiKey && isOAuthToken(apiKey)) {
-        const advertisedClaudeCodeVersion = getClaudeCodeVersion(claudeCodeVersion, env);
-        const client = new PiAnthropic({
-            apiKey: null,
-            authToken: apiKey,
-            baseURL: model.baseUrl,
-            dangerouslyAllowBrowser: true,
-            fetch,
-            defaultHeaders: sanitizeAdaptiveThinkingHeaders(model, mergeClientHeaders(model, {
-                accept: "application/json",
-                "anthropic-dangerous-direct-browser-access": "true",
-                "anthropic-beta": ["claude-code-20250219", "oauth-2025-04-20", ...betaFeatures].join(","),
-                "user-agent": `claude-cli/${advertisedClaudeCodeVersion}`,
-                "x-app": "cli",
-            }, model.headers, optionsHeaders)),
-        });
-        return { client, isOAuthToken: true, claudeCodeVersion: advertisedClaudeCodeVersion };
+        return client;
     }
     // API key, header-owned auth, or workload identity federation.
     const affinityCompat = getAnthropicCompat(model);
@@ -1721,9 +1638,9 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
             });
             federationClient = { key, fetch, client };
         }
-        return { client: federationClient.client.withOptions({ defaultHeaders }), isOAuthToken: false };
+        return federationClient.client.withOptions({ defaultHeaders });
     }
-    const client = new PiAnthropic({
+    return new PiAnthropic({
         apiKey: apiKey ?? null,
         authToken: null,
         baseURL: model.baseUrl,
@@ -1731,13 +1648,12 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
         fetch,
         defaultHeaders,
     });
-    return { client, isOAuthToken: false };
 }
 export function buildAnthropicWarmPromptCacheParams(model, context, options) {
     // Public fork entry (warmPromptCache, cache-keepalive): accepts a raw Context and builds
     // the same transcript the turn's stream() resolves, so the warmed prefix matches.
     const transcript = resolveTranscript(normalizeContext(context), supportsMidConvoSystemMessages(model));
-    const params = buildParams(model, transcript, false, {
+    const params = buildParams(model, transcript, {
         ...options,
         maxTokens: 0,
         thinkingEnabled: undefined,
@@ -1759,14 +1675,12 @@ function configuredBetaHeader(model, options) {
     }
     return configured;
 }
-function getBetaFeatures(model, context, isOAuthToken, shape, options) {
+function getBetaFeatures(model, context, shape, options) {
     const configured = configuredBetaHeader(model, options);
     if (configured === null)
         return [];
     // Betas the request body depends on: the API rejects the request without them.
     const required = [];
-    if (isOAuthToken)
-        required.push("claude-code-20250219", "oauth-2025-04-20");
     if (shape.midConvoEffort)
         required.push(MID_CONVERSATION_OUTPUT_CONFIG_BETA);
     if (shape.thinkingBinding)
@@ -1801,7 +1715,7 @@ function defaultOptionalBetas(model, context, options) {
         features.push(SERVER_SIDE_FALLBACK_BETA);
     return features;
 }
-function buildParams(model, context, isOAuthToken, options, unsignedThinkingReplay = getAnthropicCompat(model).unsignedThinkingReplay) {
+function buildParams(model, context, options, unsignedThinkingReplay = getAnthropicCompat(model).unsignedThinkingReplay) {
     const compat = getAnthropicCompat(model);
     const { cacheControl } = getCacheControl(model, options?.cacheRetention ?? model.cacheRetention, options?.env);
     const initialSystemMessage = getInitialSystemMessage(context.messages);
@@ -1816,7 +1730,7 @@ function buildParams(model, context, isOAuthToken, options, unsignedThinkingRepl
     // old boundary (read) and the new one (written for the next step) are marked. Two checkpoints fit
     // only when the system block holds one, which then also covers the tools before it (senpi#3242).
     const stablePrefixMarkers = conversationMessages.filter((message) => message.role === "assistant" && message.promptCacheBreakpoint === true).length;
-    const systemHoldsCheckpoint = isOAuthToken || initialSystemText.length > 0;
+    const systemHoldsCheckpoint = initialSystemText.length > 0;
     const stablePrefixCheckpointLimit = stablePrefixMarkers >= 2 && systemHoldsCheckpoint ? 2 : Math.min(1, stablePrefixMarkers);
     // Native tool changes reference tools by name, so a redefined name cannot be expressed,
     // and Anthropic rejects a tool list where every tool is deferred, so there must be an
@@ -1824,18 +1738,14 @@ function buildParams(model, context, isOAuthToken, options, unsignedThinkingRepl
     const initialTools = initialSystemMessage?.toolsAdded ?? [];
     // 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.
+    // no server-side fallbacks (senpi#2957).
     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);
-    const normalizeToolName = isOAuthToken ? toClaudeCodeName : (name) => name;
     // A marker on a discarded pre-fallback result must not defer its tool:
     // convertMessages drops that result, so no tool_reference would replay to
     // load the deferred definition.
@@ -1846,23 +1756,23 @@ function buildParams(model, context, isOAuthToken, options, unsignedThinkingRepl
     // `defer_loading` and loaded by a `tool_reference`. Native tool changes own deferral otherwise.
     const toolPlacement = nativeToolChanges
         ? { immediate: [], deferred: new Map() }
-        : splitDeferredTools({ tools: getCurrentTools(context.messages), messages: partitionMessages }, compat.supportsToolReferences, normalizeToolName);
+        : splitDeferredTools({ tools: getCurrentTools(context.messages), messages: partitionMessages }, compat.supportsToolReferences);
     let immediateTools = toolPlacement.immediate;
     let deferredTools = [...toolPlacement.deferred.values()];
     if (immediateTools.length === 0 && deferredTools.length > 0) {
         immediateTools = deferredTools;
         deferredTools = [];
     }
-    const deferredToolNames = new Set(deferredTools.map((tool) => normalizeToolName(tool.name)));
+    const deferredToolNames = new Set(deferredTools.map((tool) => tool.name));
     const activeEffort = managedEffortForRequest(model, options) ?? "high";
     const sendFallbacks = options?.refusalFallbacks !== undefined && !betasSuppressed;
-    const betaFeatures = getBetaFeatures(model, context, isOAuthToken, {
+    const betaFeatures = getBetaFeatures(model, context, {
         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, stablePrefixCheckpointLimit);
+    const convertedMessages = convertMessages(conversationMessages, model, cacheControl, unsignedThinkingReplay, deferredToolNames, midConvoEffort ? model.provider : undefined, nativeToolChanges, stablePrefixCheckpointLimit);
     const messages = midConvoEffort
         ? insertThinkingLevelMessages(convertedMessages, activeEffort)
         : convertedMessages.messages;
@@ -1888,21 +1798,7 @@ function buildParams(model, context, isOAuthToken, options, unsignedThinkingRepl
         stream: true,
         ...(betaFeatures.length > 0 ? { betas: betaFeatures } : {}),
     };
-    // For OAuth tokens, we MUST include Claude Code identity
-    if (isOAuthToken) {
-        params.system = [
-            {
-                type: "text",
-                text: "You are Claude Code, Anthropic's official CLI for Claude.",
-                ...(!initialSystemText && cacheControl ? { cache_control: cacheControl } : {}),
-            },
-        ];
-        if (initialSystemText) {
-            params.system.push(...anthropicSystemTextBlocks(initialSystemText, initialSystemMessage?.stablePrefix, cacheControl));
-        }
-    }
-    else if (initialSystemText) {
-        // Add cache control to system prompt for non-OAuth tokens
+    if (initialSystemText) {
         params.system = anthropicSystemTextBlocks(initialSystemText, initialSystemMessage?.stablePrefix, cacheControl);
     }
     // Temperature is incompatible with extended thinking and unsupported on Claude Opus 4.7+.
@@ -1923,15 +1819,15 @@ function buildParams(model, context, isOAuthToken, options, unsignedThinkingRepl
         const initialNames = new Set(initialTools.map((tool) => tool.name));
         const laterTools = getDeclaredTools(context.messages).filter((tool) => !initialNames.has(tool.name));
         params.tools = [
-            ...convertTools(initialTools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools, toolCacheControl),
+            ...convertTools(initialTools, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools, toolCacheControl),
             DEFERRED_TOOL_PLACEHOLDER,
-            ...convertTools(laterTools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools, undefined, true),
+            ...convertTools(laterTools, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools, undefined, true),
         ];
     }
     else if (immediateTools.length > 0 || deferredTools.length > 0) {
         params.tools = [
-            ...convertTools(immediateTools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools, toolCacheControl),
-            ...convertTools(deferredTools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools, undefined, true),
+            ...convertTools(immediateTools, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools, toolCacheControl),
+            ...convertTools(deferredTools, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools, undefined, true),
         ];
     }
     // Managed effort models always use adaptive thinking so prefix mismatches can
@@ -2052,17 +1948,13 @@ function finalAssistantTurnStartsWithToolUse(messages) {
     }
     return false;
 }
-function convertToolResult(msg, isOAuthToken, deferredToolNames, loadedToolNames, normalizeToolName) {
+function convertToolResult(msg, deferredToolNames, loadedToolNames) {
     const references = [];
     for (const name of msg.addedToolNames ?? []) {
-        const normalizedName = normalizeToolName(name);
-        if (!deferredToolNames.has(normalizedName) || loadedToolNames.has(normalizedName))
+        if (!deferredToolNames.has(name) || loadedToolNames.has(name))
             continue;
-        loadedToolNames.add(normalizedName);
-        references.push({
-            type: "tool_reference",
-            tool_name: isOAuthToken ? toClaudeCodeName(name) : name,
-        });
+        loadedToolNames.add(name);
+        references.push({ type: "tool_reference", tool_name: name });
     }
     // The video block variant is not in the SDK's ContentBlockParam union, so the
     // converted array is cast through the same escape hatch as tool_reference blocks.
@@ -2082,7 +1974,7 @@ function convertToolResult(msg, isOAuthToken, deferredToolNames, loadedToolNames
                 : convertedContent,
     };
 }
-function convertMessages(transformedMessages, model, isOAuthToken, cacheControl, unsignedThinkingReplay = "text", deferredToolNames = new Set(), normalizeToolName = (name) => name, managedProvider, nativeToolChanges = false, stablePrefixCheckpointLimit = 0) {
+function convertMessages(transformedMessages, model, cacheControl, unsignedThinkingReplay = "text", deferredToolNames = new Set(), managedProvider, nativeToolChanges = false, stablePrefixCheckpointLimit = 0) {
     const params = [];
     const assistantLevels = new Map();
     const loadedToolNames = new Set();
@@ -2101,7 +1993,7 @@ function convertMessages(transformedMessages, model, isOAuthToken, cacheControl,
     // assistant turn below; drop their tool_results in lockstep so none dangle.
     const discardedFallbackToolCallIds = collectDiscardedFallbackToolCallIds(transformedMessages, model);
     const rejectsNativeWebSearchReplay = !getAnthropicCompat(model).supportsWebSearch;
-    const providerNativeToolPairing = collectProviderNativeToolPairing(transformedMessages, model, deferredToolNames, normalizeToolName, discardedFallbackToolCallIds);
+    const providerNativeToolPairing = collectProviderNativeToolPairing(transformedMessages, model, deferredToolNames, discardedFallbackToolCallIds);
     for (let i = 0; i < transformedMessages.length; i++) {
         const msg = transformedMessages[i];
         if (msg.role === "system") {
@@ -2113,16 +2005,10 @@ function convertMessages(transformedMessages, model, isOAuthToken, cacheControl,
                 blocks.push({ type: "text", text: sanitizeSurrogates(text) });
             if (nativeToolChanges) {
                 for (const tool of msg.toolsRemoved ?? []) {
-                    blocks.push({
-                        type: "tool_removal",
-                        tool: { type: "tool_reference", name: isOAuthToken ? toClaudeCodeName(tool.name) : tool.name },
-                    });
+                    blocks.push({ type: "tool_removal", tool: { type: "tool_reference", name: tool.name } });
                 }
                 for (const tool of msg.toolsAdded ?? []) {
-                    blocks.push({
-                        type: "tool_addition",
-                        tool: { type: "tool_reference", name: isOAuthToken ? toClaudeCodeName(tool.name) : tool.name },
-                    });
+                    blocks.push({ type: "tool_addition", tool: { type: "tool_reference", name: tool.name } });
                 }
             }
             if (blocks.length > 0)
@@ -2253,7 +2139,7 @@ function convertMessages(transformedMessages, model, isOAuthToken, cacheControl,
                     blocks.push({
                         type: "tool_use",
                         id: block.id,
-                        name: isOAuthToken ? toClaudeCodeName(block.name) : block.name,
+                        name: block.name,
                         input: block.arguments ?? {},
                     });
                 }
@@ -2298,7 +2184,7 @@ function convertMessages(transformedMessages, model, isOAuthToken, cacheControl,
             while (j < transformedMessages.length && transformedMessages[j].role === "toolResult") {
                 const nextMsg = transformedMessages[j]; // We know it's a toolResult
                 if (!discardedFallbackToolCallIds.has(nextMsg.toolCallId)) {
-                    const converted = convertToolResult(nextMsg, isOAuthToken, deferredToolNames, loadedToolNames, normalizeToolName);
+                    const converted = convertToolResult(nextMsg, deferredToolNames, loadedToolNames);
                     toolResults.push(converted.toolResult);
                     siblingContent.push(...converted.siblingContent);
                 }
@@ -2390,7 +2276,7 @@ const isAnthropicStrictUnsupportedKeyword = (key, value) => {
         return typeof value !== "string" || !ANTHROPIC_STRICT_STRING_FORMATS.has(value);
     return false;
 };
-function convertTools(tools, isOAuthToken, supportsEagerToolInputStreaming, supportsStrictTools, cacheControl, deferLoading = false) {
+function convertTools(tools, supportsEagerToolInputStreaming, supportsStrictTools, cacheControl, deferLoading = false) {
     if (!tools)
         return [];
     return tools.map((tool, index) => {
@@ -2411,7 +2297,7 @@ function convertTools(tools, isOAuthToken, supportsEagerToolInputStreaming, supp
             }
             : legacyInputSchema;
         return {
-            name: isOAuthToken ? toClaudeCodeName(tool.name) : tool.name,
+            name: tool.name,
             description: tool.description,
             ...(supportsEagerToolInputStreaming ? { eager_input_streaming: true } : {}),
             ...(strict === true ? { strict: true } : {}),

package/dist/api/openai-completions.js

@@ -1500,7 +1500,24 @@ export function convertMessages(model, context, compat, options = {}) {
     return params;
 }
 function convertTools(tools, compat) {
-    return tools.map((tool) => {
+    const strictByTool = tools.map((tool) => tool.freeform || resolveGrammarConstrainedSampling(tool, compat.supportsOpenAIGrammarTools)
+        ? undefined
+        : resolveJsonSchemaStrictSampling(tool, compat.supportsStrictMode !== false));
+    if (compat.mixedStrictTools === false) {
+        const nonStrictTool = tools.find((tool, index) => !tool.freeform &&
+            !resolveGrammarConstrainedSampling(tool, compat.supportsOpenAIGrammarTools) &&
+            strictByTool[index] !== true);
+        if (nonStrictTool) {
+            const requiredTool = tools.find((tool) => tool.constrainedSampling &&
+                tool.constrainedSampling.type === "json_schema" &&
+                tool.constrainedSampling.strict === "require");
+            if (requiredTool) {
+                throw new Error(`Tool "${requiredTool.name}" requires JSON-schema constrained sampling, but tool "${nonStrictTool.name}" cannot be strict and this provider rejects mixed strict and non-strict tools.`);
+            }
+            strictByTool.fill(undefined);
+        }
+    }
+    return tools.map((tool, index) => {
         const grammar = resolveGrammarConstrainedSampling(tool, compat.supportsOpenAIGrammarTools);
         if (grammar) {
             return {
@@ -1521,7 +1538,7 @@ function convertTools(tools, compat) {
         if (tool.freeform) {
             throw new Error("Freeform tools cannot be sent to OpenAI Chat Completions; use Responses API");
         }
-        const strict = resolveJsonSchemaStrictSampling(tool, compat.supportsStrictMode !== false);
+        const strict = strictByTool[index];
         const schemaParameters = getJsonSchemaToolParameters(tool, strict);
         const normalizedParameters = compat.toolSchemaFlavor === "moonshot-mfjs"
             ? normalizeToolParametersForMoonshot(schemaParameters)

package/dist/api/openai-responses-shared.d.ts

@@ -2,6 +2,8 @@ import type { Tool as OpenAITool, ResponseCreateParamsStreaming, ResponseInput,
 import type { Api, AssistantMessage, Message, Model, StreamOptions, Tool, TranscriptContext, Usage } from "../types.ts";
 import type { AssistantMessageEventStream } from "../utils/event-stream.ts";
 export interface OpenAIResponsesStreamOptions {
+    /** SIWC succeeds only on response.completed, never on a finished tool alone. */
+    siwc?: boolean;
     onProviderStreamEvent?: StreamOptions["onProviderStreamEvent"];
     serviceTier?: ResponseCreateParamsStreaming["service_tier"] | "fast" | "ultrafast";
     grammarToolInputProperties?: ReadonlyMap<string, string>;

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

@@ -1029,12 +1029,22 @@ export async function processResponsesStream(openaiStream, output, stream, model
         }
         else if (event.type === "response.completed" || event.type === "response.incomplete") {
             finalizeResponse(event.response);
+            if (options?.siwc && event.type === "response.incomplete") {
+                throw new Error(`Response incomplete: ${event.response.incomplete_details?.reason ?? "unknown reason"}`);
+            }
         }
         else if (event.type === "error") {
             const errorEvent = event;
             const code = errorEvent.error?.code ?? errorEvent.code ?? errorEvent.status;
             const message = errorEvent.error?.message || errorEvent.message || "Unknown error";
-            throw new Error(code == null ? message : `Error Code ${code}: ${message}`);
+            const failure = new Error(code == null ? message : `Error Code ${code}: ${message}`);
+            throw options?.siwc
+                ? Object.assign(failure, {
+                    code: typeof code === "string" ? code : undefined,
+                    status: errorEvent.status,
+                    param: errorEvent.error?.param ?? errorEvent.param,
+                })
+                : failure;
         }
         else if (event.type === "response.failed") {
             sawTerminalResponseEvent = true;
@@ -1046,11 +1056,17 @@ export async function processResponsesStream(openaiStream, output, stream, model
                 : details?.reason
                     ? `incomplete: ${details.reason}`
                     : "Unknown error (no error details in response)";
-            throw new Error(msg);
+            const failure = new Error(msg);
+            throw options?.siwc
+                ? Object.assign(failure, {
+                    code: error?.code,
+                    param: error && "param" in error ? error.param : undefined,
+                })
+                : failure;
         }
     }
     const hasFinalizedToolCall = output.content.some((block) => block.type === "toolCall" && !("partialJson" in block));
-    if (!sawTerminalResponseEvent && !hasFinalizedToolCall) {
+    if (!sawTerminalResponseEvent && (options?.siwc || !hasFinalizedToolCall)) {
         throw new Error("OpenAI Responses stream ended before a terminal response event");
     }
     // The agent runs every tool call in the final message. Refuse to hand over calls whose