@juspay/neurolink 11.2.4 → 11.3.0

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

@@ -639,80 +639,6 @@ export async function collectStreamChunks(stream) {
         reasoningTokens,
     };
 }
-/**
- * Create a push-based text channel that bridges a background producer
- * (the agentic tool-calling loop) with an async-iterable consumer.
- *
- * This enables truly incremental streaming: text parts are yielded to the
- * caller as they arrive from the network, rather than being buffered until
- * the model finishes generating.
- */
-export function createTextChannel() {
-    const queue = [];
-    let done = false;
-    let fatalError = undefined;
-    // Resolve the current "wait for data" promise when new data arrives
-    let notify = null;
-    function wake() {
-        if (notify) {
-            const fn = notify;
-            notify = null;
-            fn();
-        }
-    }
-    function push(text) {
-        if (done) {
-            return;
-        }
-        queue.push({ content: text });
-        wake();
-    }
-    function close() {
-        done = true;
-        wake();
-    }
-    function error(err) {
-        done = true;
-        fatalError = err;
-        wake();
-    }
-    let readIndex = 0;
-    async function* iterable() {
-        try {
-            while (true) {
-                if (readIndex < queue.length) {
-                    yield queue[readIndex++];
-                    // Periodically compact consumed chunks to avoid unbounded retention
-                    if (readIndex > 1024 && readIndex * 2 >= queue.length) {
-                        queue.splice(0, readIndex);
-                        readIndex = 0;
-                    }
-                }
-                else if (done) {
-                    if (fatalError !== undefined) {
-                        throw fatalError instanceof Error
-                            ? fatalError
-                            : new Error(String(fatalError));
-                    }
-                    return;
-                }
-                else {
-                    // Wait until the producer pushes data or signals completion
-                    await new Promise((resolve) => {
-                        notify = resolve;
-                    });
-                }
-            }
-        }
-        finally {
-            // Consumer stopped reading (e.g. disconnect/cancel): stop buffering.
-            done = true;
-            queue.length = 0;
-            notify?.();
-        }
-    }
-    return { push, close, error, iterable: iterable() };
-}
 /**
  * Iterate a single stream step incrementally, pushing text parts to `channel`
  * as they arrive from the network while simultaneously accumulating the full
@@ -741,7 +667,7 @@ export async function collectStreamChunksIncremental(stream, channel) {
                 rawResponseParts.push(part);
                 // Forward text parts to the consumer immediately
                 if (typeof part.text === "string" && part.text.length > 0) {
-                    channel.push(part.text);
+                    channel.push({ content: part.text });
                 }
             }
         }

package/dist/lib/providers/googleVertex/client.js

@@ -29,7 +29,9 @@ import { convertZodToJsonSchema, inlineJsonSchema, ensureNestedSchemaTypes, } fr
 import { createNativeThinkingConfig } from "../../utils/thinkingConfig.js";
 import { TimeoutError, raceWithAbort, withTimeout, } from "../../utils/async/index.js";
 import { parseTimeout } from "../../utils/timeout.js";
-import { appendStepText, buildAbortedTurnMessage, buildContextCapMessage, buildToolLoopCapMessage, buildTurnStalledMessage, buildTurnTimeoutMessage, buildWrapupNudgeText, createContextGuard, createTextChannel, createTurnClock, extractThoughtSignature, isAbortError, mapGeminiFinishReason, prependConversationMessages, resolveTurnStopReason, DedupExecuteMap, } from "../googleNativeGemini3/index.js";
+import { appendStepText, buildAbortedTurnMessage, buildContextCapMessage, buildToolLoopCapMessage, buildTurnStalledMessage, buildTurnTimeoutMessage, buildWrapupNudgeText, createContextGuard, createTurnClock, extractThoughtSignature, isAbortError, mapGeminiFinishReason, prependConversationMessages, resolveTurnStopReason, DedupExecuteMap, } from "../googleNativeGemini3/index.js";
+import { createStreamChannel } from "../../core/streamChannel.js";
+import { toNativeToolDeclarations } from "../../core/nativeToolFormat.js";
 import { getAvailableInputTokens, getContextWindowSize, } from "../../constants/contextWindows.js";
 import { resolveLiveTool } from "../../tools/toolDiscovery.js";
 import { ATTR, LANGFUSE_ATTR, spanJsonAttribute, tracers, withClientSpan, withClientStreamSpan, withSpan, } from "../../telemetry/index.js";
@@ -1145,17 +1147,14 @@ export class GoogleVertexProvider extends BaseProvider {
         if (options.tools &&
             Object.keys(options.tools).length > 0 &&
             !options.disableTools) {
-            const functionDeclarations = [];
-            for (const [name, tool] of Object.entries(options.tools)) {
-                functionDeclarations.push(this.buildGeminiFunctionDeclaration(name, tool));
-                if (tool.execute) {
-                    executeMap.set(name, tool.execute);
-                }
+            const declared = toNativeToolDeclarations(options.tools, "functionDeclarations");
+            tools = declared.toolsConfig;
+            for (const [name, execute] of declared.executeMap) {
+                executeMap.set(name, execute);
             }
-            tools = [{ functionDeclarations }];
             logger.debug("[GoogleVertex] Converted tools for native SDK", {
-                toolCount: functionDeclarations.length,
-                toolNames: functionDeclarations.map((t) => t.name),
+                toolCount: declared.toolsConfig[0].functionDeclarations.length,
+                toolNames: declared.toolsConfig[0].functionDeclarations.map((t) => t.name),
             });
         }
         // Check if we need to use the final_result tool pattern for structured output with tools
@@ -2154,17 +2153,14 @@ export class GoogleVertexProvider extends BaseProvider {
         let tools;
         const executeMap = new DedupExecuteMap();
         if (Object.keys(combinedTools).length > 0) {
-            const functionDeclarations = [];
-            for (const [name, tool] of Object.entries(combinedTools)) {
-                functionDeclarations.push(this.buildGeminiFunctionDeclaration(name, tool));
-                if (tool.execute) {
-                    executeMap.set(name, tool.execute);
-                }
+            const declared = toNativeToolDeclarations(combinedTools, "functionDeclarations");
+            tools = declared.toolsConfig;
+            for (const [name, execute] of declared.executeMap) {
+                executeMap.set(name, execute);
             }
-            tools = [{ functionDeclarations }];
             logger.debug("[GoogleVertex] Converted tools for native SDK generate", {
-                toolCount: functionDeclarations.length,
-                toolNames: functionDeclarations.map((t) => t.name),
+                toolCount: declared.toolsConfig[0].functionDeclarations.length,
+                toolNames: declared.toolsConfig[0].functionDeclarations.map((t) => t.name),
             });
         }
         // Check if we need to use the final_result tool pattern for structured output with tools
@@ -3374,7 +3370,7 @@ export class GoogleVertexProvider extends BaseProvider {
             : maxSteps;
         const allToolCalls = [];
         const toolExecutions = [];
-        const channel = createTextChannel();
+        const channel = createStreamChannel();
         // Mutable holders the StreamResult references. Background loop updates
         // these as state progresses; consumer reads them after iterating the
         // stream to completion (channel.close() is called AFTER mutations).
@@ -3593,7 +3589,7 @@ export class GoogleVertexProvider extends BaseProvider {
                                     firstDeltaSeen = true;
                                     generationSpan.setAttribute(LANGFUSE_ATTR.OBSERVATION_COMPLETION_START_TIME, new Date().toISOString());
                                 }
-                                channel.push(delta);
+                                channel.push({ content: delta });
                                 liveTextPushedLength += delta.length;
                             }
                         });
@@ -3694,7 +3690,7 @@ export class GoogleVertexProvider extends BaseProvider {
                         const finalResultCall = toolUseBlocks.find((block) => block.name === "final_result");
                         if (finalResultCall) {
                             structuredOutputRef.value = finalResultCall.input;
-                            channel.push(JSON.stringify(finalResultCall.input));
+                            channel.push({ content: JSON.stringify(finalResultCall.input) });
                             modelFinished = true;
                             logger.debug("[GoogleVertex] Extracted structured output from final_result tool (stream)", { keys: Object.keys(finalResultCall.input) });
                             break;
@@ -4052,7 +4048,7 @@ export class GoogleVertexProvider extends BaseProvider {
                                 maxSteps,
                                 toolCallCount: externalToolCallCount,
                             });
-                            channel.push(exitMessage);
+                            channel.push({ content: exitMessage });
                             aggregatedTurnText = exitMessage;
                         }
                     }
@@ -4117,7 +4113,9 @@ export class GoogleVertexProvider extends BaseProvider {
                             const forcedFinalResult = response.content.find((block) => block.type === "tool_use" && block.name === "final_result");
                             if (forcedFinalResult) {
                                 structuredOutputRef.value = forcedFinalResult.input;
-                                channel.push(JSON.stringify(forcedFinalResult.input));
+                                channel.push({
+                                    content: JSON.stringify(forcedFinalResult.input),
+                                });
                                 synthesizedFinalAnswer = true;
                                 logger.debug("[GoogleVertex] Forced finalization returned structured output (stream)", { keys: Object.keys(forcedFinalResult.input) });
                             }
@@ -4125,7 +4123,7 @@ export class GoogleVertexProvider extends BaseProvider {
                                 const capMessage = hitContextLimit
                                     ? buildContextCapMessage(externalToolCallCount)
                                     : buildToolLoopCapMessage(maxSteps, externalToolCallCount);
-                                channel.push(capMessage);
+                                channel.push({ content: capMessage });
                                 aggregatedTurnText += capMessage;
                             }
                         }
@@ -4151,7 +4149,7 @@ export class GoogleVertexProvider extends BaseProvider {
                                     maxSteps,
                                     toolCallCount: externalToolCallCount,
                                 });
-                            channel.push(exitMessage);
+                            channel.push({ content: exitMessage });
                             aggregatedTurnText += exitMessage;
                         }
                     }
@@ -4222,14 +4220,14 @@ export class GoogleVertexProvider extends BaseProvider {
                                     .join("");
                                 if (backstopText) {
                                     synthesizedFinalAnswer = true;
-                                    channel.push(backstopText);
+                                    channel.push({ content: backstopText });
                                     aggregatedTurnText = backstopText;
                                 }
                                 else {
                                     const capMessage = hitContextLimit
                                         ? buildContextCapMessage(externalToolCallCount)
                                         : buildToolLoopCapMessage(maxSteps, externalToolCallCount);
-                                    channel.push(capMessage);
+                                    channel.push({ content: capMessage });
                                     aggregatedTurnText = capMessage;
                                 }
                             }
@@ -4255,7 +4253,7 @@ export class GoogleVertexProvider extends BaseProvider {
                                         maxSteps,
                                         toolCallCount: externalToolCallCount,
                                     });
-                                channel.push(exitMessage);
+                                channel.push({ content: exitMessage });
                                 aggregatedTurnText = exitMessage;
                             }
                         }
@@ -4281,7 +4279,7 @@ export class GoogleVertexProvider extends BaseProvider {
                             maxSteps,
                             toolCallCount: externalToolCallTotal,
                         });
-                    channel.push(exitMessage);
+                    channel.push({ content: exitMessage });
                     aggregatedTurnText = exitMessage;
                 }
                 // Honest finish reason (same mapping as the generate twin): "length"

package/dist/lib/providers/openaiChatCompletionsBase.js

@@ -36,7 +36,8 @@ import { resolveToolChoice } from "../utils/toolChoice.js";
 import { transformToolExecutions } from "../utils/transformationUtils.js";
 import { withProviderRetry } from "../utils/providerRetry.js";
 import { resolveDeferredTool } from "../tools/toolDiscovery.js";
-import { buildAPIError, buildBody, buildToolsForOpenAI, buildWireToolNameMaps, createChunkQueue, createDeferredAnalytics, ensureJsonWordInBody, estimateWireTokens, mapNeuroLinkToolChoice, mergeUsage, messageBuilderToOpenAI, parseSSEStream, stringifyToolOutput, stripTrailingSlash, v3ResponseFormatToOpenAI, v3ToolChoiceToOpenAI, v3ToolsToOpenAI, } from "./openaiChatCompletionsClient.js";
+import { buildAPIError, buildBody, buildToolsForOpenAI, buildWireToolNameMaps, createDeferredAnalytics, ensureJsonWordInBody, estimateWireTokens, mapNeuroLinkToolChoice, mergeUsage, messageBuilderToOpenAI, parseSSEStream, stringifyToolOutput, stripTrailingSlash, v3ResponseFormatToOpenAI, v3ToolChoiceToOpenAI, v3ToolsToOpenAI, } from "./openaiChatCompletionsClient.js";
+import { createStreamChannel } from "../core/streamChannel.js";
 /**
  * Safety margin (tokens) when fitting `max_tokens` to a runtime-discovered
  * context window: the char-based input estimate and the backend's own prompt
@@ -647,7 +648,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         const toolsUsed = [];
         const toolExecutionSummaries = [];
         const { usagePromise, finishPromise, resolveUsage, resolveFinish } = createDeferredAnalytics();
-        const { pushChunk, nextChunk } = createChunkQueue();
+        const channel = createStreamChannel();
         // Per-provider lifecycle hook (e.g. OTel span wrap for LiteLLM).
         const lifecycle = this.onStreamStart(modelId);
         const loopPromise = this.runStreamLoop({
@@ -665,7 +666,8 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             emitter,
             toolsUsed,
             toolExecutionSummaries,
-            pushChunk,
+            pushChunk: channel.push,
+            closeChannel: channel.close,
             resolveUsage,
             resolveFinish,
         });
@@ -695,11 +697,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         const transformedStream = async function* () {
             let contentYielded = 0;
             try {
-                for (;;) {
-                    const chunk = await nextChunk();
-                    if ("done" in chunk) {
-                        break;
-                    }
+                for await (const chunk of channel.iterable) {
                     if ("content" in chunk &&
                         typeof chunk.content === "string" &&
                         chunk.content.length > 0) {
@@ -707,7 +705,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                     }
                     yield chunk;
                 }
-                // Surface any error that the loop threw after we drained the queue.
+                // Surface any error that the loop threw after we drained the channel.
                 await loopPromise;
                 // No-output path: stream completed normally but yielded zero text.
                 // Build an enriched sentinel + stamp the active OTel span so
@@ -782,7 +780,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         return result;
     }
     async runStreamLoop(args) {
-        const { maxSteps, modelId, url, fetchImpl, abortSignal, options, conversation, openAITools, openAIToolChoice, toolsRecord, toolNameFromWire, emitter, toolsUsed, toolExecutionSummaries, pushChunk, resolveUsage, resolveFinish, } = args;
+        const { maxSteps, modelId, url, fetchImpl, abortSignal, options, conversation, openAITools, openAIToolChoice, toolsRecord, toolNameFromWire, emitter, toolsUsed, toolExecutionSummaries, pushChunk, closeChannel, resolveUsage, resolveFinish, } = args;
         // Hoisted above the try so the catch can resolve the usage accumulated
         // by steps that completed BEFORE the failure — those steps were billed.
         let stepFinish = null;
@@ -905,7 +903,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             }
             resolveUsage(toDeferredUsage());
             resolveFinish(stepFinish ?? "stop");
-            pushChunk({ done: true });
+            closeChannel();
             return {
                 finishReason: stepFinish ?? "stop",
                 usage: stepUsage,
@@ -919,7 +917,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             // instead of zeroing the whole turn.
             resolveUsage(toDeferredUsage());
             resolveFinish("error");
-            pushChunk({ done: true });
+            closeChannel();
             throw err;
         }
     }

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

@@ -13,7 +13,7 @@
  * Nothing here imports from "ai" or "@ai-sdk/*". The whole point of this
  * module is to be the native replacement for the AI SDK's OpenAI wrapper.
  */
