@remodex/rmx 1.0.2

package/src/responses/reasoning-envelope.ts

@@ -0,0 +1,60 @@
+/**
+ * Anthropic extended-thinking signature round-trip through Codex's `encrypted_content` slot.
+ *
+ * Anthropic requires the previous assistant turn's `thinking`/`redacted_thinking` blocks to be
+ * replayed VERBATIM (with their signatures) while extended thinking is enabled; a signature-less
+ * replay 400s ("Expected `thinking` or `redacted_thinking`, but found `tool_use`"). Codex round-trips
+ * whatever `encrypted_content` a reasoning output item carries (include: reasoning.encrypted_content
+ * is set whenever reasoning is on — codex-rs client.rs), so the proxy smuggles the real Anthropic
+ * signature (and any redacted blocks) inside a transparent `ocxr1:` + base64(JSON) envelope.
+ *
+ * Native OpenAI-encrypted blobs (no ocxr1 prefix) are left untouched by the decoder, and the
+ * passthrough scrub strips ocxr1 envelopes before native forwarding.
+ */
+
+export const OCX_REASONING_PREFIX = "ocxr1:";
+
+export interface ReasoningEnvelope {
+  /** Anthropic thinking-block signature (signature_delta), if captured. */
+  sig?: string;
+  /** Raw redacted_thinking block data payloads, order preserved. */
+  red?: string[];
+  /**
+   * Hidden thinking text (hideThinkingSummary providers): the signature signs this exact text,
+   * so replay needs it even though the visible summary was suppressed.
+   */
+  txt?: string;
+  /**
+   * Kiro `reasoningContentEvent.redactedContent`: a KMS-encrypted reasoning blob that is opaque to
+   * the proxy. Kiro's own CLI replays it on the matching `assistantResponseMessage` to preserve
+   * model reasoning across turns, so it round-trips here the same way a signature does.
+   */
+  krc?: string;
+}
+
+export function encodeReasoningEnvelope(envelope: ReasoningEnvelope): string {
+  return OCX_REASONING_PREFIX + Buffer.from(JSON.stringify(envelope), "utf-8").toString("base64");
+}
+
+/** Decode an ocxr1 envelope; returns null for native (OpenAI-encrypted) blobs or garbage. */
+export function decodeReasoningEnvelope(encryptedContent: string): ReasoningEnvelope | null {
+  if (!encryptedContent.startsWith(OCX_REASONING_PREFIX)) return null;
+  try {
+    const parsed: unknown = JSON.parse(Buffer.from(encryptedContent.slice(OCX_REASONING_PREFIX.length), "base64").toString("utf-8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+    const obj = parsed as { sig?: unknown; red?: unknown };
+    const envelope: ReasoningEnvelope = {};
+    if (typeof obj.sig === "string") envelope.sig = obj.sig;
+    if (Array.isArray(obj.red)) {
+      const red = obj.red.filter((r): r is string => typeof r === "string");
+      if (red.length > 0) envelope.red = red;
+    }
+    const txt = (parsed as { txt?: unknown }).txt;
+    if (typeof txt === "string" && txt.length > 0) envelope.txt = txt;
+    const krc = (parsed as { krc?: unknown }).krc;
+    if (typeof krc === "string" && krc.length > 0) envelope.krc = krc;
+    return envelope.sig || envelope.red || envelope.txt || envelope.krc ? envelope : null;
+  } catch {
+    return null;
+  }
+}

package/src/responses/reasoning-replay-cache.ts

@@ -0,0 +1,106 @@
+/**
+ * In-process fallback store pairing raw reasoning text with the tool call it
+ * preceded (issue #950).
+ *
+ * DeepSeek thinking mode requires the assistant's original `reasoning_content`
+ * to be replayed on every continuation of a tool-call turn. The bridge records
+ * the raw reasoning here when it closes a reasoning block and a tool call
+ * follows; the openai-chat adapter re-attaches it when a `tool_calls`
+ * assistant message is about to serialize without thinking parts (compacted
+ * history, lost assistant turn, orphan-repaired tool results).
+ *
+ * Entries are scoped by an optional conversation identity in addition to the
+ * call id: provider-generated ids like `call_1` are not globally unique, so a
+ * process-wide key would let one conversation's reasoning bleed into another
+ * when ids collide (CodeRabbit P1 on #971).
+ *
+ * Privacy: entries hold reasoning text in memory only — never logged,
+ * serialized, or exported. Bounded by entry count, total bytes, and TTL, so a
+ * long-lived proxy cannot grow without limit.
+ */
+
+const MAX_ENTRIES = 64;
+const MAX_TOTAL_BYTES = 256 * 1024;
+const TTL_MS = 60 * 60 * 1000;
+
+interface CacheEntry {
+  text: string;
+  bytes: number;
+  at: number;
+}
+
+const entries = new Map<string, CacheEntry>();
+let totalBytes = 0;
+let clockForTests: (() => number) | null = null;
+
+const now = (): number => clockForTests?.() ?? Date.now();
+const keyFor = (callId: string, scope: string | undefined): string =>
+  `${scope ?? "global"}\u0000${callId}`;
+
+/**
+ * Record the raw reasoning text that preceded the given tool call.
+ *
+ * Expired entries are swept on insert so the TTL bound holds even when a call
+ * id is never read again.
+ */
+export function rememberReasoningForCall(callId: string, text: string, scope?: string): void {
+  // Empty provider deltas are absence of new reasoning, not a request to erase a candidate.
+  if (!callId || typeof text !== "string" || text.length === 0) return;
+  const bytes = Buffer.byteLength(text, "utf8");
+  // A single entry larger than the whole budget would immediately evict itself.
+  if (bytes > MAX_TOTAL_BYTES) return;
+  const at = now();
+  // Delete every due entry first so expired reasoning cannot linger until a
+  // later peek or capacity eviction.
+  for (const [key, entry] of entries) {
+    if (at - entry.at >= TTL_MS) {
+      entries.delete(key);
+      totalBytes -= entry.bytes;
+    }
+  }
+  const key = keyFor(callId, scope);
+  const previous = entries.get(key);
+  if (previous) totalBytes -= previous.bytes;
+  entries.set(key, { text, bytes, at });
+  totalBytes += bytes;
+  // Evict oldest-first until both caps hold (never evict the entry just written
+  // while it is the only one — the loop guards on size > 1).
+  while ((totalBytes > MAX_TOTAL_BYTES || entries.size > MAX_ENTRIES) && entries.size > 1) {
+    let oldestKey: string | undefined;
+    let oldestAt = Infinity;
+    for (const [candidateKey, entry] of entries) {
+      if (entry.at < oldestAt) {
+        oldestAt = entry.at;
+        oldestKey = candidateKey;
+      }
+    }
+    if (oldestKey === undefined) break;
+    const evicted = entries.get(oldestKey)!;
+    totalBytes -= evicted.bytes;
+    entries.delete(oldestKey);
+  }
+}
+
+/**
+ * Read the recorded reasoning for a call id without removing it: retries after
+ * a failed continuation reuse the same fallback.
+ */
+export function peekReasoningForCall(callId: string, scope?: string): string | undefined {
+  if (!callId) return undefined;
+  const key = keyFor(callId, scope);
+  const entry = entries.get(key);
+  if (!entry) return undefined;
+  if (now() - entry.at >= TTL_MS) {
+    entries.delete(key);
+    totalBytes -= entry.bytes;
+    return undefined;
+  }
+  return entry.text;
+}
+
+/** Test-only: reset the cache and optionally pin the clock. */
+export function clearReasoningReplayCacheForTests(clock?: (() => number) | null): void {
+  entries.clear();
+  totalBytes = 0;
+  clockForTests = clock ?? null;
+}

package/src/responses/schema.ts

@@ -0,0 +1,159 @@
+import * as z from "zod/v4";
+
+const inputTextSchema = z.object({ type: z.literal("input_text"), text: z.string() });
+const plainTextSchema = z.object({ type: z.literal("text"), text: z.string() });
+const inputImageBlockSchema = z.object({
+  type: z.literal("input_image"),
+  // codex-rs ImageDetail: auto|low|high|original (view_image --detail original).
+  detail: z.enum(["auto", "low", "high", "original"]).optional(),
+  image_url: z.string().optional(),
+  file_id: z.string().optional(),
+}).refine(v => typeof v.image_url === "string" || typeof v.file_id === "string", {
+  message: "input_image requires at least one of image_url or file_id",
+});
+const inputFileBlockSchema = z.object({
+  type: z.literal("input_file"),
+  file_id: z.string().optional(),
+  filename: z.string().optional(),
+  file_data: z.string().optional(),
+});
+const outputTextSchema = z.object({ type: z.literal("output_text"), text: z.string() });
+const outputRefusalSchema = z.object({ type: z.literal("refusal"), refusal: z.string() });
+const summaryTextSchema = z.object({ type: z.literal("summary_text"), text: z.string() });
+const reasoningTextSchema = z.object({ type: z.literal("reasoning_text"), text: z.string() });
+// codex-rs FunctionCallOutputContentItem (protocol/src/models.rs): input_text | input_image | encrypted_content.
+const encryptedContentBlockSchema = z.object({ type: z.literal("encrypted_content"), encrypted_content: z.string() });
+
+const inputContentBlockSchema = z.union([inputTextSchema, plainTextSchema, inputImageBlockSchema, inputFileBlockSchema]);
+const outputContentBlockSchema = z.union([outputTextSchema, plainTextSchema, outputRefusalSchema]);
+// Tool outputs on the wire mix codex-rs FunctionCallOutputContentItem with legacy output blocks.
+const toolOutputContentBlockSchema = z.union([
+  outputTextSchema, plainTextSchema, outputRefusalSchema,
+  inputTextSchema, inputImageBlockSchema, encryptedContentBlockSchema,
+]);
+const toolOutputSchema = z.union([z.string(), z.array(toolOutputContentBlockSchema)]);
+
+const userMessageItemSchema = z.object({
+  type: z.literal("message").optional(),
+  role: z.union([z.literal("user"), z.literal("developer")]),
+  content: z.union([z.string(), z.array(inputContentBlockSchema)]).optional(),
+});
+const systemMessageItemSchema = z.object({
+  type: z.literal("message").optional(),
+  role: z.literal("system"),
+  content: z.union([z.string(), z.array(inputContentBlockSchema)]).optional(),
+});
+const assistantMessageItemSchema = z.object({
+  type: z.literal("message").optional(),
+  role: z.literal("assistant"),
+  content: z.union([z.string(), z.array(outputContentBlockSchema)]).optional(),
+  phase: z.enum(["commentary", "final_answer"]).optional(),
+});
+const reasoningItemSchema = z.object({
+  type: z.literal("reasoning"),
+  id: z.string().optional(),
+  summary: z.array(summaryTextSchema).optional(),
+  content: z.array(reasoningTextSchema).optional(),
+  // Round-tripped opaque payload (native OpenAI encryption OR the proxy's ocxr1 envelope).
+  encrypted_content: z.string().optional(),
+});
+const functionCallItemSchema = z.object({
+  type: z.literal("function_call"),
+  id: z.string().optional(),
+  call_id: z.string().min(1),
+  name: z.string().min(1),
+  namespace: z.string().optional(),
+  arguments: z.string().optional(),
+});
+const functionCallOutputItemSchema = z.object({
+  type: z.literal("function_call_output"),
+  call_id: z.string().min(1),
+  output: toolOutputSchema.optional(),
+});
+const customToolCallItemSchema = z.object({
+  type: z.literal("custom_tool_call"),
+  id: z.string().optional(),
+  call_id: z.string().min(1),
+  name: z.string().min(1),
+  input: z.string(),
+});
+const customToolCallOutputItemSchema = z.object({
+  type: z.literal("custom_tool_call_output"),
+  call_id: z.string().min(1),
+  // codex-rs CustomToolCallOutput carries FunctionCallOutputPayload: string OR content items.
+  output: toolOutputSchema,
+});
+
+export const inputItemSchema = z.union([
+  userMessageItemSchema,
+  systemMessageItemSchema,
+  assistantMessageItemSchema,
+  reasoningItemSchema,
+  functionCallItemSchema,
+  functionCallOutputItemSchema,
+  customToolCallItemSchema,
+  customToolCallOutputItemSchema,
+  z.object({ type: z.string() }).loose(),
+]);
+
+export const toolSchema = z.object({
+  type: z.literal("function"),
+  name: z.string().min(1),
+  description: z.string().optional(),
+  parameters: z.record(z.string(), z.unknown()).optional(),
+  strict: z.boolean().optional(),
+});
+
+const builtinToolSchema = z.object({ type: z.string() }).loose();
+
+const hostedToolType = z.enum([
+  "web_search_preview", "file_search", "computer_use_preview",
+  "code_interpreter", "image_generation", "mcp",
+]);
+
+const allowedToolEntrySchema = z.object({ type: z.string(), name: z.string().optional() });
+
+export const toolChoiceSchema = z.union([
+  z.literal("auto"),
+  z.literal("none"),
+  z.literal("required"),
+  z.object({ type: z.literal("function"), name: z.string().min(1) }),
+  z.object({ type: z.literal("custom"), name: z.string().min(1) }),
+  z.object({ type: hostedToolType }),
+  z.object({ type: z.literal("allowed_tools"), mode: z.enum(["auto", "required"]), tools: z.array(allowedToolEntrySchema) }),
+]);
+
+export const reasoningConfigSchema = z.object({
+  effort: z.string().optional(),
+  summary: z.enum(["auto", "concise", "detailed", "none"]).optional(),
+});
+
+export const stopSchema = z.union([z.string(), z.array(z.string()), z.null()]);
+
+export const responsesRequestSchema = z.object({
+  model: z.string().min(1),
+  input: z.union([z.string(), z.array(inputItemSchema)]).optional(),
+  instructions: z.union([z.string(), z.null()]).optional(),
+  tools: z.array(z.union([toolSchema, builtinToolSchema])).optional(),
+  tool_choice: toolChoiceSchema.optional(),
+  max_output_tokens: z.number().optional(),
+  temperature: z.number().optional(),
+  top_p: z.number().optional(),
+  stop: stopSchema.optional(),
+  stream: z.boolean().optional(),
+  reasoning: reasoningConfigSchema.nullable().optional(),
+  store: z.boolean().optional(),
+  previous_response_id: z.string().optional(),
+  parallel_tool_calls: z.boolean().optional(),
+  prompt_cache_key: z.string().optional(),
+  metadata: z.unknown().optional(),
+  user: z.string().optional(),
+  service_tier: z.string().optional(),
+  presence_penalty: z.number().optional(),
+  frequency_penalty: z.number().optional(),
+  background: z.unknown().optional(),
+  include: z.unknown().optional(),
+  prompt: z.unknown().optional(),
+  text: z.unknown().optional(),
+  truncation: z.unknown().optional(),
+});