@juspay/neurolink 12.20.2 → 12.21.1

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

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+/**
+ * NeuroLink CLI Decide Command
+ *
+ * Calls `NeuroLink.decide()` — the third inference type, alongside `generate`
+ * and `stream`. Takes a `state` plus a map of named typed questions and
+ * prints one calibrated answer per question. See src/lib/types/decision.ts
+ * for the full vocabulary.
+ *
+ * Credentials are env-only here, exactly as every other CLI command: the
+ * decision provider (TypeSafe) reads `TYPESAFE_API_KEY` itself.
+ */
+import type { CommandModule } from "yargs";
+import type { CliDecideArgs } from "../../types/index.js";
+export declare const decideCommand: CommandModule<object, CliDecideArgs>;
+/**
+ * Create decide command factory for CLICommandFactory-style registration,
+ * matching the EvaluateCommandFactory pattern.
+ */
+export declare class DecideCommandFactory {
+    static createDecideCommand(): CommandModule;
+}

package/dist/cli/commands/decide.js

@@ -0,0 +1,287 @@
+#!/usr/bin/env node
+/**
+ * NeuroLink CLI Decide Command
+ *
+ * Calls `NeuroLink.decide()` — the third inference type, alongside `generate`
+ * and `stream`. Takes a `state` plus a map of named typed questions and
+ * prints one calibrated answer per question. See src/lib/types/decision.ts
+ * for the full vocabulary.
+ *
+ * Credentials are env-only here, exactly as every other CLI command: the
+ * decision provider (TypeSafe) reads `TYPESAFE_API_KEY` itself.
+ */
+import chalk from "chalk";
+import ora from "ora";
+import fs from "node:fs";
+import { NeuroLink } from "../../neurolink.js";
+import { readDecisionChoice } from "../../utils/decisionAnswers.js";
+import { calculateCost, hasPricing } from "../../utils/pricing.js";
+import { logger } from "../../utils/logger.js";
+const VALID_QUESTION_TYPES = new Set(["boolean", "choice", "score"]);
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Validates that parsed JSON is a non-empty map of `{ type, ... }` question
+ * objects. Runs before any provider work — a malformed `--questions` payload
+ * must never reach the network.
+ */
+function isDecisionQuestionMap(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    const ids = Object.keys(value);
+    return (ids.length > 0 &&
+        ids.every((id) => {
+            const question = value[id];
+            return (isRecord(question) &&
+                typeof question.type === "string" &&
+                VALID_QUESTION_TYPES.has(question.type));
+        }));
+}
+/** `state` is the raw text, or its parsed JSON when that JSON is an object or array. */
+function parseState(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (isRecord(parsed) || Array.isArray(parsed)) {
+            // Single assertion (CLAUDE.md rule 14 allows this) — `isRecord`/
+            // `Array.isArray` narrow `unknown` down to a structural shape TS can't
+            // itself equate with the recursive `DecisionInput` union.
+            return parsed;
+        }
+    }
+    catch {
+        // Not JSON — treat as plain text.
+    }
+    return raw;
+}
+function isDecisionErrorCause(value) {
+    return (isRecord(value) &&
+        typeof value.kind === "string" &&
+        typeof value.message === "string");
+}
+const ERROR_KIND_MESSAGES = {
+    authentication: "Authentication failed — check the decision provider's API key.",
+    invalid_request: "The decision provider rejected the request as invalid.",
+    max_tokens_exceeded: "The decision request exceeded the provider's token limit.",
+    rate_limit: "The decision provider is rate-limiting requests — try again shortly.",
+    overloaded: "The decision provider is overloaded — try again shortly.",
+    server: "The decision provider returned a server error.",
+    timeout: "The decision request timed out.",
+    network: "A network error occurred while calling the decision provider.",
+};
+/** One clean line describing a `decide()` failure — never a stack trace. */
+function describeDecideError(error) {
+    const cause = error instanceof Error
+        ? error.cause
+        : undefined;
+    if (isDecisionErrorCause(cause)) {
+        const generic = ERROR_KIND_MESSAGES[cause.kind];
+        if (!generic) {
+            return cause.message;
+        }
+        // The provider's own text is what says which field or question was
+        // rejected, so it is kept alongside the generic line.
+        const detail = cause.message.trim();
+        return detail && detail !== generic ? `${generic} (${detail})` : generic;
+    }
+    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 message;
+}
+function formatNumber(value) {
+    return value.toFixed(2);
+}
+function formatAnswerLine(id, answers) {
+    const answer = answers[id];
+    if (!answer) {
+        return `${id}: (no answer)`;
+    }
+    switch (answer.type) {
+        case "boolean":
+            return `${id}: probability ${formatNumber(answer.probability)}`;
+        case "choice": {
+            const reading = readDecisionChoice(answers, id);
+            if (!reading) {
+                return `${id}: (unreadable choice answer)`;
+            }
+            const alternatives = reading.ranked
+                .filter((entry) => entry.name !== reading.choice)
+                .slice(0, 2)
+                .map((entry) => `${entry.name} (${formatNumber(entry.probability)})`)
+                .join(", ");
+            return (`${id}: choice ${reading.choice}, confidence ${formatNumber(reading.confidence)}` +
+                (alternatives ? `, alternatives: ${alternatives}` : ""));
+        }
+        case "score":
+            return `${id}: score ${formatNumber(answer.score)}, confidence ${formatNumber(answer.confidence)}`;
+        default:
+            return `${id}: (unrecognised answer type)`;
+    }
+}
+function printTextResult(result) {
+    for (const id of Object.keys(result.answers)) {
+        logger.always(formatAnswerLine(id, result.answers));
+    }
+    logger.always("");
+    logger.always(chalk.gray(`Model: ${result.model}`));
+    logger.always(chalk.gray(`Latency: ${result.latencyMs}ms`));
+    if (hasPricing(result.provider, result.model)) {
+        const cost = calculateCost(result.provider, result.model, {
+            input: result.usage.inputTokens,
+            output: result.usage.outputTokens,
+            total: result.usage.inputTokens + result.usage.outputTokens,
+        });
+        logger.always(chalk.gray(`Cost: $${cost.toFixed(6)}`));
+    }
+}
+function readQuestionsSource(argv) {
+    if (argv.questionsFile) {
+        return fs.readFileSync(argv.questionsFile, "utf-8");
+    }
+    if (!argv.questions) {
+        // Unreachable given the exactly-one-of check in the handler; keeps this
+        // function sound on its own rather than asserting the type away.
+        throw new Error("No questions source provided.");
+    }
+    return argv.questions;
+}
+function resolveState(argv) {
+    if (argv.stateFile) {
+        return parseState(fs.readFileSync(argv.stateFile, "utf-8"));
+    }
+    if (argv.state) {
+        return parseState(argv.state);
+    }
+    return undefined;
+}
+export const decideCommand = {
+    command: "decide [state]",
+    describe: "Get typed, calibrated judgements from a decision model (no free text)",
+    builder: (yargs) => yargs
+        .positional("state", {
+        type: "string",
+        describe: "The content to judge (or use --state-file)",
+    })
+        .option("state-file", {
+        type: "string",
+        describe: "Path to a file holding the state (text or JSON)",
+    })
+        .option("questions", {
+        type: "string",
+        describe: "Inline JSON map of questions (exactly one of this or --questions-file)",
+    })
+        .option("questions-file", {
+        type: "string",
+        describe: "Path to a JSON file holding the questions map",
+    })
+        .option("provider", {
+        type: "string",
+        describe: "Decision provider to use",
+    })
+        .option("model", {
+        type: "string",
+        describe: "Overrides the provider's configured model for this call",
+    })
+        .option("timeout", {
+        type: "number",
+        describe: "Timeout in milliseconds",
+    })
+        .option("format", {
+        type: "string",
+        alias: ["f", "output-format"],
+        describe: "Output format",
+        choices: ["text", "json"],
+        default: "text",
+    })
+        .option("debug", {
+        type: "boolean",
+        alias: ["v", "verbose"],
+        default: false,
+        describe: "Enable debug logging (written to stderr when --format json is used)",
+    })
+        .example('$0 decide "Refund request for a damaged item" --questions \'{"urgent":{"type":"boolean","instructions":"Is this urgent?"}}\'', "Ask a single yes/no question")
+        .example("$0 decide --state-file ticket.json --questions-file questions.json --format json", "Read state and questions from files, emit raw JSON"),
+    handler: async (argv) => {
+        const outputFormat = argv.format ?? "text";
+        // --- Validate before any provider work ---------------------------------
+        if (!!argv.questions === !!argv.questionsFile) {
+            logger.error(chalk.red("Error: pass exactly one of --questions or --questions-file."));
+            process.exit(1);
+        }
+        let questionsRaw;
+        try {
+            questionsRaw = readQuestionsSource(argv);
+        }
+        catch (error) {
+            logger.error(chalk.red(`Error: could not read questions — ${error instanceof Error ? error.message : String(error)}`));
+            process.exit(1);
+        }
+        let parsedQuestions;
+        try {
+            parsedQuestions = JSON.parse(questionsRaw);
+        }
+        catch {
+            const flag = argv.questionsFile ? "--questions-file" : "--questions";
+            logger.error(chalk.red(`Error: ${flag} is not valid JSON.`));
+            process.exit(1);
+        }
+        if (argv.timeout !== undefined &&
+            !(Number.isFinite(argv.timeout) && argv.timeout > 0)) {
+            logger.error(chalk.red("Error: --timeout must be a positive number of milliseconds."));
+            process.exit(1);
+        }
+        if (!isDecisionQuestionMap(parsedQuestions)) {
+            logger.error(chalk.red('Error: questions must be a non-empty object of { type: "boolean" | "choice" | "score", ... }.'));
+            process.exit(1);
+        }
+        let state;
+        try {
+            state = resolveState(argv);
+        }
+        catch (error) {
+            logger.error(chalk.red(`Error: could not read state file — ${error instanceof Error ? error.message : String(error)}`));
+            process.exit(1);
+        }
+        if (state === undefined) {
+            logger.error(chalk.red("Error: provide state as a positional argument or via --state-file."));
+            process.exit(1);
+        }
+        // --- Provider work -------------------------------------------------
+        const spinner = outputFormat === "json" ? null : ora("Deciding...").start();
+        try {
+            const neurolink = new NeuroLink();
+            const result = await neurolink.decide({
+                state,
+                questions: parsedQuestions,
+                provider: argv.provider,
+                model: argv.model,
+                timeoutMs: argv.timeout,
+            });
+            spinner?.succeed("Decision complete");
+            if (outputFormat === "json") {
+                logger.always(JSON.stringify(result, null, 2));
+            }
+            else {
+                printTextResult(result);
+            }
+        }
+        catch (error) {
+            spinner?.fail("Decision failed");
+            logger.error(chalk.red(`Error: ${describeDecideError(error)}`));
+            process.exit(1);
+        }
+    },
+};
+/**
+ * Create decide command factory for CLICommandFactory-style registration,
+ * matching the EvaluateCommandFactory pattern.
+ */
+export class DecideCommandFactory {
+    static createDecideCommand() {
+        return decideCommand;
+    }
+}
+//# sourceMappingURL=decide.js.map

