@juspay/neurolink 9.79.1 → 9.79.3

package/dist/providers/googleVertex.js

@@ -22,7 +22,7 @@ import { convertZodToJsonSchema, inlineJsonSchema, ensureNestedSchemaTypes, } fr
 import { createNativeThinkingConfig } from "../utils/thinkingConfig.js";
 import { TimeoutError, withTimeout } from "../utils/async/index.js";
 import { parseTimeout } from "../utils/timeout.js";
-import { createTextChannel, extractThoughtSignature, prependConversationMessages, } from "./googleNativeGemini3.js";
+import { appendStepText, createTextChannel, extractThoughtSignature, mapGeminiFinishReason, prependConversationMessages, } from "./googleNativeGemini3.js";
 import { ATTR, LANGFUSE_ATTR, spanJsonAttribute, tracers, withClientSpan, withClientStreamSpan, withSpan, } from "../telemetry/index.js";
 import { SpanKind, SpanStatusCode, context as otelContext, trace as otelTrace, } from "@opentelemetry/api";
 import { calculateCost } from "../utils/pricing.js";
@@ -786,7 +786,7 @@ export class GoogleVertexProvider extends BaseProvider {
                 // lifecycle callbacks. Pipeline A gets these via the AI SDK
                 // wrapStream middleware; the native path has to fire them here.
                 const wrappedResult = this.wrapStreamResultWithLifecycle(options, result, streamStartTime);
-                this.emitStreamEnd(modelName, streamStartTime, true);
+                this.emitStreamEnd(modelName, streamStartTime, true, undefined, result.finishReason);
                 return wrappedResult;
             }
             catch (error) {
@@ -801,7 +801,7 @@ export class GoogleVertexProvider extends BaseProvider {
      * `model.generation` span for native Vertex stream traffic. Mirrors
      * `emitGenerationEnd` (used by `generate()`).
      */
-    emitStreamEnd(modelName, startTime, success, error) {
+    emitStreamEnd(modelName, startTime, success, error, resolvedFinishReason) {
         const emitter = this.neurolink?.getEventEmitter();
         if (!emitter) {
             return;
@@ -815,7 +815,7 @@ export class GoogleVertexProvider extends BaseProvider {
                 usage: { input: 0, output: 0, total: 0 },
                 model: modelName,
                 provider: this.providerName,
-                finishReason: success ? "stop" : "error",
+                finishReason: success ? (resolvedFinishReason ?? "stop") : "error",
             },
             success,
             ...(error
@@ -1156,7 +1156,10 @@ export class GoogleVertexProvider extends BaseProvider {
             : Math.min(DEFAULT_MAX_STEPS, 100);
         const currentContents = [...contents];
         let finalText = "";
-        let lastStepText = ""; // Track text from last step for maxSteps termination
+        // Last SDK finish reason seen across steps (Bug 2: previously never read,
+        // so callers fell back to "unknown"). Last non-empty value wins — the
+        // terminal chunk is authoritative.
+        let lastFinishReason;
         const allToolCalls = [];
         // Mirrors the generate-path shape so StreamResult.toolExecutions can be
         // populated (parity with AI-SDK-driven providers) and so the storage
@@ -1200,6 +1203,12 @@ export class GoogleVertexProvider extends BaseProvider {
                     const chunkRecord = chunk;
                     const candidates = chunkRecord.candidates;
                     const firstCandidate = candidates?.[0];
+                    // Capture the SDK finish reason (Bug 2: previously dropped). Last
+                    // non-empty value across chunks wins.
+                    const chunkFinishReason = firstCandidate?.finishReason;
+                    if (typeof chunkFinishReason === "string" && chunkFinishReason) {
+                        lastFinishReason = chunkFinishReason;
+                    }
                     const chunkContent = firstCandidate?.content;
                     if (chunkContent && Array.isArray(chunkContent.parts)) {
                         for (const part of chunkContent.parts) {
@@ -1253,8 +1262,6 @@ export class GoogleVertexProvider extends BaseProvider {
                         break;
                     }
                 }
-                // Track the last step text for maxSteps termination
-                lastStepText = stepText;
                 // Execute function calls
                 logger.debug(`[GoogleVertex] Executing ${stepFunctionCalls.length} function calls`);
                 // Add model response with ALL parts (including thoughtSignature) to history
@@ -1426,14 +1433,50 @@ export class GoogleVertexProvider extends BaseProvider {
                 throw this.handleProviderError(error);
             }
         }
-        // Handle maxSteps termination - if we exited the loop due to maxSteps being reached
+        // Handle maxSteps termination — the loop exited because the step cap was
+        // reached while the model was still calling tools. Surface a real answer
+        // instead of the canned placeholder (Bug 1) and a meaningful finishReason
+        // (Bug 2).
+        let hitStepLimit = false;
+        let synthesizedFinalAnswer = false;
         if (step >= maxSteps && !finalText) {
-            logger.warn(`[GoogleVertex] Tool call loop terminated after reaching maxSteps (${maxSteps}). ` +
-                `Model was still calling tools. Using accumulated text from last step.`);
-            finalText =
-                lastStepText ||
-                    `[Tool execution limit reached after ${maxSteps} steps. The model continued requesting tool calls beyond the limit.]`;
+            hitStepLimit = true;
+            // The consumer receives text via `incrementalTextChunks`; any text the
+            // model emitted across steps is already preserved there. Only synthesize
+            // when NOTHING was produced (the pure-functionCall case that otherwise
+            // surfaces the placeholder) so we never waste a round-trip whose output
+            // the stream would ignore.
+            if (incrementalTextChunks.length === 0) {
+                logger.warn(`[GoogleVertex] Tool call loop terminated after reaching maxSteps (${maxSteps}) ` +
+                    `with no text; synthesizing a final answer with tools disabled.`);
+                const synth = await this.synthesizeFinalAnswerWithoutTools(client, modelName, config, currentContents, useFinalResultTool, parseTimeout(options.timeout) ?? 300_000);
+                if (synth.text) {
+                    synthesizedFinalAnswer = true;
+                    finalText = synth.text;
+                    incrementalTextChunks.push(synth.text);
+                    totalInputTokens += synth.inputTokens;
+                    totalOutputTokens += synth.outputTokens;
+                    if (synth.finishReason) {
+                        lastFinishReason = synth.finishReason;
+                    }
+                }
+                else {
+                    finalText = `[Tool execution limit reached after ${maxSteps} steps. The model continued requesting tool calls beyond the limit.]`;
+                }
+            }
+            else {
+                logger.warn(`[GoogleVertex] Tool call loop terminated after reaching maxSteps (${maxSteps}); ` +
+                    `returning text already gathered from prior steps.`);
+            }
         }
+        // Unified finish reason: a step-cap exhaustion that did NOT end in a clean
+        // synthesized answer is reported as "tool-calls" (the model still wanted
+        // tools) — NOT "length", which neurolink.ts treats as token truncation
+        // (jsonTruncated + WARNING span). A clean completion maps from the SDK
+        // finish reason.
+        const resolvedFinishReason = hitStepLimit && !synthesizedFinalAnswer
+            ? "tool-calls"
+            : mapGeminiFinishReason(lastFinishReason);
         const responseTime = Date.now() - startTime;
         // Yield each text part separately so the CLI receives multiple stream
         // chunks instead of a single coalesced buffer. The SDK already gave us
@@ -1460,6 +1503,7 @@ export class GoogleVertexProvider extends BaseProvider {
             stream: createTextStream(),
             provider: this.providerName,
             model: modelName,
+            finishReason: resolvedFinishReason,
             usage: {
                 input: totalInputTokens,
                 output: totalOutputTokens,
@@ -1791,7 +1835,11 @@ export class GoogleVertexProvider extends BaseProvider {
             : Math.min(DEFAULT_MAX_STEPS, 100);
         const currentContents = [...contents];
         let finalText = "";
-        let lastStepText = ""; // Track text from last step for maxSteps termination
+        // Cross-step text accumulation + last SDK finish reason, so the
+        // maxSteps-exhaustion exit can surface real gathered text (Bug 1) and a
+        // meaningful finishReason (Bug 2) instead of a placeholder / "unknown".
+        let accumulatedText = "";
+        let lastFinishReason;
         const allToolCalls = [];
         const toolExecutions = [];
         let step = 0;
@@ -1826,6 +1874,12 @@ export class GoogleVertexProvider extends BaseProvider {
                     const chunkRecord = chunk;
                     const candidates = chunkRecord.candidates;
                     const firstCandidate = candidates?.[0];
+                    // Capture the SDK finish reason (Bug 2: previously dropped). Last
+                    // non-empty value across chunks wins.
+                    const chunkFinishReason = firstCandidate?.finishReason;
+                    if (typeof chunkFinishReason === "string" && chunkFinishReason) {
+                        lastFinishReason = chunkFinishReason;
+                    }
                     const chunkContent = firstCandidate?.content;
                     if (chunkContent && Array.isArray(chunkContent.parts)) {
                         rawResponseParts.push(...chunkContent.parts);
@@ -1874,8 +1928,11 @@ export class GoogleVertexProvider extends BaseProvider {
                         break;
                     }
                 }
-                // Track the last step text for maxSteps termination
-                lastStepText = stepText;
+                // Accumulate non-empty step text across steps so the
+                // maxSteps-exhaustion exit can surface the prose the model produced
+                // instead of a canned placeholder (Bug 1). Mirrors the Vertex-Claude
+                // loop's text accumulation.
+                accumulatedText = appendStepText(accumulatedText, stepText);
                 // Execute function calls
                 logger.debug(`[GoogleVertex] Generate executing ${stepFunctionCalls.length} function calls`);
                 // Add model response with ALL parts (including thoughtSignature) to history
@@ -2036,14 +2093,49 @@ export class GoogleVertexProvider extends BaseProvider {
                 throw this.handleProviderError(error);
             }
         }
-        // Handle maxSteps termination - if we exited the loop due to maxSteps being reached
+        // Handle maxSteps termination — the loop exited because the step cap was
+        // reached while the model was still calling tools. Surface a real answer
+        // instead of the canned placeholder (Bug 1) and a meaningful finishReason
+        // (Bug 2).
+        let hitStepLimit = false;
+        let synthesizedFinalAnswer = false;
         if (step >= maxSteps && !finalText) {
-            logger.warn(`[GoogleVertex] Generate tool call loop terminated after reaching maxSteps (${maxSteps}). ` +
-                `Model was still calling tools. Using accumulated text from last step.`);
-            finalText =
-                lastStepText ||
-                    `[Tool execution limit reached after ${maxSteps} steps. The model continued requesting tool calls beyond the limit.]`;
+            hitStepLimit = true;
+            if (accumulatedText) {
+                // Prefer the prose the model already produced across steps.
+                logger.warn(`[GoogleVertex] Generate tool call loop terminated after reaching maxSteps (${maxSteps}); ` +
+                    `returning text already gathered from prior steps.`);
+                finalText = accumulatedText;
+            }
+            else {
+                // Pure functionCall turns leave no text — make one tools-disabled call
+                // so the model answers from the gathered tool results instead of the
+                // canned placeholder.
+                logger.warn(`[GoogleVertex] Generate tool call loop terminated after reaching maxSteps (${maxSteps}) ` +
+                    `with no text; synthesizing a final answer with tools disabled.`);
+                const synth = await this.synthesizeFinalAnswerWithoutTools(client, modelName, config, currentContents, useFinalResultTool, parseTimeout(options.timeout) ?? 300_000);
+                if (synth.text) {
+                    synthesizedFinalAnswer = true;
+                    finalText = synth.text;
+                    totalInputTokens += synth.inputTokens;
+                    totalOutputTokens += synth.outputTokens;
+                    if (synth.finishReason) {
+                        lastFinishReason = synth.finishReason;
+                    }
+                }
+                else {
+                    finalText = `[Tool execution limit reached after ${maxSteps} steps. The model continued requesting tool calls beyond the limit.]`;
+                }
+            }
         }
+        // Unified finish reason: a step-cap exhaustion that did NOT end in a clean
+        // synthesized answer is reported as "tool-calls" (the model still wanted
+        // tools) — NOT "length", which neurolink.ts treats as token truncation
+        // (jsonTruncated + WARNING span). A clean completion maps from the SDK
+        // finish reason.
+        const resolvedFinishReason = hitStepLimit && !synthesizedFinalAnswer
+            ? "tool-calls"
+            : mapGeminiFinishReason(lastFinishReason);
         const responseTime = Date.now() - startTime;
         // Filter out final_result from tool calls and executions as it's an internal pattern
         const externalToolCalls = allToolCalls.filter((tc) => tc.toolName !== "final_result");
@@ -2053,6 +2145,7 @@ export class GoogleVertexProvider extends BaseProvider {
             content: finalText,
             provider: this.providerName,
             model: modelName,
+            finishReason: resolvedFinishReason,
             usage: {
                 input: totalInputTokens,
                 output: totalOutputTokens,
@@ -2073,6 +2166,89 @@ export class GoogleVertexProvider extends BaseProvider {
         // Vertex Gemini generate path.
         return this.enhanceResult(result, options, startTime);
     }
+    /**
+     * One-shot, tools-disabled model call used when a native Gemini agentic loop
+     * is force-terminated by the step cap with no text produced. Lets the model
+     * synthesize a final answer from the function results already in `contents`
+     * instead of returning a canned placeholder (Bug 1, part b).
+     *
+     * Tools are disabled by OMITTING `config.tools` — the codebase's established
+     * mechanism. `@google/genai`'s `FunctionCallingConfigMode.NONE` is documented
+     * as equivalent to passing no function declarations, and `functionCallingConfig`
+     * is not used anywhere in this codebase. When the structured-output
+     * (`final_result`) pattern was active, a trailing instruction countermands the
+     * earlier "you MUST call final_result" directive so the model answers in plain
+     * text. Never throws — returns empty text so the caller falls back to the
+     * placeholder, guaranteeing no new failure path.
+     */
+    async synthesizeFinalAnswerWithoutTools(client, modelName, config, contents, useFinalResultTool, timeoutMs) {
+        try {
+            // Shallow clone so the loop's config is never mutated; dropping the
+            // top-level `tools` key is sufficient (nested thinkingConfig /
+            // systemInstruction are intentionally preserved).
+            const synthConfig = { ...config };
+            delete synthConfig.tools;
+            if (useFinalResultTool) {
+                const baseSystemInstruction = typeof synthConfig.systemInstruction === "string"
+                    ? synthConfig.systemInstruction
+                    : "";
+                synthConfig.systemInstruction =
+                    baseSystemInstruction +
+                        "\n\nThe final_result tool is no longer available. Provide your " +
+                        "final answer directly as plain text now, using the information " +
+                        "gathered so far.";
+            }
+            // Bound the whole connect + drain with a timeout. The surrounding
+            // try/catch only catches throws, not hangs, so without this a stalled
+            // Vertex endpoint would hang the maxSteps recovery path indefinitely.
+            // On timeout withTimeout rejects (TimeoutError) and the catch below
+            // falls back to the placeholder — no new failure path is introduced.
+            return await withTimeout((async () => {
+                const stream = await client.models.generateContentStream({
+                    model: modelName,
+                    contents,
+                    config: synthConfig,
+                });
+                const parts = [];
+                let finishReason;
+                let inputTokens = 0;
+                let outputTokens = 0;
+                for await (const chunk of stream) {
+                    const chunkRecord = chunk;
+                    const candidates = chunkRecord.candidates;
+                    const firstCandidate = candidates?.[0];
+                    const chunkFinishReason = firstCandidate?.finishReason;
+                    if (typeof chunkFinishReason === "string" && chunkFinishReason) {
+                        finishReason = chunkFinishReason;
+                    }
+                    const chunkContent = firstCandidate?.content;
+                    if (chunkContent && Array.isArray(chunkContent.parts)) {
+                        parts.push(...chunkContent.parts);
+                    }
+                    const usageMetadata = chunkRecord.usageMetadata;
+                    if (usageMetadata) {
+                        if (usageMetadata.promptTokenCount !== undefined &&
+                            usageMetadata.promptTokenCount > 0) {
+                            inputTokens = usageMetadata.promptTokenCount;
+                        }
+                        if (usageMetadata.candidatesTokenCount !== undefined &&
+                            usageMetadata.candidatesTokenCount > 0) {
+                            outputTokens = usageMetadata.candidatesTokenCount;
+                        }
+                    }
+                }
+                const text = parts
+                    .filter((part) => typeof part.text === "string")
+                    .map((part) => part.text)
+                    .join("");
+                return { text, finishReason, inputTokens, outputTokens };
+            })(), timeoutMs, "Gemini synthesis call timed out");
+        }
+        catch (error) {
+            logger.warn("[GoogleVertex] Tools-disabled synthesis call failed; falling back to placeholder", { error: error instanceof Error ? error.message : String(error) });
+            return { text: "", inputTokens: 0, outputTokens: 0 };
+        }
+    }
     /**
      * Create native AnthropicVertex client for Claude models
      */
@@ -3685,7 +3861,7 @@ export class GoogleVertexProvider extends BaseProvider {
                     }
                     : undefined,
                 duration: Date.now() - startTime,
-                finishReason: "stop",
+                finishReason: result?.finishReason ?? "stop",
             });
             Promise.resolve(callbackResult).catch((err) => logger.warn(`[GoogleVertex] onFinish callback rejected: ${err instanceof Error ? err.message : String(err)}`));
         }
@@ -3890,7 +4066,7 @@ export class GoogleVertexProvider extends BaseProvider {
                 usage,
                 model: modelName,
                 provider: this.providerName,
-                finishReason: success ? "stop" : "error",
+                finishReason: success ? (result?.finishReason ?? "stop") : "error",
             },
             success,
             ...(error

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;
+}