@juspay/neurolink 11.2.4 → 11.3.0

package/dist/lib/core/loopEngine.js

@@ -0,0 +1,246 @@
+import { createStreamChannel } from "./streamChannel.js";
+import { logger } from "../utils/logger.js";
+import { withProviderRetry } from "../utils/providerRetry.js";
+/**
+ * Marks a step error that occurred AFTER at least one chunk had already
+ * been streamed to the consumer for this step. Retrying at that point
+ * would duplicate or interleave already-emitted output, so this wrapper
+ * deliberately carries none of the original error's status/retry
+ * metadata (`.statusCode`/`.status`, no APICallError/NeuroLinkError
+ * branding) — that makes `withProviderRetry`'s internal
+ * `isRetryableProviderError()` check return false via its duck-typed
+ * fallback, which ends the retry loop on the very next classification
+ * instead of sleeping and re-invoking `adapter.executeStep`. The engine
+ * unwraps back to the original `cause` before it ever reaches the
+ * caller — see the try/catch around the `withProviderRetry` call below.
+ */
+class PostEmissionStepError extends Error {
+    cause;
+    constructor(cause) {
+        super(cause instanceof Error ? cause.message : String(cause));
+        this.cause = cause;
+    }
+}
+function sumUsage(a, b) {
+    return {
+        inputTokens: a.inputTokens + b.inputTokens,
+        outputTokens: a.outputTokens + b.outputTokens,
+        cacheReadTokens: (a.cacheReadTokens ?? 0) + (b.cacheReadTokens ?? 0) || undefined,
+        cacheWriteTokens: (a.cacheWriteTokens ?? 0) + (b.cacheWriteTokens ?? 0) || undefined,
+        reasoningTokens: (a.reasoningTokens ?? 0) + (b.reasoningTokens ?? 0) || undefined,
+    };
+}
+/**
+ * Run one adapter-parameterized agentic tool-calling turn. Owns the
+ * maxSteps-bounded loop, generic tool dispatch (with an opt-in
+ * TOOL_NOT_FOUND/failure-strike breaker — see AgenticLoopAdapter.toolFailureBreaker),
+ * per-step usage accumulation, a single optional malformed-call retry,
+ * chunk emission through streamChannel, and a pre-first-chunk 429/5xx
+ * retry (via withProviderRetry) around every adapter.executeStep() call.
+ * The retry wrap is unconditional and adapter-agnostic — every migrated
+ * provider gets it for free, not just the ones that had a hand-rolled
+ * version before migration (see Verified Fact 4-adjacent note in Task 4
+ * Step 1 and the Risks & Rollback "Deliberate behavior changes" list for
+ * which families are gaining this for the first time). Everything
+ * wire-format-specific (building the request, parsing the SDK response,
+ * serializing tool results back into the conversation, mapping the raw
+ * stop reason) is delegated to `adapter`.
+ */
+export function runAgenticLoop(adapter, initialConversation, options) {
+    const channel = createStreamChannel();
+    const internalAbort = new AbortController();
+    const onCallerAbort = () => internalAbort.abort();
+    options.abortSignal?.addEventListener("abort", onCallerAbort);
+    if (options.abortSignal?.aborted) {
+        internalAbort.abort();
+    }
+    const failedTools = new Map();
+    let malformedRetryUsed = false;
+    const resultPromise = (async () => {
+        let conversation = initialConversation;
+        let usage = { inputTokens: 0, outputTokens: 0 };
+        let finalText = "";
+        let rawStopReason;
+        const allToolCalls = [];
+        const allToolExecutions = [];
+        let hadToolCallsAtCap = false;
+        try {
+            for (let step = 0; step < adapter.maxSteps; step++) {
+                if (internalAbort.signal.aborted) {
+                    break;
+                }
+                if (adapter.planReclaim) {
+                    const reclaimed = adapter.planReclaim(conversation, step);
+                    if (reclaimed) {
+                        conversation = reclaimed.conversation;
+                    }
+                }
+                const request = adapter.buildStepRequest(conversation, step);
+                // Pre-first-chunk 429/5xx retry: watch whether THIS attempt of
+                // THIS step pushes anything to the shared channel before it
+                // throws. `hasEmitted` resets at the top of every attempt
+                // withProviderRetry makes; the instant an attempt emits and then
+                // throws, the thrown error is rewrapped as a PostEmissionStepError
+                // (no status/branding info survives the rewrap), which
+                // isRetryableProviderError() duck-types as non-retryable — so
+                // withProviderRetry gives up immediately instead of sleeping and
+                // re-invoking executeStep, which would duplicate/interleave
+                // output already sent to the consumer. The original error (not
+                // the wrapper) is what the caller of runAgenticLoop ultimately
+                // sees, via the unwrap in the catch below.
+                let hasEmitted = false;
+                const watchedChannel = {
+                    push: (chunk) => {
+                        hasEmitted = true;
+                        channel.push(chunk);
+                    },
+                };
+                let stepResult;
+                try {
+                    stepResult = await withProviderRetry(async () => {
+                        hasEmitted = false;
+                        try {
+                            return await adapter.executeStep(request, watchedChannel, internalAbort.signal);
+                        }
+                        catch (err) {
+                            throw hasEmitted ? new PostEmissionStepError(err) : err;
+                        }
+                    }, undefined, // no OTel span threaded through the engine today; adapters instrument their own steps if they need span-level detail
+                    `${adapter.providerLabel}.step`);
+                }
+                catch (err) {
+                    throw err instanceof PostEmissionStepError ? err.cause : err;
+                }
+                usage = sumUsage(usage, stepResult.usage);
+                rawStopReason = stepResult.rawStopReason;
+                if (adapter.isMalformedStep?.(stepResult) &&
+                    !malformedRetryUsed &&
+                    !internalAbort.signal.aborted) {
+                    malformedRetryUsed = true;
+                    logger.warn(`[${adapter.providerLabel}] Malformed function call at step ${step + 1}/${adapter.maxSteps}; retrying once.`);
+                    conversation =
+                        adapter.buildMalformedRetryNote?.(conversation) ?? conversation;
+                    continue;
+                }
+                if (stepResult.toolCalls.length === 0) {
+                    finalText = stepResult.text || finalText;
+                    break;
+                }
+                if (step === adapter.maxSteps - 1) {
+                    hadToolCallsAtCap = true;
+                }
+                const toolResults = [];
+                for (const call of stepResult.toolCalls) {
+                    allToolCalls.push(call);
+                    const breaker = adapter.toolFailureBreaker;
+                    const failInfo = breaker ? failedTools.get(call.name) : undefined;
+                    if (breaker && failInfo && failInfo.count >= breaker.maxRetries) {
+                        const output = {
+                            error: `TOOL_PERMANENTLY_FAILED: "${call.name}" has failed ${failInfo.count} times. Last error: ${failInfo.lastError}.`,
+                            status: "permanently_failed",
+                            do_not_retry: true,
+                        };
+                        toolResults.push({
+                            ...call,
+                            output,
+                            error: output.error,
+                            permanentlyFailed: true,
+                        });
+                        allToolExecutions.push({
+                            name: call.name,
+                            input: call.args,
+                            output,
+                        });
+                        continue;
+                    }
+                    const tool = options.tools?.[call.name];
+                    if (!tool?.execute) {
+                        const output = breaker
+                            ? {
+                                error: `TOOL_NOT_FOUND: "${call.name}" does not exist.`,
+                                status: "permanently_failed",
+                                do_not_retry: true,
+                            }
+                            : { error: `Tool not found: ${call.name}` };
+                        toolResults.push({
+                            ...call,
+                            output,
+                            error: output.error,
+                            permanentlyFailed: !!breaker,
+                        });
+                        allToolExecutions.push({
+                            name: call.name,
+                            input: call.args,
+                            output,
+                        });
+                        continue;
+                    }
+                    try {
+                        const output = await tool.execute(call.args, {
+                            toolCallId: call.id,
+                            abortSignal: internalAbort.signal,
+                        });
+                        toolResults.push({ ...call, output });
+                        allToolExecutions.push({
+                            name: call.name,
+                            input: call.args,
+                            output,
+                        });
+                    }
+                    catch (err) {
+                        const message = err instanceof Error ? err.message : String(err);
+                        if (breaker) {
+                            const current = failedTools.get(call.name) ?? {
+                                count: 0,
+                                lastError: "",
+                            };
+                            current.count++;
+                            current.lastError = message;
+                            failedTools.set(call.name, current);
+                        }
+                        const output = { error: message, status: "failed" };
+                        toolResults.push({ ...call, output, error: message });
+                        allToolExecutions.push({
+                            name: call.name,
+                            input: call.args,
+                            output,
+                        });
+                    }
+                }
+                conversation = adapter.buildToolResultMessages(conversation, stepResult, toolResults);
+            }
+            const finishReason = adapter.mapFinishReason(rawStopReason, hadToolCallsAtCap);
+            return {
+                text: finalText,
+                toolCalls: allToolCalls,
+                toolExecutions: allToolExecutions,
+                usage,
+                finishReason,
+                rawStopReason,
+                conversation,
+            };
+        }
+        catch (err) {
+            // Must run before the finally block's channel.close(): a consumer
+            // parked in the channel's iterable is woken by whichever of
+            // error()/close() runs first, and close() alone would let a
+            // stream-only consumer observe a clean end of stream for a turn that
+            // actually failed. Calling error() here — synchronously, inside this
+            // catch — guarantees it lands before close(), with no dependence on
+            // microtask scheduling (unlike an outer promise-chained catch handler
+            // on this IIFE, which would run in a later microtask after `finally`
+            // already closed the channel).
+            channel.error(err);
+            throw err;
+        }
+        finally {
+            // close() after error() is harmless: it only flips `done`, and
+            // streamChannel.error() keeps its error state intact regardless of a
+            // later close() call.
+            channel.close();
+            options.abortSignal?.removeEventListener("abort", onCallerAbort);
+        }
+    })();
+    return { stream: channel.iterable, resultPromise };
+}
+//# sourceMappingURL=loopEngine.js.map

