@juspay/neurolink 9.79.0 → 9.79.2

package/dist/lib/server/routes/claudeProxyRoutes.js

@@ -20,6 +20,7 @@ import { tracers } from "../../telemetry/tracers.js";
 import { withSpan } from "../../telemetry/withSpan.js";
 import { ProxyTracer, recordFallbackAttempt } from "../../proxy/proxyTracer.js";
 import { createRawStreamCapture } from "../../proxy/rawStreamCapture.js";
+import { relocateClientSystemIntoMessages } from "../../proxy/systemRelocation.js";
 import { logBodyCapture, logRequest, logRequestAttempt, logStreamError, } from "../../proxy/requestLogger.js";
 import { createSSEInterceptor } from "../../proxy/sseInterceptor.js";
 import { needsRefresh, persistTokens, refreshToken, } from "../../proxy/tokenRefresh.js";
@@ -332,6 +333,63 @@ async function maybeRefreshClaudeSnapshot(accountLabel, accountKey, headers, bod
     }
     return next;
 }
+/**
+ * Parse response-side details (model, finish reason, invoked tools) from a
+ * non-streaming Anthropic reply so they can be recorded on the trace span.
+ */
+function extractResponseInfo(responseJson) {
+    const info = {};
+    if (!responseJson || typeof responseJson !== "object") {
+        return info;
+    }
+    const r = responseJson;
+    if (typeof r.model === "string") {
+        info.responseModel = r.model;
+    }
+    if (typeof r.stop_reason === "string") {
+        info.finishReason = r.stop_reason;
+    }
+    if (typeof r.stop_sequence === "string") {
+        info.stopSequence = r.stop_sequence;
+    }
+    if (Array.isArray(r.content)) {
+        const toolCalls = r.content
+            .filter((b) => !!b &&
+            typeof b === "object" &&
+            b.type === "tool_use")
+            .map((b) => String(b.name ?? ""))
+            .filter((n) => n.length > 0);
+        if (toolCalls.length > 0) {
+            info.toolCalls = toolCalls;
+        }
+    }
+    return info;
+}
+/**
+ * Build response-info from streaming telemetry (responding model, finish
+ * reason, and the tools the model invoked via tool_use content blocks) so the
+ * streaming path records the same gen_ai.response.* attributes as non-streaming.
+ */
+function responseInfoFromStream(data) {
+    const info = {};
+    if (data.model) {
+        info.responseModel = data.model;
+    }
+    if (data.stopReason) {
+        info.finishReason = data.stopReason;
+    }
+    if (data.stopSequence) {
+        info.stopSequence = data.stopSequence;
+    }
+    const toolCalls = (data.contentBlocks ?? [])
+        .filter((b) => b.type === "tool_use")
+        .map((b) => String(b.toolName ?? ""))
+        .filter((n) => n.length > 0);
+    if (toolCalls.length > 0) {
+        info.toolCalls = toolCalls;
+    }
+    return info;
+}
 /**
  * Polyfill the request body for OAuth accounts.
  * Claude Code injects a billing header, agent block, and metadata.user_id
@@ -350,25 +408,21 @@ function polyfillOAuthBody(bodyStr, accountToken, snapshot, preferredSessionId)
             text: snapshot?.body?.agentBlock ||
                 "You are a Claude agent, built on Anthropic's Claude Agent SDK.",
         };
-        // Normalise system to array and APPEND billing + agent blocks.
-        // IMPORTANT: We append (not prepend) to preserve the client's cache
-        // prefix chain. Anthropic's prompt caching uses prefix matching — if we
-        // insert anything before the client's system blocks, we invalidate all
-        // cached content (tools, system prompt, message history).
+        // Normalise system to an array, then route by client type.
         //
-        // Claude Code sends a billing block with a `cch=<hash>` value that changes
-        // on every request. We fix this by:
-        //   1. Removing the client's billing block from its current position
-        //   2. Stabilizing it while keeping the official Claude Code shape
-        //   3. Appending it at the END so the cacheable system blocks stay
-        //      at the front of the prefix chain
+        // The subscription/OAuth path only accepts a `system` it recognises as the
+        // genuine Claude Code prompt. A real CC client sends its own billing + agent
+        // identity blocks alongside the canonical prompt — we keep those in place and
+        // just stabilise the volatile billing `cch`. A custom client (Curator) sends
+        // its own arbitrary system prompt with NO agent block; left in `system` it is
+        // rejected as `rate_limit_error: "Error"`, so we relocate it into the message
+        // stream and send only the recognised billing + agent blocks as `system`.
         if (parsed.system) {
             if (typeof parsed.system === "string") {
                 parsed.system = [{ type: "text", text: parsed.system }];
             }
             if (Array.isArray(parsed.system)) {
-                // Find and remove existing billing/agent blocks from wherever
-                // the client placed them (typically at system[0])
+                // Find existing billing/agent blocks wherever the client placed them.
                 const billingIdx = parsed.system.findIndex((b) => typeof b.text === "string" &&
                     b.text.includes("x-anthropic-billing-header"));
                 const agentIdx = parsed.system.findIndex((b) => typeof b.text === "string" && b.text.includes("Claude Agent SDK"));
@@ -376,17 +430,29 @@ function polyfillOAuthBody(bodyStr, accountToken, snapshot, preferredSessionId)
                     type: "text",
                     text: buildStableClaudeCodeBillingHeader(parsed.system[billingIdx]?.text ?? snapshot?.body?.billingHeader),
                 };
-                // Remove in reverse index order so indices stay valid
+                // A genuine Claude Code client supplies its own agent-identity block;
+                // a custom client (Curator) does not.
+                const isClaudeCodeClient = agentIdx >= 0;
+                // Strip billing/agent from their positions (reverse order so indices
+                // stay valid). What remains is the client's "extra" system content.
                 const indicesToRemove = [billingIdx, agentIdx]
                     .filter((i) => i >= 0)
                     .sort((a, b) => b - a);
                 for (const idx of indicesToRemove) {
                     parsed.system.splice(idx, 1);
                 }
-                // Always append a deterministic billing block at the end.
-                // If the client sent one, we stripped its dynamic cch= and use
-                // our stable version instead. If not, we add ours.
-                parsed.system = [...parsed.system, billingBlock, agentBlock];
+                if (!isClaudeCodeClient && parsed.system.length > 0) {
+                    // Non-CC client: relocate its system into the message stream so the
+                    // subscription/OAuth path accepts the request, then send only the
+                    // recognised billing + agent blocks as `system`.
+                    relocateClientSystemIntoMessages(parsed, parsed.system);
+                    parsed.system = [billingBlock, agentBlock];
+                }
+                else {
+                    // Genuine Claude Code (or no extra blocks): keep the recognised system
+                    // and append the deterministic billing + agent blocks at the end.
+                    parsed.system = [...parsed.system, billingBlock, agentBlock];
+                }
             }
         }
         else {
@@ -680,6 +746,7 @@ async function handleClaudePassthroughStreamResponse(args) {
                     cacheReadTokens: data.usage.cacheReadInputTokens,
                 });
                 capturedTracer.logStreamEvents(data.events);
+                capturedTracer.setResponseInfo(responseInfoFromStream(data));
                 const rateLimit5h = parseFloat(capturedResponse.headers.get("anthropic-ratelimit-unified-5h-utilization") ?? "");
                 const rateLimit7d = parseFloat(capturedResponse.headers.get("anthropic-ratelimit-unified-7d-utilization") ?? "");
                 const usageUpdate = {
@@ -871,6 +938,7 @@ async function handleClaudePassthroughJsonResponse(args) {
                 tracer.setUsage(usageWithRates);
             }
         }
+        tracer.setResponseInfo(extractResponseInfo(responseJson));
         tracer.recordMetrics();
         const responseJsonStr = JSON.stringify(responseJson);
         tracer.recordBodySizes(bodyStr.length, responseJsonStr.length);
@@ -1556,6 +1624,7 @@ function attachAnthropicSuccessStreamTelemetry(args) {
                     cacheReadTokens: data.usage.cacheReadInputTokens,
                 });
                 capturedTracer.logStreamEvents(data.events);
+                capturedTracer.setResponseInfo(responseInfoFromStream(data));
                 const rateLimit5h = parseFloat(capturedResponse.headers.get("anthropic-ratelimit-unified-5h-utilization") ?? "");
                 const rateLimit7d = parseFloat(capturedResponse.headers.get("anthropic-ratelimit-unified-7d-utilization") ?? "");
                 const usageUpdate = {
@@ -1773,6 +1842,7 @@ async function handleAnthropicJsonSuccessResponse(args) {
                 tracer.setUsage(usageWithRates);
             }
         }
+        tracer.setResponseInfo(extractResponseInfo(responseJson));
         tracer.recordMetrics();
         const responseJsonStr = JSON.stringify(responseJson);
         tracer.recordBodySizes(finalBodyStr.length, responseJsonStr.length);
@@ -1875,6 +1945,7 @@ async function handleAnthropicSuccessfulRetryResponse(args) {
                         cacheReadTokens: data.usage.cacheReadInputTokens,
                     });
                     capturedTracer.logStreamEvents(data.events);
+                    capturedTracer.setResponseInfo(responseInfoFromStream(data));
                     capturedTracer.logUpstreamResponseHeaders(Object.fromEntries([...capturedRetryResp.headers.entries()]));
                     capturedTracer.recordMetrics();
                     capturedTracer.recordBodySizes(capturedRetryRequestBytes, data.totalBytesReceived);
@@ -1961,6 +2032,7 @@ async function handleAnthropicSuccessfulRetryResponse(args) {
                 cacheReadTokens: retryUsage.cache_read_input_tokens ?? 0,
             });
         }
+        tracer.setResponseInfo(extractResponseInfo(retryJson));
         tracer.recordMetrics();
         const retryJsonStr = JSON.stringify(retryJson);
         tracer.recordBodySizes(finalBodyStr.length, retryJsonStr.length);
@@ -2083,7 +2155,14 @@ async function handleAnthropicAuthRetry(args) {
             currentLastError = retryBody;
             logger.debug(`[proxy] retry ${authRetry + 1} failed: ${retryStatus} ${retryBody.substring(0, 120)}`);
             recordAttemptError(account.label, account.type, retryStatus);
-            if (retryStatus === 429) {
+            // A real rate-limit 429 rotates accounts. But an anti-abuse / construction
+            // 429 (no rate-limit headers, body "Error") is NOT a real rate limit:
+            // advancing the primary or rotating cannot help and only burns quota. Skip
+            // the rotate path for it so it falls through to the terminal error return
+            // below, surfacing the truthful upstream error — mirroring the initial
+            // fetch path's fast-fail (isAntiAbuseConstruction429).
+            if (retryStatus === 429 &&
+                !isAntiAbuseConstruction429(retryRespHeaders, retryBody)) {
                 currentSawRateLimit = true;
                 advancePrimaryIfCurrent(account.key, enabledAccounts.length, orderedAccounts[0]?.key);
                 break;
@@ -2373,6 +2452,13 @@ function createClaudeRequestRuntimeContext(args) {
             model: body.model,
             stream: body.stream ?? false,
             toolCount: Array.isArray(body.tools) ? body.tools.length : 0,
+            toolNames: Array.isArray(body.tools)
+                ? body.tools
+                    .map((t) => t && typeof t === "object" && "name" in t
+                    ? String(t.name ?? "")
+                    : "")
+                    .filter((n) => n.length > 0)
+                : undefined,
             sessionId: ctx.headers["x-neurolink-session-id"] ??
                 ctx.headers["x-claude-code-session-id"] ??
                 undefined,
@@ -2649,6 +2735,24 @@ async function prepareAnthropicAccountAttempt(args) {
         upstreamSpan,
     };
 }
+/**
+ * Detect Anthropic's anti-abuse / request-construction 429.
+ *
+ * The subscription/OAuth path rejects requests it does not recognise as genuine
+ * Claude Code traffic with a 429 `rate_limit_error` whose message is literally
+ * "Error" and which carries NONE of the real rate-limit headers (no retry-after,
+ * no anthropic-ratelimit-*). This is NOT a capacity limit — retrying or rotating
+ * accounts cannot fix it and only burns quota, so the caller must fail fast and
+ * surface the truthful upstream error instead of "all accounts rate-limited".
+ */
+function isAntiAbuseConstruction429(headers, body) {
+    const hasRetryAfter = !!headers["retry-after"];
+    const hasRateLimitHeaders = Object.keys(headers).some((k) => k.toLowerCase().startsWith("anthropic-ratelimit-"));
+    if (hasRetryAfter || hasRateLimitHeaders) {
+        return false;
+    }
+    return (body.includes("rate_limit_error") && /"message"\s*:\s*"Error"/.test(body));
+}
 async function fetchAnthropicAccountResponse(args) {
     const { url, headers, finalBodyStr, account, accountState: _accountState2, enabledAccounts: _enabledAccounts, orderedAccounts: _orderedAccounts, tracer, logAttempt, logProxyBody, fetchStartMs, attemptNumber, currentLastError, currentSawRateLimit, currentSawNetworkError, upstreamSpan, } = args;
     let lastError = currentLastError;
@@ -2719,6 +2823,30 @@ async function fetchAnthropicAccountResponse(args) {
             responseStatus: 429,
             durationMs: Date.now() - fetchStartMs,
         });
