@juspay/neurolink 12.47.13 → 12.48.0

package/dist/providers/openaiChatCompletionsBase.js

@@ -33,9 +33,8 @@ import { redactUrlCredentials } from "../utils/logSanitize.js";
 import { NoOutputGeneratedError } from "../utils/generationErrors.js";
 import { buildNoOutputSentinel, stampNoOutputSpan, } from "../utils/noOutputSentinel.js";
 import { composeAbortSignalsScoped, createTimeoutController, mergeAbortSignals, TimeoutError, } from "../utils/timeout.js";
-import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { resolveRequestKind } from "../core/resolveRequestKind.js";
-import { appendJsonSchemaInstruction, hasNativeDoGenerate, runNativeGenerateLoop, } from "../core/nativeGenerateLoop.js";
+import { appendJsonSchemaInstruction, hasNativeDoGenerate, resolveStepToolChoice, runNativeGenerateLoop, toPrepareStepRecord, } from "../core/nativeGenerateLoop.js";
 import { resolveToolExecutionRecords, toolCallsFromSummaries, } from "../core/toolExecutionRecorder.js";
 import { convertZodToJsonSchema } from "../utils/schemaConversion.js";
 import { coerceJsonToSchema, recoverScalarRoot, schemaAccepts, } from "../utils/json/coerce.js";
@@ -908,6 +907,11 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         }
         const doGenerate = model.doGenerate.bind(model);
         const shouldUseTools = !options.disableTools && this.supportsTools();
+        // `options.tools` arrives from BaseProvider's merge (getToolsForStream)
+        // already event-wrapped, recorder-wrapped and discovery-partitioned. It
+        // must be used AS IS: copying it would drop the discovery record's null
+        // prototype and non-enumerable resolver, and tools search_tools hydrates
+        // later land only in the original object.
         const toolsRecord = shouldUseTools
             ? options.tools || (await this.getAllTools())
             : {};
@@ -979,6 +983,11 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 ...(withTools && hasTools && options.toolChoice
                     ? { toolChoice: resolveToolChoice(options, toolsRecord, true) }
                     : {}),
+                ...(options.toolChoiceSteps !== undefined
+                    ? { toolChoiceSteps: options.toolChoiceSteps }
+                    : {}),
+                ...(options.prepareStep ? { prepareStep: options.prepareStep } : {}),
+                modelId,
                 // The per-call `timeout` keeps its per-MODEL-CALL meaning once
                 // `turnTimeoutMs` owns the whole-turn deadline, and it reaches the
                 // model layer only through this channel. Without it each step fell
@@ -1008,6 +1017,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 runStep: (call) => withProviderRetry(call, trace.getActiveSpan() ?? undefined, `${this.providerName} generate`, undefined, options.abortSignal).catch((err) => {
                     throw this.handleProviderError(err);
                 }),
+                onRejectedToolCall: (name, error, id) => this.emitRejectedToolCall(name, error, id),
             }, toolExecutionSummaries);
         };
         // Structured output rides `response_format` first. When a vendor rejects
@@ -1138,7 +1148,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             toolExecutions: resolveToolExecutionRecords(options, transformToolExecutions(toolExecutionSummaries)),
             enhancedWithTools: toolsUsed.length > 0,
         };
