@juspay/neurolink 9.70.0 → 9.70.1

package/dist/neurolink.js

@@ -66,6 +66,7 @@ import { CircuitBreaker, ERROR_CODES, ErrorFactory, isAbortError, isRetriableErr
 import { hasLifecycleErrorFired, markLifecycleErrorFired, } from "./utils/lifecycleCallbacks.js";
 import { resolveLifecycleTimeoutMs } from "./utils/lifecycleTimeout.js";
 import { cloneOptionsForCallIsolation } from "./utils/cloneOptions.js";
+import { coerceJsonToSchema } from "./utils/json/coerce.js";
 // Factory processing imports
 import { createCleanStreamOptions, enhanceTextGenerationOptions, processFactoryOptions, processStreamingFactoryOptions, validateFactoryConfig, } from "./utils/factoryProcessing.js";
 import { logger, mcpLogger } from "./utils/logger.js";
@@ -3345,6 +3346,60 @@ Current user's request: ${currentInput}`;
     }
     finalizeGenerateRequestResult(params) {
         const { generateSpan, options, textOptions, textResult, factoryResult, originalPrompt, startTime, } = params;
+        // Provider-agnostic JSON coercion for schema requests. Structured-output
+        // enforcement makes valid JSON the overwhelming case; for every other
+        // provider path — including generate() overrides (Vertex, Anthropic,
+        // Bedrock, Google AI Studio) — object/array roots are recovered here via
+        // balanced-scan + jsonrepair and scalar JSON roots via plain JSON.parse,
+        // with the parsed value exposed as `structuredData`. If nothing
+        // JSON-shaped is recoverable (pure prose), the raw text is returned,
+        // `structuredData` stays undefined, and a WARN makes the case observable.
+        // Runs BEFORE the end-of-generation emits below so event consumers see
+        // the same coerced content/structuredData the caller receives.
+        if (textOptions.schema &&
+            textResult.structuredData === undefined &&
+            typeof textResult.content === "string") {
+            const coerced = coerceJsonToSchema(textResult.content, textOptions.schema);
+            if (coerced) {
+                textResult.content = coerced.content;
+                textResult.structuredData = coerced.structuredData;
+                if (coerced.repaired) {
+                    textResult.jsonRepaired = true;
+                }
+                if (coerced.truncated) {
+                    textResult.jsonTruncated = true;
+                }
+            }
+            else {
+                try {
+                    const scalar = JSON.parse(textResult.content);
+                    if (scalar !== null && scalar !== undefined) {
+                        textResult.structuredData = scalar;
+                    }
+                }
+                catch {
+                    logger.warn("[NeuroLink] schema requested but no JSON could be recovered from model output; returning raw text", { provider: textResult.provider, model: textResult.model });
+                }
+            }
+        }
+        // Surface truncation when a schema was requested: either the provider
+        // reported finishReason="length" or the recovered JSON came from an
+        // unclosed span. Either way `structuredData` may be incomplete — warn at
+        // info level so it is observable in production (not just debug logs).
+        if (textOptions.schema) {
+            if (textResult.finishReason === "length") {
+                textResult.jsonTruncated = true;
+            }
+            if (textResult.jsonTruncated) {
+                logger.warn("[NeuroLink] Structured output may be truncated (finishReason=length or unclosed JSON); " +
+                    "increase maxTokens to fit the full response.", {
+                    provider: textResult.provider,
+                    model: textResult.model,
+                    finishReason: textResult.finishReason,
+                    outputTokens: textResult.usage?.output,
+                });
+            }
+        }
         // Skip the top-level `generation:end` emission when the provider already
         // emitted it from its native generate path (Vertex / Google AI Studio).
         // Without this guard, native-path providers would surface TWO events
@@ -3378,7 +3433,10 @@ Current user's request: ${currentInput}`;
         this.emitter.emit("message", `Generation completed in ${Date.now() - startTime}ms`);
         const generateResult = {
             content: textResult.content,
+            structuredData: textResult.structuredData,
             finishReason: textResult.finishReason,
+            jsonRepaired: textResult.jsonRepaired,
+            jsonTruncated: textResult.jsonTruncated,
             provider: textResult.provider,
             model: textResult.model,
             usage: textResult.usage

package/dist/providers/anthropic.js

@@ -21,6 +21,7 @@ import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 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 { createChunkQueue, createDeferredAnalytics, stringifyToolInput, } from "./openaiChatCompletionsClient.js";
 /**
  * Beta headers for Claude Code integration.
@@ -493,10 +494,19 @@ const mapAnthropicStopReason = (raw) => {
             return "stop";
     }
 };
-// Anthropic's Messages API requires max_tokens on every request. The previous
-// @ai-sdk/anthropic implementation defaulted it to 4096 when the caller did
-// not specify maxTokens — preserve that wire behavior.
-const ANTHROPIC_DEFAULT_MAX_TOKENS = 4096;
+// Anthropic's Messages API requires max_tokens on every request. When the
+// caller omits it, default to the model's real output ceiling via
+// resolveClaudeMaxTokens (e.g. 64K for Sonnet 4.x) instead of the legacy 4096,
+// which silently truncated large structured responses mid-JSON.
+//
+// Client-level request timeout. The Anthropic SDK throws "Streaming is required
+// for long requests" from a NON-streaming `messages.create` when `max_tokens`
+// is large AND no client-level timeout is configured (it can't estimate a safe
+// timeout). Setting an explicit client timeout — equal to the SDK's own default
+// for the non-throwing path — suppresses that pre-flight throw so large
+// max_tokens (our model-ceiling default) works. Per-request duration is still
+// bounded by the abort signal NeuroLink composes for each call.
+const ANTHROPIC_CLIENT_TIMEOUT_MS = 600_000;
 /**
  * Anthropic Provider v2 - BaseProvider Implementation
  * Enhanced with OAuth support, subscription tiers, and beta headers for Claude Code integration.
@@ -602,6 +612,7 @@ export class AnthropicProvider extends BaseProvider {
                 apiKey: "oauth-authenticated", // Placeholder, actual auth is in fetch wrapper
                 // Note: No headers passed - fetch wrapper sets oauth-2025-04-20 beta header
                 fetch: oauthFetch,
+                timeout: ANTHROPIC_CLIENT_TIMEOUT_MS,
             });
             logger.debug("[AnthropicProvider] Anthropic SDK client created with OAuth fetch wrapper");
             logger.debug("Anthropic Provider initialized with OAuth", {
@@ -647,6 +658,7 @@ export class AnthropicProvider extends BaseProvider {
                 defaultHeaders: headers,
                 ...(normalizedBaseURL && { baseURL: normalizedBaseURL }),
                 fetch: createProxyFetch(),
+                timeout: ANTHROPIC_CLIENT_TIMEOUT_MS,
             });
             logger.debug("Anthropic Provider initialized with API key", {
                 modelName: this.modelName,
@@ -1122,7 +1134,7 @@ export class AnthropicProvider extends BaseProvider {
                 const params = {
                     model: modelId,
                     messages,
-                    max_tokens: options.maxOutputTokens ?? ANTHROPIC_DEFAULT_MAX_TOKENS,
+                    max_tokens: resolveClaudeMaxTokens(modelId, options.maxOutputTokens),
                     ...(system ? { system } : {}),
                     ...(options.temperature !== undefined && options.temperature !== null
                         ? { temperature: options.temperature }
@@ -1137,7 +1149,22 @@ export class AnthropicProvider extends BaseProvider {
                     ...(toolChoice ? { tool_choice: toolChoice } : {}),
                     ...(thinking ? { thinking } : {}),
                 };
-                const timeoutController = createTimeoutController(getTimeoutForOptions(options), providerName, "generate");
+                // The 60s anthropic generate default was tuned for the old ~4096
+                // max_tokens. Now that the default ceiling is the model's real max,
+                // a large structured response needs more wall-clock to be produced —
+                // otherwise the inner controller aborts mid-generation (the AI-SDK
+                // doGenerate layer doesn't see the caller's `timeout`). Raise the
+                // floor to 5 min when a large output budget is in play — but only
+                // when the caller did NOT set an explicit timeout: an explicit value
+                // is a contract and must never be silently extended. The abort
+                // signal stays the real bound.
+                const callerTimeout = options
+                    .timeout;
+                const callerSpecifiedTimeout = callerTimeout !== undefined && callerTimeout !== null;
+                const generateTimeoutMs = params.max_tokens > 8192 && !callerSpecifiedTimeout
+                    ? Math.max(getTimeoutForOptions(options), 300_000)
+                    : getTimeoutForOptions(options);
+                const timeoutController = createTimeoutController(generateTimeoutMs, providerName, "generate");
                 let response;
                 try {
                     response = await client.messages.create(params, {
@@ -1356,7 +1383,7 @@ export class AnthropicProvider extends BaseProvider {
                 const params = {
                     model: modelId,
                     messages: conversation,
-                    max_tokens: options.maxTokens ?? ANTHROPIC_DEFAULT_MAX_TOKENS,
+                    max_tokens: resolveClaudeMaxTokens(modelId, options.maxTokens),
                     stream: true,
                     ...(payload.system ? { system: payload.system } : {}),
                     ...(options.temperature !== undefined && options.temperature !== null

package/dist/providers/googleVertex.js

@@ -14,6 +14,7 @@ import { FileDetector } from "../utils/fileDetector.js";
 import { processUnifiedFilesArray } from "../utils/messageBuilder.js";
 import { logger } from "../utils/logger.js";
 import { hasRestrictedOutputLimit, RESTRICTED_OUTPUT_TOKEN_LIMIT, } from "../utils/modelDetection.js";
+import { resolveClaudeMaxTokens } from "../utils/tokenLimits.js";
 import { validateApiKey, createVertexProjectConfig, createGoogleAuthConfig, } from "../utils/providerConfig.js";
 import { convertZodToJsonSchema, inlineJsonSchema, ensureNestedSchemaTypes, } from "../utils/schemaConversion.js";
 import { createNativeThinkingConfig } from "../utils/thinkingConfig.js";
@@ -2293,7 +2294,11 @@ export class GoogleVertexProvider extends BaseProvider {
                 : undefined;
         const requestParams = {
             model: modelName,
-            max_tokens: options.maxTokens || 4096,
+            // Default to the model's real output ceiling (e.g. 64K for Sonnet 4.x)
+            // instead of the legacy 4096, which silently truncated large structured
+            // responses mid-JSON. resolveClaudeMaxTokens also clamps over-large
+            // caller values so the native Vertex path never 400s.
+            max_tokens: resolveClaudeMaxTokens(modelName, options.maxTokens),
             messages: messages,
             ...(tools && tools.length > 0 && { tools }),
             ...(useFinalResultTool && { tool_choice: { type: "any" } }),
@@ -2813,7 +2818,8 @@ export class GoogleVertexProvider extends BaseProvider {
                 : undefined;
         const requestParams = {
             model: modelName,
-            max_tokens: options.maxTokens || 4096,
+            // Default to the model's real output ceiling (see stream path note).
+            max_tokens: resolveClaudeMaxTokens(modelName, options.maxTokens),
             messages,
             ...(tools && tools.length > 0 && { tools }),
             ...(useFinalResultTool && { tool_choice: { type: "any" } }),
@@ -2835,6 +2841,10 @@ export class GoogleVertexProvider extends BaseProvider {
         const allToolCalls = [];
         let totalInputTokens = 0;
         let totalOutputTokens = 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.
+        let lastStopReason;
         const currentMessages = [...messages];
         while (step < maxSteps) {
             step++;
@@ -2849,6 +2859,7 @@ export class GoogleVertexProvider extends BaseProvider {
                 // Update token counts
                 totalInputTokens += response.usage?.input_tokens || 0;
                 totalOutputTokens += response.usage?.output_tokens || 0;
+                lastStopReason = response.stop_reason;
                 // Check if we need to handle tool use
                 const toolUseBlocks = response.content.filter((block) => block.type === "tool_use");
                 // Check for final_result tool call (for structured output)
@@ -2997,6 +3008,10 @@ export class GoogleVertexProvider extends BaseProvider {
         const externalToolExecutions = toolExecutions.filter((te) => te.name !== "final_result");
         const result = {
             content: finalText,
+            // Surface truncation: Anthropic "max_tokens" → unified "length" so the
+            // SDK boundary can flag/observe incomplete structured output. Anything
+            // else (end_turn / stop_sequence / tool_use) is a normal stop.
+            finishReason: lastStopReason === "max_tokens" ? "length" : "stop",
             provider: this.providerName,
             model: modelName,
             usage: {

package/dist/types/generate.d.ts

@@ -249,30 +249,32 @@ export type GenerateOptions = {
     /**
      * Zod schema for structured output validation
      *
-     * @important Google Gemini Limitation
-     * Google Vertex AI and Google AI Studio cannot combine function calling with
-     * structured output. You MUST use `disableTools: true` when using schemas with
-     * Google providers.
-     *
-     * Error without disableTools: "Function calling with a response mime type:
-     * 'application/json' is unsupported"
-     *
-     * This is a documented Google API limitation, not a NeuroLink bug.
-     * All frameworks (LangChain, Vercel AI SDK, Agno, Instructor) use this approach.
+     * @important Google GEMINI limitation (Gemini models only)
+     * Gemini models (Google AI Studio, and Vertex GEMINI models) cannot combine
+     * function calling with schema-enforced structured output — a Gemini API
+     * limitation ("Function calling with a response mime type:
+     * 'application/json' is unsupported"). Vertex CLAUDE models and all other
+     * providers support tools + schema simultaneously.
+     *
+     * You do NOT need to set `disableTools` yourself: when the combination is
+     * impossible, NeuroLink automatically falls back to text-mode JSON coercion
+     * (see `coerceJsonToSchema`), and `disableTools: true` remains available as
+     * an explicit override.
      *
      * @example
      * ```typescript
-     * // ✅ Correct for Google providers
+     * // ✅ Vertex + Claude: tools AND schema together are fully supported
      * const result = await neurolink.generate({
      *   schema: MySchema,
      *   provider: "vertex",
-     *   disableTools: true  // Required for Google
+     *   model: "claude-sonnet-4-6",
      * });
      *
-     * // ✅ No restriction for other providers
+     * // ✅ Gemini + tools: SDK auto-falls back to coerced text-mode JSON
      * const result = await neurolink.generate({
      *   schema: MySchema,
-     *   provider: "openai"  // Works without disableTools
+     *   provider: "google-ai",
+     *   model: "gemini-2.5-pro",
      * });
      * ```
      *
@@ -300,16 +302,18 @@ export type GenerateOptions = {
     /**
      * Disable tool execution (including built-in tools)
      *
-     * @required For Google Gemini providers when using schemas
-     * Google Vertex AI and Google AI Studio require this flag when using
-     * structured output (schemas) due to Google API limitations.
+     * Optional with schemas: the tools↔schema exclusion applies only to Google
+     * GEMINI models (Google AI Studio / Vertex Gemini — a Gemini API
+     * limitation), and NeuroLink handles it automatically by falling back to
+     * text-mode JSON coercion. Vertex CLAUDE models support tools + schema
+     * together. Set this only when you explicitly want a tool-free call.
      *
      * @example
      * ```typescript
-     * // Required for Google providers with schemas
+     * // Explicit override: schema-only call with no tools at all
      * await neurolink.generate({
      *   schema: MySchema,
-     *   provider: "vertex",
+     *   provider: "google-ai",
      *   disableTools: true
      * });
      * ```
@@ -551,6 +555,13 @@ export type AdditionalMemoryUser = {
  */
 export type GenerateResult = {
     content: string;
+    /**
+     * Parsed structured object when a `schema` was requested. Populated from
+     * AI-SDK experimental_output, or from text-mode coercion (balanced-scan +
+     * jsonrepair). Prefer this over JSON.parse(content) — it never requires the
+     * caller to re-parse hand-escaped model text.
+     */
+    structuredData?: unknown;
     outputs?: {
         text: string;
     };
@@ -638,6 +649,17 @@ export type GenerateResult = {
     provider?: string;
     model?: string;
     finishReason?: string;
+    /**
+     * True when the schema JSON in `content`/`structuredData` was repaired from
+     * malformed model text (jsonrepair ran). The result is still valid JSON.
+     */
+    jsonRepaired?: boolean;
+    /**
+     * True when the schema JSON appears truncated — the model hit the output
+     * token cap (finishReason="length") or the recovered object came from an
+     * unclosed span. `structuredData` may be incomplete; raise `maxTokens`.
+     */
+    jsonTruncated?: boolean;
     usage?: TokenUsage;
     responseTime?: number;
     toolCalls?: Array<{
@@ -1090,7 +1112,13 @@ export type TextGenerationOptions = {
  */
 export type TextGenerationResult = {
     content: string;
+    /** Parsed structured object when a `schema` was requested (see GenerateResult.structuredData). */
+    structuredData?: unknown;
     finishReason?: string;
+    /** True when the schema JSON was repaired from malformed model text. */
+    jsonRepaired?: boolean;
+    /** True when the schema JSON appears truncated (output hit the token cap). */
+    jsonTruncated?: boolean;
     provider?: string;
     model?: string;
     usage?: TokenUsage;

package/dist/types/utilities.d.ts

@@ -263,3 +263,19 @@ export type StepToolResult = {
     result?: unknown;
     error?: string;
 };
+/**
+ * Result of coercing arbitrary model text into canonical, valid JSON.
+ * `content` is a JSON.stringify of the recovered object; `structuredData` is
+ * the parsed object itself.
+ */
+export type JsonCoercionResult = {
+    content: string;
+    structuredData: unknown;
+    /** True when jsonrepair altered the model text to make it parse. */
+    repaired: boolean;
+    /**
+     * True when the recovered object came from a truncated (unclosed) span —
+     * the response likely hit the output-token cap and data may be incomplete.
+     */
+    truncated: boolean;
+};

package/dist/utils/json/coerce.d.ts

@@ -0,0 +1,10 @@
+import type { JsonCoercionResult, ValidationSchema } from "../../types/index.js";
+/**
+ * Try to produce canonical JSON from `text`. Returns null when no JSON object
+ * could be recovered (caller should then keep the raw text).
+ *
+ * When `schema` is a Zod schema, candidates that satisfy it are preferred; a
+ * syntactically-valid-but-schema-failing object is still returned (we guarantee
+ * JSON *validity*, leaving schema/content checks to the caller's own pipeline).
+ */
+export declare function coerceJsonToSchema(text: string, schema?: ValidationSchema): JsonCoercionResult | null;

package/dist/utils/json/coerce.js

@@ -0,0 +1,140 @@
+/**
+ * Coerce arbitrary model text into canonical, syntactically-valid JSON.
+ *
+ * Used on the text-mode path (providers/models that could not use AI-SDK
+ * structured output, e.g. real Gemini + tools). The model hand-writes JSON and
+ * frequently mis-escapes the content field (bare newline, unescaped quote,
+ * invalid escape like \d). A balanced-brace scan finds the object span; if
+ * JSON.parse rejects it, jsonrepair fixes common escaping mistakes; the result
+ * is re-serialised with JSON.stringify so downstream consumers always receive
+ * valid JSON.
+ *
+ * NOTE: jsonrepair is a heuristic. On content where a lone backslash is
+ * meaningful (regex/script/Windows path) it may drop the backslash, producing
+ * valid-but-semantically-altered content. This only affects the residual
+ * text-mode path — the primary Vertex+Claude path uses experimental_output and
+ * never reaches here. When jsonrepair changes the input we log at debug level
+ * so the event is observable.
+ */
+import { jsonrepair } from "jsonrepair";
+import { logger } from "../logger.js";
+import { nextBalancedJsonSpan } from "./extract.js";
+/** True when the schema exposes a Zod-style `safeParse` we can validate with. */
+function hasSafeParse(schema) {
+    return typeof schema.safeParse === "function";
+}
+/**
+ * Parse `candidate` as JSON, repairing common escaping mistakes on failure.
+ * Returns the parsed value plus whether jsonrepair had to alter the text.
+ */
+function parseOrRepair(candidate) {
+    try {
+        return { value: JSON.parse(candidate), repaired: false };
+    }
+    catch {
+        // fall through to repair
+    }
+    try {
+        const repaired = jsonrepair(candidate);
+        const value = JSON.parse(repaired);
+        if (repaired !== candidate && logger.shouldLog("debug")) {
+            logger.debug("[coerceJsonToSchema] jsonrepair altered model output", {
+                originalLength: candidate.length,
+                repairedLength: repaired.length,
+            });
+        }
+        return { value, repaired: repaired !== candidate };
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Try to produce canonical JSON from `text`. Returns null when no JSON object
+ * could be recovered (caller should then keep the raw text).
+ *
+ * When `schema` is a Zod schema, candidates that satisfy it are preferred; a
+ * syntactically-valid-but-schema-failing object is still returned (we guarantee
+ * JSON *validity*, leaving schema/content checks to the caller's own pipeline).
+ */
+export function coerceJsonToSchema(text, schema) {
+    if (typeof text !== "string" || text.trim().length === 0) {
+        return null;
+    }
+    // Ordered candidate substrings, best-formed first:
+    //  1. every balanced object/array span (clean, common case)
+    //  2. first "{" or "[" to last "}" or "]" (drops surrounding prose; lets
+    //     jsonrepair fix escaping inside) — root ARRAYS matter for array schemas
+    //  3. first "{" or "[" to end of text (TRUNCATED output —
+    //     finishReason=length — where the closing bracket was cut off;
+    //     jsonrepair closes it)
+    // `truncated` marks the first-open-to-end candidate: it is only reachable
+    // when no balanced span and no first-to-last span matched, i.e. there was no
+    // closing bracket at all — the signature of token-truncated output.
+    const candidates = [];
+    let searchFrom = 0;
+    for (;;) {
+        const found = nextBalancedJsonSpan(text, searchFrom);
+        if (!found) {
+            break;
+        }
+        candidates.push({ text: found.span, truncated: false });
+        searchFrom = found.end;
+    }
+    const openIndexes = [text.indexOf("{"), text.indexOf("[")].filter((i) => i >= 0);
+    const firstOpen = openIndexes.length > 0 ? Math.min(...openIndexes) : -1;
+    const lastClose = Math.max(text.lastIndexOf("}"), text.lastIndexOf("]"));
+    if (firstOpen >= 0 && lastClose > firstOpen) {
+        candidates.push({
+            text: text.slice(firstOpen, lastClose + 1),
+            truncated: false,
+        });
+    }
+    if (firstOpen >= 0) {
+        candidates.push({ text: text.slice(firstOpen), truncated: true });
+    }
+    let firstValid;
+    let schemaMatch;
+    const seen = new Set();
+    for (const candidate of candidates) {
+        if (seen.has(candidate.text)) {
+            continue;
+        }
+        seen.add(candidate.text);
+        const outcome = parseOrRepair(candidate.text);
+        if (outcome === undefined ||
+            outcome.value === null ||
+            typeof outcome.value !== "object") {
+            continue;
+        }
+        const record = {
+            value: outcome.value,
+            repaired: outcome.repaired,
+            truncated: candidate.truncated,
+        };
+        if (firstValid === undefined) {
+            firstValid = record;
+        }
+        if (schema && hasSafeParse(schema)) {
+            const safeParseable = schema;
+            if (safeParseable.safeParse(outcome.value).success) {
+                schemaMatch = record;
+                break;
+            }
+        }
+        else {
+            // No Zod schema to discriminate — first parseable object wins.
+            break;
+        }
+    }
+    const chosen = schemaMatch ?? firstValid;
+    if (chosen === undefined) {
+        return null;
+    }
+    return {
+        content: JSON.stringify(chosen.value),
+        structuredData: chosen.value,
+        repaired: chosen.repaired,
+        truncated: chosen.truncated,
+    };
+}

package/dist/utils/json/extract.d.ts

@@ -4,6 +4,16 @@
  * Utilities for extracting JSON from mixed text content.
  * Particularly useful for parsing AI responses that contain JSON within prose.
  */
+/**
+ * Find the first balanced JSON object/array span starting at or after
+ * `fromIndex`. Quote- and escape-aware: braces inside string literals do not
+ * affect depth. Returns the matched substring and the index just past it, or
+ * null if no balanced span exists.
+ */
+export declare function nextBalancedJsonSpan(text: string, fromIndex?: number): {
+    span: string;
+    end: number;
+} | null;
 /**
  * Extract JSON string from text that may contain surrounding content.
  *

package/dist/utils/json/extract.js

@@ -5,6 +5,53 @@
  * Particularly useful for parsing AI responses that contain JSON within prose.
  */
 import { parseJsonOrNull } from "./safeParse.js";
+/**
+ * Find the first balanced JSON object/array span starting at or after
+ * `fromIndex`. Quote- and escape-aware: braces inside string literals do not
+ * affect depth. Returns the matched substring and the index just past it, or
+ * null if no balanced span exists.
+ */
+export function nextBalancedJsonSpan(text, fromIndex = 0) {
+    for (let start = fromIndex; start < text.length; start++) {
+        const openChar = text[start];
+        if (openChar !== "{" && openChar !== "[") {
+            continue;
+        }
+        const closeChar = openChar === "{" ? "}" : "]";
+        let depth = 0;
+        let inString = false;
+        let escapeNext = false;
+        for (let i = start; i < text.length; i++) {
+            const ch = text[i];
+            if (escapeNext) {
+                escapeNext = false;
+                continue;
+            }
+            if (ch === "\\") {
+                escapeNext = true;
+                continue;
+            }
+            if (ch === '"') {
+                inString = !inString;
+                continue;
+            }
+            if (inString) {
+                continue;
+            }
+            if (ch === openChar) {
+                depth++;
+            }
+            else if (ch === closeChar) {
+                depth--;
+                if (depth === 0) {
+                    return { span: text.substring(start, i + 1), end: i + 1 };
+                }
+            }
+        }
+        // Unbalanced from this start — try the next opening char.
+    }
+    return null;
+}
 /**
  * Extract JSON string from text that may contain surrounding content.
  *
@@ -45,21 +92,24 @@ export function extractJsonStringFromText(text) {
             // Continue to other patterns
         }
     }
-    // Try to find JSON object or array pattern using non-greedy iterative scan.
-    // Note: [\s\S]*? is non-greedy but can still produce over-spanning matches
-    // in texts with many braces. This is acceptable as we try-parse each candidate
-    // and move to the next on failure. A bracket-balancing parser would be more
-    // precise but significantly more complex for marginal benefit.
-    const candidateRegex = /(\{[\s\S]*?\}|\[[\s\S]*?\])/g;
-    let candidate;
-    while ((candidate = candidateRegex.exec(text)) !== null) {
+    // Scan for balanced JSON object/array spans (quote/escape aware) and return
+    // the first one that parses. Unlike a non-greedy regex, this never stops at a
+    // "}" that lives inside a string value, so nested objects are preserved.
+    let searchFrom = 0;
+    for (;;) {
+        const found = nextBalancedJsonSpan(text, searchFrom);
+        if (!found) {
+            break;
+        }
         try {
-            JSON.parse(candidate[1]);
-            return candidate[1];
+            JSON.parse(found.span);
+            return found.span;
         }
         catch {
-            // Try next candidate
+            // Not valid JSON — resume scanning just past this opening character so a
+            // valid inner object/array can still be found.
         }
+        searchFrom = found.end - found.span.length + 1;
     }
     return null;
 }

package/dist/utils/tokenLimits.d.ts

@@ -7,6 +7,26 @@ import { PROVIDER_MAX_TOKENS } from "../core/constants.js";
  * Get the safe maximum tokens for a provider and model
  */
 export declare function getSafeMaxTokens(provider: keyof typeof PROVIDER_MAX_TOKENS | string, model?: string, requestedMaxTokens?: number): number | undefined;
+/**
+ * Maximum output tokens supported by a given Anthropic Claude model.
+ *
+ * The native Vertex+Claude and native Anthropic message paths send `max_tokens`
+ * straight to the Anthropic API, which returns 400 if the value exceeds the
+ * model's published output ceiling. (The AI-SDK path clamps automatically;
+ * these native paths do not.) This table lets those paths default to the
+ * model's real ceiling — 64K for Sonnet/Haiku 4.x, 32K for Opus 4.x — instead of
+ * the legacy 4096 that silently truncated large structured responses.
+ *
+ * Unknown identifiers fall back to a safe modern floor (8192).
+ */
+export declare function getClaudeMaxOutputTokens(model: string | undefined): number;
+/**
+ * Resolve the `max_tokens` to send on a native Anthropic/Claude request: honour
+ * the caller's value but clamp it to the model's published ceiling, and default
+ * to that ceiling when the caller did not specify one. Prevents both silent
+ * truncation (the legacy 4096 default) and 400s from over-large requests.
+ */
+export declare function resolveClaudeMaxTokens(model: string | undefined, requested?: number): number;
 /**
  * Validate if maxTokens is safe for a provider/model combination
  */