+        // Anti-abuse / request-construction 429 (no rate-limit headers, body
+        // "Error"): rotating accounts cannot help and only burns quota. Fail fast
+        // and surface the truthful upstream error instead of the misleading
+        // "all accounts rate-limited" after 44 wasted attempts.
+        if (isAntiAbuseConstruction429(errRespHeaders, String(lastError))) {
+            logger.always(`[proxy] ← 429 account=${account.label} anti-abuse/construction rejection (no ratelimit headers, body="Error") — NOT a real rate limit; returning upstream error without rotating`);
+            logAttempt(429, "construction_rejection", String(lastError));
+            tracer?.setError("construction_rejection", String(lastError).slice(0, 500));
+            currentUpstreamSpan?.end();
+            const passthrough = new Response(String(lastError), {
+                status: 429,
+                headers: {
+                    "content-type": errRespHeaders["content-type"] ?? "application/json",
+                },
+            });
+            return {
+                continueLoop: false,
+                response: passthrough,
+                lastError,
+                sawRateLimit,
+                sawNetworkError,
+                upstreamSpan: undefined,
+            };
+        }
         logger.always(`[proxy] ← 429 account=${account.label} retry-after=${retryAfterMs}ms (upstream) ratelimit-status=${errRespHeaders["anthropic-ratelimit-unified-status"] ?? "unknown"}`);
         logAttempt(429, "rate_limit_error", String(lastError));
         tracer?.setError("rate_limit_error", String(lastError).slice(0, 500));