package/dist/lib/core/nativeToolFormat.d.ts

@@ -0,0 +1,33 @@
+import type { NativeAnthropicToolDeclaration, NativeToolDeclarationsResult, Tool } from "../types/index.js";
+/**
+ * Convert a NeuroLink tool record into the wire-format a native
+ * (non-AI-SDK) provider SDK expects. Absorbs the direct-Anthropic
+ * provider's `toolsToAnthropic` — previously duplicated between the
+ * streaming loop's pre-loop snapshot and its mid-turn discovery-hydration
+ * call site (both in anthropic/client.ts). Gemini's `functionDeclarations`
+ * shape was already centralized in `buildNativeToolDeclarations`; this
+ * function is a thin facade over it so every native provider calls one
+ * entry point.
+ *
+ * Scope note: Vertex's Claude-on-Vertex `input_schema` builder
+ * (`buildAnthropicToolDeclaration` in googleVertex/client.ts) is
+ * deliberately NOT routed through this function. Despite the superficial
+ * similarity, it is not a byte-for-byte duplicate of `toolsToAnthropic`: it
+ * strips the converted schema down to `{type, properties, required}` only
+ * (dropping any other JSON-Schema keywords `convertZodToJsonSchema` may
+ * produce), it always runs `inlineJsonSchema` (Anthropic-direct never has),
+ * it prefers `parameters` over `inputSchema` (the opposite fallback order
+ * from Anthropic-direct), and it has no `cache_control` support of its own
+ * because Vertex applies cache breakpoints later via the separate
+ * `applyVertexAnthropicCacheBreakpoints` pass. Collapsing these into one
+ * shared implementation would risk a live tool-calling regression on one
+ * provider or the other; see the Task 2 report for the full comparison.
+ *
+ * These are genuine TS overload declarations, not redeclarations: the base
+ * `no-redeclare` ESLint rule doesn't understand the overload-signatures +
+ * implementation pattern (the TS-aware `@typescript-eslint/no-redeclare`
+ * variant would, but isn't enabled project-wide), so each signature below
+ * is individually exempted.
+ */
+export declare function toNativeToolDeclarations(tools: Record<string, Tool>, format: "input_schema"): NativeAnthropicToolDeclaration[] | undefined;
+export declare function toNativeToolDeclarations(tools: Record<string, Tool>, format: "functionDeclarations"): NativeToolDeclarationsResult;

