@code-yeongyu/senpi-ai 2026.10.10-9 → 2026.10.11

package/dist/api/google-shared.js

@@ -127,6 +127,17 @@ export function requiresToolCallId(modelId) {
         modelId.startsWith("gpt-oss-") ||
         (geminiMajorVersion !== undefined && geminiMajorVersion >= 3));
 }
+/**
+ * Gemini 3+ strictly validates replayed tool calls: the first functionCall part of every step
+ * in the current turn must carry the thoughtSignature the model returned, or the API answers
+ * 400 "Function call is missing a thought_signature in functionCall parts" (Vertex and AI
+ * Studio both; enforced even at MINIMAL thinking). See:
+ * https://docs.cloud.google.com/vertex-ai/generative-ai/docs/thought-signatures
+ */
+function requiresThoughtSignatureReplay(modelId) {
+    const geminiMajorVersion = getGeminiMajorVersion(modelId);
+    return geminiMajorVersion !== undefined && geminiMajorVersion >= 3;
+}
 function getGeminiMajorVersion(modelId) {
     const match = modelId.toLowerCase().match(/^gemini(?:-live)?-(\d+)/);
     if (!match)
@@ -155,6 +166,25 @@ function appendContent(contents, content) {
     }
     contents.push(content);
 }
+// The current turn starts after the last user message that carries content. An image-only
+// user message (a pasted screenshot with no caption) starts a new turn exactly like a text
+// prompt does: assistant steps after it are current-turn steps. Empty user messages carry
+// no content and never act as the boundary.
+function findLastUserContentMessageIndex(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg.role !== "user")
+            continue;
+        if (typeof msg.content === "string") {
+            if (msg.content.trim().length > 0)
+                return i;
+        }
+        else if (msg.content.some((item) => (item.type === "text" ? item.text.trim().length > 0 : true))) {
+            return i;
+        }
+    }
+    return -1;
+}
 /**
  * Convert internal messages to Gemini Content[] format.
  */