package/dist/lib/types/providers.d.ts

@@ -1797,11 +1797,21 @@ export type VertexGenaiFunctionDeclaration = {
  * Message payload passed to the Anthropic Vertex SDK — mirrors the Anthropic
  * Messages API shape (role + structured content blocks).
  */
+/**
+ * Anthropic ephemeral prompt-cache breakpoint marker. Placed on a content
+ * block / tool / system block to make the rendered prefix up to that point a
+ * cache breakpoint. Vertex has NO automatic caching, so these explicit markers
+ * are the only way the conversation prefix is cached across turns.
+ */
+export type VertexAnthropicCacheControl = {
+    type: "ephemeral";
+};
 export type VertexAnthropicMessage = {
     role: "user" | "assistant";
     content: string | Array<{
         type: "text";
         text: string;
+        cache_control?: VertexAnthropicCacheControl;
     } | {
         type: "image";
         source: {
@@ -1809,6 +1819,7 @@ export type VertexAnthropicMessage = {
             media_type: string;
             data: string;
         };
+        cache_control?: VertexAnthropicCacheControl;
     } | {
         type: "document";
         source: {
@@ -1816,23 +1827,38 @@ export type VertexAnthropicMessage = {
             media_type: string;
             data: string;
         };
+        cache_control?: VertexAnthropicCacheControl;
     } | {
         type: "tool_use";
         id: string;
         name: string;
         input: unknown;
+        cache_control?: VertexAnthropicCacheControl;
     } | {
         type: "tool_result";
         tool_use_id: string;
         content: string;
+        cache_control?: VertexAnthropicCacheControl;
     } | {
         type: "thinking";
         thinking: string;
+        cache_control?: VertexAnthropicCacheControl;
     } | {
         type: "redacted_thinking";
         data: string;
+        cache_control?: VertexAnthropicCacheControl;
     }>;
 };
+/**
+ * System prompt block form accepted by the Anthropic Vertex SDK. Used instead
+ * of a bare string when a `cache_control` breakpoint must ride on the system
+ * prompt (a string `system` cannot carry one).
+ */
+export type VertexAnthropicSystemBlock = {
+    type: "text";
+    text: string;
+    cache_control?: VertexAnthropicCacheControl;
+};
 /** Tool definition accepted by the Anthropic Vertex SDK. */
 export type VertexAnthropicTool = {
     name: string;
@@ -1842,6 +1868,26 @@ export type VertexAnthropicTool = {
         properties?: Record<string, unknown>;
         required?: string[];
     };
+    cache_control?: VertexAnthropicCacheControl;
+};
+/** Input to `applyVertexAnthropicCacheBreakpoints`. */
+export type VertexAnthropicCacheInput = {
+    system?: string;
+    tools?: VertexAnthropicTool[];
+    messages: VertexAnthropicMessage[];
+    /**
+     * Cap on how many of the most-recent messages receive a rolling history
+     * breakpoint. Defaults to "use the remaining budget". Two or more gives
+     * cross-turn continuity and resilience against Anthropic's 20-block cache
+     * lookback window on tool-heavy turns.
+     */
+    maxHistoryBreakpoints?: number;
+};
+/** Output of `applyVertexAnthropicCacheBreakpoints` — a cache-annotated request. */
+export type VertexAnthropicCacheOutput = {
+    system?: string | VertexAnthropicSystemBlock[];
+    tools?: VertexAnthropicTool[];
+    messages: VertexAnthropicMessage[];
 };
 /**
  * Content block variants returned by the Anthropic Vertex SDK during streaming

package/dist/lib/types/proxy.d.ts

@@ -771,10 +771,20 @@ export type ProxyRequestContext = {
     model: string;
     stream: boolean;
     toolCount: number;
+    /** Names of the tools advertised in the request (what the caller exposed). */
+    toolNames?: string[];
     sessionId?: string;
     userAgent?: string;
     clientApp?: string;
 };
+/** Response-side details parsed from the upstream reply (model, finish, tools). */
+export type ResponseInfoContext = {
+    responseModel?: string;
+    finishReason?: string;
+    stopSequence?: string;
+    /** Names of the tools the model actually invoked (tool_use blocks). */
+    toolCalls?: string[];
+};
 /** Context recorded when an account is selected for a proxy request. */
 export type AccountSelectionContext = {
     strategy: string;

package/dist/lib/utils/anthropicCacheBreakpoints.d.ts

@@ -0,0 +1,15 @@
+import type { VertexAnthropicCacheInput, VertexAnthropicCacheOutput } from "../types/index.js";
+/**
+ * Annotate a native Vertex+Claude request with prompt-cache breakpoints.
+ *
+ * Budget allocation (max 4 markers):
+ *   1. The stable prefix — the last system block when a system prompt is
+ *      present (this single marker caches `tools + system`, since system
+ *      renders after tools); otherwise the last tool definition.
+ *   2-4. A rolling breakpoint on the last few messages, so the
+ *      growing-but-now-stable conversation history is cached and only the
+ *      newest turn is billed as fresh input.
+ *
+ * Pure: the inputs are cloned, never mutated.
+ */
+export declare function applyVertexAnthropicCacheBreakpoints(input: VertexAnthropicCacheInput): VertexAnthropicCacheOutput;

package/dist/lib/utils/anthropicCacheBreakpoints.js

@@ -0,0 +1,98 @@
+/**
+ * Anthropic prompt-cache breakpoint placement for the native Vertex+Claude
+ * request path.
+ *
+ * Vertex does NOT support automatic prompt caching — the only way the
+ * conversation prefix gets cached across turns is explicit `cache_control`
+ * markers in the request. Anthropic renders a request as `tools → system →
+ * messages` and caches the prefix up to each marker, with a hard ceiling of
+ * four markers.
+ *
+ * Without a marker on the message history, the entire (growing, often
+ * tool-result-heavy) conversation falls *after* the last breakpoint and is
+ * re-billed at full input price on every turn. That is the regression this
+ * fixes: it gives the history a rolling breakpoint so the stable prefix is
+ * cached at ~0.1x and only the newest turn is fresh.
+ */
+const EPHEMERAL = { type: "ephemeral" };
+/** Anthropic allows at most four `cache_control` breakpoints per request. */
+const MAX_BREAKPOINTS = 4;
+/**
+ * Annotate a native Vertex+Claude request with prompt-cache breakpoints.
+ *
+ * Budget allocation (max 4 markers):
+ *   1. The stable prefix — the last system block when a system prompt is
+ *      present (this single marker caches `tools + system`, since system
+ *      renders after tools); otherwise the last tool definition.
+ *   2-4. A rolling breakpoint on the last few messages, so the
+ *      growing-but-now-stable conversation history is cached and only the
+ *      newest turn is billed as fresh input.
+ *
+ * Pure: the inputs are cloned, never mutated.
+ */
+export function applyVertexAnthropicCacheBreakpoints(input) {
+    let budget = MAX_BREAKPOINTS;
+    // 1. Stable prefix. A bare string `system` cannot carry cache_control, so
+    // convert it to block form. Marking the last system block caches the whole
+    // tools + system prefix; only fall back to marking the last tool when there
+    // is no system prompt to mark.
+    let system = input.system;
+    let tools = input.tools;
+    const hasSystem = !!input.system && input.system.trim().length > 0;
+    if (hasSystem) {
+        system = [
+            { type: "text", text: input.system, cache_control: EPHEMERAL },
+        ];
+        budget--;
+    }
+    else if (input.tools && input.tools.length > 0) {
+        const lastIndex = input.tools.length - 1;
+        tools = input.tools.map((tool, i) => i === lastIndex ? { ...tool, cache_control: EPHEMERAL } : tool);
+        budget--;
+    }
+    // 2. Rolling history breakpoints over the tail of the conversation.
+    const messages = input.messages.map((m) => ({ ...m }));
+    let remaining = Math.min(budget, input.maxHistoryBreakpoints ?? MAX_BREAKPOINTS);
+    for (let i = messages.length - 1; i >= 0 && remaining > 0; i--) {
+        if (markLastContentBlock(messages, i)) {
+            remaining--;
+        }
+    }
+    return { system, tools, messages };
+}
+/**
+ * Place a cache breakpoint on the last content block of `messages[i]`.
+ * Anthropic attaches `cache_control` to a content block, not the message
+ * envelope, so a string content body is first converted to block form.
+ * Returns false when the message has no markable block (caller then walks to
+ * an earlier message), so an empty turn never silently consumes a breakpoint.
+ */
+function markLastContentBlock(messages, i) {
+    const message = messages[i];
+    if (typeof message.content === "string") {
+        if (message.content.length === 0) {
+            return false;
+        }
+        messages[i] = {
+            ...message,
+            content: [
+                { type: "text", text: message.content, cache_control: EPHEMERAL },
+            ],
+        };
+        return true;
+    }
+    if (!Array.isArray(message.content) || message.content.length === 0) {
+        return false;
+    }
+    // Shallow clone is sufficient: we only ever add a top-level `cache_control`
+    // field to the last block and never mutate nested members (e.g. an image's
+    // `source`). Those nested objects stay shared with the input by reference,
+    // which is safe because they are never written to. If a future block shape
+    // requires mutating nested members, deep-clone that block instead.
+    const content = message.content.map((block) => ({ ...block }));
+    const lastIndex = content.length - 1;
+    content[lastIndex] = { ...content[lastIndex], cache_control: EPHEMERAL };
+    messages[i] = { ...message, content };
+    return true;
+}
+//# sourceMappingURL=anthropicCacheBreakpoints.js.map

package/dist/processors/document/ExcelProcessor.js

@@ -44,7 +44,15 @@ async function loadExcelJS() {
         return _exceljs;
     }
     try {
-        _exceljs = await import(/* @vite-ignore */ "exceljs");
+        const mod = await import(/* @vite-ignore */ "exceljs");
+        // exceljs is a CommonJS module. Under Node ESM (and some bundlers) the
+        // `Workbook` constructor is exposed at runtime on the namespace's `default`
+        // export rather than on the namespace itself — so a bare
+        // `new ExcelJS.Workbook()` throws "ExcelJS.Workbook is not a constructor"
+        // (TS still types it as present via esModuleInterop, masking the bug).
+        // Normalise here so the constructor is reachable regardless of interop style.
+        const ns = mod;
+        _exceljs = (ns.Workbook ? ns : (ns.default ?? ns));
         return _exceljs;
     }
     catch (err) {

package/dist/providers/anthropic.js

@@ -22,6 +22,8 @@ import { NoOutputGeneratedError } from "../utils/generationErrors.js";
 import { buildNoOutputSentinel, stampNoOutputSpan, } from "../utils/noOutputSentinel.js";
 import { convertZodToJsonSchema } from "../utils/schemaConversion.js";
 import { resolveClaudeMaxTokens } from "../utils/tokenLimits.js";
+import { toAnthropicImageBlock, fileToAnthropicBlock, } from "./anthropicImageBlocks.js";
+import { modelDeprecatesTemperature } from "../core/modules/structuredOutputPolicy.js";
 import { createChunkQueue, createDeferredAnalytics, stringifyToolInput, } from "./openaiChatCompletionsClient.js";
 /**
  * Beta headers for Claude Code integration.
@@ -209,45 +211,6 @@ const parseRateLimitHeaders = (headers) => {
 // ───────────────────────────────────────────────────────────────────────────
 // Native Messages-API conversion helpers (NeuroLink/V3 shapes → Anthropic)
 // ───────────────────────────────────────────────────────────────────────────
-/**
- * Convert an image part (data URL, bare base64, https URL, or byte array)
- * into an Anthropic image block. Returns undefined for unusable inputs.
- */
-const toAnthropicImageBlock = (data) => {
-    if (data instanceof Uint8Array) {
-        return {
-            type: "image",
-            source: {
-                type: "base64",
-                media_type: "image/png",
-                data: Buffer.from(data).toString("base64"),
-            },
-        };
-    }
-    if (typeof data !== "string" && !(data instanceof URL)) {
-        return undefined;
-    }
-    const str = data instanceof URL ? data.toString() : data;
-    const dataUrlMatch = str.match(/^data:(image\/[a-z+.-]+);base64,(.+)$/i);
-    if (dataUrlMatch) {
-        return {
-            type: "image",
-            source: {
-                type: "base64",
-                media_type: dataUrlMatch[1],
-                data: dataUrlMatch[2],
-            },
-        };
-    }
-    if (/^https?:\/\//i.test(str)) {
-        return { type: "image", source: { type: "url", url: str } };
-    }
-    // Bare base64 payload — assume PNG (matches the OpenAI-compat client).
-    return {
-        type: "image",
-        source: { type: "base64", media_type: "image/png", data: str },
-    };
-};
 /**
  * Read an Anthropic cache breakpoint from a message/part/tool carrier.
  * MessageBuilder marks system messages (and GenerationHandler marks the last
@@ -347,6 +310,35 @@ const messagesToAnthropic = (msgs) => {
                             blocks.push(cc ? { ...img, cache_control: cc } : img);
                         }
                     }
+                    else if (p?.type === "file") {
+                        // AI-SDK v6 encodes images AND PDFs as `type:"file"` parts in the
+                        // LanguageModel prompt that `doGenerate` receives. Without this
+                        // branch the image is dropped on the tool-using generate path and
+                        // the model never sees it ("no image detected").
+                        //
+                        // Runtime guard: p comes from message parsing and may not match the
+                        // expected shape. Verify p is an object and that mediaType, if
+                        // present, is a string (not an object/array from a malformed part).
+                        // Skip gracefully rather than passing a bad shape to fileToAnthropicBlock.
+                        const isValidFilePart = typeof p === "object" &&
+                            p !== null &&
+                            ("mediaType" in p
+                                ? typeof p.mediaType === "string"
+                                : true);
+                        const block = isValidFilePart
+                            ? fileToAnthropicBlock(p)
+                            : undefined;
+                        if (block) {
+                            const cc = cacheControlOf(p);
+                            if (cc) {
+                                // block is a fresh object from fileToAnthropicBlock; mutate in
+                                // place to keep the discriminated-union type (a spread widens it
+                                // past ContentBlockParam).
+                                block.cache_control = cc;
+                            }
+                            blocks.push(block);
+                        }
+                    }
                 }
                 if (blocks.length > 0) {
                     applyMessageCacheControl(blocks, msg);
@@ -1136,7 +1128,9 @@ export class AnthropicProvider extends BaseProvider {
                     messages,
                     max_tokens: resolveClaudeMaxTokens(modelId, options.maxOutputTokens),
                     ...(system ? { system } : {}),
-                    ...(options.temperature !== undefined && options.temperature !== null
+                    ...(options.temperature !== undefined &&
+                        options.temperature !== null &&
+                        !modelDeprecatesTemperature(modelId)
                         ? { temperature: options.temperature }
                         : {}),
                     ...(options.topP !== undefined && options.topP !== null
@@ -1386,7 +1380,9 @@ export class AnthropicProvider extends BaseProvider {
                     max_tokens: resolveClaudeMaxTokens(modelId, options.maxTokens),
                     stream: true,
                     ...(payload.system ? { system: payload.system } : {}),
-                    ...(options.temperature !== undefined && options.temperature !== null
+                    ...(options.temperature !== undefined &&
+                        options.temperature !== null &&
+                        !modelDeprecatesTemperature(modelId)
                         ? { temperature: options.temperature }
                         : {}),
                     ...(anthropicTools && anthropicTools.length > 0