@juspay/neurolink 11.8.1 → 11.10.0

package/dist/lib/providers/anthropic/loopAdapter.js

@@ -0,0 +1,313 @@
+/**
+ * Direct Anthropic's adapter onto the shared agentic loop engine.
+ *
+ * Everything here is the wire-format half of the turn: building one Messages
+ * request, folding an SSE event sequence into content blocks, serializing tool
+ * results back into the conversation, and mapping the stop reason. The turn
+ * loop, the step cap, tool dispatch, retry and usage accumulation belong to
+ * `runAgenticLoop`.
+ *
+ * Two behaviours here are easy to lose in a migration and are called out
+ * because losing either is silent:
+ *
+ *  - Thinking deltas ride the channel as `{ content: "", reasoning }`. The
+ *    engine's chunk type carries `reasoning` for exactly this reason; a
+ *    channel that only understood `content` would drop every thinking delta
+ *    while the text path kept working.
+ *  - `resolveToolOnMiss` is wired to real deferred-catalog hydration, not as
+ *    interface decoration. The pre-migration loop resolves every tool call as
+ *    `toolsRecord[name] ?? resolveDeferredTool(toolsRecord, name)`, which is
+ *    how a cataloged tool the model calls without having loaded it via
+ *    `search_tools` gets found. Dropping it would break those tools with a
+ *    "Tool not found" that looks like a hallucination.
+ */
+import { resolveDeferredTool } from "../../tools/toolDiscovery.js";
+import { stringifyAnthropicToolOutput } from "./toolOutput.js";
+/** Map Anthropic's stop_reason onto the unified finish reason. */
+function mapAnthropicFinishReason(rawStopReason, hadToolCallsAtCap) {
+    switch (rawStopReason) {
+        case "max_tokens":
+            return "length";
+        case "tool_use":
+            return "tool-calls";
+        case "refusal":
+            return "content-filter";
+        default:
+            return hadToolCallsAtCap ? "tool-calls" : "stop";
+    }
+}
+export function createAnthropicLoopAdapter(config) {
+    return {
+        providerLabel: "anthropic",
+        maxSteps: config.maxSteps,
+        ...(config.toolFailureBreaker
+            ? { toolFailureBreaker: config.toolFailureBreaker }
+            : {}),
+        /**
+         * The engine decides WHEN to reclaim; the provider decides HOW, in its own
+         * concrete message types. Not optional dressing: this loop appends an
+         * assistant tool_use message and a user tool_result message every step,
+         * and nothing else bounds that growth.
+         */
+        ...(config.planReclaim
+            ? {
+                planReclaim: (conversation, step) => {
+                    const reclaimed = config.planReclaim?.(conversation, step);
+                    return reclaimed ? { conversation: reclaimed } : undefined;
+                },
+            }
+            : {}),
+        resolveToolOnMiss: (name) => {
+            const hydrated = resolveDeferredTool(config.toolsRecord, name);
+            const execute = hydrated?.execute;
+            if (!execute) {
+                return undefined;
+            }
+            // Wrapped rather than handed over directly: the engine's hook types
+            // `opts` as `unknown`, and a function declaring a narrower options type
+            // is not assignable to one accepting `unknown`. One assertion at the
+            // boundary, never a double assertion through `unknown`.
+            return {
+                execute: async (args, opts) => execute(args, opts),
+            };
+        },
+        buildStepRequest(conversation, step) {
+            return { raw: config.buildParams(conversation, step) };
+        },
+        async executeStep(request, channel, signal) {
+            const params = request.raw;
+            // Single assertion, not a double: `messages.create` returns a union of
+            // Message and Stream, and Stream<RawMessageStreamEvent> already IS an
+            // AsyncIterable of that event, so the two types overlap and the
+            // compiler still checks the narrowing.
+            const events = (await config.client.messages.create({ ...params, stream: true }, 
+            // The engine's signal, not config's: runAgenticLoop already derives
+            // it from the caller's abortSignal, so preferring config's would
+            // ignore engine-initiated cancellation entirely.
+            { signal }));
+            const textByIndex = new Map();
+            const toolByIndex = new Map();
+            const thinkingByIndex = new Map();
+            const redactedByIndex = new Map();
+            let text = "";
+            let reasoning = "";
+            let rawStopReason;
+            let inputTokens = 0;
+            let outputTokens = 0;
+            let cacheReadTokens = 0;
+            let cacheWriteTokens = 0;
+            let stepOutputTokens = 0;
+            for await (const rawEvent of events) {
+                if (signal.aborted) {
+                    break;
+                }
+                // Narrowed through the SDK's own discriminated union rather than
+                // re-declared: `RawMessageStreamEvent` already describes every event
+                // shape, so `event.type` checks below are compiler-checked instead of
+                // asserted.
+                const event = rawEvent;
+                if (event.type === "message_start") {
+                    const usage = event.message?.usage;
+                    inputTokens += usage?.input_tokens ?? 0;
+                    const startOutput = usage?.output_tokens ?? 0;
+                    outputTokens += startOutput - stepOutputTokens;
+                    stepOutputTokens = startOutput;
+                    // Anthropic reports cache reads/writes separately from input_tokens
+                    // on this same event; without these the stream drops all cache
+                    // accounting.
+                    cacheReadTokens += usage?.cache_read_input_tokens ?? 0;
+                    cacheWriteTokens += usage?.cache_creation_input_tokens ?? 0;
+                    // The guard calibrates from the FULL prompt size, not input_tokens
+                    // alone: on a cache hit the uncached remainder is tiny and using it
+                    // would let the guard drift far under the real cost.
+                    config.noteObservedPromptTokens?.((usage?.input_tokens ?? 0) +
+                        (usage?.cache_read_input_tokens ?? 0) +
+                        (usage?.cache_creation_input_tokens ?? 0));
+                    continue;
+                }
+                if (event.type === "content_block_start") {
+                    const index = event.index ?? 0;
+                    // A redacted_thinking block carries its whole payload here and
+                    // produces no deltas, so if it is not captured on this event it is
+                    // never seen again. Anthropic validates the thinking chain when
+                    // extended thinking continues across a tool-use turn, so a missing
+                    // one fails the NEXT request — and only for accounts where safety
+                    // redaction actually triggers, which is why it survives testing.
+                    if (event.content_block?.type === "redacted_thinking") {
+                        const data = event.content_block.data;
+                        if (typeof data === "string") {
+                            redactedByIndex.set(index, data);
+                        }
+                    }
+                    if (event.content_block?.type === "tool_use") {
+                        toolByIndex.set(index, {
+                            id: event.content_block.id ?? "",
+                            name: event.content_block.name ?? "",
+                            inputJson: "",
+                        });
+                    }
+                    continue;
+                }
+                if (event.type === "content_block_delta") {
+                    const index = event.index ?? 0;
+                    const delta = event.delta;
+                    if (delta?.type === "text_delta" && delta.text) {
+                        text += delta.text;
+                        textByIndex.set(index, (textByIndex.get(index) ?? "") + delta.text);
+                        channel.push({ content: delta.text });
+                    }
+                    else if (delta?.type === "thinking_delta" && delta.thinking) {
+                        const acc = thinkingByIndex.get(index) ?? {
+                            text: "",
+                            signature: "",
+                        };
+                        acc.text += delta.thinking;
+                        thinkingByIndex.set(index, acc);
+                        reasoning += delta.thinking;
+                        // Reasoning rides its own field; `content` stays a present string
+                        // so plain-text consumers are unaffected.
+                        channel.push({ content: "", reasoning: delta.thinking });
+                    }
+                    else if (delta?.type === "signature_delta" && delta.signature) {
+                        const acc = thinkingByIndex.get(index) ?? {
+                            text: "",
+                            signature: "",
+                        };
+                        acc.signature += delta.signature;
+                        thinkingByIndex.set(index, acc);
+                    }
+                    else if (delta?.type === "input_json_delta" && delta.partial_json) {
+                        const pending = toolByIndex.get(index);
+                        if (pending) {
+                            pending.inputJson += delta.partial_json;
+                        }
+                    }
+                    continue;
+                }
+                if (event.type === "message_delta") {
+                    rawStopReason = event.delta?.stop_reason ?? rawStopReason;
+                    const cumulative = event.usage?.output_tokens ?? stepOutputTokens;
+                    outputTokens += cumulative - stepOutputTokens;
+                    stepOutputTokens = cumulative;
+                }
+            }
+            // JSON.parse happily yields null, an array or a primitive, and an
+            // assertion converts none of them. Both `tool_use.input` and
+            // AgenticLoopToolCall.args require an object, so anything else becomes
+            // {} rather than being passed through as invalid wire content.
+            const parseArgs = (json) => {
+                if (!json) {
+                    return {};
+                }
+                try {
+                    const parsed = JSON.parse(json);
+                    return typeof parsed === "object" &&
+                        parsed !== null &&
+                        !Array.isArray(parsed)
+                        ? parsed
+                        : {};
+                }
+                catch {
+                    return {};
+                }
+            };
+            // Rebuild the assistant turn in wire order so it can be replayed as the
+            // assistant message on the next step. Text that arrived before a tool
+            // call has to survive here, or the model stops seeing its own reasoning
+            // mid-turn.
+            const blocks = [];
+            const indices = new Set([
+                ...textByIndex.keys(),
+                ...toolByIndex.keys(),
+                ...thinkingByIndex.keys(),
+                ...redactedByIndex.keys(),
+            ]);
+            for (const index of [...indices].sort((a, b) => a - b)) {
+                // Thinking blocks are replayed with their signature. Anthropic
+                // validates that signature when extended thinking continues across
+                // turns, so dropping the block — or keeping the text without the
+                // signature — breaks the next step of a thinking turn.
+                const redacted = redactedByIndex.get(index);
+                if (redacted) {
+                    blocks.push({ type: "redacted_thinking", data: redacted });
+                }
+                const thinking = thinkingByIndex.get(index);
+                // Both halves required: Anthropic's thinking block carries a
+                // mandatory signature, and replaying one with an empty string is
+                // rejected outright. A thinking block that never received a
+                // signature_delta is dropped rather than sent unsigned.
+                if (thinking?.text && thinking.signature) {
+                    blocks.push({
+                        type: "thinking",
+                        thinking: thinking.text,
+                        signature: thinking.signature,
+                    });
+                }
+                const blockText = textByIndex.get(index);
+                if (blockText) {
+                    blocks.push({
+                        type: "text",
+                        text: blockText,
+                    });
+                }
+                const pending = toolByIndex.get(index);
+                if (pending) {
+                    blocks.push({
+                        type: "tool_use",
+                        id: pending.id,
+                        name: pending.name,
+                        input: parseArgs(pending.inputJson),
+                    });
+                }
+            }
+            const allCalls = [...toolByIndex.values()].map((pending) => ({
+                id: pending.id,
+                name: pending.name,
+                args: parseArgs(pending.inputJson),
+            }));
+            // A terminal structured-output call ends the turn: its arguments are the
+            // answer. Reporting it as text and leaving it out of `toolCalls` is what
+            // routes it through the engine's ordinary zero-tool-calls exit, so it is
+            // never dispatched, never counted against the breaker, and never shows
+            // up as a tool execution.
+            const terminal = config.finalResultToolName
+                ? allCalls.find((call) => call.name === config.finalResultToolName)
+                : undefined;
+            const toolCalls = terminal ? [] : allCalls;
+            const finalText = terminal ? JSON.stringify(terminal.args) : text;
+            return {
+                text: finalText,
+                ...(reasoning ? { reasoning } : {}),
+                toolCalls,
+                usage: {
+                    inputTokens,
+                    outputTokens,
+                    cacheReadTokens,
+                    cacheWriteTokens,
+                },
+                rawStopReason,
+                raw: blocks,
+            };
+        },
+        buildToolResultMessages(conversation, stepResult, toolResults) {
+            const assistantMessage = {
+                role: "assistant",
+                content: stepResult.raw,
+            };
+            const resultMessage = {
+                role: "user",
+                content: toolResults.map((result) => ({
+                    type: "tool_result",
+                    tool_use_id: result.id,
+                    content: result.error
+                        ? `Error executing tool ${result.name}: ${result.error}`
+                        : stringifyAnthropicToolOutput(result.output),
+                    ...(result.error ? { is_error: true } : {}),
+                })),
+            };
+            return [...conversation, assistantMessage, resultMessage];
+        },
+        mapFinishReason: mapAnthropicFinishReason,
+    };
+}
+//# sourceMappingURL=loopAdapter.js.map