-import type { OpenAICompatBuildBodyArgs, OpenAICompatChatMessage, OpenAICompatChatRequest, OpenAICompatChatTool, OpenAICompatMessage, OpenAICompatMessageContent, OpenAICompatResponseFormat, OpenAICompatSSEResult, OpenAICompatStreamChunk, OpenAICompatToolChoiceWire, OpenAICompatUsage, OpenAICompatV3CallToolChoice, OpenAICompatV3CallTools, DeferredUsage, Tool } from "../types/index.js";
+import type { OpenAICompatBuildBodyArgs, OpenAICompatChatMessage, OpenAICompatChatRequest, OpenAICompatChatTool, OpenAICompatMessage, OpenAICompatMessageContent, OpenAICompatResponseFormat, OpenAICompatSSEResult, OpenAICompatToolChoiceWire, OpenAICompatUsage, OpenAICompatV3CallToolChoice, OpenAICompatV3CallTools, DeferredUsage, Tool } from "../types/index.js";
 export declare const stripTrailingSlash: (s: string) => string;
 /**
  * Build a bijective original ↔ wire tool-name map. Returns undefined when
@@ -67,8 +67,4 @@ export declare const createDeferredAnalytics: () => {
     resolveUsage: (u: DeferredUsage) => void;
     resolveFinish: (reason: string) => void;
 };
-export declare const createChunkQueue: () => {
-    pushChunk: (c: OpenAICompatStreamChunk) => void;
-    nextChunk: () => Promise<OpenAICompatStreamChunk>;
-};
 export declare const mergeUsage: (a: OpenAICompatUsage | undefined, b: OpenAICompatUsage | undefined) => OpenAICompatUsage | undefined;

package/dist/lib/providers/openaiChatCompletionsClient.js

@@ -649,32 +649,6 @@ export const createDeferredAnalytics = () => {
     });
     return { usagePromise, finishPromise, resolveUsage, resolveFinish };
 };
-// Single-producer / single-consumer chunk queue. The streaming loop pushes
-// `{content}` deltas as they arrive from SSE and a final `{done:true}` when
-// it finishes; the consumer's AsyncIterable pulls from `nextChunk()`.
-export const createChunkQueue = () => {
-    const chunkQueue = [];
-    let pendingResolve;
-    const pushChunk = (c) => {
-        if (pendingResolve) {
-            const r = pendingResolve;
-            pendingResolve = undefined;
-            r(c);
-        }
-        else {
-            chunkQueue.push(c);
-        }
-    };
-    const nextChunk = () => new Promise((resolve) => {
-        if (chunkQueue.length > 0) {
-            resolve(chunkQueue.shift());
-        }
-        else {
-            pendingResolve = resolve;
-        }
-    });
-    return { pushChunk, nextChunk };
-};
 export const mergeUsage = (a, b) => {
     if (!a) {
         return b;

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

@@ -32,12 +32,14 @@ export * from "./hitl.js";
 export * from "./isolatedAgent.js";
 export * from "./knowledge.js";
 export * from "./livekit.js";
+export * from "./loopEngine.js";
 export * from "./mcp.js";
 export * from "./mcpOutput.js";
 export * from "./memory.js";
 export * from "./middleware.js";
 export * from "./model.js";
 export * from "./multimodal.js";
+export * from "./nativeTools.js";
 export * from "./observability.js";
 export * from "./openaiCompatible.js";
 export * from "./ppt.js";
@@ -51,6 +53,7 @@ export * from "./server.js";
 export * from "./service.js";
 export * from "./skills.js";
 export * from "./stream.js";
+export * from "./streaming.js";
 export * from "./subscription.js";
 export * from "./task.js";
 export * from "./taskClassification.js";

package/dist/lib/types/index.js

@@ -33,12 +33,14 @@ export * from "./hitl.js";
 export * from "./isolatedAgent.js";
 export * from "./knowledge.js";
 export * from "./livekit.js";
+export * from "./loopEngine.js";
 export * from "./mcp.js";
 export * from "./mcpOutput.js";
 export * from "./memory.js";
 export * from "./middleware.js";
 export * from "./model.js";
 export * from "./multimodal.js";
+export * from "./nativeTools.js";
 export * from "./observability.js";
 export * from "./openaiCompatible.js";
 export * from "./ppt.js";
@@ -52,6 +54,7 @@ export * from "./server.js";
 export * from "./service.js";
 export * from "./skills.js";
 export * from "./stream.js";
+export * from "./streaming.js";
 export * from "./subscription.js";
 export * from "./task.js";
 export * from "./taskClassification.js";

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

@@ -0,0 +1,78 @@
+export type AgenticLoopToolCall = {
+    id: string;
+    name: string;
+    args: Record<string, unknown>;
+};
+export type AgenticLoopUsage = {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+    reasoningTokens?: number;
+};
+export type AgenticLoopStepResult<TRaw = unknown> = {
+    text: string;
+    reasoning?: string;
+    toolCalls: AgenticLoopToolCall[];
+    usage: AgenticLoopUsage;
+    /** Provider's own raw stop/finish-reason string, e.g. "tool_use", "MAX_TOKENS" */
+    rawStopReason: string | undefined;
+    /** Adapter-private accumulated response data needed by buildToolResultMessages
+     *  (e.g. Anthropic's ordered content blocks, Gemini's rawResponseParts). */
+    raw: TRaw;
+};
+export type AgenticLoopToolCallResult = AgenticLoopToolCall & {
+    output: unknown;
+    error?: string;
+    permanentlyFailed?: boolean;
+};
+export type AgenticLoopStepRequest = {
+    raw: unknown;
+};
+export type AgenticLoopReclaimResult<TConversation> = {
+    conversation: TConversation;
+};
+export type AgenticLoopToolFailureBreaker = {
+    maxRetries: number;
+};
+export type AgenticLoopAdapter<TConversation = unknown, TRaw = unknown> = {
+    readonly providerLabel: string;
+    readonly maxSteps: number;
+    /** Pre-existing per-family flat timeout, used as createTurnClock's deadline default. */
+    readonly defaultTurnTimeoutMs?: number;
+    readonly stallTimeoutMs?: number;
+    /** Set only for adapter instances whose client has the TOOL_NOT_FOUND strike breaker today: both Gemini adapters (AI Studio, Vertex+Gemini) AND the Vertex+Claude call to createAnthropicLoopAdapter — NOT the native-Anthropic call to that same factory, and not Bedrock. See Verified Fact 4. */
+    readonly toolFailureBreaker?: AgenticLoopToolFailureBreaker;
+    buildStepRequest(conversation: TConversation, step: number): AgenticLoopStepRequest;
+    executeStep(request: AgenticLoopStepRequest, channel: {
+        push(chunk: {
+            content: string;
+        }): void;
+    }, signal: AbortSignal): Promise<AgenticLoopStepResult<TRaw>>;
+    buildToolResultMessages(conversation: TConversation, stepResult: AgenticLoopStepResult<TRaw>, toolResults: AgenticLoopToolCallResult[]): TConversation;
+    mapFinishReason(rawStopReason: string | undefined, hadToolCalls: boolean): string;
+    /** Optional: in-turn context-budget reclaim, called once per step before buildStepRequest. */
+    planReclaim?(conversation: TConversation, step: number): AgenticLoopReclaimResult<TConversation> | undefined;
+    /** Optional: Vertex+Gemini-only single-retry-on-malformed-call. */
+    isMalformedStep?(stepResult: AgenticLoopStepResult<TRaw>): boolean;
+    buildMalformedRetryNote?(conversation: TConversation): TConversation;
+};
+export type AgenticLoopOptions = {
+    tools?: Record<string, {
+        execute?: (args: Record<string, unknown>, opts: unknown) => Promise<unknown>;
+    }>;
+    abortSignal?: AbortSignal;
+};
+export type AgenticLoopResult<TConversation> = {
+    text: string;
+    toolCalls: AgenticLoopToolCall[];
+    toolExecutions: Array<{
+        name: string;
+        input: Record<string, unknown>;
+        output: unknown;
+    }>;
+    usage: AgenticLoopUsage;
+    finishReason: string;
+    rawStopReason: string | undefined;
+    conversation: TConversation;
+};

