@juspay/neurolink 12.49.6 → 12.49.8

package/dist/context/contextDecision.js

@@ -101,8 +101,8 @@ export async function selectIrrelevantMessages(messages, currentRequest, decide,
             type: "boolean",
             instructions: RELEVANCE_INSTRUCTIONS,
             criteria: {
-                true: `The current request depends on this message: "${preview(entry.message)}"`,
-                false: "The current request does not depend on this message.",
+                true: `The current request depends on conversation[${position}].`,
+                false: `The current request does not depend on conversation[${position}].`,
             },
         };
     });
@@ -230,7 +230,7 @@ export async function summaryPreservesContext(summary, replacedMessages, decide,
     }
     return true;
 }
-/** Bounded text for one message, used in both state and criteria. */
+/** Bounded text stored once in decision state and referenced by position. */
 function preview(message) {
     return message.content.slice(0, MAX_MESSAGE_CHARS);
 }

package/dist/core/toolRoutingDecision.js

@@ -48,42 +48,21 @@ const MAX_SERVERS = 200;
 /**
  * The question wording, and why it is this wording.
  *
- * The obvious phrasing — "answering this request will require calling at least
- * one tool from this server", with a `false` criterion reading "this server is
- * unrelated, OR the request needs no tool at all" — was measured against a
- * 10-request × 5-server labelled set. It separated correctly but weakly:
- * unrelated servers averaged p=0.31 and reached 0.80, so at the 0.6 drop bar
- * only 12 of 39 unneeded servers were dropped.
- *
- * Naming the server, asking in the present tense about what carrying out the
- * request *involves*, and splitting the bundled `false` criterion into a single
- * claim moved unrelated servers to a mean of p=0.03 with a maximum of 0.35 —
- * **37 of 39** dropped at the same bar, still with zero wrong drops.
- *
- * The lesson generalises: a decision model reads literally, and an `or` in a
- * criterion is two questions wearing one coat.
+ * The server capability already exists once in structured state. Referencing
+ * that indexed field avoids copying the same long description into the
+ * instruction and both criteria while still binding each question to one
+ * concrete server.
  */
