@juspay/neurolink 12.49.20 → 12.51.0

package/dist/neurolink.d.ts

@@ -6,7 +6,7 @@
  * Uses real MCP infrastructure for tool discovery and execution.
  */
 import type { DecisionCallerOptions, DecisionLimitsQuery, DecisionLimitsReading, DecisionOptions, DecisionResult, AgentDefinition, AgentNetworkConfig, AgentRunOptions, AgentRunOutcome, AgentToolRegistrationOptions, IsolatedAgentDefinition, NetworkExecutionInput, NetworkExecutionOptions, NetworkExecutionResult, NetworkStreamChunk, WorkerInstanceOptions } from "./types/index.js";
-import type { CompactionConfig, CompactionResult, ArtifactStore, SpanData, ObservabilityConfig, MetricsSummary, MCPToolAnnotations, TraceView, AuthenticatedContext, AuthProvider, JsonObject, NeuroLinkEvents, TypedEventEmitter, MCPEnhancementsConfig, NeuroLinkAuthConfig, NeurolinkConstructorConfig, ChatMessage, ExternalMCPOperationResult, ExternalMCPServerInstance, ExternalMCPServerHealth, ExternalMCPToolInfo, GenerateOptions, GenerateResult, ProviderStatus, TextGenerationOptions, TextGenerationResult, MCPExecutableTool, MCPServerInfo, MCPStatus, StreamOptions, StreamResult, ToolExecutionContext, ToolExecutionSummary, ToolInfo, ToolRegistrationOptions, BatchOperationResult, StreamGenerationEndContext, ToolRoutingServerDescriptor, ToolDedupConfig, ToolConfig, KnowledgeEngineStatus, ChecklistState, ArtifactPageRequest, BankArtifactOptions, BankedArtifactRef, DelegateCollectRequest, DelegateCollectResult, DelegateHandle, DelegateRegistrationOptions, DelegateSpawnOptions, BackgroundCommandHandle, BackgroundCommandOptions, BackgroundCommandOutputPage, BackgroundCommandPageRequest, BackgroundCommandPolicy, BackgroundCommandStatus, GitToolResult, GitToolsetOptions } from "./types/index.js";
+import type { CompactionConfig, CompactionResult, ArtifactStore, SpanData, ObservabilityConfig, MetricsSummary, MCPToolAnnotations, TraceView, AuthenticatedContext, AuthProvider, JsonObject, NeuroLinkEvents, TypedEventEmitter, MCPEnhancementsConfig, NeuroLinkAuthConfig, NeurolinkConstructorConfig, ChatMessage, ConversationSeedMessage, ConversationSeedOptions, RecordConversationTurnOptions, RecordConversationTurnResult, ExternalMCPOperationResult, ExternalMCPServerInstance, ExternalMCPServerHealth, ExternalMCPToolInfo, GenerateOptions, GenerateResult, ProviderStatus, TextGenerationOptions, TextGenerationResult, MCPExecutableTool, MCPServerInfo, MCPStatus, StreamOptions, StreamResult, ToolExecutionContext, ToolExecutionSummary, ToolInfo, ToolRegistrationOptions, BatchOperationResult, StreamGenerationEndContext, ToolRoutingServerDescriptor, ToolDedupConfig, ToolConfig, KnowledgeEngineStatus, ChecklistState, ArtifactPageRequest, BankArtifactOptions, BankedArtifactRef, DelegateCollectRequest, DelegateCollectResult, DelegateHandle, DelegateRegistrationOptions, DelegateSpawnOptions, BackgroundCommandHandle, BackgroundCommandOptions, BackgroundCommandOutputPage, BackgroundCommandPageRequest, BackgroundCommandPolicy, BackgroundCommandStatus, GitToolResult, GitToolsetOptions } from "./types/index.js";
 import { ConversationMemoryManager } from "./core/conversationMemoryManager.js";
 import type { RedisConversationMemoryManager } from "./core/redisConversationMemoryManager.js";
 import { ExternalServerManager } from "./mcp/externalServerManager.js";
