@juspay/neurolink 12.19.0 → 12.19.1

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/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;
     };