@juspay/neurolink 12.19.0 → 12.19.2

package/dist/proxy/codexFallback.d.ts

@@ -22,6 +22,24 @@ export declare class CodexFallbackStreamError extends Error {
     readonly usage?: CodexFallbackResult["usage"];
     constructor(payload: Record<string, unknown>, eventType: string, usage?: CodexFallbackResult["usage"]);
 }
+/**
+ * Stable per-conversation routing key for OpenAI prompt caching.
+ *
+ * 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.
+ *
+ * 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
+ * prefixes onto one cache instead of separating them.
+ */
+export declare function codexPromptCacheKey(body: ClaudeRequest): string | undefined;
 /** Convert a Claude Messages request into the ChatGPT Codex Responses shape. */
 export declare function convertClaudeRequestToCodex(body: ClaudeRequest, model: string, reasoningEffort?: CodexReasoningEffort): CodexResponsesRequest;
 /**

package/dist/proxy/codexFallback.js

@@ -6,6 +6,7 @@
  * in the native Codex proxy handler so fallback traffic follows the same pool
  * rules as a native Codex request.
  */
+import { createHash } from "node:crypto";
 import { ClaudeStreamSerializer, generateToolUseId } from "./claudeFormat.js";
 import { classifyProxyFailureCode } from "./proxyFailureDetails.js";
 import { extractCodexUsage } from "./codexUsage.js";
@@ -235,6 +236,45 @@ function convertClaudeMessage(role, content) {
     flushMessage();
     return input;
 }
+/**
+ * Stable per-conversation routing key for OpenAI prompt caching.
+ *
+ * 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.
+ *
+ * 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
+ * prefixes onto one cache instead of separating them.
+ */
+export function codexPromptCacheKey(body) {
+    const raw = body.metadata?.user_id;
+    if (typeof raw !== "string" || raw.length === 0) {
+        return undefined;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return undefined;
+    }
+    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");
+}
 /** Convert a Claude Messages request into the ChatGPT Codex Responses shape. */
 export function convertClaudeRequestToCodex(body, model, reasoningEffort) {
     const input = body.messages.flatMap((message) => message.role === "system"
@@ -250,6 +290,10 @@ export function convertClaudeRequestToCodex(body, model, reasoningEffort) {
             ? { reasoning: { effort: reasoningEffort } }
             : {}),
     };
+    const promptCacheKey = codexPromptCacheKey(body);
+    if (promptCacheKey) {
+        request.prompt_cache_key = promptCacheKey;
+    }
     const instructions = buildSystemInstructions(body);
     if (instructions) {
         request.instructions = instructions;

package/dist/proxy/vertexAnthropicFallback.d.ts

@@ -21,7 +21,6 @@ import type { UsageContext, VertexPassthroughTerminal, VertexAnthropicPassthroug
  * `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. */
 export declare function buildVertexAnthropicPayload(body: Readonly<Record<string, unknown>>): Record<string, unknown>;
 /**
  * Publisher endpoint for a Claude model on Vertex.

package/dist/proxy/vertexAnthropicFallback.js

@@ -69,6 +69,33 @@ export function mapVertexOutputConfig(value) {
     return Object.keys(rest).length > 0 ? rest : undefined;
 }
 /** Strip what Vertex rejects and pin the API version it requires. */
+/**
+ * Vertex refuses `role: "system"` messages outright — "role 'system' is not
+ * supported on this model" — where the first-party Messages API accepts them
+ * anywhere except index 0.
+ *
+ * Claude Code interleaves them as positional notices: a file changed on disk
+ * since it was last read, a tool became available, an MCP server dropped. Their
+ * meaning depends on where they sit, so hoisting them into the top-level
+ * `system` parameter would strip exactly what makes them useful, and dropping
+ * them would silently lose context the turn depends on. They become user turns
+ * instead, which keeps both the text and the position. Consecutive same-role
+ * turns are accepted, so this never produces an invalid sequence.
+ */
+function normalizeVertexRoles(messages) {
+    if (!Array.isArray(messages)) {
+        return messages;
+    }
+    let changed = false;
+    const mapped = messages.map((message) => {
+        if (!record(message) || message.role !== "system") {
+            return message;
+        }
+        changed = true;
+        return { ...message, role: "user" };
+    });
+    return changed ? mapped : messages;
+}
 export function buildVertexAnthropicPayload(body) {
     const dropped = new Set(UNSUPPORTED_FIELDS);
     const payload = Object.fromEntries(Object.entries(body).filter(([key]) => !dropped.has(key)));
@@ -81,6 +108,9 @@ export function buildVertexAnthropicPayload(body) {
             payload.output_config = mapped;
         }
     }
+    if ("messages" in payload) {
+        payload.messages = normalizeVertexRoles(payload.messages);
+    }
     return { ...payload, anthropic_version: VERTEX_ANTHROPIC_VERSION };
 }
 /**

package/dist/types/codex.d.ts

@@ -156,6 +156,8 @@ export type CodexResponsesRequest = {
     input: CodexResponsesInputItem[];
     stream: true;
     store: false;
+    /** Pins one conversation to the cache that already holds its prefix. */
+    prompt_cache_key?: string;
     reasoning?: {
         effort: CodexReasoningEffort;
     };

package/docs/changelog.md

@@ -1,15 +1,24 @@
 # Changelog
 
-All notable changes to NeuroLink are documented in this changelog.
+**The current release notes live on GitHub Releases:
+[github.com/juspay/neurolink/releases](https://github.com/juspay/neurolink/releases)** — generated
+automatically by semantic-release on every publish, so they are always current. An RSS/Atom feed
+is available at [releases.atom](https://github.com/juspay/neurolink/releases.atom).
 
-For the complete and most up-to-date changelog, please visit:
-**[CHANGELOG.md](https://github.com/juspay/neurolink/blob/release/CHANGELOG.md)** in the GitHub repository.
+> `CHANGELOG.md` in the repository is **not** a reliable source of the current version.
+> `@semantic-release/git` was deliberately removed so that nothing pushes back to the `release`
+> branch (branch protection rejects pushes that carry no check runs), which means the committed
+> `CHANGELOG.md` stops at the last version that was committed by hand. It still ships inside the
+> published npm package, where it is generated at publish time and is correct.
 
 ---
 
-## Latest Releases
+## Release highlights
 
-### v9.14.0 (Current Release - February 28, 2026)
+The entries below are hand-written highlights for selected past releases. They are an archive,
+not a complete or current list — use GitHub Releases above for that.
+
+### v9.14.0 (February 28, 2026)
 
 **Features:**