@juspay/neurolink 9.80.4 → 9.81.1

package/dist/types/analytics.d.ts

@@ -35,6 +35,16 @@ export type AnalyticsData = {
     timestamp: string;
     cost?: number;
     context?: JsonValue;
+    /** Number of agentic steps (model calls) the turn used. */
+    stepsUsed?: number;
+    /** Number of external tool calls the turn made (final_result excluded). */
+    toolCallCount?: number;
+    /** Why the turn ended — see GenerateStopReason. */
+    stopReason?: string;
+    /** Wall-clock duration of the turn in milliseconds. */
+    elapsedMs?: number;
+    /** Verbatim provider finish/stop reason for the terminal model call. */
+    rawFinishReason?: string;
 };
 /**
  * Stream Analytics Data - Enhanced for performance tracking

package/dist/types/generate.d.ts

@@ -310,6 +310,38 @@ export type GenerateOptions = {
      * provider+model with the same doomed budget.
      */
     timeout?: number | string;
+    /**
+     * Hard wall-clock cap for the WHOLE agentic turn (all model calls + tool
+     * executions), in milliseconds. When the deadline passes the turn ends
+     * gracefully with `stopReason: "time-limit"` and an honest time message —
+     * never the step-cap text. Unset = no turn-level deadline (the library
+     * imposes no product policy).
+     *
+     * Enforced by the native Vertex loops (Gemini + Claude); AI-SDK-driven
+     * providers currently ignore it.
+     */
+    turnTimeoutMs?: number;
+    /**
+     * Maximum time with NO progress — no stream chunk received, no tool
+     * execution started or finished, no step started — before the turn ends
+     * with `stopReason: "stalled"`. Catches wedged tools and hung model calls
+     * that a whole-turn deadline would let run to the bitter end.
+     * Unset = disabled.
+     */
+    stallTimeoutMs?: number;
+    /**
+     * When the remaining turn time drops below this, a wrap-up nudge rides the
+     * next tool-result turn telling the model to consolidate what it has and
+     * produce its final answer. Defaults to 120_000 when `turnTimeoutMs` is
+     * set; ignored when it is not.
+     */
+    wrapupTimeLeadMs?: number;
+    /**
+     * Per-tool-execution timeout in milliseconds (default 300_000). A tool
+     * that exceeds it fails with an error tool_result and costs one step —
+     * the turn continues instead of hanging on a wedged tool.
+     */
+    toolTimeoutMs?: number;
     /** AbortSignal for external cancellation of the AI call */
     abortSignal?: AbortSignal;
     /**
@@ -562,6 +594,21 @@ export type AdditionalMemoryUser = {
     /** Max words for this user's condensed memory. Overrides the default maxWords. */
     maxWords?: number;
 };
+/**
+ * Why an agentic turn ended — the discriminator consumers should branch on
+ * instead of sniffing the provider-shaped `finishReason` (whose values are
+ * overloaded: e.g. "tool-calls" historically covered both step-cap exits and
+ * Gemini MALFORMED_FUNCTION_CALL provider errors).
+ *
+ * - `completed` — the model finished on its own (text answer or final_result)
+ * - `step-cap` — the `maxSteps` budget ran out while the model still wanted tools
+ * - `time-limit` — the `turnTimeoutMs` wall-clock deadline passed
+ * - `stalled` — no progress (no chunk, no tool start/finish) for `stallTimeoutMs`
+ * - `aborted` — the caller's `abortSignal` ended the turn
+ * - `provider-error` — the provider/model failed the turn (e.g. persistent
+ *   MALFORMED_FUNCTION_CALL after retry); usually worth a caller-side retry
+ */
+export type GenerateStopReason = "completed" | "step-cap" | "time-limit" | "stalled" | "aborted" | "provider-error";
 /**
  * Generate function result type - Primary output format
  * Future-ready for multi-modal outputs while maintaining text focus
@@ -662,6 +709,20 @@ export type GenerateResult = {
     provider?: string;
     model?: string;
     finishReason?: string;
+    /**
+     * Why the agentic turn ended, independent of the provider-shaped
+     * `finishReason`. Populated by the native Vertex loops (Gemini + Claude);
+     * undefined on providers that don't run a native loop — fall back to
+     * `finishReason` heuristics there.
+     */
+    stopReason?: GenerateStopReason;
+    /**
+     * Verbatim provider finish/stop reason for the turn's terminal model call
+     * (e.g. "MALFORMED_FUNCTION_CALL", "MAX_TOKENS", "max_tokens", "tool_use").
+     */
+    rawFinishReason?: string;
+    /** Number of agentic steps (model calls) the turn used. */
+    stepsUsed?: number;
     /**
      * True when the schema JSON in `content`/`structuredData` was repaired from
      * malformed model text (jsonrepair ran). The result is still valid JSON.
@@ -882,6 +943,14 @@ export type TextGenerationOptions = {
      */
     enabledToolNames?: string[];
     timeout?: number | string;
