@juspay/neurolink 12.25.5 → 12.26.1

package/dist/cli/commands/decide.d.ts

@@ -8,7 +8,8 @@
  * for the full vocabulary.
  *
  * Credentials are env-only here, exactly as every other CLI command: the
- * decision provider (TypeSafe) reads `TYPESAFE_API_KEY` itself.
+ * decision provider reads its own settings (TYPESAFE_API_KEY, or LAYA_API_KEY
+ * and LAYA_BASE_URL) itself.
  */
 import type { CommandModule } from "yargs";
 import type { CliDecideArgs } from "../../types/index.js";

package/dist/cli/commands/decide.js

@@ -8,11 +8,13 @@
  * for the full vocabulary.
  *
  * Credentials are env-only here, exactly as every other CLI command: the
- * decision provider (TypeSafe) reads `TYPESAFE_API_KEY` itself.
+ * decision provider reads its own settings (TYPESAFE_API_KEY, or LAYA_API_KEY
+ * and LAYA_BASE_URL) itself.
  */
 import chalk from "chalk";
 import ora from "ora";
 import fs from "node:fs";
+import { describeDecisionProviderKeys } from "../../factories/providerDescriptors.js";
 import { NeuroLink } from "../../neurolink.js";
 import { readDecisionChoice } from "../../utils/decisionAnswers.js";
 import { calculateCost, hasPricing } from "../../utils/pricing.js";
@@ -87,7 +89,7 @@ function describeDecideError(error) {
     }
     const message = error instanceof Error ? error.message : String(error);
     if (message.includes("No decision provider is configured")) {
-        return "No decision provider is configured. Set TYPESAFE_API_KEY, or AI_GATEWAY_API_KEY for the Vercel AI Gateway route.";
+        return `No decision provider is configured. Set ${describeDecisionProviderKeys()}.`;
     }
     return message;
 }

package/dist/cli/commands/setup.js

@@ -20,7 +20,7 @@ import { handleGCPSetup } from "./setup-gcp.js";
 import { handleHuggingFaceSetup } from "./setup-huggingface.js";
 import { handleMistralSetup } from "./setup-mistral.js";
 import { PROVIDER_DESCRIPTORS_BY_NAME } from "../../factories/providerDescriptors.js";