package/dist/lib/types/loopEngine.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=loopEngine.js.map

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

@@ -0,0 +1,16 @@
+/**
+ * Wire formats accepted by `toNativeToolDeclarations` (src/lib/core/nativeToolFormat.ts).
+ * `"input_schema"` is Anthropic's native Messages-API tool shape;
+ * `"functionDeclarations"` is the @google/genai SDK shape shared by the
+ * Gemini-family native providers (Google AI Studio, Vertex+Gemini).
+ */
+export type NativeToolFormat = "input_schema" | "functionDeclarations";
+/** A single tool declaration in Anthropic's native `input_schema` wire format. */
+export type NativeAnthropicToolDeclaration = {
+    name: string;
+    description?: string;
+    input_schema: Record<string, unknown>;
+    cache_control?: {
+        type: "ephemeral";
+    };
+};

package/dist/lib/types/nativeTools.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=nativeTools.js.map

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

@@ -203,8 +203,6 @@ export type OpenAICompatSSEResult = {
 export type OpenAICompatStreamChunk = {
     content: string;
     reasoning?: string;
-} | {
-    done: true;
 };
 export type ToolExecutionSummaryInternal = {
     toolCallId: string;
@@ -232,6 +230,8 @@ export type StreamLoopArgs = {
     toolsUsed: string[];
     toolExecutionSummaries: ToolExecutionSummaryInternal[];
     pushChunk: (chunk: OpenAICompatStreamChunk) => void;
+    /** Signals the channel that no further chunks will arrive (success or error path alike). */
+    closeChannel: () => void;
     resolveUsage: (u: {
         promptTokens: number;
         completionTokens: number;

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

@@ -1740,19 +1740,6 @@ export type CollectedChunkResult = {
      */
     reasoningTokens?: number;
 };
-/** Push-based text channel for incremental streaming. */
-export type TextChannel = {
-    /** Push a text chunk to the consumer. */
-    push: (text: string) => void;
-    /** Signal that no more chunks will arrive. */
-    close: () => void;
-    /** Signal that the producer encountered a fatal error. */
-    error: (err: unknown) => void;
-    /** Async iterable consumed by the StreamResult. */
-    iterable: AsyncIterable<{
-        content: string;
-    }>;
-};
 /** Language model object shape (LanguageModelV2/V3). */
 export type LanguageModelObject = {
     readonly modelId: string;

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

@@ -0,0 +1,15 @@
+/**
+ * Shared push-based channel bridging a background producer (an agentic
+ * tool-calling loop) with an async-iterable consumer. Replaces the two
+ * independently-invented primitives this type unifies: the OpenAI-family
+ * `createChunkQueue` (pull-based, in-band `{done:true}` sentinel) and the
+ * Gemini-family `createTextChannel` (push-based, out-of-band close/error).
+ */
+export type StreamChannel<T = {
+    content: string;
+}> = {
+    push(value: T): void;
+    close(): void;
+    error(err: unknown): void;
+    readonly iterable: AsyncIterable<T>;
+};

package/dist/lib/types/streaming.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=streaming.js.map

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

@@ -0,0 +1,12 @@
+import type Anthropic from "@anthropic-ai/sdk";
+/**
+ * Read an Anthropic cache breakpoint from a message/part/tool carrier.
+ * MessageBuilder marks system messages (and GenerationHandler marks the last
+ * tool definition) with `providerOptions.anthropic.cacheControl` — the
+ * AI-SDK-era prompt-caching contract this native path must keep honoring.
+ *
+ * Extracted from anthropic/client.ts so `src/lib/core/nativeToolFormat.ts`
+ * can share it without importing the provider client (which would create a
+ * circular import: client.ts -> core/nativeToolFormat.ts -> client.ts).
+ */
+export declare const cacheControlOf: (carrier: unknown) => Anthropic.Messages.CacheControlEphemeral | undefined;

package/dist/providers/anthropic/cacheControl.js

@@ -0,0 +1,14 @@
+/**
+ * Read an Anthropic cache breakpoint from a message/part/tool carrier.
+ * MessageBuilder marks system messages (and GenerationHandler marks the last
+ * tool definition) with `providerOptions.anthropic.cacheControl` — the
+ * AI-SDK-era prompt-caching contract this native path must keep honoring.
+ *
+ * Extracted from anthropic/client.ts so `src/lib/core/nativeToolFormat.ts`
+ * can share it without importing the provider client (which would create a
+ * circular import: client.ts -> core/nativeToolFormat.ts -> client.ts).
+ */
+export const cacheControlOf = (carrier) => {
+    const cc = carrier?.providerOptions?.anthropic?.cacheControl;
+    return cc?.type === "ephemeral" ? { type: "ephemeral" } : undefined;
+};