-function serverQuestion(server) {
-    const does = uncapitalize(describeServer(server));
+function serverQuestion(server, index) {
     return {
         type: "boolean",
-        instructions: `The request needs the "${server.id}" server, which can ${does}.`,
+        instructions: `Does the request need the "${server.id}" server? Read available_servers[${index}].does.`,
         criteria: {
-            true: `Carrying out the request involves ${does}.`,
-            false: `The request is about something else; nothing it asks for involves ${does}.`,
+            true: "Needed.",
+            false: "Not needed.",
         },
     };
 }
-/**
- * Lowercase only the FIRST character. A plain `toLowerCase()` would turn
- * "Read and write GitHub issues" into "…github issues", and the proper noun is
- * often the strongest signal in the sentence.
- */
-function uncapitalize(text) {
-    // charAt rather than an index: it returns "" for an empty string, so this
-    // needs no length guard and no non-null assertion.
-    return text.charAt(0).toLowerCase() + text.slice(1);
-}
 /**
  * Ask one yes/no question per routable server and return the servers to keep.
  *
@@ -98,7 +77,7 @@ export async function selectServersByDecision(userQuery, routableServers, decide
     const servers = routableServers.slice(0, MAX_SERVERS);
     const questions = {};
     servers.forEach((server, index) => {
-        questions[decisionKey(SERVER_NAMESPACE, index)] = serverQuestion(server);
+        questions[decisionKey(SERVER_NAMESPACE, index)] = serverQuestion(server, index);
     });
     const result = await decide({
         site: "toolRouting",

package/dist/factories/providerDescriptors.js

@@ -655,25 +655,34 @@ const HAND_DESCRIPTORS = [
         // Measured 2026-10-03: 0.3 to 1.0 s for a small request, 1.1 s for 64 questions on
         // clef-flash and 1.3 s on clef, and 2.2 s at most for any of 60 requests
         // sent at once. On 2026-10-04, 64 questions took 1.5 s (flash) / 2.3 s (clef).
-        // 5s covers those observations and keeps a fail-open consumer
-        // from waiting on a stuck call.
+        // 5s covers a small request and keeps a fail-open consumer from waiting on a
+        // stuck call. The state adds time, so the provider adds 250 ms for each full
+        // 1,000 estimated state tokens (9s at the limit below). Measured 2026-10-07 at
+        // about 0.2 s per 1,000 input tokens from 50,000 tokens up on both models
+        // (clef-flash 4.9 s at 52,154 tokens, clef 11.8 s, clef-flash 19.2 s at
+        // 86,819 and 30.9 s at 158,153), and 1.7 to 1.9 s at 20,954 tokens.
         timeouts: { decideMs: 5_000 },
-        // The Workers AI endpoint ignores state text past about 2,048 tokens
-        // (hosted service or model: unknown), despite the documented 64K. The local
-        // 1,500-token estimate refuses before every measured cut. On 2026-10-04,
-        // both models read facts at the original clef-flash lower bounds for logs,
-        // number lists, digit arrays and compact JSON, but not 2.5% to 3.1% further on;
-        // English prose and random CJK already matched on both. Digits cost 1,
-        // ASCII symbols 0.75, BMP non-ASCII 1.5 and astral characters 3 tokens.
-        // Natural Chinese, Japanese, Korean and Hindi prose and emoji-rich English
-        // were also safe under those rates on clef. A many-key object cut between
-        // 128 and 134 preceding keys on both models: its lower bound was 4,883
-        // compact-JSON characters, estimated at 2,299 tokens. The probe used an
-        // explicit field-name question and zero-padded keys together after the
-        // control failed three times. It then passed; necessity was not established.
-        // Other object shapes and Unicode sequences may differ.
+        // On 2026-10-03 and 2026-10-04 the Workers AI endpoint ignored state text
+        // past about 2,048 tokens (hosted service or model: unknown), and the local
+        // limit was 1,500. On 2026-10-07 it no longer did: clef-flash read a fact at
+        // the very end of a 190,153-token digit array and of an 86,819-token prose
+        // state, and clef read a 52,154-token prose state, while clef answered
+        // HTTP 529 (code 5012, "Clef inference failed") after 15 s for the digit
+        // array. The limit is now 16,000 estimated tokens. The estimate runs 35%
+        // over real tokens for prose and 14% under for a digit array, whose commas
+        // cost a token each, so the limit is at most about 18,400 real tokens, 2.8
+        // times less than the 52,154 clef read in full. It also bounds how long a
+        // fail-open consumer can wait (the timeout above). The service changed twice
+        // in four days, so live canaries 19.10 and 19.10b read a fact at the end of a
+        // state at this limit on both models. Digits cost 1, ASCII symbols 0.75, BMP
+        // non-ASCII 1.5 and astral characters 3: the rates now approximate real
+        // tokens and no longer stand for a cut.
+        // The 2026-10-04 follow-up on the old cut (logs, number lists, digit arrays
+        // and compact JSON on both models; natural Chinese, Japanese, Korean and
+        // Hindi prose and emoji-rich English on clef; a many-key object) is in the
+        // guide; it explains where the rates come from, not what limit applies now.
         decisionLimits: {
-            maxStateTokens: 1_500,
+            maxStateTokens: 16_000,
             maxQuestions: 64,
             nonAsciiTokensPerChar: 1.5,
             digitTokensPerChar: 1,

package/dist/models/manifests/cloudflareClef.d.ts

@@ -4,9 +4,10 @@ import type { ProviderModelManifest } from "../../types/index.js";
  * generation, and not the Workers AI text models of the `cloudflare` provider.
  *
  * `contextWindow` is the figure Cloudflare documents (65,536 tokens). The
- * Workers AI endpoint ignores state text past about 2,048 tokens without an
- * error (hosted service or model: unknown), so NeuroLink enforces the limit on
- * the descriptor's `decisionLimits`, not this. `vision` describes `generate()`
+ * Workers AI endpoint ignored state text past about 2,048 tokens until
+ * 2026-10-04 and read far more on 2026-10-07 (hosted service or model:
+ * unknown), so NeuroLink enforces the limit on the descriptor's
+ * `decisionLimits`, not this. `vision` describes `generate()`
  * input, which this provider does not serve; its image input is
  * `DecisionRequest.images`.
  *

package/dist/models/manifests/cloudflareClef.js

@@ -3,9 +3,10 @@
  * generation, and not the Workers AI text models of the `cloudflare` provider.
  *
  * `contextWindow` is the figure Cloudflare documents (65,536 tokens). The
- * Workers AI endpoint ignores state text past about 2,048 tokens without an
- * error (hosted service or model: unknown), so NeuroLink enforces the limit on
- * the descriptor's `decisionLimits`, not this. `vision` describes `generate()`
+ * Workers AI endpoint ignored state text past about 2,048 tokens until
+ * 2026-10-04 and read far more on 2026-10-07 (hosted service or model:
+ * unknown), so NeuroLink enforces the limit on the descriptor's
+ * `decisionLimits`, not this. `vision` describes `generate()`
  * input, which this provider does not serve; its image input is
  * `DecisionRequest.images`.
  *

package/dist/providers/cloudflareClef.d.ts

@@ -13,9 +13,9 @@ import { SystemOneDecisionProvider } from "./systemOneDecision.js";
  * reads (`CLOUDFLARE_API_KEY`, `CLOUDFLARE_ACCOUNT_ID`), so a host that has
  * configured that provider has also configured this one.
  *
- * The Workers AI endpoint ignores text past about 2,048 tokens, far below
- * the documented 64K (hosted service or model: unknown). See `decisionLimits`
- * on the descriptor for the measured figures.
+ * The Workers AI state window changed in October 2026: about 2,048 tokens until
+ * 2026-10-04, far more on 2026-10-07 (hosted service or model: unknown). See
+ * `decisionLimits` on the descriptor for the measured figures.
  *
  * @see https://developers.cloudflare.com/workers-ai/models/clef/
  */
@@ -30,6 +30,7 @@ export declare class CloudflareClefProvider extends SystemOneDecisionProvider {
     protected decisionApiKey(): string;
     protected missingKeyMessage(): string;
     protected missingConfigMessage(): string | undefined;
+    protected defaultTimeoutMs(_questionCount: number, stateTokens: number): number | undefined;
     /** The model is part of the path, so the endpoint depends on the model asked for. */
     protected decisionEndpoint(model: string): string;
     protected decisionHeaders(): Record<string, string>;

package/dist/providers/cloudflareClef.js

@@ -5,6 +5,15 @@ import { getProviderModel } from "../utils/providerConfig.js";
 import { isRecord, redactCredentials, SystemOneDecisionProvider, } from "./systemOneDecision.js";
 const CLOUDFLARE_DEFAULT_BASE_URL = "https://api.cloudflare.com/client/v4";
 const MODEL_PREFIX = "@cf/cloudflare/";
+/**
+ * Added to the descriptor's `decideMs` for each full 1,000 estimated state
+ * tokens. Latency follows the input size: measured 2026-10-07 at about 0.2 s per
+ * 1,000 input tokens from 50,000 tokens up on both models, so a state at the
+ * descriptor's limit (16,000 estimated, about 18,400 real tokens at most) gets
+ * 4 s on top of the 5 s allowance, and a flat 5 s would cut off a request that
+ * is merely large and retry it into the same wait.
+ */
+const TIMEOUT_MS_PER_THOUSAND_STATE_TOKENS = 250;
 /**
  * Cloudflare account ids are 32 hex digits. The pattern is wider so that a
  * change of format needs no release, but it still keeps `/`, `.`, `?` and
@@ -188,9 +197,9 @@ function cloudflareErrorKind(status, code) {
  * reads (`CLOUDFLARE_API_KEY`, `CLOUDFLARE_ACCOUNT_ID`), so a host that has
  * configured that provider has also configured this one.
  *
- * The Workers AI endpoint ignores text past about 2,048 tokens, far below
- * the documented 64K (hosted service or model: unknown). See `decisionLimits`
- * on the descriptor for the measured figures.
+ * The Workers AI state window changed in October 2026: about 2,048 tokens until
+ * 2026-10-04, far more on 2026-10-07 (hosted service or model: unknown). See
+ * `decisionLimits` on the descriptor for the measured figures.
  *
  * @see https://developers.cloudflare.com/workers-ai/models/clef/
  */
@@ -248,6 +257,14 @@ export class CloudflareClefProvider extends SystemOneDecisionProvider {
         }
         return baseURLProblem(this.baseURL);
     }
+    defaultTimeoutMs(_questionCount, stateTokens) {
+        const allowance = this.getDescriptorDecideMs();
+        return allowance === undefined
+            ? undefined
+            : allowance +
+                Math.floor(stateTokens / 1_000) *
+                    TIMEOUT_MS_PER_THOUSAND_STATE_TOKENS;
+    }
     /** The model is part of the path, so the endpoint depends on the model asked for. */
     decisionEndpoint(model) {
         return `${this.baseURL}/accounts/${encodeURIComponent(this.accountId)}/ai/run/${MODEL_PREFIX}${encodeURIComponent(wireModel(model) ?? model)}`;

package/dist/providers/systemOneDecision.d.ts

@@ -82,9 +82,11 @@ export declare abstract class SystemOneDecisionProvider extends BaseProvider {
     protected readRetryAfterMs(_headers: Headers): number | undefined;
     /**
      * The per-attempt timeout when the caller sets none. A provider whose latency
-     * grows with the number of questions scales the descriptor's allowance here.
+     * grows with the number of questions or the size of the state scales the
+     * descriptor's allowance here. `stateTokens` is the local estimate, 0 when the
+     * descriptor sets no local limits.
      */
-    protected defaultTimeoutMs(_questionCount: number): number | undefined;
+    protected defaultTimeoutMs(_questionCount: number, _stateTokens: number): number | undefined;
     /**
      * The part of a successful response that holds `answers`, `usage` and
      * `model`. The default is the response itself; a vendor that wraps every

package/dist/providers/systemOneDecision.js

@@ -230,9 +230,11 @@ export class SystemOneDecisionProvider extends BaseProvider {
     }
     /**
      * The per-attempt timeout when the caller sets none. A provider whose latency
-     * grows with the number of questions scales the descriptor's allowance here.
+     * grows with the number of questions or the size of the state scales the
+     * descriptor's allowance here. `stateTokens` is the local estimate, 0 when the
+     * descriptor sets no local limits.
      */
-    defaultTimeoutMs(_questionCount) {
+    defaultTimeoutMs(_questionCount, _stateTokens) {
         return this.getDescriptorDecideMs();
     }
     /**
@@ -327,7 +329,7 @@ export class SystemOneDecisionProvider extends BaseProvider {
             });
         }
         const resolvedModel = request.model ?? this.modelName ?? this.getDefaultModel();
-        this.assertWithinDecisionLimits(request, resolvedModel, questionEntries.length);
+        const stateTokens = this.assertWithinDecisionLimits(request, resolvedModel, questionEntries.length);
         const wireQuestions = Object.fromEntries(questionEntries.map(([id, question]) => [
             id,
             this.encodeQuestion(question),
@@ -336,7 +338,7 @@ export class SystemOneDecisionProvider extends BaseProvider {
         const body = JSON.stringify(this.buildDecisionBody(request.state, wireQuestions, resolvedModel, media));
         this.assertWithinRequestBytes(body);
         const timeoutMs = request.timeoutMs ??
-            this.defaultTimeoutMs(questionEntries.length) ??
+            this.defaultTimeoutMs(questionEntries.length, stateTokens) ??
             this.defaultTimeout ??
             DEFAULT_DECISION_TIMEOUT_MS;
         let lastError;
@@ -511,7 +513,7 @@ export class SystemOneDecisionProvider extends BaseProvider {
             ? resolveDecisionLimitsReading(descriptor, model)
             : null;
         if (!limits || !limits.enforcedLocally) {
-            return;
+            return 0;
         }
         const label = this.vendorLabel();
         if (limits.maxQuestions !== undefined &&
@@ -531,6 +533,7 @@ export class SystemOneDecisionProvider extends BaseProvider {
                 retryable: false,
             });
         }
+        return stateTokens;
     }
     /**
      * Wrap a normalised decision failure in the provider error type, keeping

package/dist/utils/providerConfig.js

@@ -1391,7 +1391,7 @@ export function createCloudflareClefConfig() {
         instructions: [
             "1. Create an API token with the 'Workers AI: Read + Write' permission (https://dash.cloudflare.com/profile/api-tokens)",
             "2. Set CLOUDFLARE_API_KEY to it, and CLOUDFLARE_ACCOUNT_ID to your account id (in the dashboard URL, or under 'Account ID'); they are the same settings the Cloudflare text provider reads, so setting them also lets decide() use Clef when no other decision provider is configured",
-            "3. The Clef endpoint ignores state text past about 2,048 tokens, so use it for short decisions",
+            "3. NeuroLink refuses a state it estimates at more than 16,000 tokens (about 60,000 characters of prose); long states also take seconds, so Clef suits short decisions",
         ],
     };
 }

package/dist/voice/providers/CartesiaTTS.js

@@ -18,7 +18,7 @@ import { logger } from "../../utils/logger.js";
 import { TTS_ERROR_CODES, TTSError } from "../../utils/ttsProcessor.js";
 const DEFAULT_BASE_URL = "https://api.cartesia.ai";
 const DEFAULT_API_VERSION = "2025-04-16";
-const DEFAULT_MODEL = "sonic-2";
+const DEFAULT_MODEL = "sonic-3.6";
 // Same default voice as the streaming handler — a publicly available
 // Cartesia voice id ("Bright Female"). Override per-call via TTSOptions.voice.
 const DEFAULT_VOICE_ID = "694f9389-aac1-45b6-b726-9d9369183238";