@juspay/neurolink 9.79.0 → 9.79.2

package/dist/providers/anthropicImageBlocks.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Pure converters from multimodal content parts into native Anthropic
+ * Messages-API content blocks (image / document).
+ *
+ * Two input shapes reach the native Anthropic surface:
+ *
+ *  1. NeuroLink/V3 multimodal parts — `{ type: "image", image }` produced by
+ *     the multimodal message builder (base64, data URL, https URL, or bytes).
+ *
+ *  2. AI-SDK LanguageModel prompt parts — `{ type: "file", mediaType, data }`.
+ *     This is how `ai@6` encodes BOTH images and PDFs in the prompt that the
+ *     provider's `doGenerate(options.prompt)` receives. Before this module the
+ *     converter only handled `type:"image"`, so on the tool-using generate
+ *     path (which always normalises images to `type:"file"`) the image part
+ *     was silently dropped — the model never saw the image ("no image
+ *     detected"). Gemini/Vertex are immune because they read `input.images`
+ *     directly in their own builders instead of going through this conversion.
+ *
+ * Media type is taken from the AI-SDK-provided `mediaType` when present, then
+ * sniffed from magic bytes, and only then defaulted — a hardcoded `image/png`
+ * default silently corrupts JPEG/GIF/WebP uploads (the Anthropic API rejects a
+ * mislabeled base64 image with HTTP 400 and the image vanishes).
+ */
+import type Anthropic from "@anthropic-ai/sdk";
+/**
+ * Detect a supported image media type from a buffer's magic bytes. Returns
+ * undefined when the bytes are not one of the four Anthropic-supported formats.
+ */
+export declare function sniffImageMediaType(bytes: Uint8Array): Anthropic.Messages.Base64ImageSource["media_type"] | undefined;
+/**
+ * Convert an image part (data URL, bare base64, https URL, byte array, or
+ * ArrayBuffer) into an Anthropic image block. Honors `mediaTypeHint` (the
+ * AI-SDK `mediaType`), falls back to magic-byte sniffing, then to image/png.
+ * Returns undefined for unusable inputs.
+ */
+export declare function toAnthropicImageBlock(data: unknown, mediaTypeHint?: string): Anthropic.Messages.ImageBlockParam | undefined;
+/**
+ * Convert an AI-SDK `{ type: "file", mediaType, data }` content part into the
+ * matching Anthropic content block: image/* → image block (media type honored,
+ * not hardcoded), application/pdf → document block. Returns undefined for
+ * unsupported media types (so the caller simply omits them rather than 400ing).
+ * When `mediaType` is absent, image bytes are still salvaged via sniffing.
+ */
+export declare function fileToAnthropicBlock(part: {
+    mediaType?: string;
+    data?: unknown;
+}): Anthropic.Messages.ContentBlockParam | undefined;

package/dist/providers/anthropicImageBlocks.js

@@ -0,0 +1,222 @@
+/**
+ * Pure converters from multimodal content parts into native Anthropic
+ * Messages-API content blocks (image / document).
+ *
+ * Two input shapes reach the native Anthropic surface:
+ *
+ *  1. NeuroLink/V3 multimodal parts — `{ type: "image", image }` produced by
+ *     the multimodal message builder (base64, data URL, https URL, or bytes).
+ *
+ *  2. AI-SDK LanguageModel prompt parts — `{ type: "file", mediaType, data }`.
+ *     This is how `ai@6` encodes BOTH images and PDFs in the prompt that the
+ *     provider's `doGenerate(options.prompt)` receives. Before this module the
+ *     converter only handled `type:"image"`, so on the tool-using generate
+ *     path (which always normalises images to `type:"file"`) the image part
+ *     was silently dropped — the model never saw the image ("no image
+ *     detected"). Gemini/Vertex are immune because they read `input.images`
+ *     directly in their own builders instead of going through this conversion.
+ *
+ * Media type is taken from the AI-SDK-provided `mediaType` when present, then
+ * sniffed from magic bytes, and only then defaulted — a hardcoded `image/png`
+ * default silently corrupts JPEG/GIF/WebP uploads (the Anthropic API rejects a
+ * mislabeled base64 image with HTTP 400 and the image vanishes).
+ */
+// The base64 image media types the Anthropic Messages API accepts are exactly
+// `Anthropic.Messages.Base64ImageSource["media_type"]` — referenced inline below
+// rather than redeclared as a local alias (project rule: type aliases live in
+// src/lib/types/, and this provider-internal shape does not warrant a barrel entry).
+const SUPPORTED_IMAGE_MEDIA_TYPES = new Set([
+    "image/jpeg",
+    "image/png",
+    "image/gif",
+    "image/webp",
+]);
+/** Map a caller-provided MIME hint onto a supported image media type (or undefined). */
+const normalizeImageMediaType = (hint) => {
+    if (!hint) {
+        return undefined;
+    }
+    const h = hint.toLowerCase().split(";")[0].trim();
+    if (h === "image/jpg") {
+        return "image/jpeg";
+    }
+    return SUPPORTED_IMAGE_MEDIA_TYPES.has(h)
+        ? h
+        : undefined;
+};
+/**
+ * Detect a supported image media type from a buffer's magic bytes. Returns
+ * undefined when the bytes are not one of the four Anthropic-supported formats.
+ */
+export function sniffImageMediaType(bytes) {
+    // PNG: 89 50 4E 47 0D 0A 1A 0A
+    if (bytes.length >= 8 &&
+        bytes[0] === 0x89 &&
+        bytes[1] === 0x50 &&
+        bytes[2] === 0x4e &&
+        bytes[3] === 0x47) {
+        return "image/png";
+    }
+    // JPEG: FF D8 FF
+    if (bytes.length >= 3 &&
+        bytes[0] === 0xff &&
+        bytes[1] === 0xd8 &&
+        bytes[2] === 0xff) {
+        return "image/jpeg";
+    }
+    // GIF: "GIF"
+    if (bytes.length >= 6 &&
+        bytes[0] === 0x47 &&
+        bytes[1] === 0x49 &&
+        bytes[2] === 0x46) {
+        return "image/gif";
+    }
+    // WebP: "RIFF"...."WEBP"
+    if (bytes.length >= 12 &&
+        bytes[0] === 0x52 &&
+        bytes[1] === 0x49 &&
+        bytes[2] === 0x46 &&
+        bytes[3] === 0x46 &&
+        bytes[8] === 0x57 &&
+        bytes[9] === 0x45 &&
+        bytes[10] === 0x42 &&
+        bytes[11] === 0x50) {
+        return "image/webp";
+    }
+    return undefined;
+}
+// The longest signature `sniffImageMediaType` checks is WebP — "RIFF"…"WEBP",
+// which spans the first 12 decoded bytes. Base64 packs 3 bytes per 4 chars, so
+// 16 chars already cover those 12 bytes; we slice 32 (a clean 4-char boundary
+// that decodes to 24 bytes) for a comfortable margin over every signature.
+const SNIFF_BASE64_CHARS = 32;
+/** Sniff the leading bytes of a base64 payload (best-effort, never throws). */
+const sniffBase64 = (b64) => {
+    try {
+        return sniffImageMediaType(Buffer.from(b64.slice(0, SNIFF_BASE64_CHARS), "base64"));
+    }
+    catch {
+        return undefined;
+    }
+};
+/**
+ * Convert an image part (data URL, bare base64, https URL, byte array, or
+ * ArrayBuffer) into an Anthropic image block. Honors `mediaTypeHint` (the
+ * AI-SDK `mediaType`), falls back to magic-byte sniffing, then to image/png.
+ * Returns undefined for unusable inputs.
+ */
+export function toAnthropicImageBlock(data, mediaTypeHint) {
+    if (data instanceof ArrayBuffer) {
+        return toAnthropicImageBlock(new Uint8Array(data), mediaTypeHint);
+    }
+    if (data instanceof Uint8Array) {
+        const media_type = normalizeImageMediaType(mediaTypeHint) ??
+            sniffImageMediaType(data) ??
+            "image/png";
+        return {
+            type: "image",
+            source: {
+                type: "base64",
+                media_type,
+                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-z0-9+.-]+);base64,(.+)$/i);
+    if (dataUrlMatch) {
+        const media_type = normalizeImageMediaType(dataUrlMatch[1]) ?? sniffBase64(dataUrlMatch[2]);
+        if (!media_type) {
+            return undefined;
+        }
+        return {
+            type: "image",
+            source: { type: "base64", media_type, data: dataUrlMatch[2] },
+        };
+    }
+    if (/^https?:\/\//i.test(str)) {
+        return { type: "image", source: { type: "url", url: str } };
+    }
+    // Bare base64 payload — prefer the hint, then sniff, then assume PNG
+    // (matches the OpenAI-compat client's historical default).
+    const media_type = normalizeImageMediaType(mediaTypeHint) ?? sniffBase64(str) ?? "image/png";
+    return {
+        type: "image",
+        source: { type: "base64", media_type, data: str },
+    };
+}
+/** Convert a PDF file part into an Anthropic document block. */
+const toAnthropicPdfBlock = (data) => {
+    if (data instanceof ArrayBuffer) {
+        return toAnthropicPdfBlock(new Uint8Array(data));
+    }
+    if (data instanceof Uint8Array) {
+        return {
+            type: "document",
+            source: {
+                type: "base64",
+                media_type: "application/pdf",
+                data: Buffer.from(data).toString("base64"),
+            },
+        };
+    }
+    if (data instanceof URL) {
+        return { type: "document", source: { type: "url", url: data.toString() } };
+    }
+    if (typeof data === "string") {
+        const m = data.match(/^data:application\/pdf;base64,(.+)$/i);
+        if (m) {
+            return {
+                type: "document",
+                source: { type: "base64", media_type: "application/pdf", data: m[1] },
+            };
+        }
+        if (/^https?:\/\//i.test(data)) {
+            return { type: "document", source: { type: "url", url: data } };
+        }
+        return {
+            type: "document",
+            source: { type: "base64", media_type: "application/pdf", data },
+        };
+    }
+    return undefined;
+};
+/**
+ * Convert an AI-SDK `{ type: "file", mediaType, data }` content part into the
+ * matching Anthropic content block: image/* → image block (media type honored,
+ * not hardcoded), application/pdf → document block. Returns undefined for
+ * unsupported media types (so the caller simply omits them rather than 400ing).
+ * When `mediaType` is absent, image bytes are still salvaged via sniffing.
+ */
+export function fileToAnthropicBlock(part) {
+    const data = part?.data;
+    if (data === undefined || data === null) {
+        return undefined;
+    }
+    const mediaType = typeof part.mediaType === "string"
+        ? part.mediaType.toLowerCase().split(";")[0].trim()
+        : "";
+    if (SUPPORTED_IMAGE_MEDIA_TYPES.has(mediaType) || mediaType === "image/jpg") {
+        // Hint is one of the four Anthropic-supported image types (or the jpg alias).
+        return toAnthropicImageBlock(data, mediaType);
+    }
+    if (mediaType === "application/pdf") {
+        return toAnthropicPdfBlock(data);
+    }
+    // No media type, unknown media type, OR an unsupported image/* hint
+    // (e.g. image/svg+xml, image/bmp) — attempt magic-byte salvage so that the
+    // part is included only when the actual bytes sniff to a supported format,
+    // otherwise omit it rather than mislabeling it as image/png.
+    const bytes = data instanceof ArrayBuffer
+        ? new Uint8Array(data)
+        : data instanceof Uint8Array
+            ? data
+            : undefined;
+    if (bytes && sniffImageMediaType(bytes)) {
+        return toAnthropicImageBlock(bytes);
+    }
+    return undefined;
+}

package/dist/providers/googleVertex.js

@@ -10,6 +10,7 @@ import { ModelConfigurationManager } from "../core/modelConfiguration.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../types/index.js";
 import { ERROR_CODES, NeuroLinkError } from "../utils/errorHandling.js";
+import { applyVertexAnthropicCacheBreakpoints } from "../utils/anthropicCacheBreakpoints.js";
 import { FileDetector } from "../utils/fileDetector.js";
 import { processUnifiedFilesArray } from "../utils/messageBuilder.js";
 import { logger } from "../utils/logger.js";
@@ -2491,9 +2492,27 @@ export class GoogleVertexProvider extends BaseProvider {
                     }, turnContext);
                     let response;
                     try {
+                        // Vertex has no automatic prompt caching — place explicit
+                        // cache_control breakpoints (system, tools, rolling history) so the
+                        // conversation prefix is cached across turns instead of re-billed as
+                        // fresh input every call. Re-applied per step: the stable prefix
+                        // stays byte-identical (consistent cache key) while the rolling
+                        // breakpoint follows the growing tail.
+                        const cachedStream = applyVertexAnthropicCacheBreakpoints({
+                            system: systemPromptWithSchema,
+                            tools,
+                            messages: currentMessages,
+                        });
                         const stream = await client.messages.stream({
                             ...requestParams,
-                            messages: currentMessages,
+                            ...(cachedStream.system !== undefined && {
+                                system: cachedStream.system,
+                            }),
+                            ...(cachedStream.tools &&
+                                cachedStream.tools.length > 0 && {
+                                tools: cachedStream.tools,
+                            }),
+                            messages: cachedStream.messages,
                         });
                         activeStream = stream;
                         // Forward each text delta as it arrives — the Anthropic SDK fires
@@ -2750,6 +2769,17 @@ export class GoogleVertexProvider extends BaseProvider {
                 }
                 metadata.responseTime = Date.now() - startTime;
                 metadata.totalToolExecutions = allToolCalls.filter((tc) => tc.toolName !== "final_result").length;
+                // Surface cache metrics once, after the agentic loop, from the
+                // cumulative turnCacheUsage running totals (accumulated via += on every
+                // step above). Assigned here — not per-iteration — so the final values
+                // are unambiguous: analytics sees caching is working and calculateCost
+                // can price the cache-read/write tiers instead of full input rate.
+                if (turnCacheUsage.read > 0) {
+                    usage.cacheReadTokens = turnCacheUsage.read;
+                }
+                if (turnCacheUsage.creation > 0) {
+                    usage.cacheCreationTokens = turnCacheUsage.creation;
+                }
                 const turnOutputAttribute = spanJsonAttribute({
                     text: aggregatedTurnText,
                     ...(structuredOutputRef.value
@@ -3110,6 +3140,12 @@ export class GoogleVertexProvider extends BaseProvider {
         const allToolCalls = [];
         let totalInputTokens = 0;
         let totalOutputTokens = 0;
+        // Cache metrics (Anthropic reports these separately from input_tokens, which
+        // is the uncached remainder). Surfaced on the result so analytics can see
+        // caching is working and calculateCost can price the ~0.1x cache-read /
+        // ~1.25x cache-write tiers instead of billing everything at full input rate.
+        let totalCacheReadTokens = 0;
+        let totalCacheCreationTokens = 0;
         // Track the final Anthropic stop_reason so we can surface finishReason
         // (notably "length" on token truncation) — the legacy native path always
         // reported "stop", hiding truncation from callers.
@@ -3121,13 +3157,36 @@ export class GoogleVertexProvider extends BaseProvider {
                 // Bound the SDK wait so a stalled Vertex/Anthropic call can't hang
                 // generate forever. options.timeout wins if set, otherwise default
                 // to 5 min — generous for tool-heavy turns.
+                // Vertex has no automatic prompt caching — place explicit cache_control
+                // breakpoints (system, tools, rolling history) so the conversation
+                // prefix is cached across turns instead of re-billed as fresh input
+                // every call. Re-applied per step: the stable prefix stays
+                // byte-identical (consistent cache key) while the rolling breakpoint
+                // follows the growing tail.
+                const cachedGenerate = applyVertexAnthropicCacheBreakpoints({
+                    system: systemPromptWithSchema,
+                    tools,
+                    messages: currentMessages,
+                });
                 const response = await withTimeout(client.messages.create({
                     ...requestParams,
-                    messages: currentMessages,
+                    ...(cachedGenerate.system !== undefined && {
+                        system: cachedGenerate.system,
+                    }),
+                    ...(cachedGenerate.tools &&
+                        cachedGenerate.tools.length > 0 && {
+                        tools: cachedGenerate.tools,
+                    }),
+                    messages: cachedGenerate.messages,
                 }), generateTimeoutMs, "Anthropic generate timed out");
-                // Update token counts
+                // Update token counts. input_tokens is the uncached remainder; cache
+                // reads/writes are reported separately and accumulated here so the
+                // result reflects the full picture.
                 totalInputTokens += response.usage?.input_tokens || 0;
                 totalOutputTokens += response.usage?.output_tokens || 0;
+                totalCacheReadTokens += response.usage?.cache_read_input_tokens || 0;
+                totalCacheCreationTokens +=
+                    response.usage?.cache_creation_input_tokens || 0;
                 lastStopReason = response.stop_reason;
                 // Check if we need to handle tool use
                 const toolUseBlocks = response.content.filter((block) => block.type === "tool_use");
@@ -3287,6 +3346,12 @@ export class GoogleVertexProvider extends BaseProvider {
                 input: totalInputTokens,
                 output: totalOutputTokens,
                 total: totalInputTokens + totalOutputTokens,
+                ...(totalCacheReadTokens > 0 && {
+                    cacheReadTokens: totalCacheReadTokens,
+                }),
+                ...(totalCacheCreationTokens > 0 && {
+                    cacheCreationTokens: totalCacheCreationTokens,
+                }),
             },
             responseTime,
             toolsUsed: externalToolCalls.map((tc) => tc.toolName),
@@ -3761,6 +3826,8 @@ export class GoogleVertexProvider extends BaseProvider {
         const inputTokens = usage.input ?? usage.inputTokens ?? 0;
         const outputTokens = usage.output ?? usage.outputTokens ?? 0;
         const totalTokens = usage.total ?? usage.totalTokens ?? inputTokens + outputTokens;
+        const cacheReadTokens = usage.cacheReadTokens ?? 0;
+        const cacheCreationTokens = usage.cacheCreationTokens ?? 0;
         if (inputTokens > 0) {
             span.setAttribute("gen_ai.usage.input_tokens", inputTokens);
         }
@@ -3770,11 +3837,22 @@ export class GoogleVertexProvider extends BaseProvider {
         if (totalTokens > 0) {
             span.setAttribute("gen_ai.usage.total_tokens", totalTokens);
         }
+        if (cacheReadTokens > 0) {
+            span.setAttribute("gen_ai.usage.cache_read_input_tokens", cacheReadTokens);
+        }
+        if (cacheCreationTokens > 0) {
+            span.setAttribute("gen_ai.usage.cache_creation_input_tokens", cacheCreationTokens);
+        }
         try {
+            // Pass cache tokens through so calculateCost prices the ~0.1x cache-read
+            // and ~1.25x cache-write tiers instead of billing cached content at the
+            // full input rate.
             const cost = calculateCost(this.providerName, modelName, {
                 input: inputTokens,
                 output: outputTokens,
                 total: totalTokens,
+                cacheReadTokens,
+                cacheCreationTokens,
             });
             if (typeof cost === "number" && cost > 0) {
                 span.setAttribute("neurolink.cost", cost);

package/dist/proxy/oauthFetch.js

@@ -13,6 +13,7 @@
 import { buildStableClaudeCodeBillingHeader, CLAUDE_CLI_USER_AGENT, CLAUDE_CODE_OAUTH_BETAS, getOrCreateClaudeCodeIdentity, MCP_TOOL_PREFIX, } from "../auth/anthropicOAuth.js";
 import { logger } from "../utils/logger.js";
 import { createProxyFetch } from "./proxyFetch.js";
+import { relocateClientSystemIntoMessages } from "./systemRelocation.js";
 // Re-export constants for consumers that previously imported them alongside
 // the function from `providers/anthropic.ts`.
 export { CLAUDE_CLI_USER_AGENT, MCP_TOOL_PREFIX };
@@ -150,23 +151,21 @@ function transformOAuthJsonBody(body, requestHeaders, getToken, enableMcpPrefix)
         type: "text",
         text: "You are a Claude agent, built on Anthropic's Claude Agent SDK.",
     };
-    // Normalise `system` to an 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 remove any existing billing/agent
-    // blocks from their positions and always append our stable
-    // Claude-Code-shaped versions at the end.
+    // 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 — we keep those and just stabilise the volatile billing
+    // `cch`. A custom client 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"));
@@ -174,15 +173,28 @@ function transformOAuthJsonBody(body, requestHeaders, getToken, enableMcpPrefix)
                 type: "text",
                 text: buildStableClaudeCodeBillingHeader(parsed.system[billingIdx]?.text),
             };
-            // Remove in reverse index order so indices stay valid
+            // A genuine Claude Code client supplies its own agent-identity block;
+            // a custom client 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 deterministic billing + agent blocks at the end
-            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.
+                relocateClientSystemIntoMessages(parsed, parsed.system);
+                parsed.system = [billingBlock, agentBlock];
+            }
+            else {
+                // Genuine Claude Code (or no extra blocks): keep system and append the
+                // deterministic billing + agent blocks at the end.
+                parsed.system = [...parsed.system, billingBlock, agentBlock];
+            }
         }
     }
     else {

package/dist/proxy/proxyTracer.d.ts

@@ -14,7 +14,7 @@
  * - TelemetryService for metrics recording
  */
 import { type Span } from "@opentelemetry/api";
-import type { AccountSelectionContext, ProxyRequestContext, UpstreamAttemptContext, UsageContext } from "../types/index.js";
+import type { AccountSelectionContext, ProxyRequestContext, ResponseInfoContext, UpstreamAttemptContext, UsageContext } from "../types/index.js";
 declare class ProxyTracer {
     private readonly rootSpan;
     private readonly proxyTracer;
@@ -46,6 +46,12 @@ declare class ProxyTracer {
     setAccountSelection(ctx: AccountSelectionContext): void;
     /** Record token usage and cost on the root span. */
     setUsage(ctx: UsageContext): void;
+    /**
+     * Record response-side details parsed from the upstream reply: the model
+     * that actually answered, the finish reason, and which tools the model
+     * invoked (tool_use blocks). Uses gen_ai.* semantic-convention attributes.
+     */
+    setResponseInfo(ctx: ResponseInfoContext): void;
     /** Record an error on the root span. */
     setError(errorType: string, errorMessage: string): void;
     /** Record whether the request was handled in full or passthrough mode. */

package/dist/proxy/proxyTracer.js

@@ -240,6 +240,10 @@ class ProxyTracer {
         if (ctx.userAgent) {
             rootSpan.setAttribute("http.user_agent", ctx.userAgent);
         }
+        if (ctx.toolNames && ctx.toolNames.length > 0) {
+            // What the caller exposed to the model (tool catalogue for this request).
+            rootSpan.setAttribute("gen_ai.request.tool_names", JSON.stringify(ctx.toolNames));
+        }
         // Read x-neurolink-* context headers from calling SDK (e.g., Curator)
         const nlSessionId = incomingHeaders?.["x-neurolink-session-id"];
         const nlUserId = incomingHeaders?.["x-neurolink-user-id"];
@@ -387,6 +391,31 @@ class ProxyTracer {
             this.rootSpan.setAttribute("proxy.ratelimit.after.7d", ctx.rateLimitAfter7d);
         }
     }
+    /**
+     * Record response-side details parsed from the upstream reply: the model
+     * that actually answered, the finish reason, and which tools the model
+     * invoked (tool_use blocks). Uses gen_ai.* semantic-convention attributes.
+     */
+    setResponseInfo(ctx) {
+        if (ctx.responseModel) {
+            this.rootSpan.setAttribute("gen_ai.response.model", ctx.responseModel);
+        }
+        if (ctx.finishReason) {
+            this.rootSpan.setAttribute("gen_ai.response.finish_reason", ctx.finishReason);
+        }
+        if (ctx.stopSequence) {
+            this.rootSpan.setAttribute("gen_ai.response.stop_sequence", ctx.stopSequence);
+        }
+        if (ctx.toolCalls && ctx.toolCalls.length > 0) {
+            this.rootSpan.setAttributes({
+                "gen_ai.response.tool_calls": JSON.stringify(ctx.toolCalls),
+                "gen_ai.response.tool_call_count": ctx.toolCalls.length,
+            });
+            this.rootSpan.addEvent("proxy.response.tool_calls", {
+                "gen_ai.response.tool_calls": JSON.stringify(ctx.toolCalls),
+            });
+        }
+    }
     /** Record an error on the root span. */
     setError(errorType, errorMessage) {
         this.rootSpan.setAttributes({

package/dist/proxy/systemRelocation.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Relocate a non-Claude-Code client's `system` blocks into the message stream.
+ *
+ * Anthropic's subscription/OAuth path rejects any `system` content it does not
+ * recognise as the genuine Claude Code system prompt — anti-abuse fingerprinting
+ * surfaced as a header-less `rate_limit_error: "Error"` (NOT a real rate limit).
+ * Custom clients (Curator/Tara) send their own system prompt, so we move it into
+ * a leading user block and keep only the recognised billing+agent blocks in
+ * `system`. The model still honours the instructions, and any `cache_control` is
+ * carried over so the prompt prefix stays cacheable.
+ *
+ * Shared by both proxy entry points (`oauthFetch.ts` and `claudeProxyRoutes.ts`)
+ * so the OAuth anti-abuse workaround stays in one place and can't drift between
+ * the two paths.
+ */
+export declare function relocateClientSystemIntoMessages(parsed: {
+    messages?: unknown;
+}, instructionBlocks: Array<{
+    text?: unknown;
+    cache_control?: unknown;
+}>): void;

package/dist/proxy/systemRelocation.js

@@ -0,0 +1,50 @@
+/**
+ * Relocate a non-Claude-Code client's `system` blocks into the message stream.
+ *
+ * Anthropic's subscription/OAuth path rejects any `system` content it does not
+ * recognise as the genuine Claude Code system prompt — anti-abuse fingerprinting
+ * surfaced as a header-less `rate_limit_error: "Error"` (NOT a real rate limit).
+ * Custom clients (Curator/Tara) send their own system prompt, so we move it into
+ * a leading user block and keep only the recognised billing+agent blocks in
+ * `system`. The model still honours the instructions, and any `cache_control` is
+ * carried over so the prompt prefix stays cacheable.
+ *
+ * Shared by both proxy entry points (`oauthFetch.ts` and `claudeProxyRoutes.ts`)
+ * so the OAuth anti-abuse workaround stays in one place and can't drift between
+ * the two paths.
+ */
+export function relocateClientSystemIntoMessages(parsed, instructionBlocks) {
+    if (instructionBlocks.length === 0) {
+        return;
+    }
+    const blocks = instructionBlocks.map((b) => {
+        const text = typeof b.text === "string" ? b.text : String(b.text ?? "");
+        const out = {
+            type: "text",
+            text,
+        };
+        if (b.cache_control) {
+            out.cache_control = b.cache_control;
+        }
+        return out;
+    });
+    // Wrap the relocated system in an explicit delimiter so the model treats it
+    // as authoritative instructions, clearly separated from the user's message.
+    blocks[0].text = `<system_instructions>\n${blocks[0].text}`;
+    const last = blocks.length - 1;
+    blocks[last].text = `${blocks[last].text}\n</system_instructions>`;
+    const messages = Array.isArray(parsed.messages) ? parsed.messages : [];
+    const first = messages[0];
+    if (first && first.role === "user") {
+        const existing = typeof first.content === "string"
+            ? [{ type: "text", text: first.content }]
+            : Array.isArray(first.content)
+                ? first.content
+                : [];
+        first.content = [...blocks, ...existing];
+    }
+    else {
+        messages.unshift({ role: "user", content: blocks });
+    }
+    parsed.messages = messages;
+}