package/dist/lib/providers/anthropic/toolOutput.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Tool-result serialization shared by Anthropic's client and its loop adapter.
+ *
+ * Extracted rather than exported from `client.ts` because the adapter is
+ * imported BY the client: importing back the other way would close a cycle.
+ * The behaviour is unchanged from the module-private version it replaces.
+ */
+/** Serialize a tool-result `output` into text for a tool_result block. */
+export declare const stringifyAnthropicToolOutput: (output: unknown) => string;

package/dist/lib/providers/anthropic/toolOutput.js

@@ -0,0 +1,39 @@
+/**
+ * Tool-result serialization shared by Anthropic's client and its loop adapter.
+ *
+ * Extracted rather than exported from `client.ts` because the adapter is
+ * imported BY the client: importing back the other way would close a cycle.
+ * The behaviour is unchanged from the module-private version it replaces.
+ */
+/** Serialize a tool-result `output` into text for a tool_result block. */
+export const stringifyAnthropicToolOutput = (output) => {
+    if (output === null || output === undefined) {
+        return "";
+    }
+    if (typeof output === "string") {
+        return output;
+    }
+    const o = output;
+    if (o.type === "text" && typeof o.value === "string") {
+        return o.value;
+    }
+    if (o.type === "json" || o.type === "error-json") {
+        try {
+            // `?? String(...)`: JSON.stringify returns undefined for an undefined
+            // value, which would break this function's string contract and emit an
+            // invalid tool_result.content.
+            return JSON.stringify(o.value) ?? String(o.value);
+        }
+        catch {
+            return String(o.value);
+        }
+    }
+    try {
+        // Same guard: a function or symbol stringifies to undefined.
+        return JSON.stringify(output) ?? String(output);
+    }
+    catch {
+        return String(output);
+    }
+};
+//# sourceMappingURL=toolOutput.js.map