package/dist/lib/core/nativeToolFormat.js

@@ -0,0 +1,31 @@
+import { buildNativeToolDeclarations } from "../providers/googleNativeGemini3/utils.js";
+import { cacheControlOf } from "../providers/anthropic/cacheControl.js";
+import { convertZodToJsonSchema } from "../utils/schemaConversion.js";
+// eslint-disable-next-line no-redeclare -- TS overload implementation signature, not a redeclaration
+export function toNativeToolDeclarations(tools, format) {
+    if (format === "functionDeclarations") {
+        return buildNativeToolDeclarations(tools);
+    }
+    const entries = Object.entries(tools ?? {});
+    if (entries.length === 0) {
+        return undefined;
+    }
+    return entries.map(([name, tool]) => {
+        const t = tool;
+        const rawSchema = t.inputSchema ?? t.parameters;
+        const input_schema = (rawSchema
+            ? convertZodToJsonSchema(rawSchema)
+            : { type: "object", properties: {} });
+        // GenerationHandler marks the last tool definition with a cache
+        // breakpoint when prompt caching is active — keep honoring it.
+        const cc = cacheControlOf(tool);
+        const declaration = {
+            name,
+            ...(t.description ? { description: t.description } : {}),
+            input_schema,
+            ...(cc ? { cache_control: cc } : {}),
+        };
+        return declaration;
+    });
+}
+//# sourceMappingURL=nativeToolFormat.js.map