@@ -162,6 +192,9 @@ export function convertMessages(model, context, options = {}) {
     // Gemini has no mid-conversation system messages; the leading prompt is sent as systemInstruction.
     const conversation = withoutInitialSystemMessage(collapseSystemMessages(context).messages);
     const contents = [];
+    // Tool-call blocks replayed as text under a strict-signature model; their paired tool
+    // results must follow the same shape so no unpaired functionResponse part is emitted.
+    const textToolCallIds = new Set();
     const normalizeId = (id) => {
         if (!requiresToolCallId(model.id))
             return id;
@@ -170,7 +203,9 @@ export function convertMessages(model, context, options = {}) {
     const transformedMessages = transformMessages(conversation, model, normalizeId, {
         preserveThinking: options.preserveThinking,
     });
-    for (const msg of transformedMessages) {
+    const lastUserContentIndex = findLastUserContentMessageIndex(transformedMessages);
+    for (let msgIndex = 0; msgIndex < transformedMessages.length; msgIndex++) {
+        const msg = transformedMessages[msgIndex];
         if (msg.role === "user") {
             if (typeof msg.content === "string") {
                 appendContent(contents, {
@@ -204,6 +239,17 @@ export function convertMessages(model, context, options = {}) {
             const parts = [];
             // Check if message is from same provider and model - only then keep thinking blocks
             const isSameProviderAndModel = msg.provider === model.provider && msg.model === model.id;
+            // Strict validation (requiring a thoughtSignature on the first functionCall part) applies
+            // to the current turn — assistant steps after the last user message carrying content.
+            // Earlier turns preserve structured function calls. In the current turn, if the first
+            // toolCall block lacks a valid signature, the whole step is replayed as text, because
+            // the documented skip_thought_signature_validator sentinel is rejected by Vertex (pi-mono #4032)
+            // and an unsigned functionCall part is a hard 400 on Gemini 3+.
+            const isCurrentTurn = msgIndex > lastUserContentIndex;
+            const firstToolCall = msg.content.find((b) => b.type === "toolCall");
+            const hasValidFirstSignature = firstToolCall !== undefined &&
+                resolveThoughtSignature(isSameProviderAndModel, firstToolCall.thoughtSignature) !== undefined;
+            const replayUnsignedToolCallsAsText = requiresThoughtSignatureReplay(model.id) && isCurrentTurn && !hasValidFirstSignature;
             for (const block of msg.content) {
                 if (block.type === "text") {
                     const thoughtSignature = resolveThoughtSignature(isSameProviderAndModel, block.textSignature);
@@ -243,16 +289,24 @@ export function convertMessages(model, context, options = {}) {
                     }
                 }
                 else if (block.type === "toolCall") {
-                    const thoughtSignature = resolveThoughtSignature(isSameProviderAndModel, block.thoughtSignature);
-                    const part = {
-                        functionCall: {
-                            name: block.name,
-                            args: block.arguments ?? {},
-                            ...(requiresToolCallId(model.id) ? { id: block.id } : {}),
-                        },
-                        ...(thoughtSignature && { thoughtSignature }),
-                    };
-                    parts.push(part);
+                    if (replayUnsignedToolCallsAsText) {
+                        textToolCallIds.add(block.id);
+                        parts.push({
+                            text: sanitizeSurrogates(`[Tool Call: ${block.name} (id: ${block.id})]\nArguments: ${JSON.stringify(block.arguments ?? {}, null, 2)}`),
+                        });
+                    }
+                    else {
+                        const thoughtSignature = resolveThoughtSignature(isSameProviderAndModel, block.thoughtSignature);
+                        const part = {
+                            functionCall: {
+                                name: block.name,
+                                args: block.arguments ?? {},
+                                ...(requiresToolCallId(model.id) ? { id: block.id } : {}),
+                            },
+                            ...(thoughtSignature && { thoughtSignature }),
+                        };
+                        parts.push(part);
+                    }
                 }
                 else if (block.type === "providerNative") {
                 }
@@ -268,9 +322,41 @@ export function convertMessages(model, context, options = {}) {
             // Extract text and image content
             const textContent = msg.content.filter((c) => c.type === "text");
             const textResult = textContent.map((c) => c.text).join("\n");
-            const imageContent = model.input.includes("image")
-                ? msg.content.filter((c) => c.type === "image")
-                : [];
+            const allImageBlocks = msg.content.filter((c) => c.type === "image");
+            const modelAcceptsImages = model.input.includes("image");
+            const imageContent = modelAcceptsImages ? allImageBlocks : [];
+            const imageParts = imageContent.map((imageBlock) => ({
+                inlineData: {
+                    mimeType: imageBlock.mimeType,
+                    data: imageBlock.data,
+                },
+            }));
+            const sanitizedToolName = sanitizeSurrogates(msg.toolName);
+            // A tool call replayed as text pairs with its result as text: an unpaired
+            // functionResponse part would break the model turn's call/response pairing.
+            if (textToolCallIds.has(msg.toolCallId)) {
+                // Unsupported tool images never arrive here as image blocks: transformMessages already
+                // replaced them with placeholder text for non-vision models, so an image-only result on
+                // such a model reaches this branch as text. A vision model's image-only result keeps an
+                // empty body and pairs with the inlineData parts appended below.
+                let bodyText = "";
+                if (textResult.length > 0) {
+                    bodyText = `\n${sanitizeSurrogates(textResult)}`;
+                }
+                else if (allImageBlocks.length === 0) {
+                    bodyText = "\n(no output)";
+                }
+                const errorMarker = msg.isError ? " (error)" : "";
+                const callIdPart = ` (id: ${msg.toolCallId})`;
+                appendContent(contents, {
+                    role: "user",
+                    parts: [
+                        { text: `[Tool Result: ${sanitizedToolName}${callIdPart}]${errorMarker}${bodyText}` },
+                        ...imageParts,
+                    ],
+                });
+                continue;
+            }
             const hasText = textResult.length > 0;
             const hasImages = imageContent.length > 0;
             // Gemini 3+ models support multimodal function responses with images nested inside
@@ -279,16 +365,10 @@ export function convertMessages(model, context, options = {}) {
             const modelSupportsMultimodalFunctionResponse = supportsMultimodalFunctionResponse(model.id);
             // Use "output" key for success, "error" key for errors as per SDK documentation
             const responseValue = hasText ? sanitizeSurrogates(textResult) : hasImages ? "(see attached image)" : "";
-            const imageParts = imageContent.map((imageBlock) => ({
-                inlineData: {
-                    mimeType: imageBlock.mimeType,
-                    data: imageBlock.data,
-                },
-            }));
             const includeId = requiresToolCallId(model.id);
             const functionResponsePart = {
                 functionResponse: {
-                    name: msg.toolName,
+                    name: sanitizedToolName,
                     response: msg.isError ? { error: responseValue } : { output: responseValue },
                     ...(hasImages && modelSupportsMultimodalFunctionResponse && { parts: imageParts }),
                     ...(includeId ? { id: msg.toolCallId } : {}),

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

@@ -450,9 +450,9 @@ function buildRequestBody(model, context, options, cacheSessionId, grammarToolIn
 function getServiceTierCostMultiplier(model, serviceTier) {
     switch (serviceTier) {
         case "ultrafast":
-            // OpenAI publishes an Ultrafast price for GPT-6 Astra only: 6x Standard on every
+            // OpenAI prices GPT-6 Astra and GPT-6.1 Sol Ultrafast at 6x Standard on every
             // token class and context tier. Any other model keeps its base rate.
-            return model.id === "gpt-6-astra" ? 6 : 1;
+            return ["gpt-6-astra", "gpt-6.1-sol"].includes(model.upstreamModelId ?? model.id) ? 6 : 1;
         case "flex":
             return 0.5;
         case "priority":

package/dist/api/openai-responses-allowed-tools.d.ts

@@ -0,0 +1,33 @@
+import type { ResponseCreateParamsStreaming } from "openai/resources/responses/responses.js";
+import type { Api, Model, OpenAIResponsesCompat, TranscriptContext } from "../types.ts";
+export type AllowedToolsTarget = Pick<Model<Api>, "api" | "provider" | "baseUrl" | "id">;
+export declare function hasRefusedAllowedToolsChoice(target: AllowedToolsTarget): boolean;
+export declare function rememberAllowedToolsChoiceRefusal(target: AllowedToolsTarget): void;
+export declare function clearAllowedToolsChoiceRefusals(): void;
+/**
+ * A refusal of `allowed_tools` as a `tool_choice` type, sent to a request that carried one. Over HTTP it is
+ * a 400; a WebSocket error event before any content carries no status, so the caller vouches for it with
+ * `beforeContent`. Observed on a Responses-compatible gateway: "Invalid value: 'allowed_tools'. Supported
+ * values are: ..." with param `tool_choice.type`.
+ */
+export declare function isAllowedToolsChoiceRefusal(error: unknown, params: {
+    readonly tool_choice?: unknown;
+}, options?: {
+    readonly beforeContent?: boolean;
+}): boolean;
+/**
+ * The pre-senpi#2095 request shape for an `allowed_tools` request: top-level function and custom tools
+ * outside the allowed list leave `tools`, hosted tools stay, and `tool_choice` goes. Tools that transcript
+ * items load in place are not filtered; a call to an inactive one is still refused by the session's active
+ * tool set. Any other request is unchanged.
+ */
+export declare function restrictToAllowedTools<TParams extends ResponseCreateParamsStreaming>(params: TParams): TParams;
+/**
+ * senpi#2095: `tools` carries every tool declared this session, so removing a tool never rewrites the
+ * cached prefix; the callable subset rides `tool_choice: allowed_tools` instead. Hosted tools a payload
+ * hook added stay callable, and deferred tools (declared by transcript items rather than `tools`) are
+ * referenced by name. A declared tool a payload hook removed from `tools` is not referenced (senpi#2234).
+ * An empty subset forbids tool calls. An explicit `tool_choice` always wins.
+ */
+export declare function applyAllowedToolsChoice<TParams extends ResponseCreateParamsStreaming>(params: TParams, context: TranscriptContext, activeToolNames: readonly string[] | undefined, compat: Required<OpenAIResponsesCompat>): TParams;
+//# sourceMappingURL=openai-responses-allowed-tools.d.ts.map

package/dist/api/openai-responses-allowed-tools.js

@@ -0,0 +1,108 @@
+import { isRequestRefusal } from "../utils/tool-choice-fallback.js";
+import { getCurrentTools } from "../utils/transcript.js";
+import { convertResponsesTools, resolveResponsesDeferredToolsMode, resolveResponsesToolPlacement, } from "./openai-responses-shared.js";
+/**
+ * Models whose endpoint refused `tool_choice: allowed_tools` and then accepted the same request
+ * restricted to the active tools, for the life of the process (senpi#3080).
+ */
+const allowedToolsRefusals = new Set();
+function refusalKey(target) {
+    return JSON.stringify([target.api, target.provider, target.baseUrl, target.id]);
+}
+export function hasRefusedAllowedToolsChoice(target) {
+    return allowedToolsRefusals.has(refusalKey(target));
+}
+export function rememberAllowedToolsChoiceRefusal(target) {
+    allowedToolsRefusals.add(refusalKey(target));
+}
+export function clearAllowedToolsChoiceRefusals() {
+    allowedToolsRefusals.clear();
+}
+function allowedReference(tool) {
+    if (tool.type === "function" || tool.type === "custom")
+        return { type: tool.type, name: tool.name };
+    if (tool.type === "mcp")
+        return { type: "mcp", server_label: tool.server_label };
+    return { type: tool.type };
+}
+function allowedToolsChoice(params) {
+    const choice = params.tool_choice;
+    if (typeof choice !== "object" || choice === null)
+        return undefined;
+    const { type, tools } = choice;
+    return type === "allowed_tools" && Array.isArray(tools) ? tools : undefined;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * A refusal of `allowed_tools` as a `tool_choice` type, sent to a request that carried one. Over HTTP it is
+ * a 400; a WebSocket error event before any content carries no status, so the caller vouches for it with
+ * `beforeContent`. Observed on a Responses-compatible gateway: "Invalid value: 'allowed_tools'. Supported
+ * values are: ..." with param `tool_choice.type`.
+ */
+export function isAllowedToolsChoiceRefusal(error, params, options = {}) {
+    if (allowedToolsChoice(params) === undefined)
+        return false;
+    if (!options.beforeContent && !isRequestRefusal(error))
+        return false;
+    const message = errorMessage(error);
+    return /\ballowed_tools\b/.test(message) && /invalid|unsupported|not\s+supported/i.test(message);
+}
+/**
+ * The pre-senpi#2095 request shape for an `allowed_tools` request: top-level function and custom tools
+ * outside the allowed list leave `tools`, hosted tools stay, and `tool_choice` goes. Tools that transcript
+ * items load in place are not filtered; a call to an inactive one is still refused by the session's active
+ * tool set. Any other request is unchanged.
+ */
+export function restrictToAllowedTools(params) {
+    const allowed = allowedToolsChoice(params);
+    if (allowed === undefined)
+        return params;
+    const allowedNames = new Set(allowed.map((tool) => tool.name).filter((name) => typeof name === "string"));
+    const tools = (params.tools ?? []).filter((tool) => (tool.type !== "function" && tool.type !== "custom") || allowedNames.has(tool.name));
+    const restricted = { ...params, tools };
+    delete restricted.tool_choice;
+    return restricted;
+}
+/**
+ * senpi#2095: `tools` carries every tool declared this session, so removing a tool never rewrites the
+ * cached prefix; the callable subset rides `tool_choice: allowed_tools` instead. Hosted tools a payload
+ * hook added stay callable, and deferred tools (declared by transcript items rather than `tools`) are
+ * referenced by name. A declared tool a payload hook removed from `tools` is not referenced (senpi#2234).
+ * An empty subset forbids tool calls. An explicit `tool_choice` always wins.
+ */
+export function applyAllowedToolsChoice(params, context, activeToolNames, compat) {
+    if (!compat.supportsAllowedTools || activeToolNames === undefined || params.tool_choice !== undefined) {
+        return params;
+    }
+    const active = new Set(activeToolNames);
+    const declaredTools = getCurrentTools(context.messages);
+    if (declaredTools.every((tool) => active.has(tool.name)))
+        return params;
+    const allowed = [];
+    const namedInTools = new Set();
+    for (const tool of params.tools ?? []) {
+        if (tool.type === "function" || tool.type === "custom") {
+            namedInTools.add(tool.name);
+            if (!active.has(tool.name))
+                continue;
+        }
+        allowed.push(allowedReference(tool));
+    }
+    // Tools missing from the request-level `tools` placement are the ones transcript items load in place.
+    const requestToolNames = new Set(resolveResponsesToolPlacement(context.messages, resolveResponsesDeferredToolsMode(compat) !== undefined).requestTools.map((tool) => tool.name));
+    for (const tool of declaredTools) {
+        if (namedInTools.has(tool.name) || !active.has(tool.name) || requestToolNames.has(tool.name))
+            continue;
+        const [converted] = convertResponsesTools([tool], {
+            supportsStrictMode: compat.supportsStrictMode,
+            supportsOpenAIGrammarTools: compat.supportsOpenAIGrammarTools,
+        });
+        if (converted)
+            allowed.push(allowedReference(converted));
+    }
+    const toolChoice = allowed.length > 0 ? { type: "allowed_tools", mode: "auto", tools: allowed } : "none";
+    return { ...params, tool_choice: toolChoice };
+}
+//# sourceMappingURL=openai-responses-allowed-tools.js.map

package/dist/api/openai-responses.js

@@ -1,5 +1,6 @@
 import OpenAI from "openai";
 import { calculateCost, clampThinkingLevel, inferOpenAIThinkingLevelMap, supportsMax, supportsXhigh, } from "../models.js";
+import { supportsAllowedToolChoice } from "../openai-responses-compat.js";
 import { readProviderDiagnostic } from "../provider-diagnostic.js";
 import { formatProviderError, normalizeProviderError } from "../utils/error-body.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
@@ -10,13 +11,14 @@ import { awaitProviderTransport, openAICompatibleProviderDiagnosticFromError, }
 import { getProviderEnvValue } from "../utils/provider-env.js";
 import { retryProviderRequest } from "../utils/provider-retry.js";
 import { sendWithForcedToolChoiceFallback } from "../utils/tool-choice-fallback.js";
-import { getCurrentTools, getDeclaredTools, normalizeContext, resolveTranscript } from "../utils/transcript.js";
+import { getDeclaredTools, normalizeContext, resolveTranscript } from "../utils/transcript.js";
 import { isCloudflareProvider, resolveCloudflareBaseUrl } from "./cloudflare.js";
 import { createGrammarToolInputProperties } from "./constrained-sampling.js";
 import { withGitHubCopilotFailureNote } from "./github-copilot-errors.js";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
 import { resolveOpenAIClientAuth } from "./openai-client-auth.js";
 import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
+import { applyAllowedToolsChoice, hasRefusedAllowedToolsChoice, isAllowedToolsChoiceRefusal, rememberAllowedToolsChoiceRefusal, restrictToAllowedTools, } from "./openai-responses-allowed-tools.js";
 import { findPromptCacheComparisonResponseId, withPromptCacheComparison, } from "./openai-responses-prompt-cache.js";
 import { convertResponsesMessages, convertResponsesTools, processResponsesStream, resolveResponsesDeferredToolsMode, resolveResponsesToolPlacement, } from "./openai-responses-shared.js";
 import { buildBaseOptions, clampMaxForOpenAI, OPENAI_RESPONSES_RESERVED_BODY_KEYS } from "./simple-options.js";
@@ -70,7 +72,7 @@ function getCompat(model, env) {
         supportsConfigurationUpdate: model.compat?.supportsConfigurationUpdate ?? false,
         supportsMaxOutputTokens: model.compat?.supportsMaxOutputTokens ?? true,
         supportsForcedToolChoice: model.compat?.supportsForcedToolChoice ?? true,
-        supportsAllowedTools: model.compat?.supportsAllowedTools ?? false,
+        supportsAllowedTools: supportsAllowedToolChoice(model),
     };
 }
 function isOpenAIResponsesNativeEndpoint(model, env) {
@@ -141,53 +143,6 @@ function sanitizeUnsupportedNativeTools(params, compat) {
     }
     return sanitized ? sanitized : params;
 }
-function allowedReference(tool) {
-    if (tool.type === "function" || tool.type === "custom")
-        return { type: tool.type, name: tool.name };
-    if (tool.type === "mcp")
-        return { type: "mcp", server_label: tool.server_label };
-    return { type: tool.type };
-}
-/**
- * senpi#2095: `tools` carries every tool declared this session, so removing a tool never rewrites the
- * cached prefix; the callable subset rides `tool_choice: allowed_tools` instead. Hosted tools a payload
- * hook added stay callable, and deferred tools (declared by transcript items rather than `tools`) are
- * referenced by name. A declared tool a payload hook removed from `tools` is not referenced (senpi#2234).
- * An empty subset forbids tool calls. An explicit `tool_choice` always wins.
- */
-function applyAllowedToolsChoice(params, context, activeToolNames, compat) {
-    if (!compat.supportsAllowedTools || activeToolNames === undefined || params.tool_choice !== undefined) {
-        return params;
-    }
-    const active = new Set(activeToolNames);
-    const declaredTools = getCurrentTools(context.messages);
-    if (declaredTools.every((tool) => active.has(tool.name)))
-        return params;
-    const allowed = [];
-    const namedInTools = new Set();
-    for (const tool of params.tools ?? []) {
-        if (tool.type === "function" || tool.type === "custom") {
-            namedInTools.add(tool.name);
-            if (!active.has(tool.name))
-                continue;
-        }
-        allowed.push(allowedReference(tool));
-    }
-    // Tools missing from the request-level `tools` placement are the ones transcript items load in place.
-    const requestToolNames = new Set(resolveResponsesToolPlacement(context.messages, resolveResponsesDeferredToolsMode(compat) !== undefined).requestTools.map((tool) => tool.name));
-    for (const tool of declaredTools) {
-        if (namedInTools.has(tool.name) || !active.has(tool.name) || requestToolNames.has(tool.name))
-            continue;
-        const [converted] = convertResponsesTools([tool], {
-            supportsStrictMode: compat.supportsStrictMode,
-            supportsOpenAIGrammarTools: compat.supportsOpenAIGrammarTools,
-        });
-        if (converted)
-            allowed.push(allowedReference(converted));
-    }
-    const toolChoice = allowed.length > 0 ? { type: "allowed_tools", mode: "auto", tools: allowed } : "none";
-    return { ...params, tool_choice: toolChoice };
-}
 function formatOpenAIResponsesError(error, provider) {
     const errorMessage = formatProviderError(normalizeProviderError(error), `${provider === "openai" ? "OpenAI" : provider} API error`);
     // Sign in with ChatGPT shares the subscription's usage limit with other apps.
@@ -234,12 +189,15 @@ export const stream = (model, context, options) => {
             }
             params = sanitizeUnsupportedNativeTools(params, compat);
             params = applyAllowedToolsChoice(params, normalizedContext, context.activeToolNames, compat);
+            if (hasRefusedAllowedToolsChoice(model))
+                params = restrictToAllowedTools(params);
             const limitedTools = limitGitHubCopilotTools(model.provider, params.tools, params.tool_choice);
             if (limitedTools.omittedCount > 0) {
                 params = { ...params, tools: limitedTools.tools };
                 recordGitHubCopilotToolLimit(output, limitedTools.omittedCount);
             }
             const transport = options?.transport ?? "sse";
+            let refusedAllowedToolsOverWebSocket = false;
             if (transport !== "sse" && compat.supportsWebSocket) {
                 let websocketStarted = false;
                 try {
@@ -254,9 +212,16 @@ export const stream = (model, context, options) => {
                     return;
                 }
                 catch (error) {
-                    if (transport === "websocket" || websocketStarted) {
+                    const refusedAllowedTools = output.content.length === 0 && isAllowedToolsChoiceRefusal(error, params, { beforeContent: true });
+                    if (!refusedAllowedTools && (transport === "websocket" || websocketStarted)) {
                         throw error;
                     }
+                    if (refusedAllowedTools) {
+                        params = restrictToAllowedTools(params);
+                        refusedAllowedToolsOverWebSocket = true;
+                        output.stopReason = "pending";
+                        delete output.errorMessage;
+                    }
                 }
             }
             const requestOptions = {
@@ -264,26 +229,46 @@ export const stream = (model, context, options) => {
                 ...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
                 maxRetries: 0,
             };
-            const createRequest = async () => {
+            const sendOnce = async (body) => {
                 const sent = await sendWithForcedToolChoiceFallback({
                     target: model,
-                    params,
+                    params: body,
                     acceptsForcedToolChoice: compat.supportsForcedToolChoice,
                     isForced: isForcedOpenAIResponsesToolChoice,
-                    send: (body) => model.provider === "github-copilot"
-                        ? awaitProviderTransport(() => client.responses.create(body, requestOptions).withResponse(), openAICompatibleProviderDiagnosticFromError)
-                        : client.responses.create(body, requestOptions).withResponse(),
+                    send: (request) => model.provider === "github-copilot"
+                        ? awaitProviderTransport(() => client.responses.create(request, requestOptions).withResponse(), openAICompatibleProviderDiagnosticFromError)
+                        : client.responses.create(request, requestOptions).withResponse(),
                 });
                 params = sent.params;
                 return sent.result;
             };
+            // senpi#3080: an endpoint that refuses `allowed_tools` gets the request restricted to the active
+            // tools; the model is remembered once that restricted request is accepted.
+            const createRequest = async () => {
+                try {
+                    const result = await sendOnce(params);
+                    if (refusedAllowedToolsOverWebSocket)
+                        rememberAllowedToolsChoiceRefusal(model);
+                    return result;
+                }
+                catch (error) {
+                    if (!isAllowedToolsChoiceRefusal(error, params))
+                        throw error;
+                    params = restrictToAllowedTools(params);
+                    const result = await sendOnce(params);
+                    rememberAllowedToolsChoiceRefusal(model);
+                    return result;
+                }
+            };
             const { data: openaiStream, response } = await retryProviderRequest(() => createRequest(), {
                 maxRetries: options?.maxRetries,
                 maxRetryDelayMs: options?.maxRetryDelayMs,
                 signal: options?.signal,
             });
             await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
-            stream.push({ type: "start", partial: output });
+            // A WebSocket attempt that fell through after its refusal already pushed `start`.
+            if (!refusedAllowedToolsOverWebSocket)
+                stream.push({ type: "start", partial: output });
             await processResponsesStream(openaiStream, output, stream, model, {
                 onProviderStreamEvent: options?.onProviderStreamEvent,
                 serviceTier: options?.serviceTier,
@@ -861,9 +846,9 @@ function buildWebSocketHeaders(model, context, apiKey, optionsHeaders, sessionId
 function getServiceTierCostMultiplier(model, serviceTier) {
     switch (serviceTier) {
         case "ultrafast":
-            // OpenAI publishes an Ultrafast price for GPT-6 Astra only: 6x Standard on every
+            // OpenAI prices GPT-6 Astra and GPT-6.1 Sol Ultrafast at 6x Standard on every
             // token class and context tier. Any other model keeps its base rate.
-            return model.id === "gpt-6-astra" ? 6 : 1;
+            return ["gpt-6-astra", "gpt-6.1-sol"].includes(model.upstreamModelId ?? model.id) ? 6 : 1;
         case "flex":
             return 0.5;
         case "priority":

package/dist/openai-responses-compat.d.ts

@@ -42,10 +42,15 @@ export interface OpenAIResponsesCompat {
      * Whether the model accepts `tool_choice: { type: "allowed_tools" }`. When set, callers keep every
      * declared tool in `tools` and restrict the callable subset through `Context.activeToolNames`, so a
      * shrinking tool set does not rewrite the cached prompt prefix. Honored by the `openai-responses`
-     * adapter. Default: false.
+     * adapter, and only on the native OpenAI API hosts (`api.openai.com` and its regional `*.api.openai.com`
+     * hosts): Responses-compatible gateways reject the choice (senpi#3080), and since a provider `baseUrl`
+     * override keeps the catalog compat, the flag cannot opt a gateway in. Default: false.
      */
     supportsAllowedTools?: boolean;
 }
-/** Whether a model's compat declares `allowed_tools` support (see {@link OpenAIResponsesCompat.supportsAllowedTools}). */
+/**
+ * Whether requests to `model` restrict tools through `allowed_tools`: its compat declares support and it is
+ * served by the native OpenAI endpoint (see {@link OpenAIResponsesCompat.supportsAllowedTools}).
+ */
 export declare function supportsAllowedToolChoice(model: Model<Api>): boolean;
 //# sourceMappingURL=openai-responses-compat.d.ts.map

package/dist/openai-responses-compat.js

@@ -1,5 +1,18 @@
-/** Whether a model's compat declares `allowed_tools` support (see {@link OpenAIResponsesCompat.supportsAllowedTools}). */
+function isNativeOpenAIEndpoint(baseUrl) {
+    try {
+        const { hostname } = new URL(baseUrl || "https://api.openai.com/v1");
+        return hostname === "api.openai.com" || hostname.endsWith(".api.openai.com");
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Whether requests to `model` restrict tools through `allowed_tools`: its compat declares support and it is
+ * served by the native OpenAI endpoint (see {@link OpenAIResponsesCompat.supportsAllowedTools}).
+ */
 export function supportsAllowedToolChoice(model) {
-    return model.compat?.supportsAllowedTools === true;
+    return (model.compat?.supportsAllowedTools === true &&
+        isNativeOpenAIEndpoint(model.baseUrl));
 }
 //# sourceMappingURL=openai-responses-compat.js.map

package/dist/providers/data/.manifest.json

@@ -1 +1 @@
-{"schemaVersion":6,"generatedAt":"2026-10-08T17:53:41.797Z","structureHash":"c8caaf99abdf138011f2a2f12a89c7d833e523410ec5453cb90fd46a49088f5d","files":{"alibaba-token-plan.json":"16b3c6c78d72c73ca34a1e79ce71c0cf36ba409d02e83a17396ce0949a1d5363","amazon-bedrock.json":"4a95e6bf974e5ca967d5c050df580262e13573e42b3186edb448fa11a302f09f","ant-ling.json":"628feab3ef6c7d80ce96f75999804e1d9f05fec3851e5302e30fff3b69db90f6","anthropic.json":"111384e9f5845e0247bd34edf2400ef7720fcbdac140b944cf8878192d8bd6ab","azure-openai-responses.json":"a3e52bd78f0220aa32bce519e13955b8e6e567860416343844cbe19902f4a682","bai.json":"7e6861aaf27d8af34e1771c6092602194fcec0a0046e6adfab9c3ee54d32b99f","baseten.json":"b04d1423d6958bec857ffccc36726f091ec1a8f3a09cf0836b64cc94b0ee697d","cerebras.json":"3eccb58c5de3d0dc7ba49dc6e477ba29f00cb3150ce0a35cc90d59e6b5ab368e","chatgpt-subscription.json":"08f365952647594f5b07337666255f8510ef2e09bfb704530843b63121ed07f4","cloudflare-ai-gateway.json":"632b9e96edfabe0f0da4a8fcc09ba951f6bbc8878a2262aebe56d10b2b4fd699","cloudflare-workers-ai.json":"4bf0b488460c2e6cb8a6615bb2f87ca2a31cd9597eb249d5b58cba251330a99a","deepseek.json":"10a296fb3e898f7715c80890c8af0af4f5fd58f22dbcd6612fdc5d762157ccdc","fireworks.json":"c3dc21dc2e95428fc9a38e3840c05bbf90f94e4c25dee0eedf0b385b49ff65a4","github-copilot.json":"2c5a84983477a7c4f6c001088a1e043ee959ce58c99fea6eb843e0286228664b","google-vertex.json":"40090c680538bc867f2624d986a449f361be4dfa6ba96d7a27402050f036e009","google.json":"c0f5a633e5e5a5044432db3e537f4bc674d4de18df09325c6349547fcc13cabe","groq.json":"910952ad9dad07856983459d63fce0148dba1203edd7b10d801a77c5824f3405","huggingface.json":"1b8604bd31a5e05fe43a40ec1ec6dfc1a51a28b0b020151ef057fab43f57c923","meta.json":"0c7e9a370a7005c5a89dc94f0f93bc67b8935c3f802de324f11af6ff56fff429","minimax-cn.json":"f962c20ee6a6a342820f778e9dc363a18a524bf11998f6e2c57f2989915d62e5","minimax.json":"17a432f80d0ea6dd26eade80a4314250d3a855678601728a5f70dd8fa0d21dd2","mistral.json":"27aa66c71a0504b53dc87ec194286fa7e70b99747fc8df9b709b23b3548afe50","moonshotai-cn.json":"18954b55dc5edecc174d8a07a2c5993416dd9d3ce52e411438035c16ee982e8e","moonshotai.json":"62d08fd5beead025a56d5f2e4227d8516b9c5034275b1b36d761a8625918f2b9","nvidia.json":"a75e963dc81779e3eec01c051b12277c15ec37c5b94ab51ece9e9ccb3b16407c","openai.json":"9104538118053eed57f90852332b6ad274a4e4792389bdbc9cfca1ae400c705a","opencode-go.json":"48ff011f3e171f977cfed2928272667e9361f13a508e5994f00f2241f6a23419","opencode.json":"882b039f64ef266da7b02d30aee9255c191e16f0600ef5494022bc1ef746f749","opengateway.json":"fdb64c9a0906febf3a5164d43be20b901f73fd11f5c8cb5b86823c41a6e073e2","openrouter.json":"6d07953963656513f2e75a99b1c6dd93bfb6094cbf5f4c7498c56a97e911178d","qwen-token-plan-cn.json":"bd36a6d9cc2048deafacc85f7f0f2e51868c8b7aa09502e3e4e60e3e8b76f690","qwen-token-plan-individual.json":"35ffb0ba1a1ce3f68fc73262dd5e07fbcb5bf5911ad1e6e17bc0621e2894676a","qwen-token-plan.json":"ca27e49e62965221badead8e867b2007035c6b6a15a97c47219bd23d2c83c2b1","radius.json":"8214122385e8e4c4bc2e1d2a7d032f9e4c654da3bfd3ac8c5d4396e1b522e53a","together.json":"bbd7fad86cacfefe3d3d61f6638f22e9b6f5d575722fd1112a16aafe0485c46d","typesafe.json":"a4429a2f696d5cc5273969af61a7310bda07d6bdcd27bf9ac9c76c534cc43716","venice.json":"ab4e80fb489d2baa1afa053f88eb58d1fd32ba8992fa13d2d70ddd94446f7243","vercel-ai-gateway.json":"e0336a908a63cf808bffd27e8355cf13ce4e31fcd9699d6ecd19d84439028cac","xai.json":"d7771a1450b21c1f6aee887ca6fea61b6e7b3fc13b4dee5cf72a71134fe623bc","xiaomi-token-plan-ams.json":"4dd8f838e21d7aa7caf3122d0b0b1e5a02a33bc012b96e6a75bd119334152d7a","xiaomi-token-plan-cn.json":"46414ff49973b95a0c14bd33e8992cc1938a50ce2c7cea9e2e5cc02de8f1df31","xiaomi-token-plan-sgp.json":"f5b3f66bf7bb7238592d4a9667cad983a008d7539a66e9896b02422622800935","xiaomi.json":"8b62c158d55d5a165f35cd72c1fc82ab89ff8e73f08960105fc41b822f236f69","zai-coding-cn.json":"2a7f59d15f588a97d218997883f2506dfc52d3ee320697d39f14213a050fc912","zai.json":"e9cc408e1756de8abc70148d63d89d11a63c65b7ef06ad0661cd1328e4209ba3"}}
+{"schemaVersion":6,"generatedAt":"2026-10-11T10:01:11.497Z","structureHash":"0989a1c88b40439cecf9d8a82fe466628aa29d2c7cc597ed79540d082d7890d6","files":{"alibaba-token-plan.json":"16b3c6c78d72c73ca34a1e79ce71c0cf36ba409d02e83a17396ce0949a1d5363","amazon-bedrock.json":"4a95e6bf974e5ca967d5c050df580262e13573e42b3186edb448fa11a302f09f","ant-ling.json":"628feab3ef6c7d80ce96f75999804e1d9f05fec3851e5302e30fff3b69db90f6","anthropic.json":"111384e9f5845e0247bd34edf2400ef7720fcbdac140b944cf8878192d8bd6ab","azure-openai-responses.json":"a3e52bd78f0220aa32bce519e13955b8e6e567860416343844cbe19902f4a682","bai.json":"7e6861aaf27d8af34e1771c6092602194fcec0a0046e6adfab9c3ee54d32b99f","baseten.json":"1fcdab8daf2881bd099eb08f9416f7df5bf39975937d2a63b841542bd032f2e6","cerebras.json":"3eccb58c5de3d0dc7ba49dc6e477ba29f00cb3150ce0a35cc90d59e6b5ab368e","chatgpt-subscription.json":"2fbeb0141b29c340542798bce53422b93bef026a13420986e87fca89353e0aa2","cloudflare-ai-gateway.json":"5c8782fdbf2477f620b238da4344b0bcc0948b8c177461e63e7e5ba256f769c7","cloudflare-workers-ai.json":"f351e80493dea7b7a2c31dceb086ee804a88d67c5f8a3c823ea907991fe5d659","deepseek.json":"10a296fb3e898f7715c80890c8af0af4f5fd58f22dbcd6612fdc5d762157ccdc","fireworks.json":"c3dc21dc2e95428fc9a38e3840c05bbf90f94e4c25dee0eedf0b385b49ff65a4","github-copilot.json":"2c5a84983477a7c4f6c001088a1e043ee959ce58c99fea6eb843e0286228664b","google-vertex.json":"96ecc19bf20a706f99ae658b021a0ee5438146119e1e99de5fd824a01fcfd81b","google.json":"c0f5a633e5e5a5044432db3e537f4bc674d4de18df09325c6349547fcc13cabe","groq.json":"910952ad9dad07856983459d63fce0148dba1203edd7b10d801a77c5824f3405","huggingface.json":"6399e958790a9d90c21fb55d1cbef8569427a1ceb28de86dadeb3b4454ecfade","meta.json":"0c7e9a370a7005c5a89dc94f0f93bc67b8935c3f802de324f11af6ff56fff429","minimax-cn.json":"f962c20ee6a6a342820f778e9dc363a18a524bf11998f6e2c57f2989915d62e5","minimax.json":"17a432f80d0ea6dd26eade80a4314250d3a855678601728a5f70dd8fa0d21dd2","mistral.json":"27aa66c71a0504b53dc87ec194286fa7e70b99747fc8df9b709b23b3548afe50","moonshotai-cn.json":"18954b55dc5edecc174d8a07a2c5993416dd9d3ce52e411438035c16ee982e8e","moonshotai.json":"62d08fd5beead025a56d5f2e4227d8516b9c5034275b1b36d761a8625918f2b9","nvidia.json":"a75e963dc81779e3eec01c051b12277c15ec37c5b94ab51ece9e9ccb3b16407c","openai.json":"9104538118053eed57f90852332b6ad274a4e4792389bdbc9cfca1ae400c705a","opencode-go.json":"48ff011f3e171f977cfed2928272667e9361f13a508e5994f00f2241f6a23419","opencode.json":"882b039f64ef266da7b02d30aee9255c191e16f0600ef5494022bc1ef746f749","opengateway.json":"dd4259885ea6045d723b3abaae06657dfcce07b9ce3c2b0300220ac661432859","openrouter.json":"9484c1583eb1d419e89ffe258cd4efb7bb793666ae09c94db545f400fe0d628e","qwen-token-plan-cn.json":"bd36a6d9cc2048deafacc85f7f0f2e51868c8b7aa09502e3e4e60e3e8b76f690","qwen-token-plan-individual.json":"35ffb0ba1a1ce3f68fc73262dd5e07fbcb5bf5911ad1e6e17bc0621e2894676a","qwen-token-plan.json":"ca27e49e62965221badead8e867b2007035c6b6a15a97c47219bd23d2c83c2b1","radius.json":"8214122385e8e4c4bc2e1d2a7d032f9e4c654da3bfd3ac8c5d4396e1b522e53a","together.json":"bbd7fad86cacfefe3d3d61f6638f22e9b6f5d575722fd1112a16aafe0485c46d","typesafe.json":"a4429a2f696d5cc5273969af61a7310bda07d6bdcd27bf9ac9c76c534cc43716","venice.json":"3604c88c46dd3e4151b833927c6f87bcc165d0999a4339b32db2ad74a9ff173f","vercel-ai-gateway.json":"9859481f690a9a9a8131af3abfadf5378b2d1ef51990041da4465de3f1e4ab78","xai.json":"d7771a1450b21c1f6aee887ca6fea61b6e7b3fc13b4dee5cf72a71134fe623bc","xiaomi-token-plan-ams.json":"4dd8f838e21d7aa7caf3122d0b0b1e5a02a33bc012b96e6a75bd119334152d7a","xiaomi-token-plan-cn.json":"46414ff49973b95a0c14bd33e8992cc1938a50ce2c7cea9e2e5cc02de8f1df31","xiaomi-token-plan-sgp.json":"f5b3f66bf7bb7238592d4a9667cad983a008d7539a66e9896b02422622800935","xiaomi.json":"8b62c158d55d5a165f35cd72c1fc82ab89ff8e73f08960105fc41b822f236f69","zai-coding-cn.json":"2a7f59d15f588a97d218997883f2506dfc52d3ee320697d39f14213a050fc912","zai.json":"e9cc408e1756de8abc70148d63d89d11a63c65b7ef06ad0661cd1328e4209ba3"}}