package/dist/lib/providers/googleNativeGemini3/utils.js

@@ -657,10 +657,18 @@ export async function collectStreamChunksIncremental(stream, channel) {
     let outputTokens = 0;
     let cacheReadTokens = 0;
     let reasoningTokens = 0;
+    // Surfaced so a caller can map SAFETY / MALFORMED_FUNCTION_CALL rather
+    // than inferring the turn ended normally. Additive: existing callers that
+    // ignore it are unaffected.
+    let finishReason;
     for await (const chunk of stream) {
         const chunkRecord = chunk;
         const candidates = chunkRecord.candidates;
         const firstCandidate = candidates?.[0];
+        const candidateFinish = firstCandidate?.finishReason;
+        if (typeof candidateFinish === "string") {
+            finishReason = candidateFinish;
+        }
         const chunkContent = firstCandidate?.content;
         if (chunkContent && Array.isArray(chunkContent.parts)) {
             for (const part of chunkContent.parts) {
@@ -689,6 +697,7 @@ export async function collectStreamChunksIncremental(stream, channel) {
     return {
         rawResponseParts,
         stepFunctionCalls,
+        finishReason,
         inputTokens,
         outputTokens,
         cacheReadTokens,

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

@@ -1,3 +1,6 @@
+import type Anthropic from "@anthropic-ai/sdk";
+import type { Tool } from "./tools.js";
+import type { NativeFunctionCall, NativeToolDeclarationsResult } from "./providers.js";
 /**
  * One chunk on the engine's stream.
  *
@@ -121,6 +124,144 @@ export type AgenticLoopAdapter<TConversation = unknown, TRaw = unknown> = {
     isMalformedStep?(stepResult: AgenticLoopStepResult<TRaw>): boolean;
     buildMalformedRetryNote?(conversation: TConversation): TConversation;
 };
+/**
+ * Construction input for `createAnthropicLoopAdapter`, shared by direct
+ * Anthropic and Vertex+Claude.
+ *
+ * `toolFailureBreaker` is the one field the two call sites must differ on:
+ * Vertex+Claude ports the Gemini loops' failure-strike breaker, native
+ * Anthropic has never had one, and setting it for both would change native
+ * Anthropic's behaviour under the guise of a shared refactor.
+ */
+export type AnthropicLoopAdapterConfig = {
+    client: Pick<Anthropic, "messages">;
+    maxSteps: number;
+    /**
+     * Build one step's request. A closure so the per-turn work the caller
+     * already does — system prompt, tool declarations, sampling, thinking
+     * config, cache breakpoints — stays where it is rather than moving here.
+     */
+    buildParams: (conversation: Anthropic.Messages.MessageParam[], step: number) => Anthropic.Messages.MessageCreateParams;
+    /** The turn's live tool record, used for deferred-catalog resolution. */
+    toolsRecord: Record<string, Tool>;
+    /**
+     * Name of the terminal structured-output tool when one is in play. A call
+     * to it ends the turn: its arguments ARE the answer, so it is reported as
+     * text and omitted from `toolCalls`, which routes it through the engine's
+     * ordinary zero-tool-calls exit.
+     */
+    finalResultToolName?: string;
+    toolFailureBreaker?: AgenticLoopToolFailureBreaker;
+    /**
+     * In-turn context reclaim, run once per step before the request is built.
+     * Returns the rebuilt conversation when it reclaimed, undefined while the
+     * request still fits — leaving history byte-identical in the common case so
+     * the rolling prompt-cache prefix stays valid.
+     *
+     * Provider-supplied because the guard decides and the caller mutates in its
+     * own concrete types: dropping an assistant tool_use message together with
+     * its paired user tool_result is what keeps blocks paired. The loop appends
+     * both every step with nothing else bounding growth, so a migration that
+     * drops this overflows the window mid-turn.
+     */
+    planReclaim?: (conversation: Anthropic.Messages.MessageParam[], step: number) => Anthropic.Messages.MessageParam[] | undefined;
+    /**
+     * Calibration feedback for the provider's reclaim guard: the FULL prompt
+     * size for the step just made — uncached input plus both cache tiers.
+     * Passing input_tokens alone reads a cache-hit step as tiny and lets the
+     * guard drift far under the real cost.
+     */
+    noteObservedPromptTokens?: (promptTokens: number) => void;
+    abortSignal?: AbortSignal;
+};
+/** What one Gemini step produced, carried to `buildToolResultMessages`. */
+export type GeminiStepRaw = {
+    rawResponseParts: unknown[];
+    stepFunctionCalls: NativeFunctionCall[];
+};
+/** One turn entry in a Gemini conversation: a role plus its content parts. */
+export type GeminiTurnContent = {
+    role: string;
+    parts: unknown[];
+};
+/**
+ * Construction input for `createGeminiLoopAdapter`, shared by Google AI Studio
+ * and Vertex Gemini. Both issue `models.generateContentStream` and consume the
+ * same response shape, so one adapter serves four hand-rolled loops.
+ */
+export type GeminiLoopAdapterCoreConfig = {
+    /** Used in log lines and generated tool-call ids. */
+    providerLabel: string;
+    maxSteps: number;
+    /** Build one step's request object (model, contents, config). */
+    buildRequest: (conversation: GeminiTurnContent[], step: number) => unknown;
+    /** Issue the request. Kept injectable so each provider keeps its own client. */
+    sendStep: (request: unknown, signal: AbortSignal) => Promise<AsyncIterable<{
+        functionCalls?: NativeFunctionCall[];
+        [key: string]: unknown;
+    }>>;
+    /**
+     * The turn's live tool record. Mid-turn `search_tools` discovery hydrates
+     * into this, which is what both the declaration refresh and
+     * `resolveToolOnMiss` read.
+     */
+    liveTools: Record<string, Tool>;
+    /**
+     * Declarations built for this turn. Carries `originalNameMap`, which keeps
+     * Google's function-name sanitization on the adapter side of the engine
+     * boundary.
+     */
+    declarations?: NativeToolDeclarationsResult;
+    toolFailureBreaker?: AgenticLoopToolFailureBreaker;
+    /**
+     * In-turn context reclaim, run once per step before the request is built.
+     * Returns the rebuilt conversation when it reclaimed, undefined when the
+     * request still fits.
+     *
+     * Provider-supplied rather than engine-owned because the two Gemini
+     * providers reclaim differently (reclaimAiStudioContext vs
+     * reclaimVertexLoopContext) while the engine only decides WHEN to ask. The
+     * loops append a model turn plus a tool turn every step with nothing else
+     * bounding growth, so a migration that drops this overflows the context
+     * window mid-turn and loses every completed step.
+     */
+    planReclaim?: (conversation: GeminiTurnContent[], step: number) => GeminiTurnContent[] | undefined;
+    /**
+     * Usage feedback for the provider's own context guard, called after each
+     * step with that step's real token counts.
+     */
+    noteUsage?: (inputTokens: number, outputTokens: number) => void;
+};
+/**
+ * Opt in to the single MALFORMED_FUNCTION_CALL retry.
+ *
+ * Vertex Gemini only. AI Studio has no such retry today (confirmed: zero
+ * MALFORMED_FUNCTION_CALL handling in its client), and turning it on there
+ * would be a behaviour change disguised as a shared refactor. The engine owns
+ * the one-retry budget; this only says whether to ask.
+ *
+ * A union rather than two independent optional fields because the retry is
+ * only worth spending a step on if the re-issued request differs from the one
+ * that just failed. `runAgenticLoop` falls back to the unchanged conversation
+ * when no note builder is supplied (`buildMalformedRetryNote?.(…) ??
+ * conversation`), so enabling the retry without one re-sends a byte-identical
+ * request and most often reproduces the same malformed call — a step burned
+ * for nothing. Requiring the builder here makes that combination unsayable
+ * instead of merely discouraged.
+ */
+export type GeminiMalformedRetryConfig = {
+    enableMalformedRetry: true;
+    /**
+     * Append the corrective turn that the retry re-issues with.
+     * Provider-supplied because the note is written in the provider's own
+     * content shape.
+     */
+    buildMalformedRetryNote: (conversation: GeminiTurnContent[]) => GeminiTurnContent[];
+} | {
+    enableMalformedRetry?: false;
+    buildMalformedRetryNote?: never;
+};
+export type GeminiLoopAdapterConfig = GeminiLoopAdapterCoreConfig & GeminiMalformedRetryConfig;
 export type AgenticLoopOptions = {
     tools?: Record<string, {
         execute?: (args: Record<string, unknown>, opts: unknown) => Promise<unknown>;

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

@@ -842,6 +842,12 @@ export type BedrockContentBlock = {
 export type BedrockPendingContentBlock = BedrockContentBlock & {
     _inputBuffer?: string;
 };
+/** A tool_use block being assembled across Anthropic `input_json_delta` events. */
+export type AnthropicPendingToolUse = {
+    id: string;
+    name: string;
+    inputJson: string;
+};
 /**
  * Bedrock message structure
  */
@@ -1732,6 +1738,8 @@ export type NativeFunctionResponse = {
 export type CollectedChunkResult = {
     rawResponseParts: unknown[];
     stepFunctionCalls: NativeFunctionCall[];
+    /** Raw `Candidate.finishReason` from the last chunk that carried one. */
+    finishReason?: string;
     inputTokens: number;
     outputTokens: number;
     /**

package/dist/providers/anthropic/client.js

@@ -22,6 +22,7 @@ import { redactUrlCredentials } from "../../utils/logSanitize.js";
 import { ANTHROPIC_MAX_CACHE_BREAKPOINTS, applyAnthropicHistoryCacheBreakpoints, countAnthropicCacheMarkers, } from "../../utils/anthropicCacheBreakpoints.js";
 import { calculateCost } from "../../utils/pricing.js";
 import { resolveDeferredTool } from "../../tools/toolDiscovery.js";
+import { stringifyAnthropicToolOutput } from "./toolOutput.js";
 import { createAnthropicConfig, getProviderModel, validateApiKey, } from "../../utils/providerConfig.js";
 import { composeAbortSignals, createTimeoutController, mergeAbortSignals, } from "../../utils/timeout.js";
 import { resolveToolChoice } from "../../utils/toolChoice.js";
@@ -183,33 +184,6 @@ const detectAuthMethod = (oauthToken) => {
 // ───────────────────────────────────────────────────────────────────────────
 // Native Messages-API conversion helpers (NeuroLink/V3 shapes → Anthropic)
 // ───────────────────────────────────────────────────────────────────────────
-/** Serialize a tool-result `output` into text for a tool_result block. */
-const stringifyAnthropicToolOutput = (output) => {
-    if (output === null || output === undefined) {
-        return "";
-    }
-    if (typeof output === "string") {
-        return output;
-    }
-    const o = output;
-    if (o.type === "text" && typeof o.value === "string") {
-        return o.value;
-    }
-    if (o.type === "json" || o.type === "error-json") {
-        try {
-            return JSON.stringify(o.value);
-        }
-        catch {
-            return String(o.value);
-        }
-    }
-    try {
-        return JSON.stringify(output);
-    }
-    catch {
-        return String(output);
-    }
-};
 /**
  * Convert NeuroLink/V3-shaped messages (the shape produced by
  * buildMessagesForStream and by the AI-SDK prompt on the V3 doGenerate path)

package/dist/providers/anthropic/loopAdapter.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Direct Anthropic's adapter onto the shared agentic loop engine.
+ *
+ * Everything here is the wire-format half of the turn: building one Messages
+ * request, folding an SSE event sequence into content blocks, serializing tool
+ * results back into the conversation, and mapping the stop reason. The turn
+ * loop, the step cap, tool dispatch, retry and usage accumulation belong to
+ * `runAgenticLoop`.
+ *
+ * Two behaviours here are easy to lose in a migration and are called out
+ * because losing either is silent:
+ *
+ *  - Thinking deltas ride the channel as `{ content: "", reasoning }`. The
+ *    engine's chunk type carries `reasoning` for exactly this reason; a
+ *    channel that only understood `content` would drop every thinking delta
+ *    while the text path kept working.
+ *  - `resolveToolOnMiss` is wired to real deferred-catalog hydration, not as
+ *    interface decoration. The pre-migration loop resolves every tool call as
+ *    `toolsRecord[name] ?? resolveDeferredTool(toolsRecord, name)`, which is
+ *    how a cataloged tool the model calls without having loaded it via
+ *    `search_tools` gets found. Dropping it would break those tools with a
+ *    "Tool not found" that looks like a hallucination.
+ */
+import type Anthropic from "@anthropic-ai/sdk";
+import type { AgenticLoopAdapter, AnthropicLoopAdapterConfig } from "../../types/index.js";
+export declare function createAnthropicLoopAdapter(config: AnthropicLoopAdapterConfig): AgenticLoopAdapter<Anthropic.Messages.MessageParam[], Anthropic.Messages.ContentBlockParam[]>;