package/dist/lib/core/streamChannel.d.ts

@@ -0,0 +1,10 @@
+import type { StreamChannel } from "../types/index.js";
+/**
+ * Create a push-based channel bridging a background producer (an agentic
+ * tool-calling loop) with an async-iterable consumer, enabling truly
+ * incremental streaming: values are yielded to the caller as they arrive
+ * rather than being buffered until the producer finishes.
+ */
+export declare function createStreamChannel<T = {
+    content: string;
+}>(): StreamChannel<T>;

package/dist/lib/core/streamChannel.js

@@ -0,0 +1,77 @@
+/**
+ * Create a push-based channel bridging a background producer (an agentic
+ * tool-calling loop) with an async-iterable consumer, enabling truly
+ * incremental streaming: values are yielded to the caller as they arrive
+ * rather than being buffered until the producer finishes.
+ */
+export function createStreamChannel() {
+    const queue = [];
+    let done = false;
+    let fatalError = undefined;
+    // Tracked separately from `fatalError`: a producer can legitimately
+    // reject with `undefined` (e.g. `throw undefined`), and `fatalError !==
+    // undefined` would then be indistinguishable from "no error occurred",
+    // closing the stream cleanly instead of surfacing the failure.
+    let hasError = false;
+    let notify = null;
+    function wake() {
+        if (notify) {
+            const fn = notify;
+            notify = null;
+            fn();
+        }
+    }
+    function push(value) {
+        if (done) {
+            return;
+        }
+        queue.push(value);
+        wake();
+    }
+    function close() {
+        done = true;
+        wake();
+    }
+    function error(err) {
+        done = true;
+        fatalError = err;
+        hasError = true;
+        wake();
+    }
+    let readIndex = 0;
+    async function* iterable() {
+        try {
+            while (true) {
+                if (readIndex < queue.length) {
+                    yield queue[readIndex++];
+                    // Periodically compact consumed entries to avoid unbounded retention.
+                    if (readIndex > 1024 && readIndex * 2 >= queue.length) {
+                        queue.splice(0, readIndex);
+                        readIndex = 0;
+                    }
+                }
+                else if (done) {
+                    if (hasError) {
+                        throw fatalError instanceof Error
+                            ? fatalError
+                            : new Error(String(fatalError));
+                    }
+                    return;
+                }
+                else {
+                    await new Promise((resolve) => {
+                        notify = resolve;
+                    });
+                }
+            }
+        }
+        finally {
+            // Consumer stopped reading (disconnect/cancel): stop buffering.
+            done = true;
+            queue.length = 0;
+            notify?.();
+        }
+    }
+    return { push, close, error, iterable: iterable() };
+}
+//# sourceMappingURL=streamChannel.js.map

