@juspay/neurolink 12.47.14 → 12.48.1

package/dist/cli/factories/commandFactory.d.ts

@@ -19,6 +19,13 @@ export declare class CLICommandFactory {
      * generate / batch / stream paths.
      */
     private static normalizeLoopSessionVariables;
+    /**
+     * The loop's `set toolChoiceSteps` / `set replayToolSteps` values in the
+     * shape `generate()` / `stream()` take. Session variables arrive as raw
+     * strings or numbers, so each is validated rather than cast: a bad value
+     * is dropped here and the SDK default applies.
+     */
+    private static loopToolStepOptions;
     static readonly commonOptions: {
         provider: {
             choices: string[];

package/dist/cli/factories/commandFactory.js

@@ -97,6 +97,28 @@ export class CLICommandFactory {
         }
         return normalized;
     }
+    /**
+     * The loop's `set toolChoiceSteps` / `set replayToolSteps` values in the
+     * shape `generate()` / `stream()` take. Session variables arrive as raw
+     * strings or numbers, so each is validated rather than cast: a bad value
+     * is dropped here and the SDK default applies.
+     */
+    static loopToolStepOptions(vars) {
+        const out = {};
+        const steps = typeof vars.toolChoiceSteps === "string"
+            ? vars.toolChoiceSteps.trim() === ""
+                ? undefined
+                : Number(vars.toolChoiceSteps)
+            : vars.toolChoiceSteps;
+        if (typeof steps === "number" && Number.isInteger(steps) && steps >= 0) {
+            out.toolChoiceSteps = steps;
+        }
+        const replay = vars.replayToolSteps;
+        if (replay === "full" || replay === "marker" || replay === "off") {
+            out.replayToolSteps = replay;
+        }
+        return out;
+    }
     // Common options available on all commands
     static commonOptions = {
         // Core generation options
@@ -2753,6 +2775,9 @@ export class CLICommandFactory {
                     : undefined,
                 disableTools: enhancedOptions.disableTools,
                 enabledToolNames: enhancedOptions.enabledToolNames,
+                // Loop `set` variables the schema accepts; without an explicit
+                // entry here they were echoed as set and then dropped.
+                ...CLICommandFactory.loopToolStepOptions(enhancedOptions),
                 enableAnalytics: enhancedOptions.enableAnalytics,
                 enableEvaluation: enhancedOptions.enableEvaluation,
                 evaluationDomain: enhancedOptions.evaluationDomain,
@@ -3005,6 +3030,7 @@ export class CLICommandFactory {
                 : undefined,
             disableTools: enhancedOptions.disableTools,
             enabledToolNames: enhancedOptions.enabledToolNames,
+            ...CLICommandFactory.loopToolStepOptions(enhancedOptions),
             enableAnalytics: enhancedOptions.enableAnalytics,
             enableEvaluation: enhancedOptions.enableEvaluation,
             evaluationDomain: enhancedOptions.evaluationDomain,

package/dist/cli/loop/optionsSchema.js

@@ -81,6 +81,15 @@ export const textGenerationOptionsSchema = {
         type: "number",
         description: "Maximum number of tool execution steps.",
     },
+    toolChoiceSteps: {
+        type: "number",
+        description: "Leading steps a forced toolChoice (required / named tool) stays in force before the model chooses (default 1).",
+    },
+    replayToolSteps: {
+        type: "string",
+        description: "How stored tool steps are replayed into the prompt: full, marker (default) or off.",
+        allowedValues: ["full", "marker", "off"],
+    },
     enableAnalytics: {
         type: "boolean",
         description: "Enable or disable analytics for responses.",

package/dist/context/budgetChecker.js

@@ -20,6 +20,58 @@ export const DEFAULT_COMPACTION_THRESHOLD = 0.8;
 const HISTORY_BUDGET_SAFETY_FACTOR = 0.95;
 /** Estimated tokens per tool definition */
 const TOKENS_PER_TOOL_DEFINITION = 200;
+/**
+ * Tokens one `[called <tool> → ok]` marker line costs. The tool name is the
+ * only variable part and is short; a fixed figure keeps the estimate cheap.
+ */
+const TOKENS_PER_TOOL_MARKER = 12;
+/**
+ * Estimate the history at the size it will REACH THE MODEL.
+ *
+ * Tool rows are stored at full size (arguments plus the whole output), but
+ * the prompt carries them per `replayToolSteps`: `"marker"` — the default —
+ * sends one short line per call and nothing for the result, `"off"` sends
+ * nothing, `"full"` sends the stored payload. Counting them at stored size
+ * under `"marker"` made the budget check and the summarization trigger see
+ * a history several times larger than the prompt, so summarization fired
+ * turns before the real prompt was anywhere near the window.
+ *
+ * Without a mode the rows count at stored size, which is also right for the
+ * providers that replay tool rows natively in their own wire shape
+ * regardless of the mode (see `replaysToolRowsNatively`).
+ */
+function estimateHistoryTokens(messages, provider, mode) {
+    if (mode === undefined || mode === "full") {
+        return estimateMessagesTokens(messages, provider);
+    }
+    const regular = messages.filter((m) => m.role !== "tool_call" && m.role !== "tool_result");
+    let total = estimateMessagesTokens(regular, provider);
+    if (mode === "marker") {
+        // One marker per call; a result adds nothing beyond its call's marker.
+        // `result.error` rides along on the marker only as "→ error", so it is
+        // not counted either.
+        total +=
+            messages.filter((m) => m.role === "tool_call").length *
+                (TOKENS_PER_TOOL_MARKER + TOKENS_PER_MESSAGE);
+    }
+    return total;
+}
+/**
+ * Providers whose native history builders replay stored tool rows in their
+ * own wire shape whatever `replayToolSteps` says (Claude-on-Vertex, Gemini
+ * on Vertex and AI Studio). Their tool rows always reach the model at full
+ * size, so the mode must not shrink the estimate for them.
+ */
+const NATIVE_TOOL_REPLAY_PROVIDERS = new Set([
+    "vertex",
+    "google-ai",
+    "google-vertex",
+    "googlevertex",
+    "google-ai-studio",
+]);
+function replaysToolRowsNatively(provider) {
+    return NATIVE_TOOL_REPLAY_PROVIDERS.has(provider.toLowerCase());
+}
 /**
  * Tokens the CONVERSATION HISTORY may occupy, i.e. the model's available input
  * space minus everything that rides alongside it (system prompt, current
@@ -71,14 +123,14 @@ export function checkContextBudget(params) {
     }, parentSpanId, traceId);
     const startTime = Date.now();
     try {
-        const { provider, model, maxTokens, systemPrompt, conversationMessages, currentPrompt, toolDefinitions, fileAttachments, compactionThreshold = DEFAULT_COMPACTION_THRESHOLD, } = params;
+        const { provider, model, maxTokens, systemPrompt, conversationMessages, currentPrompt, toolDefinitions, fileAttachments, compactionThreshold = DEFAULT_COMPACTION_THRESHOLD, toolReplayMode, } = params;
         const availableInputTokens = getAvailableInputTokens(provider, model, maxTokens);
         // Estimate each category
         const systemPromptTokens = systemPrompt
             ? estimateTokens(systemPrompt, provider) + TOKENS_PER_MESSAGE
             : 0;
         const conversationHistoryTokens = conversationMessages?.length
-            ? estimateMessagesTokens(conversationMessages, provider)
+            ? estimateHistoryTokens(conversationMessages, provider, replaysToolRowsNatively(provider) ? undefined : toolReplayMode)
             : 0;
         const currentPromptTokens = currentPrompt
             ? estimateTokens(currentPrompt, provider) + TOKENS_PER_MESSAGE

package/dist/context/contextDecision.js

@@ -107,6 +107,7 @@ export async function selectIrrelevantMessages(messages, currentRequest, decide,
         };
     });
     const result = await decide({
+        site: "contextRelevance",
         state: {
             current_request: currentRequest.slice(0, 4000),
             conversation: eligible.map((entry, position) => ({
@@ -184,6 +185,7 @@ export async function summaryPreservesContext(summary, replacedMessages, decide,
         return true;
     }
     const result = await decide({
+        site: "summaryGate",
         state: {
             summary: summary.slice(0, 12000),
             original_messages: replacedMessages.slice(-60).map((message) => ({

package/dist/context/toolPairRepair.d.ts

@@ -19,6 +19,18 @@
  *                    positionally WITHIN the batch (call[i] ↔ result[i]).
  */
 import type { ChatMessage, RepairResult } from "../types/index.js";
+/**
+ * True for a row this module invented to stand in for a dropped call or
+ * result. Replay must not present such a row as a real outcome: the model
+ * would be told a call succeeded ("→ ok") or given a fabricated input when
+ * the truth is that the record was lost. Recognised by id prefix, with the
+ * placeholder text as a fallback for rows that travelled without their id.
+ */
+export declare function isRepairPlaceholder(row: {
+    id?: string;
+    role: string;
+    content?: unknown;
+}): boolean;
 /**
  * Move a summarize/keep split so it never falls INSIDE a tool batch.
  *

package/dist/context/toolPairRepair.js

@@ -20,6 +20,32 @@
  */
 import { randomUUID } from "crypto";
 const MISSING_RESULT_CONTENT = "[Tool result unavailable - conversation was compacted]";
+const REPAIR_RESULT_ID_PREFIX = "repair-result-";
+const REPAIR_CALL_ID_PREFIX = "repair-call-";
+const MISSING_CALL_CONTENT_SUFFIX = " - conversation was compacted]";
+/**
+ * True for a row this module invented to stand in for a dropped call or
+ * result. Replay must not present such a row as a real outcome: the model
+ * would be told a call succeeded ("→ ok") or given a fabricated input when
+ * the truth is that the record was lost. Recognised by id prefix, with the
+ * placeholder text as a fallback for rows that travelled without their id.
+ */
+export function isRepairPlaceholder(row) {
+    if (typeof row.id === "string" &&
+        (row.id.startsWith(REPAIR_RESULT_ID_PREFIX) ||
+            row.id.startsWith(REPAIR_CALL_ID_PREFIX))) {
+        return true;
+    }
+    if (typeof row.content !== "string") {
+        return false;
+    }
+    if (row.role === "tool_result") {
+        return row.content === MISSING_RESULT_CONTENT;
+    }
+    return (row.role === "tool_call" &&
+        row.content.startsWith("[Tool call for ") &&
+        row.content.endsWith(MISSING_CALL_CONTENT_SUFFIX));
+}
 /**
  * Collect the tool batch starting at `start` (which must index a tool-role
  * message). Consumes the maximal run of calls followed by the maximal run of
@@ -43,7 +69,7 @@ function collectBatch(messages, start) {
 /** Synthetic `tool_result` standing in for a call whose result was dropped. */
 function syntheticResult(call) {
     return {
-        id: `repair-result-${randomUUID()}`,
+        id: `${REPAIR_RESULT_ID_PREFIX}${randomUUID()}`,
         role: "tool_result",
         content: MISSING_RESULT_CONTENT,
         tool: call.tool,
@@ -55,9 +81,9 @@ function syntheticResult(call) {
 /** Synthetic `tool_call` standing in for a result whose call was dropped. */
 function syntheticCall(result) {
     return {
-        id: `repair-call-${randomUUID()}`,
+        id: `${REPAIR_CALL_ID_PREFIX}${randomUUID()}`,
         role: "tool_call",
-        content: `[Tool call for ${result.tool || "unknown"} - conversation was compacted]`,
+        content: `[Tool call for ${result.tool || "unknown"}${MISSING_CALL_CONTENT_SUFFIX}`,
         tool: result.tool,
         ...(result.toolCallId ? { toolCallId: result.toolCallId } : {}),
         timestamp: result.timestamp,

package/dist/core/baseProvider.d.ts

@@ -1,7 +1,7 @@
 import type { AIProviderName } from "../constants/enums.js";
 import type { EvaluationData } from "../index.js";
 import type { NeuroLink } from "../neurolink.js";
-import type { FileToolRootPolicy, UnknownRecord, MiddlewareFactoryOptions, StreamOptions, StreamResult, AIProvider, AnalyticsData, EnhancedGenerateResult, TextGenerationOptions, TextGenerationResult, ValidationSchema, EmbedInput, DecisionRequest, DecisionResult } from "../types/index.js";
+import type { FileToolRootPolicy, UnknownRecord, MiddlewareFactoryOptions, StreamOptions, StreamResult, AIProvider, AnalyticsData, EnhancedGenerateResult, TextGenerationOptions, TextGenerationResult, ValidationSchema, EmbedInput, DecisionRequest, DecisionResult, MemoryToolCallRecord, MemoryToolResultRecord, ToolExecutionSummaryInternal } from "../types/index.js";
 import { TelemetryHandler } from "./modules/TelemetryHandler.js";
 import type { LanguageModel, ModelMessage, RawUsageObject, Tool, ToolCallRepairFunction, ToolSet } from "../types/index.js";
 export declare abstract class BaseProvider implements AIProvider {
@@ -190,6 +190,21 @@ export declare abstract class BaseProvider implements AIProvider {
      * Build messages array for generation - delegated to MessageBuilder
      */
     private buildMessages;
+    /**
+     * Fold the instance's `conversationMemory.replayToolSteps` into the request
+     * when the caller set none, so every path into the message builder — text
+     * or multimodal, generate or stream — reads one resolved value. The
+     * builder itself defaults to `"marker"` when neither is set.
+     *
+     * Then degrade `"full"` to `"marker"` for a request that declares no tools:
+     * Anthropic rejects a prompt carrying tool_use / tool_result blocks without
+     * a `tools` field ("Requests which include tool_use or tool_result blocks
+     * must define tools"), so a tools-off call — `disableTools`, or a filter
+     * that removed every tool — in a session that already ran one would fail
+     * on every later turn. Runs after the provider has merged `options.tools`,
+     * which is where every native path calls the builder from.
+     */
+    protected applyToolReplayDefault(options: StreamOptions | TextGenerationOptions): void;
     /**
      * Build messages array for streaming operations - delegated to MessageBuilder
      * This is a protected helper method that providers can use to build messages
@@ -282,7 +297,60 @@ export declare abstract class BaseProvider implements AIProvider {
      */
     gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ValidationSchema): Promise<EnhancedGenerateResult | null>;
     private runGenerateInActiveContext;
+    /**
+     * Mode 1 — synthesize the input text itself, with no LLM call.
+     *
+     * This is the documented default for `generate({ tts: { enabled: true } })`
+     * and what every "speak this text" caller relies on, so a request that
+     * looks like it wanted the model's reply (tools, a system prompt, message
+     * history, a schema, conversation memory) is warned about, never rejected:
+     * those options have no effect here, and the fix is `tts.mode: "response"`.
+     */
     protected handleDirectTTSSynthesis(options: TextGenerationOptions, startTime: number): Promise<EnhancedGenerateResult>;
+    /**
+     * One warning when a direct-synthesis request carries options that only a
+     * model call would honour and the caller never chose a mode. Silence is
+     * the wrong answer here — the caller gets `usage` of zero and `content`
+     * echoing their prompt, and would otherwise have to guess why.
+     *
+     * Only options the CALLER supplied count. `conversationMemoryConfig` is
+     * attached by NeuroLink to every request on a memory-enabled instance, and
+     * on such an instance `conversationMessages` is the stored history
+     * NeuroLink injected itself — neither is something the caller set, and a
+     * voice bot with memory used to see this warning on every turn after the
+     * first for options it never passed.
+     */
+    private warnIfDirectTTSLooksLikeResponseRequest;
+    /**
+     * Outer bound on one synthesis call: the provider's request timeout, raised
+     * to whatever the handler itself may legitimately spend — `timeoutMs × (1 +
+     * retries)` plus retry pauses, with the handler defaults (30 s, one retry)
+     * standing in for a knob the caller left unset. Without the raise, a
+     * handler's own retry loop could be cut off from outside one attempt in:
+     * with the 60 s provider default, a first attempt that hung to its 30 s
+     * abort left no room for the documented default retry.
+     */
+    private resolveTTSSynthesisTimeout;
+    /**
+     * Apply `tts.sanitize` (off by default — existing callers see byte-identical
+     * input). Always runs when configured, regardless of the raw text's
+     * length against the provider's cap: sanitizing can shrink text a great
+     * deal (the default `codeBlocks: "phrase"` replaces a whole fenced block
+     * with one short phrase, `urls: "hostname"` shortens every link), so a
+     * reply that is over the cap raw can still fit after sanitizing — a coding
+     * answer with a large code block is exactly the reply this option is for.
+     * A reply still over the cap afterwards is rejected downstream by
+     * `TTSProcessor.synthesize` as `TTS_TEXT_TOO_LONG`, same as today.
+     */
+    private prepareTTSInput;
+    /**
+     * One synthesis call under the outer budget. The handler receives a signal
+     * that fires when that budget lapses or the caller's own `abortSignal`
+     * does, so a handler with a retry loop (ElevenLabs) stops rather than
+     * pausing and issuing a further billable request after the caller has
+     * already been told the synthesis failed.
+     */
+    private runTTSSynthesis;
     private handleVideoFrameGeneration;
     /**
      * Close out a turn produced by a provider's own native generate loop.
@@ -298,7 +366,23 @@ export declare abstract class BaseProvider implements AIProvider {
      * synthesis so telemetry sees the model's own usage, and `enhanceResult`
      * runs last so analytics and evaluation observe the final content.
      */
-    protected finalizeNativeGenerate(result: EnhancedGenerateResult, options: TextGenerationOptions, startTime: number): Promise<EnhancedGenerateResult>;
+    protected finalizeNativeGenerate(result: EnhancedGenerateResult, options: TextGenerationOptions, startTime: number, toolExecutionSummaries?: ReadonlyArray<ToolExecutionSummaryInternal>): Promise<EnhancedGenerateResult>;
+    /**
+     * Persist a generate() turn's tool steps into conversation memory.
+     *
+     * The stream loops store each step's calls and results as they run;
+     * generate() never did, so the same session held tool rows for streamed
+     * turns and none for generated ones, and a later turn could not replay
+     * what generate() had called. Every native generate path closes out
+     * through finalizeNativeGenerate, so this is the one place to do it.
+     *
+     * Gated on a real session id: the storage helper otherwise invents a
+     * `session-<nanoid>` key, and on the in-memory backend that creates a
+     * throwaway session per tool-using call — evicting real ones once
+     * `maxSessions` is reached. A turn with no session has no history to
+     * replay into, so there is nothing to persist.
+     */
+    private persistGenerateToolSteps;
     /**
      * Invoke a caller's `onFinish` for a native turn.
      *
@@ -555,6 +639,11 @@ export declare abstract class BaseProvider implements AIProvider {
      * another request.
      */
     setFileToolRootPolicy(policy: FileToolRootPolicy | undefined): void;
+    /**
+     * Emit the start/end pair for a tool call a loop rejected before execute
+     * (unknown tool, schema rejection). See ToolsManager.emitRejectedToolCall.
+     */
+    protected emitRejectedToolCall(toolName: string, error: string, toolCallId?: string): void;
     /**
      * Resolve roots for a provider called directly, without NeuroLink. A
      * policy NeuroLink already bound is left alone unless these options carry
@@ -748,7 +837,7 @@ export declare abstract class BaseProvider implements AIProvider {
     /**
      * Check if tool executions should be stored and handle storage
      */
-    protected handleToolExecutionStorage(toolCalls: unknown[], toolResults: unknown[], options: TextGenerationOptions | StreamOptions, currentTime: Date): Promise<void>;
+    protected handleToolExecutionStorage(toolCalls: MemoryToolCallRecord[], toolResults: MemoryToolResultRecord[], options: TextGenerationOptions | StreamOptions, currentTime: Date): Promise<void>;
     /**
      * Utility method to chunk large prompts into smaller pieces
      * @param prompt The prompt to chunk