@@ -2120,6 +2120,57 @@ export declare class NeuroLink {
      * @returns Array of ChatMessage objects, or empty array if session doesn't exist
      */
     getSessionMessages(sessionId: string, userId?: string): Promise<ChatMessage[]>;
+    /**
+     * Record one finished turn from a transport that does not go through
+     * generate()/stream() — a voice call — into the same conversation memory
+     * typed chat uses: same key, same manager, same summarization and title
+     * handling, same optional long-term memory write.
+     *
+     * Identity is never defaulted: `userId` is required, because typed chat falls
+     * back to a shared placeholder user when it is missing and a spoken turn must
+     * never be filed there. Recording the same `turnId` twice stores it once, so
+     * a caller can retry after an ambiguous failure.
+     *
+     * A turn with a blank user message, or a blank response and no tool events,
+     * is not stored (an empty assistant message makes some providers reject the
+     * next request); the result says which. Storage failures throw — the caller
+     * decides whether to retry or to carry on without the turn.
+     *
+     * @throws NeuroLinkError (INVALID_PARAMETERS) for a bad sessionId or userId
+     * @throws NeuroLinkError (MISSING_CONFIGURATION) when conversation memory is not enabled
+     * @throws ConversationMemoryError (STORAGE_ERROR) when the store rejects the write
+     */
+    recordConversationTurn(options: RecordConversationTurnOptions): Promise<RecordConversationTurnResult>;
+    /**
+     * The most recent user/assistant messages of a conversation, bounded, for
+     * seeding a model that has no history of its own — a voice model at call
+     * start. Summaries, pinned skills, tool traffic and blank messages are left
+     * out; the oldest messages are dropped first when `maxChars` would be
+     * exceeded. Best effort: a missing conversation, disabled memory or a read
+     * failure yields an empty seed and never throws, because a call must start
+     * either way.
+     */
+    getConversationSeed(options: ConversationSeedOptions): Promise<ConversationSeedMessage[]>;
+    /**
+     * Whether a conversation already holds messages under this user. A client
+     * may name the conversation a call appends to; the server accepts the name
+     * only when this is true for the user the session is verified as.
+     */
+    conversationExists(options: {
+        sessionId: string;
+        userId: string;
+    }): Promise<boolean>;
+    /**
+     * Whether a stored conversation is owned by someone other than `userId`.
+     *
+     * The Redis manager includes the user in the key, so a different user simply
+     * never finds the conversation. The in-process manager keys sessions by id
+     * alone and only records the owner, so ownership is checked here: a session
+     * that exists with no recorded owner, or another one, is not `userId`'s.
+     */
+    private isOwnedByAnotherUser;
+    /** Shared identity check for the voice-memory methods. */
+    private static assertConversationIdentity;
     /**
      * Replace the entire messages array for a session.
      * @param sessionId - The session ID to update

package/dist/neurolink.js

@@ -9342,6 +9342,9 @@ Current user's request: ${currentInput}`;
                     ...(pendingSkillMessages.length > 0
                         ? { skillMessages: pendingSkillMessages }
                         : {}),
+                    ...(enhancedOptions.modality
+                        ? { modality: enhancedOptions.modality }
+                        : {}),
                 });
                 this.recordMemorySpan("memory.store", { "memory.operation": "store", "memory.path": "stream" }, Date.now() - memStoreStart, SpanStatus.OK);
                 logger.debug("[NeuroLink.stream] Stored conversation turn with events", {
@@ -12757,6 +12760,198 @@ Current user's request: ${currentInput}`;
         }
         return await this.conversationMemory.getSessionMessages(sessionId, userId);
     }
+    /**
+     * Record one finished turn from a transport that does not go through
+     * generate()/stream() — a voice call — into the same conversation memory
+     * typed chat uses: same key, same manager, same summarization and title
+     * handling, same optional long-term memory write.
+     *
+     * Identity is never defaulted: `userId` is required, because typed chat falls
+     * back to a shared placeholder user when it is missing and a spoken turn must
+     * never be filed there. Recording the same `turnId` twice stores it once, so
+     * a caller can retry after an ambiguous failure.
+     *
+     * A turn with a blank user message, or a blank response and no tool events,
+     * is not stored (an empty assistant message makes some providers reject the
+     * next request); the result says which. Storage failures throw — the caller
+     * decides whether to retry or to carry on without the turn.
+     *
+     * @throws NeuroLinkError (INVALID_PARAMETERS) for a bad sessionId or userId
+     * @throws NeuroLinkError (MISSING_CONFIGURATION) when conversation memory is not enabled
+     * @throws ConversationMemoryError (STORAGE_ERROR) when the store rejects the write
+     */
+    async recordConversationTurn(options) {
+        const { sessionId, userId, turnId } = options;
+        NeuroLink.assertConversationIdentity(sessionId, userId);
+        const identity = { sessionId, userId, ...(turnId ? { turnId } : {}) };
+        if (!options.userMessage.trim()) {
+            return { recorded: false, reason: "empty-user-message", ...identity };
+        }
+        const hasToolEvents = (options.events ?? []).some((event) => event.type === "tool:start" || event.type === "tool:end");
+        if (!options.aiResponse.trim() && !hasToolEvents) {
+            return { recorded: false, reason: "empty-response", ...identity };
+        }
+        await this.initializeConversationMemoryForGeneration(options.requestId ?? `record-turn-${Date.now()}`, Date.now(), process.hrtime.bigint());
+        if (!this.conversationMemory) {
+            throw new NeuroLinkError({
+                code: ERROR_CODES.MISSING_CONFIGURATION,
+                message: "Conversation memory is not enabled",
+                category: ErrorCategory.VALIDATION,
+                severity: ErrorSeverity.HIGH,
+                retriable: false,
+            });
+        }
+        if (await this.isOwnedByAnotherUser(sessionId, userId)) {
+            throw new NeuroLinkError({
+                code: ERROR_CODES.INVALID_PARAMETERS,
+                message: "The conversation belongs to another user",
+                category: ErrorCategory.VALIDATION,
+                severity: ErrorSeverity.MEDIUM,
+                retriable: false,
+            });
+        }
+        const memStoreStart = Date.now();
+        try {
+            await this.conversationMemory.storeConversationTurn({
+                sessionId,
+                userId,
+                userMessage: options.userMessage,
+                aiResponse: options.aiResponse,
+                startTimeStamp: options.startTime,
+                ...(options.provider && options.model
+                    ? {
+                        providerDetails: {
+                            provider: options.provider,
+                            model: options.model,
+                        },
+                    }
+                    : {}),
+                enableSummarization: options.enableSummarization,
+                events: options.events?.length ? options.events : undefined,
+                requestId: options.requestId,
+                ...(options.modality ? { modality: options.modality } : {}),
+                ...(turnId ? { turnId } : {}),
+                ...(options.interrupted ? { interrupted: true } : {}),
+                ...(options.callEnded ? { callEnded: true } : {}),
+            });
+            this.recordMemorySpan("memory.store", { "memory.operation": "store", "memory.path": "record" }, Date.now() - memStoreStart, SpanStatus.OK);
+        }
+        catch (error) {
+            this.recordMemorySpan("memory.store", { "memory.operation": "store", "memory.path": "record" }, Date.now() - memStoreStart, SpanStatus.ERROR, error instanceof Error ? error.message : String(error));
+            throw error;
+        }
+        if (this.shouldWriteMemory(options.memory, userId, options.aiResponse)) {
+            this.storeMemoryInBackground({
+                prompt: options.userMessage,
+                response: options.aiResponse.trim(),
+                userId,
+                sessionId,
+                provider: options.provider ?? "",
+                model: options.model,
+            }, options.memory, { sessionId });
+        }
+        return { recorded: true, ...identity };
+    }
+    /**
+     * The most recent user/assistant messages of a conversation, bounded, for
+     * seeding a model that has no history of its own — a voice model at call
+     * start. Summaries, pinned skills, tool traffic and blank messages are left
+     * out; the oldest messages are dropped first when `maxChars` would be
+     * exceeded. Best effort: a missing conversation, disabled memory or a read
+     * failure yields an empty seed and never throws, because a call must start
+     * either way.
+     */
+    async getConversationSeed(options) {
+        const { sessionId, userId } = options;
+        const maxTurns = Math.max(0, Math.floor(options.maxTurns ?? 10));
+        const maxChars = Math.max(0, Math.floor(options.maxChars ?? 6000));
+        try {
+            NeuroLink.assertConversationIdentity(sessionId, userId);
+            const stored = await this.getSessionMessages(sessionId, userId);
+            const spoken = [];
+            for (const message of stored) {
+                if ((message.role !== "user" && message.role !== "assistant") ||
+                    message.metadata?.isSummary ||
+                    message.metadata?.isSkill ||
+                    typeof message.content !== "string" ||
+                    !message.content.trim()) {
+                    continue;
+                }
+                spoken.push({
+                    role: message.role,
+                    content: message.content,
+                    ...(message.metadata?.modality
+                        ? { modality: message.metadata.modality }
+                        : {}),
+                });
+            }
+            const recent = spoken.slice(-(maxTurns * 2));
+            let used = 0;
+            let firstKept = recent.length;
+            for (let index = recent.length - 1; index >= 0; index -= 1) {
+                used += recent[index].content.length;
+                if (used > maxChars) {
+                    break;
+                }
+                firstKept = index;
+            }
+            return recent.slice(firstKept);
+        }
+        catch (error) {
+            logger.warn("[NeuroLink] getConversationSeed failed, starting unseeded", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return [];
+        }
+    }
+    /**
+     * Whether a conversation already holds messages under this user. A client
+     * may name the conversation a call appends to; the server accepts the name
+     * only when this is true for the user the session is verified as.
+     */
+    async conversationExists(options) {
+        NeuroLink.assertConversationIdentity(options.sessionId, options.userId);
+        const stored = await this.getSessionMessages(options.sessionId, options.userId);
+        if (stored.length === 0) {
+            return false;
+        }
+        return !(await this.isOwnedByAnotherUser(options.sessionId, options.userId));
+    }
+    /**
+     * Whether a stored conversation is owned by someone other than `userId`.
+     *
+     * The Redis manager includes the user in the key, so a different user simply
+     * never finds the conversation. The in-process manager keys sessions by id
+     * alone and only records the owner, so ownership is checked here: a session
+     * that exists with no recorded owner, or another one, is not `userId`'s.
+     */
+    async isOwnedByAnotherUser(sessionId, userId) {
+        const memory = this.conversationMemory;
+        if (!memory || memory.isRedisConfigured) {
+            return false;
+        }
+        const session = await memory.getSession(sessionId);
+        return session !== undefined && session.userId !== userId;
+    }
+    /** Shared identity check for the voice-memory methods. */
+    static assertConversationIdentity(sessionId, userId) {
+        const problem = typeof sessionId !== "string" || !sessionId.trim()
+            ? "sessionId must be a non-empty string"
+            : sessionId.includes(":")
+                ? 'sessionId must not contain ":"'
+                : typeof userId !== "string" || !userId.trim()
+                    ? "userId must be a non-empty string"
+                    : undefined;
+        if (problem) {
+            throw new NeuroLinkError({
+                code: ERROR_CODES.INVALID_PARAMETERS,
+                message: problem,
+                category: ErrorCategory.VALIDATION,
+                severity: ErrorSeverity.MEDIUM,
+                retriable: false,
+            });
+        }
+    }
     /**
      * Replace the entire messages array for a session.
      * @param sessionId - The session ID to update

package/dist/providers/catalog/index.generated.d.ts

@@ -1,3 +1,5 @@
-import type { ProviderCatalogJson } from "../../types/index.js";
+import type { DecideCatalogJson, ProviderCatalogJson } from "../../types/index.js";
 export declare const CATALOG_JSON_ENTRIES: ProviderCatalogJson[];
 export declare const CATALOG_PROVIDER_IDS: readonly ["a2agent", "abliteration", "above-dev", "ai21", "aiand", "aihubmix", "aionlabs", "ambient", "api-route", "arcee", "atlas-cloud", "avian-io", "baidu-qianfan", "baseten", "bee-heossi", "byteplus-modelark", "bytez", "cerebras", "charm-hyper", "chutes", "cloudflare", "crusoe", "dashscope", "deepinfra", "deepseek", "empiriolabs", "featherless-ai", "fireworks", "friendli", "gmicloud", "gradientai", "groq", "hetzner-inference", "huggingface", "inception-labs", "inceptron", "inco", "inference-net", "io-intelligence", "koscompute", "lemonfox-ai", "lilac", "llmtech", "mancer", "meta-model-api", "minimax", "mistral", "moark", "modelscope", "moonshot-ai", "morph", "naver-clova-studio", "nebius", "neuralwatt", "novita", "ovhcloud", "parasail", "pareto-inference", "perplexity", "poolside", "prime-intellect", "reka", "sakana-ai", "sambanova", "sarvam", "scaleway", "siliconflow", "stackit", "stepfun", "subconscious", "synthetic", "telnyx", "thinking-machines", "tinfoil", "together-ai", "umans-ai", "upstage", "venice-ai", "vispark", "vultr-inference", "wafer", "wandb-inference", "xai", "z-ai"];
+export declare const DECIDE_CATALOG_JSON_ENTRIES: DecideCatalogJson[];
+export declare const DECIDE_CATALOG_PROVIDER_IDS: readonly ["laya"];

package/dist/providers/catalog/index.generated.js

@@ -40,6 +40,7 @@ import incoJson from "./inco.json" with { type: "json" };
 import inferenceNetJson from "./inference-net.json" with { type: "json" };
 import ioIntelligenceJson from "./io-intelligence.json" with { type: "json" };
 import koscomputeJson from "./koscompute.json" with { type: "json" };
+import layaJson from "./laya.json" with { type: "json" };
 import lemonfoxAiJson from "./lemonfox-ai.json" with { type: "json" };
 import lilacJson from "./lilac.json" with { type: "json" };
 import llmtechJson from "./llmtech.json" with { type: "json" };
@@ -84,6 +85,14 @@ import waferJson from "./wafer.json" with { type: "json" };
 import wandbInferenceJson from "./wandb-inference.json" with { type: "json" };
 import xaiJson from "./xai.json" with { type: "json" };
 import zAiJson from "./z-ai.json" with { type: "json" };
+import { isDecideCatalogEntry, parseCatalogEntry } from "./schema.js";
+const asDecideEntry = (raw) => {
+    const entry = parseCatalogEntry(raw);
+    if (!isDecideCatalogEntry(entry)) {
+        throw new Error("a catalog file listed as a decide entry parsed as a chat entry");
+    }
+    return entry;
+};
 export const CATALOG_JSON_ENTRIES = [
     a2agentJson,
     abliterationJson,
@@ -256,3 +265,5 @@ export const CATALOG_PROVIDER_IDS = [
     "xai",
     "z-ai",
 ];
+export const DECIDE_CATALOG_JSON_ENTRIES = [layaJson].map(asDecideEntry);
+export const DECIDE_CATALOG_PROVIDER_IDS = ["laya"];

package/dist/providers/catalog/laya.json

@@ -0,0 +1,107 @@
+{
+    "$schema": "./provider-catalog.schema.json",
+    "id": "laya",
+    "displayName": "Laya",
+    "aliases": [],
+    "inferenceKinds": ["decide"],
+    "wire": {},
+    "models": {
+        "default": "typed-decisions",
+        "topModels": ["typed-decisions", "multilingual", "english", "auto"],
+        "catalog": {
+            "typed-decisions": {
+                "contextWindow": 1024,
+                "maxOutputTokens": 256,
+                "vision": false,
+                "status": "production",
+                "description": "Recommended - Laya fine-tuned for typed decisions"
+            },
+            "english": {
+                "contextWindow": 512,
+                "maxOutputTokens": 256,
+                "vision": false,
+                "status": "production",
+                "description": "Laya, English base checkpoint (512-token window)"
+            },
+            "multilingual": {
+                "contextWindow": 1024,
+                "maxOutputTokens": 256,
+                "vision": false,
+                "status": "production",
+                "description": "Laya, 100+ languages"
+            },
+            "auto": {
+                "contextWindow": 512,
+                "maxOutputTokens": 256,
+                "vision": false,
+                "status": "production",
+                "description": "Let Laya pick a checkpoint by language"
+            }
+        }
+    },
+    "timeouts": { "decideMs": 5000 },
+    "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 }
+        }
+    },
+    "decide": {
+        "dialect": "system-one",
+        "order": 2,
+        "baseURLRequired": true,
+        "baseURLNormalize": ["strip-trailing-slash"],
+        "endpoint": "{baseURL}/predict",
+        "model": { "placement": "body-unless-alias", "alias": "auto" },
+        "requestIdHeaders": ["x-litellm-call-id"],
+        "response": { "modelPaths": ["routing.model", "model"] },
+        "errors": {
+            "rules": [
+                { "status": [401, 403], "kind": "authentication" },
+                { "status": 413, "kind": "max_tokens_exceeded" },
+                { "status": 429, "kind": "rate_limit" },
+                { "status": 503, "kind": "overloaded" },
+                { "statusMin": 500, "kind": "server" }
+            ],
+            "default": "invalid_request",
+            "bodyShapes": [
+                { "path": "error.message" },
+                {
+                    "path": "detail",
+                    "isArray": true,
+                    "formatter": "fastapi-validation",
+                    "kind": "invalid_request",
+                    "retryable": false
+                },
+                { "path": "detail" }
+            ]
+        }
+    },
+    "setup": {
+        "url": "https://github.com/NandhaKishorM/laya",
+        "apiKeyFormat": null,
+        "billingPolicy": "free-tier",
+        "description": "API key for your Laya endpoint",
+        "instructions": [
+            "1. Run a Laya server, or use a LiteLLM proxy with a pass-through route to one",
+            "2. Set LAYA_BASE_URL to its base URL (NeuroLink calls <LAYA_BASE_URL>/predict)",
+            "3. Set {apiKeyEnvVar} to the key it accepts (on LiteLLM, a virtual key with that route in its Allowed Routes)"
+        ]
+    },
+    "evidence": {
+        "rosterVerified": {
+            "date": "2026-09-24",
+            "method": "Checkpoint ids typed-decisions, multilingual and english as listed in docs/getting-started/providers/laya.md and answered by a live Laya 0.3.5 server (routing.model); auto sends no model and lets Laya's router choose"
+        },
+        "liveMatrix": {
+            "date": "2026-09-24",
+            "result": "A 60,000-character state was answered 200 on a 1,024-token window, so Laya truncates silently and decisionLimits refuses over-window input (768 state tokens on typed-decisions and multilingual, 320 on english and auto). Chinese measured about 1.4 tokens per character on the English tokenizer and 0.56 on multilingual."
+        },
+        "addedInPR": "https://github.com/juspay/neurolink/pull/1978"
+    }
+}

package/dist/providers/catalog/loader.d.ts

@@ -1,6 +1,9 @@
-import type { OpenAICompatCatalogEntry, ProviderCatalogJson, ProviderConfigOptions } from "../../types/index.js";
-export declare function catalogCredentialsKey(entry: ProviderCatalogJson): string;
-export declare function catalogEnvVar(entry: ProviderCatalogJson, kind: "apiKey" | "baseURL" | "model"): string;
-export declare function buildCatalogConfigOptions(entry: ProviderCatalogJson): ProviderConfigOptions;
+import type { CatalogEnvSource, CatalogKeySource, CatalogSetupSource, DecideCatalogJson, OpenAICompatCatalogEntry, ProviderCatalogJson, ProviderConfigOptions } from "../../types/index.js";
+export declare function catalogCredentialsKey(entry: CatalogKeySource): string;
+export declare function catalogEnvVar(entry: CatalogEnvSource, kind: "apiKey" | "baseURL" | "model"): string;
+export declare function buildCatalogConfigOptions(entry: CatalogSetupSource): ProviderConfigOptions;
+export declare function freezeCatalogCopy<T>(value: T): T;
 export declare function getCatalogJsonEntries(): readonly ProviderCatalogJson[];
+/** The `decide` entries, copied and frozen exactly as getCatalogJsonEntries() does. */
+export declare function getDecideCatalogEntries(): readonly DecideCatalogJson[];
 export declare function buildCatalogEntries(): OpenAICompatCatalogEntry[];

package/dist/providers/catalog/loader.js

@@ -4,7 +4,7 @@
  * knowledge about deriving env vars, template interpolation and error
  * rule matching lives HERE — the JSON stays declarative.
  */
-import { CATALOG_JSON_ENTRIES } from "./index.generated.js";
+import { CATALOG_JSON_ENTRIES, DECIDE_CATALOG_JSON_ENTRIES, } from "./index.generated.js";
 import { DEFAULT_ERROR_RULES } from "../../utils/errorClassifier.js";
 import { AuthenticationError, RateLimitError, InvalidModelError, NetworkError, ProviderError, } from "../../types/index.js";
 const ERROR_CLASS_MAP = {
@@ -18,7 +18,7 @@ const ERROR_CLASS_MAP = {
 // import from tools/ (build-time tooling depends on runtime source, not the
 // reverse).
 function toCamelCase(id) {
-    return id.replace(/-([a-z])/g, (_m, c) => c.toUpperCase());
+    return id.replace(/-([a-z0-9])/g, (_m, c) => c.toUpperCase());
 }
 // Resolves the NeurolinkCredentials key for an entry — respects a
 // credentialsKey override (required where the derived camelCase would
@@ -108,8 +108,15 @@ function deepFreeze(value) {
 // CATALOG_JSON_ENTRIES's own objects), then deepFreeze() the clone. All
 // current callers only .find/.map/.flatMap/.filter/iterate, so this is
 // behavior-preserving for them.
+export function freezeCatalogCopy(value) {
+    return deepFreeze(structuredClone(value));
+}
 export function getCatalogJsonEntries() {
-    return deepFreeze(structuredClone(CATALOG_JSON_ENTRIES));
+    return freezeCatalogCopy(CATALOG_JSON_ENTRIES);
+}
+/** The `decide` entries, copied and frozen exactly as getCatalogJsonEntries() does. */
+export function getDecideCatalogEntries() {
+    return freezeCatalogCopy(DECIDE_CATALOG_JSON_ENTRIES);
 }
 export function buildCatalogEntries() {
     return CATALOG_JSON_ENTRIES.map((entry) => {