@code-yeongyu/senpi-ai 2026.10.10 → 2026.10.11

package/dist/api/anthropic-messages.js

@@ -71,7 +71,7 @@ function getCacheControl(model, cacheRetention, env) {
 // The bundled Claude Code version and the floor of the advertised `claude-cli/<version>`
 // (see utils/claude-code-version.ts). Keep this exact declaration: a downstream installer
 // (oh-my-openagent) rewrites it byte-for-byte in the installed dist and bundle.
-const claudeCodeVersion = "2.1.289";
+const claudeCodeVersion = "2.1.292";
 // Claude Code 2.x tool names (canonical casing)
 // Source: https://cchistory.mariozechner.at/data/prompts-2.1.11.md
 // To update: https://github.com/badlogic/cchistory
@@ -164,6 +164,7 @@ const ADAPTIVE_THINKING_MODEL_MARKERS = [
     "opus-5",
     "sonnet-4-6",
     "sonnet-5",
+    "haiku-5-5",
     "fable-5",
     "mythos-5",
 ];
@@ -176,14 +177,20 @@ const NATIVE_XHIGH_EFFORT_MODEL_MARKERS = [
     "opus-4-8",
     "opus-5",
     "sonnet-5",
+    "haiku-5-5",
     "fable-5",
     "mythos-5",
 ];
 /**
- * Adaptive families that reject `thinking: {type: "disabled"}` outright (verified 400:
- * `"thinking.type.disabled" is not supported for this model`). The generated catalog also encodes
- * this as `compat.supportsDisabledThinking: false`, but `models.json` entries and third-party
- * gateway rows carry no generated compat, so the family fact has to live here as well.
+ * Families senpi never sends `thinking: {type: "disabled"}` to. Fable 5, Opus 5.5 and Sonnet 5.5 reject it
+ * outright (verified live 400: `"thinking.type.disabled" is not supported for this model`); Mythos 5 is
+ * listed by family with Fable. Claude Haiku 5.5 is listed by choice, not because it rejects `disabled`: its
+ * effort docs accept `disabled` at effort `high` or below (400 only at `xhigh` / `max`) and reject a
+ * differing per-message effort while disabled, so a real thinking-off needs marker handling first
+ * (senpi#2927). Until then a thinking-off turn sends no `thinking` and effort `low`, which is valid on all of
+ * them. The generated catalog also encodes this as `compat.supportsDisabledThinking: false`, but
+ * `models.json` entries and third-party gateway rows carry no generated compat, so the family fact has to
+ * live here as well.
  */
 const DISABLED_THINKING_REJECTING_MODEL_MARKERS = [
     "fable-5",
@@ -192,6 +199,8 @@ const DISABLED_THINKING_REJECTING_MODEL_MARKERS = [
     "opus-5.5",
     "sonnet-5-5",
     "sonnet-5.5",
+    "haiku-5-5",
+    "haiku-5.5",
 ];
 const UNSUPPORTED_NATIVE_COMPUTER_TOOL_MODEL_MARKERS = [
     "opus-4-6",
@@ -922,7 +931,7 @@ export const stream = (model, context, options) => {
     const normalizedContext = resolveTranscript(context, supportsMidConvoSystemMessages(model));
     const currentTools = getCurrentTools(normalizedContext.messages);
     (async () => {
-        const providerThinkingLevel = model.compat?.supportsMidConvoEffort ? (options?.effort ?? "high") : undefined;
+        const providerThinkingLevel = managedEffortForRequest(model, options);
         const output = {
             role: "assistant",
             content: [],
@@ -972,7 +981,7 @@ export const stream = (model, context, options) => {
                 const cacheRetention = resolveCacheRetention(options?.cacheRetention ?? model.cacheRetention, options?.env, "short");
                 const cacheSessionId = cacheRetention === "none" ? undefined : options?.sessionId;
                 openClient = () => {
-                    const created = createClient(model, apiKey, options?.interleavedThinking ?? true, shouldUseFineGrainedToolStreamingBeta(model, normalizedContext), options?.refusalFallbacks !== undefined, optionsHeaders, options?.fetch, copilotDynamicHeaders, cacheSessionId, options?.env, federation);
+                    const created = createClient(model, apiKey, options?.interleavedThinking ?? true, shouldUseFineGrainedToolStreamingBeta(model, normalizedContext), options?.refusalFallbacks !== undefined && configuredBetaHeader(model, options) !== null, optionsHeaders, options?.fetch, copilotDynamicHeaders, cacheSessionId, options?.env, federation);
                     client = created.client;
                     isOAuth = created.isOAuthToken;
                     advertisedClaudeCodeVersion = created.claudeCodeVersion;
@@ -1459,6 +1468,25 @@ function cannotDisableThinking(model, compat) {
         return true;
     return matchesModelMarker(model, DISABLED_THINKING_REJECTING_MODEL_MARKERS);
 }
+/**
+ * Effort a per-message-effort request runs at, which is also the active marker and the level recorded
+ * on the reply: the caller's effort with thinking on, `low` for a thinking-off turn on a family that
+ * cannot disable thinking, and none when thinking is actually disabled (senpi#2912).
+ */
+function managedEffortForRequest(model, options) {
+    if (model.compat?.supportsMidConvoEffort !== true)
+        return undefined;
+    if (options?.thinkingEnabled === false) {
+        return cannotDisableThinking(model, getAnthropicCompat(model)) ? "low" : undefined;
+    }
+    return options?.effort ?? "high";
+}
+function isEffortMarker(message) {
+    return (message.role === "system" &&
+        Array.isArray(message.content) &&
+        message.content.length === 0 &&
+        message.output_config?.effort !== undefined);
+}
 function disableThinkingForRequest(params, model, compat) {
     // A degraded/disabled turn must not retain the caller's higher effort.
     delete params.output_config;
@@ -1470,6 +1498,8 @@ function disableThinkingForRequest(params, model, compat) {
         return;
     }
     params.thinking = { type: "disabled" };
+    // Per-message effort is rejected alongside disabled thinking (senpi#1399).
+    params.messages = params.messages.filter((message) => !isEffortMarker(message));
 }
 function supportsAdaptiveThinking(model) {
     if (model.compat?.forceAdaptiveThinking !== undefined) {
@@ -1665,27 +1695,46 @@ export function buildAnthropicWarmPromptCacheParams(model, context, options) {
         max_tokens: 0,
     });
 }
-function getBetaFeatures(model, context, isOAuthToken, nativeToolChanges, options) {
-    let configuredFeatures;
+function configuredBetaHeader(model, options) {
+    let configured;
     for (const headers of [model.headers, options?.headers]) {
         for (const [name, value] of Object.entries(headers ?? {})) {
             if (name.toLowerCase() === "anthropic-beta")
-                configuredFeatures = value;
+                configured = value;
         }
     }
-    if (configuredFeatures === null)
+    return configured;
+}
+function getBetaFeatures(model, context, isOAuthToken, shape, options) {
+    const configured = configuredBetaHeader(model, options);
+    if (configured === null)
         return [];
-    if (configuredFeatures !== undefined) {
-        return [
-            ...new Set(configuredFeatures
-                .split(",")
-                .map((feature) => feature.trim())
-                .filter(Boolean)),
-        ];
-    }
-    const features = [];
+    // Betas the request body depends on: the API rejects the request without them.
+    const required = [];
     if (isOAuthToken)
-        features.push("claude-code-20250219", "oauth-2025-04-20");
+        required.push("claude-code-20250219", "oauth-2025-04-20");
+    if (shape.midConvoEffort)
+        required.push(MID_CONVERSATION_OUTPUT_CONFIG_BETA);
+    if (shape.thinkingBinding)
+        required.push(THINKING_BINDING_CONTROLS_BETA);
+    if (shape.nativeToolChanges)
+        required.push(MID_CONVERSATION_TOOL_CHANGES_BETA);
+    if (shape.refusalFallbacks)
+        required.push(SERVER_SIDE_FALLBACK_BETA);
+    // A configured header owns the optional betas and is merged with the required ones, never replacing them: a
+    // proxy route's own header used to drop the effort beta, and Claude 5.5 models then 400ed (senpi#2957).
+    // Interleaved thinking is stripped on adaptive models here too, as it is from the client headers.
+    const optional = configured === undefined
+        ? defaultOptionalBetas(model, context, options)
+        : configured
+            .split(",")
+            .map((feature) => feature.trim())
+            .filter(Boolean)
+            .filter((feature) => !(feature === INTERLEAVED_THINKING_BETA && supportsAdaptiveThinking(model)));
+    return [...new Set([...optional, ...required])];
+}
+function defaultOptionalBetas(model, context, options) {
+    const features = [];
     if (shouldUseFineGrainedToolStreamingBeta(model, context))
         features.push(FINE_GRAINED_TOOL_STREAMING_BETA);
     if (model.reasoning &&
@@ -1696,12 +1745,7 @@ function getBetaFeatures(model, context, isOAuthToken, nativeToolChanges, option
     }
     if (shouldUseServerSideFallbackBeta(model))
         features.push(SERVER_SIDE_FALLBACK_BETA);
-    if (model.compat?.supportsMidConvoEffort === true) {
-        features.push(MID_CONVERSATION_OUTPUT_CONFIG_BETA, THINKING_BINDING_CONTROLS_BETA);
-    }
-    if (nativeToolChanges)
-        features.push(MID_CONVERSATION_TOOL_CHANGES_BETA);
-    return [...new Set(features)];
+    return features;
 }
 function buildParams(model, context, isOAuthToken, options, unsignedThinkingReplay = getAnthropicCompat(model).unsignedThinkingReplay) {
     const compat = getAnthropicCompat(model);
@@ -1718,7 +1762,16 @@ function buildParams(model, context, isOAuthToken, options, unsignedThinkingRepl
     // and Anthropic rejects a tool list where every tool is deferred, so there must be an
     // initial active tool to anchor the deferred ones. Otherwise the current tool list is sent.
     const initialTools = initialSystemMessage?.toolsAdded ?? [];
-    const nativeToolChanges = supportsMidConvoSystemMessages(model) &&
+    // A configured `anthropic-beta: null` asks for no betas at all, so the request takes a shape that needs none:
+    // the current tool list instead of native tool changes, top-level effort instead of per-message markers, and
+    // no server-side fallbacks (senpi#2957). OAuth still needs its identity betas; getBetaFeatures names them.
+    const betasSuppressed = configuredBetaHeader(model, options) === null;
+    if (betasSuppressed && isOAuthToken) {
+        throw new Error(`The anthropic-beta header is set to null, but ${model.provider}/${model.id} is called with an OAuth token, which needs the claude-code-20250219 and oauth-2025-04-20 betas. Remove the null, or list the betas you want instead; senpi adds the ones a request needs.`);
+    }
+    const midConvoEffort = model.compat?.supportsMidConvoEffort === true && !betasSuppressed;
+    const nativeToolChanges = !betasSuppressed &&
+        supportsMidConvoSystemMessages(model) &&
         supportsMidConvoToolChanges(model) &&
         initialTools.length > 0 &&
         !hasToolRedefinitions(context.messages);
@@ -1741,15 +1794,21 @@ function buildParams(model, context, isOAuthToken, options, unsignedThinkingRepl
         deferredTools = [];
     }
     const deferredToolNames = new Set(deferredTools.map((tool) => normalizeToolName(tool.name)));
-    const activeEffort = options?.effort ?? "high";
-    const betaFeatures = getBetaFeatures(model, context, isOAuthToken, nativeToolChanges, options);
-    const convertedMessages = convertMessages(conversationMessages, model, isOAuthToken, cacheControl, unsignedThinkingReplay, deferredToolNames, normalizeToolName, model.compat?.supportsMidConvoEffort === true ? model.provider : undefined, nativeToolChanges);
-    const messages = model.compat?.supportsMidConvoEffort === true
+    const activeEffort = managedEffortForRequest(model, options) ?? "high";
+    const sendFallbacks = options?.refusalFallbacks !== undefined && !betasSuppressed;
+    const betaFeatures = getBetaFeatures(model, context, isOAuthToken, {
+        midConvoEffort,
+        thinkingBinding: midConvoEffort && options?.thinkingEnabled !== false,
+        nativeToolChanges,
+        refusalFallbacks: sendFallbacks,
+    }, options);
+    const convertedMessages = convertMessages(conversationMessages, model, isOAuthToken, cacheControl, unsignedThinkingReplay, deferredToolNames, normalizeToolName, midConvoEffort ? model.provider : undefined, nativeToolChanges);
+    const messages = midConvoEffort
         ? insertThinkingLevelMessages(convertedMessages, activeEffort)
         : convertedMessages.messages;
     // Effort markers are appended after history; re-run the fork's final-user cache checkpoint
     // against the actual last user/tool-result message so the marker cannot displace cache_control.
-    if (model.compat?.supportsMidConvoEffort === true && cacheControl) {
+    if (midConvoEffort && cacheControl) {
         for (let index = messages.length - 1; index >= 0; index--) {
             const message = messages[index];
             // A native system update after the last turn already holds the checkpoint;
@@ -1826,9 +1885,10 @@ function buildParams(model, context, isOAuthToken, options, unsignedThinkingRepl
         ];
     }
     // Managed effort models always use adaptive thinking so prefix mismatches can
-    // be dropped instead of surfacing as persistent 400 responses. Thinking-off is
-    // handled before this managed branch because these models accept `disabled`.
-    if (model.compat?.supportsMidConvoEffort === true && options?.thinkingEnabled !== false) {
+    // be dropped instead of surfacing as persistent 400 responses. A thinking-off turn
+    // skips this branch: `disableThinkingForRequest` sends `disabled` where the family
+    // accepts it and pins effort `low` where it does not (Opus/Sonnet/Haiku 5.5, Fable, Mythos).
+    if (midConvoEffort && options?.thinkingEnabled !== false) {
         params.thinking = {
             type: "adaptive",
             display: options?.thinkingDisplay ?? "summarized",
@@ -1897,7 +1957,7 @@ function buildParams(model, context, isOAuthToken, options, unsignedThinkingRepl
         }
     }
     applyExtraBodyToAnthropicParams(params, options?.extraBody);
-    if (options?.refusalFallbacks !== undefined) {
+    if (sendFallbacks && options?.refusalFallbacks !== undefined) {
         // AnthropicRefusalFallback models a readonly list; the SDK's BetaFallbacksParam
         // is mutable, so copy rather than widen the fork's public type.
         params.fallbacks = options.refusalFallbacks === "default" ? "default" : [...options.refusalFallbacks];
@@ -2070,7 +2130,6 @@ function convertMessages(transformedMessages, model, isOAuthToken, cacheControl,
             }
         }
         else if (msg.role === "assistant") {
-            flushPendingSystemMessages();
             const blocks = [];
             const isSameModel = isSameAnthropicModel(msg, model);
             // Blocks before the final fallback marker are the declined attempt; the
@@ -2156,8 +2215,12 @@ function convertMessages(transformedMessages, model, isOAuthToken, cacheControl,
                     }
                 }
             }
+            // Pending system messages are emitted only in front of an assistant param that is actually sent: a reply
+            // that converts to no blocks is skipped, and flushing for it would leave a `system` param directly before
+            // the next `user` turn, which Anthropic rejects on every later request (senpi#2864).
             if (blocks.length === 0)
                 continue;
+            flushPendingSystemMessages();
             const messageIndex = params.length;
             params.push({
                 role: "assistant",

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

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

package/dist/api/bedrock-converse-stream.js

@@ -590,6 +590,7 @@ function supportsAdaptiveThinking(modelId, modelName) {
         s.includes("opus-5") ||
         s.includes("sonnet-4-6") ||
         s.includes("sonnet-5") ||
+        s.includes("haiku-5-5") ||
         s.includes("fable-5") ||
         s.includes("mythos-5"));
 }
@@ -599,6 +600,7 @@ function supportsNativeXhighEffort(model) {
         s.includes("opus-4-8") ||
         s.includes("opus-5") ||
         s.includes("sonnet-5") ||
+        s.includes("haiku-5-5") ||
         s.includes("fable-5") ||
         s.includes("mythos-5"));
 }
@@ -616,7 +618,9 @@ function rejectsDisabledThinking(model) {
         s.includes("opus-5-5") ||
         s.includes("opus-5.5") ||
         s.includes("sonnet-5-5") ||
-        s.includes("sonnet-5.5"));
+        s.includes("sonnet-5.5") ||
+        s.includes("haiku-5-5") ||
+        s.includes("haiku-5.5"));
 }
 function mapThinkingLevelToEffort(model, level) {
     if (level === "xhigh" && supportsNativeXhighEffort(model))

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/lazy.js

@@ -1,5 +1,7 @@
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
+import { isOAuthRefreshUnavailableError } from "../utils/oauth-refresh-error.js";
 import { describeReplacedInstall } from "../utils/provider-failure-description.js";
+import { OAUTH_REFRESH_UNAVAILABLE_DIAGNOSTIC } from "../utils/retry.js";
 function createSetupErrorMessage(model, error) {
     return {
         role: "assistant",
@@ -17,6 +19,17 @@ function createSetupErrorMessage(model, error) {
         },
         stopReason: "error",
         errorMessage: describeReplacedInstall(error) ?? (error instanceof Error ? error.message : String(error)),
+        ...(isOAuthRefreshUnavailableError(error)
+            ? {
+                diagnostics: [
+                    {
+                        type: OAUTH_REFRESH_UNAVAILABLE_DIAGNOSTIC,
+                        timestamp: Date.now(),
+                        details: { provider: model.provider },
+                    },
+                ],
+            }
+            : {}),
         timestamp: Date.now(),
     };
 }

package/dist/api/mistral-conversations.js

@@ -612,6 +612,21 @@ function stripSymbolKeys(value) {
     }
     return value;
 }
+/**
+ * Consecutive user turns become one user message, as the OpenAI Chat converter does for
+ * non-OpenAI endpoints: a word message rebuilt after tool results (senpi#2920) is often followed
+ * by a steer or the next prompt, and Mistral's role-order validation is not documented to accept
+ * two user messages in a row.
+ */
+function appendUserMessage(result, content) {
+    const previous = result[result.length - 1];
+    if (previous?.role !== "user") {
+        result.push({ role: "user", content });
+        return;
+    }
+    const chunks = (value) => typeof value === "string" ? [{ type: "text", text: value }] : (value ?? []);
+    previous.content = [...chunks(previous.content), ...chunks(content)];
+}
 function toChatMessages(messages, supportsImages) {
     const result = [];
     for (const [index, msg] of messages.entries()) {
@@ -625,7 +640,7 @@ function toChatMessages(messages, supportsImages) {
         }
         if (msg.role === "user") {
             if (typeof msg.content === "string") {
-                result.push({ role: "user", content: sanitizeSurrogates(msg.content) });
+                appendUserMessage(result, sanitizeSurrogates(msg.content));
                 continue;
             }
             const hadImages = msg.content.some((item) => item.type === "image");
@@ -637,11 +652,11 @@ function toChatMessages(messages, supportsImages) {
                 return { type: "image_url", imageUrl: `data:${item.mimeType};base64,${item.data}` };
             });
             if (content.length > 0) {
-                result.push({ role: "user", content });
+                appendUserMessage(result, content);
                 continue;
             }
             if (hadImages && !supportsImages) {
-                result.push({ role: "user", content: "(image omitted: model does not support images)" });
+                appendUserMessage(result, "(image omitted: model does not support images)");
             }
             continue;
         }

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":