@juspay/neurolink 12.20.1 → 12.21.0

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/codexFallback.d.ts

@@ -23,21 +23,39 @@ export declare class CodexFallbackStreamError extends Error {
     constructor(payload: Record<string, unknown>, eventType: string, usage?: CodexFallbackResult["usage"]);
 }
 /**
- * Stable per-conversation routing key for OpenAI prompt caching.
+ * Routing key that pins a request to the cache already holding its prefix.
  *
  * Anthropic caching is explicit — the client marks breakpoints and the provider
  * honours them. OpenAI caching is automatic: a prefix is reused only when the
  * request lands on infrastructure already holding it, and `prompt_cache_key` is
- * what pins a conversation to one. Without it this hop takes its chances on
- * routing, which is the worst case for a fallback that arrives in bursts
- * separated by long gaps.
+ * what pins a request to one. Without it this hop takes its chances on routing,
+ * which is the worst case for a fallback that arrives in bursts separated by
+ * long gaps.
  *
- * Claude Code carries its session id inside `metadata.user_id`, alongside
- * account and device identifiers. Only the session id is read, and it is
- * hashed, so no account or device identifier reaches the upstream. When no
- * session id can be recovered the field is omitted rather than filled with
- * something shared: a key common to every conversation would pin unrelated
+ * The key must therefore describe the *prefix*, not the caller. Keying it by
+ * session id gives every session a private namespace, so N agents that share
+ * one system prompt and tool set each pay that shared prefix in full rather
+ * than paying it once — the cost is linear in fan-out width and invisible,
+ * because each request looks individually well-behaved. Across 42 captured
+ * fallback bodies the prefixes collapse to 10 distinct values, the largest
+ * shared by 12 requests belonging to different sessions.
+ *
+ * So derive the key from the prefix itself: the instructions and the tool
+ * declarations, which are exactly the leading bytes the upstream caches and
+ * the only part stable across a conversation's turns. Identical prefixes then
+ * share one cache across sessions and subagents, a prefix that genuinely
+ * differs still gets its own key so nothing unrelated contends, and turns
+ * within one session keep sharing a key because neither input changes between
+ * them.
+ *
+ * A request carrying neither instructions nor tools has no prefix worth
+ * pinning, and falls back to the session id so its turns at least stay
+ * together. With neither available the field is omitted rather than filled
+ * with something shared: a key common to every request would pin unrelated
  * prefixes onto one cache instead of separating them.
+ *
+ * The digest covers only content already sent upstream in `instructions` and
+ * `tools`; no account, device or session identifier reaches the wire.
  */
 export declare function codexPromptCacheKey(body: ClaudeRequest): string | undefined;
 /** Convert a Claude Messages request into the ChatGPT Codex Responses shape. */

package/dist/proxy/codexFallback.js