-        return this.finalizeNativeGenerate(enhanced, options, startTime);
+        return this.finalizeNativeGenerate(enhanced, options, startTime, toolExecutionSummaries);
     }
     /**
      * Recover structured output on a turn where tools forced `response_format`
@@ -1454,6 +1464,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 doGenerate,
                 conversation: conv,
                 toolsRecord: {},
+                modelId,
                 ...(format ? { responseFormat: format } : {}),
                 maxSteps: 1,
                 ...(options.maxTokens
@@ -1575,7 +1586,10 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         let toolsRecord;
         let wireNameMaps;
         let openAITools;
-        let openAIToolChoice;
+        // The turn's tool choice in NeuroLink shape; translated to the wire per
+        // step (see stepToolChoice below) so a forced choice can lapse after
+        // `toolChoiceSteps` instead of compelling a tool call on every step.
+        let turnToolChoice;
         // The prompt is kept in its pre-wire shape. Model middleware transforms
         // `params.prompt`, and the conversion to the chat-completions wire format
         // has to happen AFTER that or the transform would be discarded.
@@ -1583,6 +1597,8 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         try {
             modelId = await this.resolveModelName();
             const shouldUseTools = !options.disableTools && this.supportsTools();
+            // Same identity rule as executeNativeGenerate: the merged record is
+            // the discovery hot record and is never copied here.
             toolsRecord = shouldUseTools
                 ? options.tools || (await this.getAllTools())
                 : {};
@@ -1594,7 +1610,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             openAITools = shouldUseTools
                 ? buildToolsForOpenAI(toolsRecord, wireNameMaps?.toWire)
                 : undefined;
-            openAIToolChoice = mapNeuroLinkToolChoice(resolveToolChoice(options, toolsRecord, shouldUseTools), wireNameMaps?.toWire);
+            turnToolChoice = resolveToolChoice(options, toolsRecord, shouldUseTools);
             promptMessages = (await this.buildMessagesForStream(options));
         }
         catch (setupErr) {
@@ -1621,7 +1637,6 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         const url = this.getChatCompletionsURL(modelId);
         const fetchImpl = createProxyFetch();
         const maxSteps = options.maxSteps || DEFAULT_MAX_STEPS;
-        const emitter = this.neurolink?.getEventEmitter();
         const toolsUsed = [];
         const toolExecutionSummaries = [];
         const { usagePromise, finishPromise, resolveUsage, resolveFinish } = createDeferredAnalytics();
@@ -1715,10 +1730,22 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                     options: sampled,
                     conversation,
                     openAITools,
-                    openAIToolChoice,
+                    // No declared tools → no tool_choice, and the hook is not consulted:
+                    // a forced choice on a tool-less request is a 400.
+                    stepToolChoice: async (step, steps) => openAITools && openAITools.length > 0
+                        ? mapNeuroLinkToolChoice(await resolveStepToolChoice({
+                            base: turnToolChoice,
+                            step,
+                            toolChoiceSteps: options.toolChoiceSteps,
+                            prepareStep: options.prepareStep,
+                            steps,
+                            maxSteps,
+                            model: modelId,
+                            ...(abortSignal ? { abortSignal } : {}),
+                        }), wireNameMaps?.toWire)
+                        : undefined,
                     toolsRecord,
                     toolNameFromWire: wireNameMaps?.fromWire,
-                    emitter,
                     toolsUsed,
                     toolExecutionSummaries,
                     pushChunk: channel.push,
@@ -2012,7 +2039,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, closeChannel, resolveUsage, resolveFinish, responseFormat, onModelObserved, } = args;
+        const { maxSteps, modelId, url, fetchImpl, abortSignal, options, conversation, openAITools, stepToolChoice, toolsRecord, toolNameFromWire, toolsUsed, toolExecutionSummaries, pushChunk, closeChannel, resolveUsage, resolveFinish, responseFormat, onModelObserved, } = 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;
@@ -2049,7 +2076,10 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             // two different payloads would be meaningless.
             let lastObservedPromptTokens;
             let lastSentEstimate;
+            // Completed-step records handed to a caller's prepareStep hook.
+            const stepRecords = [];
             for (let step = 0; step < maxSteps; step++) {
+                const openAIToolChoice = await stepToolChoice(step, stepRecords);
                 // Mid-turn discovery sync: search_tools (tools.discovery) hydrates
                 // new tools into toolsRecord between steps. Dispatch already re-reads
                 // the record — this block makes the request DECLARE them so the model
@@ -2137,11 +2167,54 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                     conversation,
                     toolsRecord,
                     toolNameFromWire: effectiveToolNameFromWire,
-                    emitter,
                     toolsUsed,
                     toolExecutionSummaries,
                     options,
+                    stepIndex: step,
                 });
+                const executed = toolExecutionSummaries.slice(-stepResult.toolCalls.size);
+                stepRecords.push(toPrepareStepRecord({
+                    stepNumber: step,
+                    content: [
+                        ...(stepResult.text
+                            ? [{ type: "text", text: stepResult.text }]
+                            : []),
+                        ...executed.map((s) => ({
+                            type: "tool-call",
+                            toolCallId: s.toolCallId,
+                            toolName: s.toolName,
+                            input: s.input,
+                        })),
+                    ],
+                    text: stepResult.text,
+                    toolCalls: executed.map((s) => ({
+                        toolName: s.toolName,
+                        toolCallId: s.toolCallId,
+                        input: s.input,
+                    })),
+                    toolResults: executed.map((s) => ({
+                        toolName: s.toolName,
+                        toolCallId: s.toolCallId,
+                        output: s.output,
+                    })),
+                    finishReason: "tool-calls",
+                    // prompt_tokens already includes cached_tokens; subtract it so
+                    // this agrees with the generate loop's toDeferredUsage, which
+                    // reports the disjoint noCache figure for the same field —
+                    // otherwise a cached step reports cached tokens twice (once
+                    // here, once in cacheReadTokens) and a prepareStep hook that
+                    // budgets on steps[].usage sees different numbers from
+                    // stream() and generate() for the same step.
+                    inputTokens: Math.max(0, (stepResult.usage?.prompt_tokens ?? 0) -
+                        (stepResult.usage?.prompt_tokens_details?.cached_tokens ?? 0)),
+                    outputTokens: stepResult.usage?.completion_tokens ?? 0,
+                    ...(stepResult.usage?.prompt_tokens_details?.cached_tokens !==
+                        undefined
+                        ? {
+                            cacheReadTokens: Math.min(stepResult.usage.prompt_tokens_details.cached_tokens, stepResult.usage.prompt_tokens ?? 0),
+                        }
+                        : {}),
+                }));
             }
             resolveUsage(toDeferredUsage());
             resolveFinish(stepFinish ?? "stop");
@@ -2258,7 +2331,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         });
     }
     async executeToolBatch(args) {
-        const { stepResult, conversation, toolsRecord, toolNameFromWire, emitter, toolsUsed, toolExecutionSummaries, options, } = args;
+        const { stepResult, conversation, toolsRecord, toolNameFromWire, toolsUsed, toolExecutionSummaries, options, stepIndex, } = args;
         const toolCallsForMessage = [];
         for (const [, t] of stepResult.toolCalls) {
             toolCallsForMessage.push({
@@ -2295,14 +2368,14 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             // loaded via search_tools — that's a real tool, not a hallucination.
             const toolDef = toolsRecord[registryName] ??
                 resolveDeferredTool(toolsRecord, registryName);
-            emitter?.emit("tool:start", {
-                toolName: registryName,
-                toolCallId: t.id,
-                input,
-            });
+            // No `tool:start` here either: registered and built-in tools emit their
+            // own start/end pair from the executor that runs them, and this raw
+            // emission made every one of them count twice.
             if (!toolDef || typeof toolDef.execute !== "function") {
                 errorMsg = `Tool '${registryName}' is not registered.`;
                 output = { error: errorMsg };
+                // Rejected before any execute ran, so no executor will report it.
+                this.emitRejectedToolCall(registryName, errorMsg, t.id);
             }
             else {
                 try {
@@ -2323,6 +2396,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 ...(errorMsg ? { error: errorMsg } : {}),
                 startTime: startedAt,
                 endTime: endedAt,
+                stepIndex,
             });
             conversation.push({
                 role: "tool",
@@ -2331,21 +2405,27 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             });
         }
         const justExecuted = toolExecutionSummaries.slice(-stepResult.toolCalls.size);
-        emitToolEndFromStepFinish(emitter, justExecuted.map((s) => ({
-            toolName: s.toolName,
-            output: s.output,
-            ...(s.error ? { error: s.error } : {}),
-        })));
+        // No `tool:end` here: the executor already emitted start/end with the
+        // real duration, and a second emission per result doubled every
+        // consumer's count.
         try {
+            // `args`, not `input`: both stores read `args`, so the previous
+            // `input:` key persisted every tool call with empty arguments.
             await this.handleToolExecutionStorage(justExecuted.map((s) => ({
                 toolCallId: s.toolCallId,
                 toolName: s.toolName,
-                input: s.input,
-                output: s.output,
+                args: s.input !== null &&
+                    typeof s.input === "object" &&
+                    !Array.isArray(s.input)
+                    ? s.input
+                    : {},
+                ...(s.stepIndex !== undefined ? { stepIndex: s.stepIndex } : {}),
             })), justExecuted.map((s) => ({
                 toolCallId: s.toolCallId,
                 toolName: s.toolName,
                 output: s.output,
+                ...(s.error ? { error: s.error } : {}),
+                ...(s.stepIndex !== undefined ? { stepIndex: s.stepIndex } : {}),
             })), options, new Date());
         }
         catch (err) {

package/dist/providers/systemOneDecision.d.ts

@@ -133,6 +133,12 @@ export declare abstract class SystemOneDecisionProvider extends BaseProvider {
      * Refuse a request the model cannot read in full. An encoder cuts the state
      * off past its window without saying so, so without this a decision would
      * be made on input the model never saw — and reported as if it had.
+     *
+     * Advisory limits (`decisionLimits.advisory`) are skipped: they publish a
+     * server's own ceiling for `NeuroLink.decisionLimits()` to report, and the
+     * server enforces them itself. The estimator and the flattening are the
+     * same functions that method uses, so a host that sizes a state against the
+     * reading measures exactly what is checked here.
      */
     private assertWithinDecisionLimits;
     /**

package/dist/providers/systemOneDecision.js

@@ -6,7 +6,7 @@ import { ProviderError } from "../types/index.js";
 import { prepareDecisionMedia } from "../utils/decisionMedia.js";
 import { logger } from "../utils/logger.js";
 import { redactUrlsInText } from "../utils/logSanitize.js";
-import { CHARS_PER_TOKEN, estimateTokens, serializeForEstimate, } from "../utils/tokenEstimation.js";
+import { estimateDecisionStateTokens, resolveDecisionLimitsReading, } from "../utils/decisionLimits.js";
 /**
  * Generous enough for a cold start (measured at 2.0–2.7s after idle on Jev)
  * while still bounded. Every internal caller is fail-open, so this only bites
@@ -171,59 +171,6 @@ const sleep = (ms, signal) => new Promise((resolve, reject) => {
     }
     signal?.addEventListener("abort", onAbort, { once: true });
 });
-/**
- * `estimateTokens` assumes ~4 characters per token. That holds for English
- * and is several times too generous for other scripts on an English
- * tokenizer, so when a provider declares a rate, non-ASCII characters are
- * counted at it instead. ASCII text is estimated exactly as before.
- */
-function estimateDecisionStateTokens(text, nonAsciiTokensPerChar, rates = {}) {
-    const { digit, symbol, astral } = rates;
-    if (nonAsciiTokensPerChar === undefined &&
-        digit === undefined &&
-        symbol === undefined &&
-        astral === undefined) {
-        return estimateTokens(text);
-    }
-    // Each class of character is counted once, at its own rate. A class with no
-    // declared rate stays in the ordinary four-characters-a-token estimate (or,
-    // for non-ASCII, at that estimate's per-character rate), so a provider that
-    // declares none of the extra rates is estimated exactly as before.
-    const isDigit = (c) => c >= "0" && c <= "9";
-    const isSymbol = (c) => /[!-/:-@[-`{-~]/.test(c);
-    let digits = 0;
-    let symbols = 0;
-    let astrals = 0;
-    let nonAscii = 0;
-    const rest = [];
-    for (const c of text) {
-        const code = c.codePointAt(0) ?? 0;
-        if (code > 0xffff && astral !== undefined) {
-            astrals += 1;
-        }
-        else if (code > 0x7f) {
-            nonAscii += 1;
-        }
-        else if (digit !== undefined && isDigit(c)) {
-            digits += 1;
-        }
-        else if (symbol !== undefined && isSymbol(c)) {
-            symbols += 1;
-        }
-        else {
-            rest.push(c);
-        }
-    }
-    // Digits, punctuation and astral characters (emoji) are charged separately
-    // only when the provider declares a rate for them: a tokenizer that reads each
-    // digit, and most punctuation, on its own makes a number-heavy or JSON-heavy
-    // state several times longer than four characters a token suggests.
-    return (estimateTokens(rest.join("")) +
-        Math.ceil(digits * (digit ?? 0)) +
-        Math.ceil(symbols * (symbol ?? 0)) +
-        Math.ceil(astrals * (astral ?? 0)) +
-        Math.ceil(nonAscii * (nonAsciiTokensPerChar ?? 1 / CHARS_PER_TOKEN)));
-}
 /**
  * The shared half of every "System One" decision provider — a model that takes
  * one `state` plus typed questions and returns one typed answer each, with no
@@ -551,10 +498,19 @@ export class SystemOneDecisionProvider extends BaseProvider {
      * Refuse a request the model cannot read in full. An encoder cuts the state
      * off past its window without saying so, so without this a decision would
      * be made on input the model never saw — and reported as if it had.
+     *
+     * Advisory limits (`decisionLimits.advisory`) are skipped: they publish a
+     * server's own ceiling for `NeuroLink.decisionLimits()` to report, and the
+     * server enforces them itself. The estimator and the flattening are the
+     * same functions that method uses, so a host that sizes a state against the
+     * reading measures exactly what is checked here.
      */
     assertWithinDecisionLimits(request, model, questionCount) {
-        const limits = PROVIDER_DESCRIPTORS_BY_NAME.get(this.providerName)?.decisionLimits;
-        if (!limits) {
+        const descriptor = PROVIDER_DESCRIPTORS_BY_NAME.get(this.providerName);
+        const limits = descriptor
+            ? resolveDecisionLimitsReading(descriptor, model)
+            : null;
+        if (!limits || !limits.enforcedLocally) {
             return;
         }
         const label = this.vendorLabel();
@@ -566,13 +522,8 @@ export class SystemOneDecisionProvider extends BaseProvider {
                 retryable: false,
             });
         }
-        const modelLimits = limits.models?.[model];
-        const maxStateTokens = modelLimits?.maxStateTokens ?? limits.maxStateTokens;
-        const stateTokens = estimateDecisionStateTokens(serializeForEstimate(request.state), modelLimits?.nonAsciiTokensPerChar ?? limits.nonAsciiTokensPerChar, {
-            digit: limits.digitTokensPerChar,
-            symbol: limits.symbolTokensPerChar,
-            astral: limits.astralTokensPerChar,
-        });
+        const { maxStateTokens } = limits;
+        const stateTokens = estimateDecisionStateTokens(request.state, limits);
         if (stateTokens > maxStateTokens) {
             throw this.decisionError({
                 kind: "max_tokens_exceeded",

package/dist/providers/typesafe.d.ts

@@ -4,6 +4,12 @@ import { SystemOneDecisionProvider } from "./systemOneDecision.js";
  * The binding limit in practice: `state` plus the SINGLE LONGEST question.
  * Measured by bisection at single-character resolution — 33,002 reported
  * input tokens accepted, 33,003 not.
+ *
+ * The same figure sits on the TypeSafe descriptor as an ADVISORY
+ * `decisionLimits.maxStateTokens`, which is what `NeuroLink.decisionLimits()`
+ * reads; the server enforces it, NeuroLink only reports it. The descriptor
+ * cannot import this constant without a cycle, so the decide suite pins them
+ * equal instead.
  */
 export declare const TYPESAFE_MAX_STATE_TOKENS = 33000;
 /**

package/dist/providers/typesafe.js

@@ -27,6 +27,12 @@ const GATEWAY_SPEC_VERSION = "4";
  * The binding limit in practice: `state` plus the SINGLE LONGEST question.
  * Measured by bisection at single-character resolution — 33,002 reported
  * input tokens accepted, 33,003 not.
+ *
+ * The same figure sits on the TypeSafe descriptor as an ADVISORY
+ * `decisionLimits.maxStateTokens`, which is what `NeuroLink.decisionLimits()`
+ * reads; the server enforces it, NeuroLink only reports it. The descriptor
+ * cannot import this constant without a cycle, so the decide suite pins them
+ * equal instead.
  */
 export const TYPESAFE_MAX_STATE_TOKENS = 33_000;
 /**

package/dist/rag/retrieval/searchDecision.js

@@ -75,6 +75,7 @@ export async function decideSearchPlan(query, decide, capabilities) {
         };
     }
     const result = await decide({
+        site: "ragPlan",
         state: { query: query.slice(0, 4000) },
         // The map is assembled dynamically above; its members are all valid
         // question shapes, which the cast asserts once here rather than at four

package/dist/routing/classifierRouter.js

@@ -98,7 +98,7 @@ export class ClassifierRouter {
         try {
             // Both the LLM and Jev strategies can pick a model straight out of the
             // pool — the generic path for custom/registry-less models.
-            const strategy = this.resolveStrategy();
+            const strategy = this.resolveStrategy(input);
             const usesCandidates = (strategy === "jev" && !!this.deps.decide) ||
                 (strategy === "llm" && !!this.deps.generate);
             const built = usesCandidates ? this.buildCandidates() : undefined;
@@ -138,7 +138,7 @@ export class ClassifierRouter {
      * moment a decision provider is configured; without one the behaviour is
      * exactly what it was before Jev existed.
      */
-    resolveStrategy() {
+    resolveStrategy(input) {
         const configured = this.config.classifier ?? "auto";
         if (configured !== "auto") {
             return configured;
@@ -146,10 +146,11 @@ export class ClassifierRouter {
         // A decision provider that is both registered AND configured is the whole
         // activation condition — this is where "if somebody sets it we start
         // using it" lives for routing. The caller's check also counts the
-        // credentials it was constructed with.
+        // credentials it was constructed with and the request's own per-call
+        // credentials, which the decision call itself will use.
         const hasProvider = this.deps.hasDecisionProvider
-            ? this.deps.hasDecisionProvider()
-            : resolveDefaultDecisionProvider() !== undefined;
+            ? this.deps.hasDecisionProvider(input.credentials)
+            : resolveDefaultDecisionProvider(input.credentials) !== undefined;
         return this.deps.decide && hasProvider ? "jev" : "heuristic";
     }
     /** Run the chosen strategy; every one falls back to heuristic on failure. */

package/dist/routing/classifierStrategies.js

@@ -297,8 +297,15 @@ export async function classifyJev(input, decide, timeoutMs, candidates, threshol
     // short conversational one.
     // Continuity is sent as `session_bound` / `prior_messages`, never as the
     // raw sessionId: the id is an opaque identifier that tells a third-party
-    // model nothing, so it stays in-process.
+    // model nothing, so it stays in-process — as do the site stamp, the
+    // per-call credentials and the ids below, which the caller reads and the
+    // wire never sees.
     const result = await decide({
+        site: "routing",
+        credentials: input.credentials,
+        signal: input.signal,
+        sessionId: input.sessionId,
+        requestId: input.requestId,
         state: {
             request: (input.prompt ?? "").slice(0, 8000),
             estimated_input_tokens: input.estimatedInputTokens ?? 0,

package/dist/types/classifierRouter.d.ts

@@ -15,6 +15,7 @@
  */
 import type { ValidationSchema } from "./aliases.js";
 import type { DecisionCallerFn } from "./decision.js";
+import type { NeurolinkCredentials } from "./providers.js";
 /** Coarse difficulty buckets the classifier maps a request into. */
 export type ClassifierDifficulty = "trivial" | "simple" | "moderate" | "hard" | "expert";
 /**
@@ -307,6 +308,16 @@ export type ClassifierRouterInput = {
     sessionBound?: boolean;
     /** Number of prior conversation messages the caller supplied, when known. */
     priorMessageCount?: number;
+    /**
+     * The outer request's per-call credentials, forwarded to the decision call
+     * so it reaches the caller's provider account rather than the instance's.
+     * Never part of the state sent to the model.
+     */
+    credentials?: NeurolinkCredentials;
+    /** The outer request's abort signal; an abandoned turn abandons its routing call. */
+    signal?: AbortSignal;
+    /** The outer request's id, for hook and event correlation. Never sent to the model. */
+    requestId?: string;
 };
 /** Enriched per-model metadata used while ranking pool members. */
 export type ClassifierModelMeta = {
@@ -359,9 +370,11 @@ export type ClassifierRouterDeps = {
     decide?: ClassifierDecideFn;
     /**
      * Whether a decision provider is configured for this caller, counting the
-     * credentials it was given as well as the environment. Omit to check the
-     * environment alone.
+     * credentials it was given as well as the environment — and the request's
+     * own per-call `credentials`, passed in from `ClassifierRouterInput`, so a
+     * caller that holds no decision key itself can still route a request that
+     * carries one. Omit to check the environment alone.
      */
-    hasDecisionProvider?: () => boolean;
+    hasDecisionProvider?: (callCredentials?: NeurolinkCredentials) => boolean;
     logger?: ClassifierLogger;
 };

package/dist/types/common.d.ts

@@ -102,6 +102,8 @@ export type NeuroLinkEvents = {
     "stream:error": unknown;
     "generation:start": unknown;
     "generation:end": unknown;
+    "decision:before": unknown;
+    "decision:after": unknown;
     "response:start": unknown;
     "response:end": unknown;
     "externalMCP:serverConnected": unknown;

package/dist/types/config.d.ts

@@ -14,6 +14,7 @@ import type { ModelPoolConfig } from "./modelPool.js";
 import type { RequestRouter } from "./requestRouter.js";
 import type { ClassifierRouterConfig } from "./classifierRouter.js";
 import type { ContextRelevanceOptions } from "./context.js";
+import type { DecisionHooks } from "./decision.js";
 import type { SkillsConfig } from "./skills.js";
 import type { KnowledgeGroundingConfig } from "./knowledge.js";
 /**
@@ -155,6 +156,14 @@ export type NeurolinkConstructorConfig = {
      * which is the same activation rule every other decision consumer uses.
      */
     contextRelevance?: ContextRelevanceOptions;
+    /**
+     * Ride along on the decision calls NeuroLink already makes for routing,
+     * tool routing, compaction and RAG planning: add your own questions to the
+     * same round trip and read the answers back. Observe-only with respect to
+     * NeuroLink's behaviour, fail-open, and inert until a decision provider is
+     * configured. See {@link DecisionHooks}.
+     */
+    decisionHooks?: DecisionHooks;
     /**
      * Native skills: versioned, discoverable instruction packs (SOPs,
      * playbooks) with progressive disclosure. When enabled, each

package/dist/types/context.d.ts

@@ -4,7 +4,7 @@
  */
 import type { ExecutionContext } from "../types/tools.js";
 import type { JsonObject } from "./common.js";
-import type { ChatMessage, ConversationMemoryConfig } from "./conversation.js";
+import type { ChatMessage, ConversationMemoryConfig, ToolReplayMode } from "./conversation.js";
 import type { DecisionCallerFn } from "./decision.js";
 /**
  * Base context type for all AI operations
@@ -237,6 +237,13 @@ export type BudgetCheckParams = {
     }>;
     /** Compaction trigger threshold (0.0-1.0). Default: 0.80 */
     compactionThreshold?: number;
+    /**
+     * How this request replays stored `tool_call` / `tool_result` rows
+     * (`replayToolSteps`). When set, tool rows are estimated at the size they
+     * reach the model in that mode rather than at stored size; when omitted
+     * they count at stored size.
+     */
+    toolReplayMode?: ToolReplayMode;
 };
 /** A file prepared for potential summarization. */
 export type FileForSummarization = {