-import { createCohereConfig, createDeepSeekConfig, createIdeogramConfig, createJinaConfig, createNvidiaNimConfig, createOpenAICompatibleConfig, createRecraftConfig, createReplicateConfig, createStabilityConfig, createVoyageConfig, createTypeSafeConfig, satisfiesFallbacks, } from "../../utils/providerConfig.js";
+import { createCohereConfig, createDeepSeekConfig, createIdeogramConfig, createJinaConfig, createNvidiaNimConfig, createOpenAICompatibleConfig, createRecraftConfig, createReplicateConfig, createStabilityConfig, createVoyageConfig, createTypeSafeConfig, createLayaConfig, satisfiesFallbacks, } from "../../utils/providerConfig.js";
 import { getCatalogJsonEntries, buildCatalogConfigOptions, } from "../../providers/catalog/loader.js";
 // Provider information database
 const PROVIDERS = [
@@ -169,6 +169,7 @@ export const EXTRA_PROVIDER_CONFIGS = {
     ideogram: createIdeogramConfig(),
     recraft: createRecraftConfig(),
     typesafe: createTypeSafeConfig(),
+    laya: createLayaConfig(),
     ...Object.fromEntries(getCatalogJsonEntries()
         .filter((e) => e.id !== "mistral")
         .map((e) => [e.id, buildCatalogConfigOptions(e)])),

package/dist/cli/factories/commandFactory.js

@@ -593,7 +593,7 @@ export class CLICommandFactory {
         },
         classifierStrategy: {
             type: "string",
-            description: "Classifier strategy: 'auto' (default — 'jev' when TYPESAFE_API_KEY is set, else 'heuristic'), 'heuristic' (no LLM), 'llm' (a cheap model picks per prompt), or 'jev' (TypeSafe System One, ~400ms with calibrated confidence).",
+            description: "Classifier strategy: 'auto' (default — 'jev' when a decision provider is configured, such as TYPESAFE_API_KEY, or LAYA_API_KEY with LAYA_BASE_URL, else 'heuristic'), 'heuristic' (no LLM), 'llm' (a cheap model picks per prompt), or 'jev' (a System One decision model — TypeSafe Jev, or Laya — with calibrated confidence).",
             choices: ["auto", "heuristic", "llm", "jev"],
             alias: "classifier-strategy",
         },

package/dist/cli/utils/classifierRouterFlags.js

@@ -37,7 +37,7 @@ export function buildClassifierRouterConfigFromCli(flags) {
     if (!flags.classifierRouter) {
         return undefined;
     }
-    // Defaults to "auto", which resolves to "jev" when TYPESAFE_API_KEY is set
+    // Defaults to "auto", which resolves to "jev" when a decision provider's key is set
     // and "heuristic" otherwise — so a configured key upgrades CLI routing with
     // no flag change, and an unset one behaves exactly as before.
     const strategy = isStrategyKind(flags.classifierStrategy)

package/dist/constants/enums.d.ts

@@ -44,6 +44,8 @@ export declare enum AIProviderName {
     RECRAFT = "recraft",
     /** TypeSafe (Jev) — serves the `decide` inference type only. */
     TYPESAFE = "typesafe",
+    /** Laya (Convai, open weights) — serves the `decide` inference type only. */
+    LAYA = "laya",
     AUTO = "auto"
 }
 /**
@@ -1047,3 +1049,16 @@ export declare enum TypeSafeModels {
     JEV_LATEST = "jev-latest",
     JEV_PREVIEW = "jev-preview"
 }
+/**
+ * Laya checkpoints. Hand-written: Laya is a Tier-3 provider, so it is not in
+ * the provider catalog and codegen never touches this.
+ *
+ * `auto` sends no model, which lets Laya's own router pick a checkpoint by
+ * the detected language of the state.
+ */
+export declare enum LayaModels {
+    TYPED_DECISIONS = "typed-decisions",
+    ENGLISH = "english",
+    MULTILINGUAL = "multilingual",
+    AUTO = "auto"
+}

package/dist/constants/enums.js

@@ -50,6 +50,8 @@ export var AIProviderName;
     AIProviderName["RECRAFT"] = "recraft";
     /** TypeSafe (Jev) — serves the `decide` inference type only. */
     AIProviderName["TYPESAFE"] = "typesafe";
+    /** Laya (Convai, open weights) — serves the `decide` inference type only. */
+    AIProviderName["LAYA"] = "laya";
     AIProviderName["AUTO"] = "auto";
 })(AIProviderName || (AIProviderName = {}));
 /**
@@ -1295,3 +1297,17 @@ export var TypeSafeModels;
     TypeSafeModels["JEV_LATEST"] = "jev-latest";
     TypeSafeModels["JEV_PREVIEW"] = "jev-preview";
 })(TypeSafeModels || (TypeSafeModels = {}));
+/**
+ * Laya checkpoints. Hand-written: Laya is a Tier-3 provider, so it is not in
+ * the provider catalog and codegen never touches this.
+ *
+ * `auto` sends no model, which lets Laya's own router pick a checkpoint by
+ * the detected language of the state.
+ */
+export var LayaModels;
+(function (LayaModels) {
+    LayaModels["TYPED_DECISIONS"] = "typed-decisions";
+    LayaModels["ENGLISH"] = "english";
+    LayaModels["MULTILINGUAL"] = "multilingual";
+    LayaModels["AUTO"] = "auto";
+})(LayaModels || (LayaModels = {}));

package/dist/core/baseProvider.js

@@ -1,7 +1,7 @@
 import { context, SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
 import { directAgentTools } from "../agent/directTools.js";
 import { defaultProviderFor } from "../factories/mediaHandlerCatalog.js";
-import { PROVIDER_DESCRIPTORS_BY_NAME } from "../factories/providerDescriptors.js";
+import { DECISION_PROVIDERS, PROVIDER_DESCRIPTORS_BY_NAME, } from "../factories/providerDescriptors.js";
 import { MiddlewareFactory } from "../middleware/factory.js";
 import { modelSupports } from "../models/modelRegistry.js";
 import { resolveRequestKind } from "./resolveRequestKind.js";
@@ -1854,7 +1854,7 @@ export class BaseProvider {
     async decide(_request) {
         logger.warn(`decide() called on ${this.providerName}, which does not serve the decide inference type`);
         throw new Error(`The decide inference type is not supported by the ${this.providerName} provider. ` +
-            `Supported providers: typesafe. A provider declares this capability with ` +
+            `Supported providers: ${DECISION_PROVIDERS.map((d) => d.name).join(", ")}. A provider declares this capability with ` +
             `"decide" in its descriptor's inferenceKinds.`);
     }
     /**

package/dist/factories/providerDescriptors.d.ts

@@ -1,5 +1,5 @@
 import { AIProviderName } from "../constants/enums.js";
-import type { ProviderDescriptor } from "../types/index.js";
+import type { NeurolinkCredentials, ProviderDescriptor } from "../types/index.js";
 /**
  * Single source of truth for provider identity, credentials, defaults, and
  * runtime behavior classification — the hand-maintained providers plus the
@@ -21,11 +21,20 @@ export declare const PROVIDER_ALIAS_INDEX: ReadonlyMap<string, AIProviderName>;
  */
 export declare const DECISION_PROVIDERS: readonly ProviderDescriptor[];
 /**
- * The decision provider to use when a caller names none: the first one whose
- * primary credential env var is actually set.
+ * The decision provider to use when a caller names none: the first
+ * DECISION_PROVIDERS entry that is fully configured, from the environment or
+ * from `credentials`.
  *
- * This is where "if somebody sets the key, we start using it" is implemented.
- * Returns undefined when none is configured, which every internal consumer
- * treats as "carry on exactly as before".
+ * This is where "if somebody configures it, we start using it" is
+ * implemented. Returns undefined when none is configured, which every
+ * internal consumer treats as "carry on exactly as before".
  */
-export declare function resolveDefaultDecisionProvider(): string | undefined;
+export declare function resolveDefaultDecisionProvider(credentials?: NeurolinkCredentials): string | undefined;
+/**
+ * The variables that would configure each decision provider, one clause per
+ * provider in precedence order, e.g. "TYPESAFE_API_KEY or AI_GATEWAY_API_KEY
+ * for typesafe, or LAYA_API_KEY and LAYA_BASE_URL for laya". Derived from
+ * DECISION_PROVIDERS so a new decision provider appears in every "nothing is
+ * configured" message without anyone editing one.
+ */
+export declare function describeDecisionProviderKeys(): string;

package/dist/factories/providerDescriptors.js

@@ -1,5 +1,5 @@
 import { AIProviderName } from "../constants/enums.js";
-import { GoogleAIModels, OpenAIModels, AnthropicModels, VertexModels, OllamaModels, LiteLLMModels, NvidiaNimModels, OpenRouterModels, CohereModels, VoyageModels, TypeSafeModels, JinaModels, StabilityModels, IdeogramModels, RecraftModels, ReplicateModels, } from "../constants/enums.js";
+import { GoogleAIModels, OpenAIModels, AnthropicModels, VertexModels, OllamaModels, LiteLLMModels, NvidiaNimModels, OpenRouterModels, CohereModels, VoyageModels, TypeSafeModels, LayaModels, JinaModels, StabilityModels, IdeogramModels, RecraftModels, ReplicateModels, } from "../constants/enums.js";
 import { API_KEY_FORMATS } from "../utils/providerConfig.js";
 import { getCatalogJsonEntries, catalogCredentialsKey, catalogEnvVar, } from "../providers/catalog/loader.js";
 import { DEFAULT_INFERENCE_KINDS } from "../types/index.js";
@@ -451,6 +451,56 @@ const HAND_DESCRIPTORS = [
         timeouts: { decideMs: 5000 },
         setupUrl: "https://console.typesafe.ai/keys",
     },
+    // Laya MUST stay after TypeSafe. resolveDefaultDecisionProvider() returns
+    // the first configured DECISION_PROVIDERS entry, in this order, so a host
+    // configured for both keeps Jev for every built-in consumer and reaches
+    // Laya only by naming it. Reordering these two silently changes which model
+    // routes, compacts and plans for every such host.
+    {
+        name: AIProviderName.LAYA,
+        aliases: [],
+        credentialsKey: "laya",
+        envVars: {
+            apiKey: "LAYA_API_KEY",
+            baseURL: "LAYA_BASE_URL",
+            // Laya has no built-in endpoint (it is self-hosted or behind a proxy),
+            // so a key is useless without a base URL. Both are required for it to
+            // count as configured, from the environment or credentials.laya.
+            extraRequired: ["LAYA_BASE_URL"],
+            model: "LAYA_MODEL",
+        },
+        defaultModel: LayaModels.TYPED_DECISIONS,
+        // Serves only `decide`, like TypeSafe — the one declaration that keeps it
+        // out of every generation code path.
+        inferenceKinds: ["decide"],
+        toolSupport: "none",
+        localRuntime: false,
+        healthCheck: "env-only",
+        // Deliberately NO autoSelectPriority / autoSelectPreference /
+        // defaultHealthSweepPriority, for the same reason as TypeSafe above.
+        timeouts: { decideMs: 5000 },
+        // Laya's encoders cut the state off silently past their window (measured
+        // live: a 60,000-character state answered 200 on 1,024 tokens). 768 is
+        // the 1,024-token window minus the 256-token budget Laya reserves for a
+        // question and its options; 320 is the English checkpoint's 512 minus
+        // 192. `auto` may route to English, and an unlisted name (Laya's server
+        // accepts aliases such as `en`) could be any checkpoint, so both get 320.
+        // 64 is the question cap in Laya's own server. Non-ASCII rates were
+        // measured live: Chinese is ~1.4 tokens per character on the English
+        // tokenizer (typed-decisions, english) and ~0.56 on multilingual.
+        decisionLimits: {
+            maxStateTokens: 320,
+            maxQuestions: 64,
+            nonAsciiTokensPerChar: 1.5,
+            models: {
+                "typed-decisions": { maxStateTokens: 768 },
+                multilingual: { maxStateTokens: 768, nonAsciiTokensPerChar: 0.6 },
+                english: { maxStateTokens: 320 },
+                auto: { maxStateTokens: 320 },
+            },
+        },
+        setupUrl: "https://github.com/NandhaKishorM/laya",
+    },
 ];
 /**
  * Builds a ProviderDescriptor for every JSON-catalog provider. Every field
@@ -554,20 +604,52 @@ export const PROVIDER_ALIAS_INDEX = new Map(PROVIDER_DESCRIPTORS.flatMap((d) =>
  */
 export const DECISION_PROVIDERS = PROVIDER_DESCRIPTORS.filter((d) => (d.inferenceKinds ?? DEFAULT_INFERENCE_KINDS).includes("decide"));
 /**
- * The decision provider to use when a caller names none: the first one whose
- * primary credential env var is actually set.
+ * Whether a decision provider is fully configured: its key and every
+ * extraRequired variable are set, each either in the environment or in
+ * `credentials` — the same config a caller passes to
+ * `new NeuroLink({ credentials })` or per call. Whitespace counts as unset.
+ */
+function isDecisionProviderConfigured(descriptor, credentials) {
+    const isSet = (value) => typeof value === "string" && value.trim() !== "";
+    const inEnv = (name) => name !== undefined && isSet(process.env[name]);
+    const slice = descriptor.credentialsKey
+        ? credentials?.[descriptor.credentialsKey]
+        : undefined;
+    // `gatewayApiKey` is TypeSafe's config form of AI_GATEWAY_API_KEY.
+    const hasKey = [descriptor.envVars.apiKey, ...(descriptor.envVars.fallbacks ?? [])].some(inEnv) ||
+        isSet(slice?.apiKey) ||
+        isSet(slice?.gatewayApiKey);
+    // A required base URL can also come from credentials.<key>.baseURL.
+    const hasRequired = (descriptor.envVars.extraRequired ?? []).every((name) => inEnv(name) ||
+        (name === descriptor.envVars.baseURL && isSet(slice?.baseURL)));
+    return hasKey && hasRequired;
+}
+/**
+ * The decision provider to use when a caller names none: the first
+ * DECISION_PROVIDERS entry that is fully configured, from the environment or
+ * from `credentials`.
  *
- * This is where "if somebody sets the key, we start using it" is implemented.
- * Returns undefined when none is configured, which every internal consumer
- * treats as "carry on exactly as before".
+ * This is where "if somebody configures it, we start using it" is
+ * implemented. Returns undefined when none is configured, which every
+ * internal consumer treats as "carry on exactly as before".
  */
-export function resolveDefaultDecisionProvider() {
-    for (const descriptor of DECISION_PROVIDERS) {
-        const primary = descriptor.envVars.apiKey;
-        const candidates = [primary, ...(descriptor.envVars.fallbacks ?? [])];
-        if (candidates.some((v) => v && (process.env[v] ?? "").trim() !== "")) {
-            return descriptor.name;
-        }
-    }
-    return undefined;
+export function resolveDefaultDecisionProvider(credentials) {
+    return DECISION_PROVIDERS.find((descriptor) => isDecisionProviderConfigured(descriptor, credentials))?.name;
+}
+/**
+ * The variables that would configure each decision provider, one clause per
+ * provider in precedence order, e.g. "TYPESAFE_API_KEY or AI_GATEWAY_API_KEY
+ * for typesafe, or LAYA_API_KEY and LAYA_BASE_URL for laya". Derived from
+ * DECISION_PROVIDERS so a new decision provider appears in every "nothing is
+ * configured" message without anyone editing one.
+ */
+export function describeDecisionProviderKeys() {
+    return DECISION_PROVIDERS.map((descriptor) => {
+        const keys = [
+            descriptor.envVars.apiKey,
+            ...(descriptor.envVars.fallbacks ?? []),
+        ].filter((name) => typeof name === "string" && name !== "");
+        const required = descriptor.envVars.extraRequired ?? [];
+        return `${[keys.join(" or "), ...required].join(" and ")} for ${descriptor.name}`;
+    }).join(", or ");
 }

package/dist/factories/providerRegistry.js

@@ -1,6 +1,6 @@
 import { ProviderFactory } from "./providerFactory.js";
 import { logger } from "../utils/logger.js";
-import { AIProviderName, GoogleAIModels, OpenAIModels, AnthropicModels, VertexModels, OllamaModels, LiteLLMModels, NvidiaNimModels, OpenRouterModels, CohereModels, VoyageModels, JinaModels, StabilityModels, IdeogramModels, RecraftModels, TypeSafeModels, ReplicateModels, } from "../constants/enums.js";
+import { AIProviderName, GoogleAIModels, OpenAIModels, AnthropicModels, VertexModels, OllamaModels, LiteLLMModels, NvidiaNimModels, OpenRouterModels, CohereModels, VoyageModels, JinaModels, StabilityModels, IdeogramModels, RecraftModels, TypeSafeModels, LayaModels, ReplicateModels, } from "../constants/enums.js";
 import { PROVIDER_DESCRIPTORS_BY_NAME } from "./providerDescriptors.js";
 import { OPENAI_COMPAT_CATALOG } from "../providers/openaiCompatCatalog.js";
 import { providerChoicesFor } from "./mediaHandlerCatalog.js";
@@ -234,6 +234,14 @@ export class ProviderRegistry {
                 const { TypeSafeProvider } = await import("../providers/typesafe.js");
                 return new TypeSafeProvider(modelName, sdk, undefined, typesafeCreds);
             }, process.env.TYPESAFE_MODEL || TypeSafeModels.JEV_LATEST, ["jev", "typesafe-ai"], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.TYPESAFE));
+            // Register Laya — the second `decide` provider, reached at whatever base
+            // URL its config names. Its descriptor declares inferenceKinds:
+            // ["decide"], so nothing in the generation fallback chain can reach it.
+            ProviderFactory.registerProvider(AIProviderName.LAYA, async (modelName, _providerName, sdk, _region, credentials) => {
+                const layaCreds = credentials;
+                const { LayaProvider } = await import("../providers/laya.js");
+                return new LayaProvider(modelName, sdk, undefined, layaCreds);
+            }, process.env.LAYA_MODEL || LayaModels.TYPED_DECISIONS, [], PROVIDER_DESCRIPTORS_BY_NAME.get(AIProviderName.LAYA));
             logger.debug("All AI providers registered successfully");
             // ===== MEDIA HANDLER REGISTRATION =====
             // Single registration path (Task 11): each ecosystem barrel (voice,

package/dist/mcp/externalServerManager.js

@@ -1702,11 +1702,25 @@ export class ExternalServerManager extends EventEmitter {
             instance.metrics.averageResponseTime =
                 totalTime / instance.metrics.totalToolCalls;
             if (result.success) {
-                mcpLogger.debug(`[ExternalServerManager] Tool executed successfully: ${toolName} on ${serverId}`, {
+                // A resolved `{ isError: true }` still comes back with success:true so
+                // the caller receives the MCP error payload as-is, but it is a failed
+                // call for telemetry: label mcp_tool_calls_total accordingly instead
+                // of counting every resolved error as a success.
+                const resolvedError = result.isErrorResult === true;
+                if (resolvedError) {
+                    // Keep this instance's totalErrors (and the getStatistics() /
+                    // getExternalMCPStatistics() it feeds) consistent with the breaker,
+                    // TelemetryService and ToolDiscoveryService's failedCalls, all of
+                    // which already count a resolved isError result as a failure.
+                    instance.metrics.totalErrors++;
+                }
+                mcpLogger.debug(resolvedError
+                    ? `[ExternalServerManager] Tool returned a resolved MCP error: ${toolName} on ${serverId}`
+                    : `[ExternalServerManager] Tool executed successfully: ${toolName} on ${serverId}`, {
                     duration,
                 });
                 try {
-                    TelemetryService.getInstance()?.recordMCPToolCall(toolName, duration, true);
+                    TelemetryService.getInstance()?.recordMCPToolCall(toolName, duration, !resolvedError);
                 }
                 catch {
                     /* telemetry should not break execution */

package/dist/mcp/mcpCircuitBreaker.d.ts

@@ -21,9 +21,30 @@ export declare class MCPCircuitBreaker extends EventEmitter {
     private cleanupTimer?;
     constructor(name: string, config?: Partial<CircuitBreakerConfig>);
     /**
-     * Execute an operation with circuit breaker protection
-     */
-    execute<T>(operation: () => Promise<T>): Promise<T>;
+     * Execute an operation with circuit breaker protection.
+     *
+     * `operation` is handed a `recordResolvedFailure` callback so it can flag a
+     * *resolved* result as a logical failure without throwing. This matters for
+     * MCP tool calls: the client does not throw on a protocol error, it
+     * resolves with `{ isError: true, ... }`. Before this callback existed,
+     * such a call always fell through to the success path below — the breaker
+     * could never open for a tool that only ever "fails" by resolving an error
+     * result, and callers still need that resolved value returned as-is (not
+     * replaced by a thrown transport error). Call `recordResolvedFailure()`
+     * from inside `operation` when that resolved value represents a failure;
+     * the call is still counted as a normal, non-throwing success from the
+     * `Promise.race` below, so this callback is what tells `execute()`
+     * otherwise. Callers that never call it see no behavior change.
+     */
+    execute<T>(operation: (recordResolvedFailure: (reason?: string) => void) => Promise<T>): Promise<T>;
+    /**
+     * Shared bookkeeping for a failed outcome — a thrown error, or a resolved
+     * result the caller flagged via `recordResolvedFailure`. Records the call
+     * as a failure, emits `callFailure`, and runs the state transitions that
+     * used to live inline in the `catch` block: half-open failure immediately
+     * re-opens the circuit; closed checks the failure threshold.
+     */
+    private recordFailureOutcome;
     /**
      * Record a call in the history
      */

package/dist/mcp/mcpCircuitBreaker.js

@@ -46,7 +46,20 @@ export class MCPCircuitBreaker extends EventEmitter {
         this.cleanupTimer = setInterval(() => this.cleanupCallHistory(), 60000);
     }
     /**
-     * Execute an operation with circuit breaker protection
+     * Execute an operation with circuit breaker protection.
+     *
+     * `operation` is handed a `recordResolvedFailure` callback so it can flag a
+     * *resolved* result as a logical failure without throwing. This matters for
+     * MCP tool calls: the client does not throw on a protocol error, it
+     * resolves with `{ isError: true, ... }`. Before this callback existed,
+     * such a call always fell through to the success path below — the breaker
+     * could never open for a tool that only ever "fails" by resolving an error
+     * result, and callers still need that resolved value returned as-is (not
+     * replaced by a thrown transport error). Call `recordResolvedFailure()`
+     * from inside `operation` when that resolved value represents a failure;
+     * the call is still counted as a normal, non-throwing success from the
+     * `Promise.race` below, so this callback is what tells `execute()`
+     * otherwise. Callers that never call it see no behavior change.
      */
     async execute(operation) {
         const startTime = Date.now();
@@ -91,11 +104,29 @@ export class MCPCircuitBreaker extends EventEmitter {
                     });
                 }
             }
+            // resolvedFailureReason is set (via recordResolvedFailure, passed into
+            // operation() below) when operation() resolves normally but represents
+            // a logical failure — e.g. an MCP tool call that resolved
+            // { isError: true } instead of throwing. It is call-scoped (a local,
+            // not instance state), so concurrent execute() calls on the same
+            // breaker (the same tool invoked in parallel) can't cross-contaminate
+            // each other's outcome.
+            let resolvedFailureReason;
+            const recordResolvedFailure = (reason) => {
+                resolvedFailureReason = reason || "Operation resolved a failure result";
+            };
             // Execute operation with timeout
             const result = await Promise.race([
-                operation(),
+                operation(recordResolvedFailure),
                 this.timeoutPromise(this.config.operationTimeout),
             ]);
+            if (resolvedFailureReason !== undefined) {
+                // Same bookkeeping as a thrown error below, but the resolved value
+                // is still returned to the caller unchanged — no transport error is
+                // synthesized for a result the protocol itself resolved successfully.
+                this.recordFailureOutcome(resolvedFailureReason, Date.now() - startTime);
+                return result;
+            }
             // Record successful call
             this.recordCall(true, Date.now() - startTime);
             // Handle half-open success
@@ -111,26 +142,34 @@ export class MCPCircuitBreaker extends EventEmitter {
         catch (error) {
             // Record failed call
             const duration = Date.now() - startTime;
-            this.recordCall(false, duration);
             const errorMessage = error instanceof Error ? error.message : String(error);
-            // Emit failure event
-            this.emit("callFailure", {
-                error: errorMessage,
-                duration,
-                timestamp: new Date(),
-            });
-            // Handle state transitions on failure
-            if (this.state === "half-open") {
-                // Failure in half-open immediately opens circuit
-                this.changeState("open", `Half-open test failed: ${errorMessage}`);
-            }
-            else if (this.state === "closed") {
-                // Check if we should open the circuit
-                this.checkFailureThreshold();
-            }
+            this.recordFailureOutcome(errorMessage, duration);
             throw error;
         }
     }
+    /**
+     * Shared bookkeeping for a failed outcome — a thrown error, or a resolved
+     * result the caller flagged via `recordResolvedFailure`. Records the call
+     * as a failure, emits `callFailure`, and runs the state transitions that
+     * used to live inline in the `catch` block: half-open failure immediately
+     * re-opens the circuit; closed checks the failure threshold.
+     */
+    recordFailureOutcome(reason, duration) {
+        this.recordCall(false, duration);
+        this.emit("callFailure", {
+            error: reason,
+            duration,
+            timestamp: new Date(),
+        });
+        if (this.state === "half-open") {
+            // Failure in half-open immediately opens circuit
+            this.changeState("open", `Half-open test failed: ${reason}`);
+        }
+        else if (this.state === "closed") {
+            // Check if we should open the circuit
+            this.checkFailureThreshold();
+        }
+    }
     /**
      * Record a call in the history
      */

package/dist/mcp/toolDiscoveryService.js

@@ -435,8 +435,13 @@ export class ToolDiscoveryService extends EventEmitter {
                 resetTimeout: 30000,
                 operationTimeout: effectiveTimeout,
             });
-            // Execute tool with circuit breaker protection
-            const result = await circuitBreaker.execute(async () => {
+            // Execute tool with circuit breaker protection. `recordResolvedFailure`
+            // lets the callback below tell the breaker that a *resolved* MCP
+            // isError result is a failure — the MCP client does not throw on a
+            // protocol error, so without this the breaker would only ever see a
+            // clean resolve and could never open for a tool that fails this way.
+            let isErrorResultDetected = false;
+            const result = await circuitBreaker.execute(async (recordResolvedFailure) => {
                 return mcpTracer.startActiveSpan("neurolink.mcp.callTool", {
                     kind: SpanKind.CLIENT,
                     attributes: {
@@ -479,6 +484,11 @@ export class ToolDiscoveryService extends EventEmitter {
                                 code: SpanStatusCode.ERROR,
                                 message: errorText || `Tool ${toolName} returned isError`,
                             });
+                            // NLK: count a resolved isError result as a breaker failure
+                            // and label completion telemetry as error below — without
+                            // throwing, so the protocol result is still returned as-is.
+                            isErrorResultDetected = true;
+                            recordResolvedFailure(errorText || `Tool ${toolName} returned isError`);
                         }
                         else {
                             callSpan.setStatus({ code: SpanStatusCode.OK });
@@ -528,8 +538,13 @@ export class ToolDiscoveryService extends EventEmitter {
                 });
             });
             const duration = Date.now() - startTime;
-            // Update tool statistics
-            this.updateToolStats(toolKey, true, duration);
+            // Update tool statistics. A resolved isError result is a failed call
+            // for completion telemetry purposes even though the wrapper below
+            // still returns success:true / data:result unchanged — flipping
+            // `success` here would make externalServerManager.executeTool() throw
+            // instead of returning the resolved MCP error, which is exactly the
+            // "thrown transport error" this fix must not introduce.
+            this.updateToolStats(toolKey, !isErrorResultDetected, duration);
             // Validate output if requested
             if (options.validateOutput !== false) {
                 this.validateToolOutput(result);
@@ -541,6 +556,7 @@ export class ToolDiscoveryService extends EventEmitter {
             return {
                 success: true,
                 data: result,
+                isErrorResult: isErrorResultDetected,
                 duration,
                 metadata: {
                     toolName,

package/dist/models/manifestRegistry.js

@@ -20,6 +20,7 @@ import { llamacppManifest } from "./manifests/llamacpp.js";
 import { xaiManifest } from "./manifests/xai.js";
 import { groqManifest } from "./manifests/groq.js";
 import { typesafeManifest } from "./manifests/typesafe.js";
+import { layaManifest } from "./manifests/laya.js";
 import { cohereManifest } from "./manifests/cohere.js";
 import { togetherAiManifest } from "./manifests/together-ai.js";
 import { fireworksManifest } from "./manifests/fireworks.js";
@@ -118,6 +119,7 @@ export const MANIFEST_REGISTRY = {
     xai: xaiManifest,
     groq: groqManifest,
     typesafe: typesafeManifest,
+    laya: layaManifest,
     cerebras: catalogManifest("cerebras"),
     sambanova: catalogManifest("sambanova"),
     cohere: cohereManifest,

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

@@ -0,0 +1,12 @@
+import type { ProviderModelManifest } from "../../types/index.js";
+/**
+ * Laya — the `decide` inference type, not text generation.
+ *
+ * `contextWindow` is each checkpoint's encoder window, the whole budget for
+ * the state plus one question's instructions and options. `auto` carries the
+ * English figure because Laya's router may pick the English checkpoint.
+ *
+ * `maxOutputTokens` is required by the manifest type but has no honest value
+ * for a model that emits no text, so a small non-zero figure is used.
+ */
+export declare const layaManifest: ProviderModelManifest;

package/dist/models/manifests/laya.js

@@ -0,0 +1,54 @@
+/**
+ * Laya — the `decide` inference type, not text generation.
+ *
+ * `contextWindow` is each checkpoint's encoder window, the whole budget for
+ * the state plus one question's instructions and options. `auto` carries the
+ * English figure because Laya's router may pick the English checkpoint.
+ *
+ * `maxOutputTokens` is required by the manifest type but has no honest value
+ * for a model that emits no text, so a small non-zero figure is used.
+ */
+export const layaManifest = {
+    defaultContextWindow: 1024,
+    models: {
+        _default: {
+            aliases: [],
+            contextWindow: 1024,
+            maxOutputTokens: 256,
+            vision: false,
+            functionCalling: false,
+        },
+        "typed-decisions": {
+            aliases: [],
+            displayName: "Laya (typed decisions)",
+            contextWindow: 1024,
+            maxOutputTokens: 256,
+            vision: false,
+            functionCalling: false,
+        },
+        multilingual: {
+            aliases: [],
+            displayName: "Laya (multilingual)",
+            contextWindow: 1024,
+            maxOutputTokens: 256,
+            vision: false,
+            functionCalling: false,
+        },
+        english: {
+            aliases: [],
+            displayName: "Laya (English)",
+            contextWindow: 512,
+            maxOutputTokens: 256,
+            vision: false,
+            functionCalling: false,
+        },
+        auto: {
+            aliases: [],
+            displayName: "Laya (routed by language)",
+            contextWindow: 512,
+            maxOutputTokens: 256,
+            vision: false,
+            functionCalling: false,
+        },
+    },
+};