@@ -237,23 +237,95 @@ function convertClaudeMessage(role, content) {
     return input;
 }
 /**
- * Stable per-conversation routing key for OpenAI prompt caching.
+ * Routing key that pins a request to the cache already holding its prefix.
  *
  * Anthropic caching is explicit — the client marks breakpoints and the provider
  * honours them. OpenAI caching is automatic: a prefix is reused only when the
  * request lands on infrastructure already holding it, and `prompt_cache_key` is
- * what pins a conversation to one. Without it this hop takes its chances on
- * routing, which is the worst case for a fallback that arrives in bursts
- * separated by long gaps.
+ * what pins a request to one. Without it this hop takes its chances on routing,
+ * which is the worst case for a fallback that arrives in bursts separated by
+ * long gaps.
  *
- * Claude Code carries its session id inside `metadata.user_id`, alongside
- * account and device identifiers. Only the session id is read, and it is
- * hashed, so no account or device identifier reaches the upstream. When no
- * session id can be recovered the field is omitted rather than filled with
- * something shared: a key common to every conversation would pin unrelated
+ * The key must therefore describe the *prefix*, not the caller. Keying it by
+ * session id gives every session a private namespace, so N agents that share
+ * one system prompt and tool set each pay that shared prefix in full rather
+ * than paying it once — the cost is linear in fan-out width and invisible,
+ * because each request looks individually well-behaved. Across 42 captured
+ * fallback bodies the prefixes collapse to 10 distinct values, the largest
+ * shared by 12 requests belonging to different sessions.
+ *
+ * So derive the key from the prefix itself: the instructions and the tool
+ * declarations, which are exactly the leading bytes the upstream caches and
+ * the only part stable across a conversation's turns. Identical prefixes then
+ * share one cache across sessions and subagents, a prefix that genuinely
+ * differs still gets its own key so nothing unrelated contends, and turns
+ * within one session keep sharing a key because neither input changes between
+ * them.
+ *
+ * A request carrying neither instructions nor tools has no prefix worth
+ * pinning, and falls back to the session id so its turns at least stay
+ * together. With neither available the field is omitted rather than filled
+ * with something shared: a key common to every request would pin unrelated
  * prefixes onto one cache instead of separating them.
+ *
+ * The digest covers only content already sent upstream in `instructions` and
+ * `tools`; no account, device or session identifier reaches the wire.
  */
 export function codexPromptCacheKey(body) {
+    const prefix = codexCachePrefix(body);
+    if (prefix !== undefined) {
+        return createHash("sha256").update(prefix).digest("hex");
+    }
+    const sessionId = codexSessionId(body);
+    if (sessionId !== undefined) {
+        return createHash("sha256").update(sessionId).digest("hex");
+    }
+    return undefined;
+}
+/**
+ * How much of the instructions the key covers.
+ *
+ * Claude Code's system prompt is not byte-stable: measured across live 16,722
+ * character prompts, the first 14,768 characters (88.3%) are identical and the
+ * divergence sits in a trailing session-memory section that is rewritten every
+ * turn. Hashing the whole thing therefore produces a fresh key per request —
+ * the opposite of pinning. Hashing a bounded head instead tracks the part the
+ * upstream can actually reuse, since its cache is built forward from the first
+ * token.
+ *
+ * 8192 is below the observed divergence point with margin, and the error is
+ * asymmetric: too long only costs sharing, while too short pins genuinely
+ * unrelated prefixes onto one cache where they evict each other.
+ *
+ * The bound only helps a prompt long enough to have a tail beyond it. A
+ * shorter prompt is hashed whole, so a churning section inside it would move
+ * the key every turn — where keying by session used to hold still. Measured on
+ * the same corpus, that does not happen: 85 of 92 prompts carrying a system
+ * block sit under this bound, and within a session they resolve to a handful
+ * of keys rather than one per request (28 requests to 4 keys, 17 to 2, 31 to
+ * 2) — those are distinct agents, not one agent churning. Identifying the
+ * stable section structurally would remove the assumption, and is worth doing
+ * if a prompt ever proves otherwise.
+ */
+const CACHE_KEY_PREFIX_CHARS = 8192;
+/**
+ * The leading, turn-stable bytes of a Codex request: a bounded head of the
+ * instructions plus the tool names, which distinguish one agent's tool surface
+ * from another's when their instructions open identically. Descriptions and
+ * schemas are deliberately left out — they sit behind the instructions in the
+ * prefix, so two requests agreeing on this much already share a cacheable head
+ * worth routing together.
+ */
+function codexCachePrefix(body) {
+    const head = (buildSystemInstructions(body) ?? "").slice(0, CACHE_KEY_PREFIX_CHARS);
+    const toolNames = (body.tools ?? []).map((tool) => tool.name).join("\u0000");
+    if (!head && !toolNames) {
+        return undefined;
+    }
+    return `${head}\u0001${toolNames}`;
+}
+/** Claude Code carries its session id inside `metadata.user_id`. */
+function codexSessionId(body) {
     const raw = body.metadata?.user_id;
     if (typeof raw !== "string" || raw.length === 0) {
         return undefined;
@@ -270,10 +342,9 @@ export function codexPromptCacheKey(body) {
     }
     const fields = parsed;
     const sessionId = fields.session_id ?? fields.parent_session_id;
-    if (typeof sessionId !== "string" || sessionId.length === 0) {
-        return undefined;
-    }
-    return createHash("sha256").update(sessionId).digest("hex");
+    return typeof sessionId === "string" && sessionId.length > 0
+        ? sessionId
+        : undefined;
 }
 /** Convert a Claude Messages request into the ChatGPT Codex Responses shape. */
 export function convertClaudeRequestToCodex(body, model, reasoningEffort) {

package/dist/proxy/openaiFormat.js

@@ -11,6 +11,7 @@
 import { jsonSchema, tool } from "../utils/tool.js";
 import { randomBytes } from "crypto";
 import { normalizeJsonSchemaObject } from "../utils/schemaConversion.js";
+import { applyClaudeRequestCacheBreakpoints } from "../utils/anthropicCacheBreakpoints.js";
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -603,7 +604,13 @@ export function convertOpenAIToClaudeRequest(openai) {
             ? openai.stop
             : [openai.stop];
     }
-    return result;
+    // An OpenAI-shaped caller has no way to ask for caching: its provider does it
+    // automatically from the first token, so the format carries no equivalent of
+    // `cache_control`. Translating faithfully therefore produces a request
+    // Anthropic caches at 0% on every turn — and a caller that arrives here after
+    // its own pool ran dry would burn the replacement quota faster than the one
+    // it was spared. Synthesise the breakpoints the caller could not express.
+    return applyClaudeRequestCacheBreakpoints(result);
 }
 /**
  * Convert a non-streaming Claude Messages response to an OpenAI Chat

package/dist/proxy/vertexAnthropicFallback.d.ts

@@ -12,7 +12,7 @@
  * `tool_use`, `tool_result`, `cache_control` and thinking blocks all survive
  * here because nothing reshapes them.
  */
-import type { UsageContext, VertexPassthroughTerminal, VertexAnthropicPassthroughRequest, VertexAnthropicPassthroughTarget } from "../types/index.js";
+import type { VertexAccessTokenProvider, UsageContext, VertexPassthroughTerminal, VertexAnthropicPassthroughRequest, VertexAnthropicPassthroughTarget } from "../types/index.js";
 /**
  * Translate `output_config` for Vertex.
  *
@@ -29,6 +29,22 @@ export declare function buildVertexAnthropicPayload(body: Readonly<Record<string
  * caller's `stream` flag selects the verb rather than changing the body.
  */
 export declare function buildVertexAnthropicUrl(target: VertexAnthropicPassthroughTarget): string;
+/**
+ * Replace the Google credential lookup, for tests only.
+ *
+ * Without this seam the two-leg fallback chain cannot be driven end to end.
+ * The rest of the hop is reachable — `dispatchVertexAnthropicPassthrough`
+ * calls the global `fetch`, which a test can replace — but the credential
+ * lookup goes through gaxios, and gaxios resolves its transport to
+ * `(await import("node-fetch")).default` rather than `globalThis.fetch`. A
+ * test that swaps the global therefore cannot intercept the token exchange,
+ * and on a machine with no Application Default Credentials the leg throws
+ * before it ever reaches the model. That left the one path that bills in real
+ * currency with no end-to-end coverage at all.
+ *
+ * Pass `undefined` to restore the real credential lookup.
+ */
+export declare function setVertexAccessTokenProviderForTests(provider: VertexAccessTokenProvider | undefined): void;
 /**
  * Send one Anthropic-shaped request to Vertex and return the upstream response
  * untouched, so the caller can stream its bytes straight to the client.

package/dist/proxy/vertexAnthropicFallback.js

@@ -135,12 +135,36 @@ function auth() {
     cachedAuth ??= new GoogleAuth({ scopes: [CLOUD_PLATFORM_SCOPE] });
     return cachedAuth;
 }
+let accessTokenProviderForTests;
+async function vertexAccessToken() {
+    return accessTokenProviderForTests
+        ? accessTokenProviderForTests()
+        : auth().getAccessToken();
+}
+/**
+ * Replace the Google credential lookup, for tests only.
+ *
+ * Without this seam the two-leg fallback chain cannot be driven end to end.
+ * The rest of the hop is reachable — `dispatchVertexAnthropicPassthrough`
+ * calls the global `fetch`, which a test can replace — but the credential
+ * lookup goes through gaxios, and gaxios resolves its transport to
+ * `(await import("node-fetch")).default` rather than `globalThis.fetch`. A
+ * test that swaps the global therefore cannot intercept the token exchange,
+ * and on a machine with no Application Default Credentials the leg throws
+ * before it ever reaches the model. That left the one path that bills in real
+ * currency with no end-to-end coverage at all.
+ *
+ * Pass `undefined` to restore the real credential lookup.
+ */
+export function setVertexAccessTokenProviderForTests(provider) {
+    accessTokenProviderForTests = provider;
+}
 /**
  * Send one Anthropic-shaped request to Vertex and return the upstream response
  * untouched, so the caller can stream its bytes straight to the client.
  */
 export async function dispatchVertexAnthropicPassthrough(request) {
-    const token = await auth().getAccessToken();
+    const token = await vertexAccessToken();
     if (!token) {
         throw new Error("Vertex passthrough could not obtain a Google access token; " +
             "check Application Default Credentials for this project");

package/dist/routing/classifierStrategies.js

@@ -295,6 +295,9 @@ export async function classifyJev(input, decide, timeoutMs, candidates, threshol
     // are already assembled by the caller. Sending them costs almost nothing
     // and they are exactly what distinguishes a long tool-using request from a
     // short conversational one.
+    // Continuity is sent as `session_bound` / `prior_messages`, never as the
+    // raw sessionId: the id is an opaque identifier that tells a third-party
+    // model nothing, so it stays in-process.
     const result = await decide({
         state: {
             request: (input.prompt ?? "").slice(0, 8000),
@@ -302,6 +305,10 @@ export async function classifyJev(input, decide, timeoutMs, candidates, threshol
             has_tools_available: input.hasTools ?? false,
             request_includes_images: input.requiresVision ?? false,
             caller_requested_thinking: input.thinkingLevel ?? "none",
+            session_bound: input.sessionBound ?? false,
+            ...(typeof input.priorMessageCount === "number"
+                ? { prior_messages: input.priorMessageCount }
+                : {}),
         },
         questions,
         timeoutMs,