package/dist/lib/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/lib/providers/anthropic/cacheControl.js

@@ -0,0 +1,15 @@
+/**
+ * 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;
+};
+//# sourceMappingURL=cacheControl.js.map

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

@@ -33,8 +33,11 @@ import { resolveClaudeMaxTokens } from "../../utils/tokenLimits.js";
 import { withProviderRetry } from "../../utils/providerRetry.js";
 import { toAnthropicImageBlock, fileToAnthropicBlock, } from "../anthropicImageBlocks.js";
 import { resolveSamplingParams } from "../../models/modelRegistry.js";
-import { createChunkQueue, createDeferredAnalytics, stringifyToolInput, } from "../openaiChatCompletionsClient.js";
+import { createDeferredAnalytics, stringifyToolInput, } from "../openaiChatCompletionsClient.js";
+import { createStreamChannel } from "../../core/streamChannel.js";
+import { toNativeToolDeclarations } from "../../core/nativeToolFormat.js";
 import { ANTHROPIC_BETA_HEADERS } from "./constants.js";
+import { cacheControlOf } from "./cacheControl.js";
 import { appendFinalResultInstruction, appendFinalResultTool, FINAL_RESULT_TOOL_NAME, stringifyFinalResultInput, } from "./structuredOutput.js";
 // AnthropicProviderConfig is imported from types/providers.ts
 // Re-export for backward compatibility
@@ -180,16 +183,6 @@ const detectAuthMethod = (oauthToken) => {
 // ───────────────────────────────────────────────────────────────────────────
 // Native Messages-API conversion helpers (NeuroLink/V3 shapes → Anthropic)
 // ───────────────────────────────────────────────────────────────────────────
-/**
- * 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.
- */
-const cacheControlOf = (carrier) => {
-    const cc = carrier?.providerOptions?.anthropic?.cacheControl;
-    return cc?.type === "ephemeral" ? { type: "ephemeral" } : undefined;
-};
 /** Serialize a tool-result `output` into text for a tool_result block. */
 const stringifyAnthropicToolOutput = (output) => {
     if (output === null || output === undefined) {
@@ -400,29 +393,6 @@ const messagesToAnthropic = (msgs) => {
         messages,
     };
 };
-/** Convert a NeuroLink tool record into Anthropic tool definitions. */
-const toolsToAnthropic = (tools) => {
-    const entries = Object.entries(tools);
-    if (entries.length === 0) {
-        return undefined;
-    }
-    return entries.map(([name, tool]) => {
-        const t = tool;
-        const rawSchema = t.inputSchema ?? t.parameters;
-        const input_schema = (rawSchema
-            ? convertZodToJsonSchema(rawSchema)
-            : { type: "object", properties: {} });
-        // GenerationHandler marks the last tool definition with a cache
-        // breakpoint when prompt caching is active — keep honoring it.
-        const cc = cacheControlOf(tool);
-        return {
-            name,
-            ...(t.description ? { description: t.description } : {}),
-            input_schema,
-            ...(cc ? { cache_control: cc } : {}),
-        };
-    });
-};
 /** Map a NeuroLink tool choice onto Anthropic's tool_choice shape. */
 const toolChoiceToAnthropic = (choice) => {
     if (!choice || choice === "auto") {
@@ -1423,7 +1393,7 @@ export class AnthropicProvider extends BaseProvider {
                 ? options.tools || (await this.getAllTools())
                 : {};
             anthropicTools = shouldUseTools
-                ? toolsToAnthropic(toolsRecord)
+                ? toNativeToolDeclarations(toolsRecord, "input_schema")
                 : undefined;
             // Build message array from options with multimodal support, then
             // convert to the Anthropic Messages payload (system + content blocks).
@@ -1471,7 +1441,8 @@ export class AnthropicProvider extends BaseProvider {
         });
         const maxSteps = options.maxSteps || DEFAULT_MAX_STEPS;
         const emitter = this.neurolink?.getEventEmitter();
-        const { pushChunk, nextChunk } = createChunkQueue();
+        const channel = createStreamChannel();
+        const { push: pushChunk } = channel;
         const { usagePromise, finishPromise, resolveUsage, resolveFinish } = createDeferredAnalytics();
         usagePromise
             .then((usage) => {
@@ -1566,7 +1537,7 @@ export class AnthropicProvider extends BaseProvider {
                     const declared = new Set(anthropicTools.map((t) => t.name));
                     const hydrated = Object.fromEntries(Object.entries(toolsRecord).filter(([name]) => !declared.has(name)));
                     if (Object.keys(hydrated).length > 0) {
-                        anthropicTools.push(...(toolsToAnthropic(hydrated) ?? []));
+                        anthropicTools.push(...(toNativeToolDeclarations(hydrated, "input_schema") ?? []));
                         logger.info(`[Anthropic] ${Object.keys(hydrated).length} tool(s) hydrated mid-turn via discovery: ${Object.keys(hydrated).join(", ")}`);
                     }
                 }
@@ -1932,22 +1903,18 @@ export class AnthropicProvider extends BaseProvider {
                 }
             }
             timeoutController?.cleanup();
-            pushChunk({ done: true });
+            channel.close();
         });
         loopPromise.catch(() => {
             // Swallowed by design: the generator below surfaces loop errors after
-            // draining the queue; this guard only prevents an unhandled-rejection
+            // draining the channel; this guard only prevents an unhandled-rejection
             // crash when the consumer abandons the stream early.
         });
         const providerName = this.providerName;
         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) {
@@ -1955,7 +1922,7 @@ export class AnthropicProvider extends BaseProvider {
                     }
                     yield chunk;
                 }
-                // Surface any error the loop threw after draining the queue.
+                // Surface any error the loop threw after draining the channel.
                 await loopPromise;
                 // No-output path: stream completed normally but yielded zero text.
                 if (contentYielded === 0 && toolsUsed.length === 0) {

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

@@ -14,7 +14,9 @@ import { withTimeout } from "../../utils/async/index.js";
 import { estimateTokens } from "../../utils/tokenEstimation.js";
 import { transformToolExecutions } from "../../utils/transformationUtils.js";
 import { resolveToolExecutionRecords } from "../../core/toolExecutionRecorder.js";
-import { buildGeminiResponseSchema, buildNativeConfig, buildNativeToolDeclarations, collectStreamChunks, collectStreamChunksIncremental, computeMaxSteps, createContextGuard, createTextChannel, buildUserPartsWithMultimodal, executeNativeToolCalls, extractTextFromParts, extractThoughtSignature, handleMaxStepsTermination, prependConversationMessages, pushModelResponseToHistory, refreshNativeToolDeclarations, DedupExecuteMap, } from "../googleNativeGemini3/index.js";
+import { buildGeminiResponseSchema, buildNativeConfig, collectStreamChunks, collectStreamChunksIncremental, computeMaxSteps, createContextGuard, buildUserPartsWithMultimodal, executeNativeToolCalls, extractTextFromParts, extractThoughtSignature, handleMaxStepsTermination, prependConversationMessages, pushModelResponseToHistory, refreshNativeToolDeclarations, DedupExecuteMap, } from "../googleNativeGemini3/index.js";
+import { createStreamChannel } from "../../core/streamChannel.js";
+import { toNativeToolDeclarations } from "../../core/nativeToolFormat.js";
 import { createProxyFetch } from "../../proxy/proxyFetch.js";
 // Google AI Live API types now imported from ../types/providerSpecific.js
 // Import proper types for multimodal message handling
@@ -653,7 +655,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 if (options.tools &&
                     Object.keys(options.tools).length > 0 &&
                     !options.disableTools) {
-                    const result = buildNativeToolDeclarations(options.tools);
+                    const result = toNativeToolDeclarations(options.tools, "functionDeclarations");
                     declarationsResult = result;
                     toolsConfig = result.toolsConfig;
                     executeMap = result.executeMap;
@@ -686,7 +688,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 const composedSignal = composeAbortSignals(options.abortSignal, timeoutController?.controller.signal);
                 // Create a push-based text channel so the caller receives tokens as
                 // they arrive from the network rather than after full buffering.
-                const channel = createTextChannel();
+                const channel = createStreamChannel();
                 // Shared mutable state updated by the background agentic loop.
                 const allToolCalls = [];
                 // Mirror the Vertex Gemini stream path: track tool executions so
@@ -859,7 +861,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                             const fallback = handleMaxStepsTermination("[GoogleAIStudio]", step, maxSteps, "", // finalText is empty — model didn't stop on its own
                             lastStepText);
                             if (fallback) {
-                                channel.push(fallback);
+                                channel.push({ content: fallback });
                             }
                         }
                         const responseTime = Date.now() - startTime;
@@ -1002,7 +1004,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 if (shouldUseTools && !exclusionInForce) {
                     const tools = options.tools || {};
                     if (Object.keys(tools).length > 0) {
-                        const result = buildNativeToolDeclarations(tools);
+                        const result = toNativeToolDeclarations(tools, "functionDeclarations");
                         declarationsResult = result;
                         toolsConfig = result.toolsConfig;
                         executeMap = result.executeMap;

package/dist/lib/providers/googleNativeGemini3/utils.d.ts

@@ -8,7 +8,7 @@
  * This module extracts the functions that are duplicated between the two
  * providers so they can share a single implementation.
  */
-import type { GenerateStopReason, ThinkingConfig, ChatMessage, CollectedChunkResult, MinimalChatMessage, NativeFunctionCall, NativeFunctionResponse, NativeToolDeclarationsResult, NativeToolsConfig, TextChannel, VertexNativePart, GeminiMultimodalInput, MultimodalAudioEntry } from "../../types/index.js";
+import type { GenerateStopReason, ThinkingConfig, ChatMessage, CollectedChunkResult, MinimalChatMessage, NativeFunctionCall, NativeFunctionResponse, NativeToolDeclarationsResult, NativeToolsConfig, StreamChannel, VertexNativePart, GeminiMultimodalInput, MultimodalAudioEntry } from "../../types/index.js";
 import type { Tool } from "../../types/index.js";
 /**
  * A per-turn tool execute map that deduplicates identical tool calls.
@@ -166,15 +166,6 @@ export declare function collectStreamChunks(stream: AsyncIterable<{
     functionCalls?: NativeFunctionCall[];
     [key: string]: unknown;
 }>): Promise<CollectedChunkResult>;
-/**
- * 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 declare function createTextChannel(): TextChannel;
 /**
  * Iterate a single stream step incrementally, pushing text parts to `channel`
  * as they arrive from the network while simultaneously accumulating the full
@@ -189,7 +180,9 @@ export declare function createTextChannel(): TextChannel;
 export declare function collectStreamChunksIncremental(stream: AsyncIterable<{
     functionCalls?: NativeFunctionCall[];
     [key: string]: unknown;
-}>, channel: TextChannel): Promise<CollectedChunkResult>;
+}>, channel: StreamChannel<{
+    content: string;
+}>): Promise<CollectedChunkResult>;
 /**
  * Extract the thoughtSignature token from raw response parts.
  * Returns the last thoughtSignature found (each step may produce one).