package/dist/cli/parser.js

@@ -29,6 +29,7 @@ import { proxyPeerCommand } from "./commands/proxyPeer.js";
 import { proxyExposeCommand } from "./commands/proxyExpose.js";
 import { proxyReplayCommand } from "./commands/proxyReplay.js";
 import { EvaluateCommandFactory } from "./commands/evaluate.js";
+import { DecideCommandFactory } from "./commands/decide.js";
 import { TaskCommandFactory } from "./commands/task.js";
 import { AutoresearchCommandFactory } from "./commands/autoresearch.js";
 import { voiceServerCommand } from "./commands/voiceServer.js";
@@ -72,6 +73,9 @@ export function initializeCliParser() {
             // Always set to false when debug is not enabled (including when not provided)
             process.env.NEUROLINK_DEBUG = "false";
         }
+        // With --format json, stdout carries the payload; a debug or info
+        // line there would make it unparseable, so diagnostics go to stderr.
+        logger.setDiagnosticsToStderr(argv.format === "json");
         // Keep existing quiet middleware
         if (process.env.NEUROLINK_QUIET === "true" &&
             typeof argv.quiet === "undefined") {
@@ -164,6 +168,8 @@ export function initializeCliParser() {
         .command(UsageCommandFactory.createUsageCommands())
         // Stream Text Command - Using CLICommandFactory
         .command(CLICommandFactory.createStreamCommand())
+        // Decide Command - typed, calibrated judgements (no free text)
+        .command(DecideCommandFactory.createDecideCommand())
         // Batch Processing Command - Using CLICommandFactory
         .command(CLICommandFactory.createBatchCommand())
         // Provider Command Group - Using CLICommandFactory

package/dist/neurolink.js

@@ -4019,6 +4019,12 @@ Current user's request: ${currentInput}`;
         const sessionId = typeof opt.context?.sessionId === "string"
             ? opt.context.sessionId
             : undefined;
+        // Routing runs before conversation memory is loaded, so only the history
+        // the caller passed in is countable here.
+        const sessionBound = sessionId !== undefined;
+        const priorMessageCount = Array.isArray(opt.conversationMessages)
+            ? opt.conversationMessages.length
+            : undefined;
         try {
             const decision = await this.classifierRouter.route({
                 prompt: promptText,
@@ -4027,6 +4033,8 @@ Current user's request: ${currentInput}`;
                 requiresVision,
                 thinkingLevel,
                 sessionId,
+                sessionBound,
+                priorMessageCount,
             });
             if (!decision) {
                 return;

package/dist/proxy/codexAccountUsage.js

@@ -11,6 +11,15 @@ import { normalizeAnthropicAccountKey } from "./accountSelection.js";
 import { CODEX_USAGE_URL, CODEX_USER_AGENT, decodeCodexAccessToken, resolveCodexAccountId, } from "../auth/codexOAuth.js";
 import { logger } from "../utils/logger.js";
 export const CODEX_ACCOUNT_PREFIX = "codex:";
+/**
+ * Native fallback legs (e.g. Claude-on-Vertex) key their usage rows as
+ * `vertex/<model>` rather than a provider-qualified `<provider>:<label>`
+ * pair — there is no OAuth account behind them, just a served model. They
+ * are not served by Codex, so without this prefix they fell through to the
+ * generic "other" branch below and lost both their identity and their live
+ * status in the CLI's proxy status output.
+ */
+const VERTEX_ACCOUNT_PREFIX = "vertex/";
 /** Keep an account label in the Codex namespace used by its token store. */
 export function normalizeCodexAccountKey(value) {
     const trimmed = value.trim();
@@ -32,12 +41,18 @@ export function resolveProxyStatusAccountIdentity(label, type, persistedKey) {
     if (persistedKey?.startsWith(CODEX_ACCOUNT_PREFIX)) {
         return { provider: "codex", key: persistedKey };
     }
+    if (persistedKey?.startsWith(VERTEX_ACCOUNT_PREFIX)) {
+        return { provider: "vertex", key: persistedKey };
+    }
     if (type === "oauth" || type === "api_key") {
         return { provider: "anthropic", key: normalizeAnthropicAccountKey(label) };
     }
     if (type === "codex-oauth") {
         return { provider: "codex", key: normalizeCodexAccountKey(label) };
     }
+    if (type === "vertex") {
+        return { provider: "vertex", key: persistedKey ?? label };
+    }
     return { provider: "other", key: null };
 }
 /** Enumerate Codex OAuth accounts from the token store for usage refresh. */

package/dist/proxy/codexFallback.js

@@ -739,7 +739,21 @@ export async function createCodexFallbackStream(response, model) {
         try {
             yield* serializer.start();
             while (true) {
-                const chunk = await reader.read();
+                let chunk;
+                try {
+                    chunk = await reader.read();
+                }
+                catch (err) {
+                    // A premature stream close after a complete SSE stream (but before
+                    // the zero-length terminator) rejects here. If response.completed
+                    // already landed, treat the close as a normal end-of-stream rather
+                    // than failing a fully successful turn; otherwise this is genuine
+                    // truncation and must still fail visibly.
+                    if (completed) {
+                        break;
+                    }
+                    throw err;
+                }
                 carry += decoder.decode(chunk.value, { stream: !chunk.done });
                 // Search only new bytes plus the boundary overlap. Long tool payloads
                 // split over many chunks must not rescan their accumulated prefix.

package/dist/proxy/vertexAnthropicFallback.d.ts

@@ -21,6 +21,17 @@ import type { VertexAccessTokenProvider, UsageContext, VertexPassthroughTerminal
  * `effort` key, never the sibling settings beside it.
  */
 export declare function mapVertexOutputConfig(value: unknown): Record<string, unknown> | undefined;
+/**
+ * Strip what Vertex rejects and pin the API version it requires.
+ *
+ * Prompt caching constrains every rewrite here. Anthropic caches only up to an
+ * explicit `cache_control` marker, at most four per request, over a prefix
+ * rendered `tools → system → messages`; anything removed or inserted before a
+ * marker invalidates it and everything after. So: never drop a marker, never
+ * reorder `system`, and keep each rewrite deterministic so consecutive turns
+ * share a prefix. Vertex holds its own cache, apart from the first-party one,
+ * so nothing here can disturb first-party hits.
+ */
 export declare function buildVertexAnthropicPayload(body: Readonly<Record<string, unknown>>): Record<string, unknown>;
 /**
  * Publisher endpoint for a Claude model on Vertex.
@@ -45,6 +56,13 @@ export declare function buildVertexAnthropicUrl(target: VertexAnthropicPassthrou
  * Pass `undefined` to restore the real credential lookup.
  */
 export declare function setVertexAccessTokenProviderForTests(provider: VertexAccessTokenProvider | undefined): void;
+/**
+ * Run once more after a short pause when the first attempt hit a transient
+ * network failure: anything the shared proxy classifier retries, plus a DNS
+ * blip. One retry absorbs a blip without hiding a real outage: a second
+ * failure, or any other error, surfaces unchanged.
+ */
+export declare function withTransientNetworkRetry<T>(run: () => Promise<T>, delayMs?: number): Promise<T>;
 /**
  * Send one Anthropic-shaped request to Vertex and return the upstream response
  * untouched, so the caller can stream its bytes straight to the client.