+    /** Wall-clock cap for the whole agentic turn (ms). See GenerateOptions.turnTimeoutMs. */
+    turnTimeoutMs?: number;
+    /** Max time with no progress before the turn ends as "stalled" (ms). See GenerateOptions.stallTimeoutMs. */
+    stallTimeoutMs?: number;
+    /** Remaining-time threshold that triggers the wrap-up nudge (ms). See GenerateOptions.wrapupTimeLeadMs. */
+    wrapupTimeLeadMs?: number;
+    /** Per-tool-execution timeout (ms, default 300_000). See GenerateOptions.toolTimeoutMs. */
+    toolTimeoutMs?: number;
     /** AbortSignal for external cancellation of the AI call */
     abortSignal?: AbortSignal;
     disableTools?: boolean;
@@ -1128,6 +1197,12 @@ export type TextGenerationResult = {
     /** Parsed structured object when a `schema` was requested (see GenerateResult.structuredData). */
     structuredData?: unknown;
     finishReason?: string;
+    /** Turn-exit discriminator from native agentic loops (see GenerateStopReason). */
+    stopReason?: GenerateStopReason;
+    /** Verbatim provider finish/stop reason for the turn's terminal model call. */
+    rawFinishReason?: string;
+    /** Number of agentic steps (model calls) the turn used. */
+    stepsUsed?: number;
     /** True when the schema JSON was repaired from malformed model text. */
     jsonRepaired?: boolean;
     /** True when the schema JSON appears truncated (output hit the token cap). */

package/dist/types/stream.d.ts

@@ -8,7 +8,7 @@ import type { JsonValue, UnknownRecord } from "./common.js";
 import type { Content, ImageWithAltText } from "./content.js";
 import type { ChatMessage } from "./conversation.js";
 import type { StreamNoOutputSentinel } from "./noOutputSentinel.js";
-import type { AdditionalMemoryUser } from "./generate.js";
+import type { AdditionalMemoryUser, GenerateStopReason } from "./generate.js";
 import type { AIModelProviderConfig, NeurolinkCredentials } from "./providers.js";
 import type { TTSChunk, TTSOptions, TTSResult } from "./tts.js";
 import type { STTOptions, STTResult } from "./stt.js";
@@ -326,6 +326,14 @@ export type StreamOptions = {
     schema?: ValidationSchema;
     tools?: Record<string, Tool>;
     timeout?: number | string;
+    /** Wall-clock cap for the whole agentic turn (ms). See GenerateOptions.turnTimeoutMs. */
+    turnTimeoutMs?: number;
+    /** Max time with no progress before the turn ends as "stalled" (ms). See GenerateOptions.stallTimeoutMs. */
+    stallTimeoutMs?: number;
+    /** Remaining-time threshold that triggers the wrap-up nudge (ms). See GenerateOptions.wrapupTimeLeadMs. */
+    wrapupTimeLeadMs?: number;
+    /** Per-tool-execution timeout (ms, default 300_000). See GenerateOptions.toolTimeoutMs. */
+    toolTimeoutMs?: number;
     /** AbortSignal for external cancellation of the AI call */
     abortSignal?: AbortSignal;
     disableTools?: boolean;
@@ -518,6 +526,15 @@ export type StreamResult = {
     model?: string;
     usage?: TokenUsage;
     finishReason?: string;
+    /**
+     * Why the agentic turn ended (see GenerateStopReason). For background-loop
+     * streams (native Vertex paths) prefer `metadata.stopReason` after draining
+     * the stream — this top-level field may be a getter that resolves late, and
+     * wrapper spreads can snapshot it before the loop finishes.
+     */
+    stopReason?: GenerateStopReason;
+    /** Verbatim provider finish/stop reason for the turn's terminal model call. */
+    rawFinishReason?: string;
     toolCalls?: StreamToolCall[];
     toolResults?: StreamToolResult[];
     toolEvents?: AsyncIterable<ToolExecutionEvent>;
@@ -537,6 +554,9 @@ export type StreamResult = {
         guardrailsBlocked?: boolean;
         error?: string;
         finishReason?: string;
+        stopReason?: GenerateStopReason;
+        rawFinishReason?: string;
+        stepsUsed?: number;
         thoughtSignature?: string;
         thoughts?: Array<{
             id?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "9.80.4",
+  "version": "9.81.1",
   "packageManager": "pnpm@10.15.1",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, voice (TTS/STT/realtime), and professional CLI. 58+ external MCP servers discoverable, multimodal file processing, RAG pipelines. Build, test, and deploy AI applications with 21+ providers: OpenAI, Anthropic, Google AI Studio, Google Vertex, AWS Bedrock, Azure OpenAI, Mistral, LiteLLM, SageMaker, Hugging Face, Ollama, OpenAI-compatible, OpenRouter, DeepSeek, NVIDIA NIM, LM Studio, llama.cpp, plus voice (OpenAI TTS, ElevenLabs, Deepgram, Azure Speech).",
   "author": {