@juspay/neurolink 11.2.4 → 11.3.0

package/dist/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/types/loopEngine.js

@@ -0,0 +1 @@
+export {};

package/dist/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/types/nativeTools.js

@@ -0,0 +1 @@
+export {};

package/dist/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/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/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/types/streaming.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "11.2.4",
+  "version": "11.3.0",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {
@@ -86,6 +86,7 @@
     "test:adjust-body-after-400": "npx tsx test/continuous-test-suite-adjust-body-after-400.ts",
     "test:error-classification-e2e": "npx tsx test/continuous-test-suite-error-classification-e2e.ts",
     "test:error-classifier-contract": "npx tsx test/continuous-test-suite-error-classifier-contract.ts",
+    "test:loop-engine": "npx tsx test/continuous-test-suite-loop-engine.ts",
     "test:middleware": "npx tsx test/continuous-test-suite-middleware.ts",
     "test:observability": "npx tsx test/continuous-test-suite-observability.ts",
     "test:ppt": "npx tsx test/continuous-test-suite-ppt.ts",
@@ -110,6 +111,7 @@
     "test:tts:unit": "npx tsx test/continuous-test-suite-tts-unit.ts",
     "test:stt:unit": "npx tsx test/continuous-test-suite-stt-unit.ts",
     "test:realtime:unit": "npx tsx test/continuous-test-suite-realtime-unit.ts",
+    "test:video:unit": "npx tsx test/continuous-test-suite-video-generation-unit.ts",
     "test:voice": "npx tsx test/continuous-test-suite-voice.ts",
     "test:avatar": "npx tsx test/continuous-test-suite-avatar.ts",
     "test:avatar:unit": "npx tsx test/continuous-test-suite-avatar-unit.ts",