@coseung2/opencodex 2.8.0-cs.15 → 2.8.0-cs.17

package/src/responses/snapshot-policy.ts

@@ -0,0 +1,108 @@
+import { lstatSync, realpathSync, statSync } from "node:fs";
+import { dirname } from "node:path";
+import {
+  forgetHardenedSecretPath,
+  hardenSecretPathAsync,
+  windowsSecretAclApplies,
+} from "../lib/windows-secret-acl";
+
+const BASE_DEBOUNCE_MS = 2_000;
+const SCALE_FROM_BYTES = 1024 * 1024;
+const MAX_DEBOUNCE_MS = 30_000;
+
+/** Large snapshots trade a bounded hard-kill recovery window for fewer atomic replacements. */
+export function responseSnapshotDebounceMs(bytes: number): number {
+  if (!Number.isFinite(bytes) || bytes <= SCALE_FROM_BYTES) return BASE_DEBOUNCE_MS;
+  return Math.min(MAX_DEBOUNCE_MS, Math.round(BASE_DEBOUNCE_MS * bytes / SCALE_FROM_BYTES));
+}
+
+export interface ResponseSnapshotWriteMetrics {
+  writes: number;
+  unchangedSkips: number;
+  bytesWritten: number;
+  lastSnapshotBytes: number;
+  debounceMs: number;
+}
+
+type SnapshotWrite = (path: string, payload: string) => Promise<void>;
+
+/**
+ * Memoize only a digest, size and resolved target, never another copy of the snapshot.
+ * The state store owns the single-flight writer gate; this class does not queue writes.
+ */
+export class ResponseSnapshotWriter {
+  private digest: string | null = null;
+  private target: string | null = null;
+  private bytes = 0;
+  private writes = 0;
+  private unchangedSkips = 0;
+  private bytesWritten = 0;
+
+  constructor(private readonly write: SnapshotWrite) {}
+
+  metrics(): ResponseSnapshotWriteMetrics {
+    return {
+      writes: this.writes,
+      unchangedSkips: this.unchangedSkips,
+      bytesWritten: this.bytesWritten,
+      lastSnapshotBytes: this.bytes,
+      debounceMs: responseSnapshotDebounceMs(this.bytes),
+    };
+  }
+
+  reset(): void {
+    this.digest = null;
+    this.target = null;
+    this.bytes = 0;
+    this.writes = 0;
+    this.unchangedSkips = 0;
+    this.bytesWritten = 0;
+  }
+
+  private async diskMatches(path: string, payload: string, bytes: number): Promise<boolean> {
+    try {
+      const before = lstatSync(path);
+      // Atomic replacement would replace a symlink or break a hardlink. An optimization must
+      // not silently preserve either, even if it currently resolves to identical bytes.
+      if (!before.isFile() || before.nlink !== 1 || before.size !== bytes) return false;
+      if (realpathSync(path) !== this.target) return false;
+      if (!windowsSecretAclApplies()) {
+        if ((before.mode & 0o777) !== 0o600) return false;
+        if ((statSync(dirname(path)).mode & 0o777) !== 0o700) return false;
+      } else {
+        // An ordinary atomic write hardens a new temp. A skipped write must still use the
+        // required publication policy, not a potentially stale pathname-only success memo.
+        forgetHardenedSecretPath(path);
+        try { await hardenSecretPathAsync(path, { required: true }); }
+        finally { forgetHardenedSecretPath(path); }
+      }
+      // The digest records our last write, not the current disk contents. A same-size edit,
+      // a second process or a deleted snapshot must never turn into a false cache hit.
+      if (await Bun.file(path).text() !== payload) return false;
+      const after = lstatSync(path);
+      return after.isFile() && after.nlink === 1 && after.dev === before.dev
+        && after.ino === before.ino && after.size === before.size
+        && after.mtimeMs === before.mtimeMs && realpathSync(path) === this.target;
+    } catch {
+      return false;
+    }
+  }
+
+  async persist(path: string, payload: string): Promise<void> {
+    const bytes = Buffer.byteLength(payload, "utf8");
+    const digest = Bun.hash(payload).toString(36);
+    if (this.digest === digest && this.bytes === bytes && await this.diskMatches(path, payload, bytes)) {
+      this.unchangedSkips += 1;
+      return;
+    }
+    await this.write(path, payload);
+    // Publish the memo only after a successful atomic write. A failed write keeps the previous
+    // fingerprint, which is harmless because every prospective skip rechecks the disk.
+    this.digest = digest;
+    this.bytes = bytes;
+    this.writes += 1;
+    this.bytesWritten += bytes;
+    try { this.target = realpathSync(path); }
+    catch { this.target = null; }
+  }
+}

package/src/responses/state.ts

@@ -4,6 +4,7 @@ import { isDeepStrictEqual } from "node:util";
 import { atomicWriteFileAsync, getConfigDir } from "../config";
 import { enforceAppOwnedMemoryBudget, type RetainedStoreSnapshot } from "../lib/app-owned-memory";
 import type { OcxProviderContinuationState } from "../types";
+import { ResponseSnapshotWriter } from "./snapshot-policy";
 import {
   deleteResponseSpill,
   noteStubSwapForTest,
@@ -17,7 +18,6 @@ import {
 
 const MAX_STORED_RESPONSES = 1_000;
 const RESPONSE_TTL_MS = 60 * 60 * 1_000;
-const SNAPSHOT_DEBOUNCE_MS = 2_000;
 /** In-memory high-water byte cap across all entries. Forced store:false retention (kiro/cursor
  * continuation chains) stores the full expanded input each turn — ~quadratic bytes per chain —
  * so a count cap alone cannot bound memory. Oldest-first eviction applies past this mark. */
@@ -69,6 +69,17 @@ let oldestResidentId: string | undefined;
 let oldestResidentAt: number | null = null;
 let byteCapOverride: number | null = null;
 let stateRevision = 0;
+const snapshotWriter = new ResponseSnapshotWriter(async (path, payload) => {
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  try { chmodSync(dirname(path), 0o700); } catch { /* best-effort (e.g. Windows) */ }
+  await atomicWriteFileAsync(path, payload);
+});
+
+/** Scalar-only observation; does not load, prune or retain snapshot contents. */
+export function responseSnapshotMetricsForTests() {
+  return snapshotWriter.metrics();
+}
+
 const spillCounters = { writes: 0, writeFailures: 0, readFailures: 0 };
 const admissionCounters = { directSpills: 0, oversizedDrops: 0, snapshotOversizedRefusals: 0 };
 
@@ -573,14 +584,14 @@ function ensureLoaded(): void {
 
 type SnapshotWriteOutcome = "stable" | "unstable" | "failed";
 
-async function writeBoundedSnapshot(path: string): Promise<SnapshotWriteOutcome> {
+async function writeBoundedSnapshot(path: string, attemptLimit: number): Promise<SnapshotWriteOutcome> {
   // Serialize writers so concurrent flush + debounce cannot race on temps / ACL (#612).
   const previous = persistGate;
   let release!: () => void;
   persistGate = new Promise<void>(resolve => { release = resolve; });
   await previous;
   try {
-    for (let attempt = 0; attempt < MAX_SNAPSHOT_REWRITE_ATTEMPTS; attempt += 1) {
+    for (let attempt = 0; attempt < attemptLimit; attempt += 1) {
       const revision = stateRevision;
       const entries: Array<[string, unknown]> = [];
       let total = 0;
@@ -602,9 +613,7 @@ async function writeBoundedSnapshot(path: string): Promise<SnapshotWriteOutcome>
         entries.push(persistEntry);
       }
       entries.reverse();
-      mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-      try { chmodSync(dirname(path), 0o700); } catch { /* best-effort (e.g. Windows) */ }
-      await atomicWriteFileAsync(path, JSON.stringify({ version: 2, states: entries }));
+      await snapshotWriter.persist(path, JSON.stringify({ version: 2, states: entries }));
       persistAttemptHookForTests?.();
       if (revision === stateRevision) return "stable";
     }
@@ -627,7 +636,7 @@ function schedulePersistAt(path: string, replace = false): void {
   if (persistTimer && !replace) return;
   if (persistTimer) clearTimeout(persistTimer);
   pendingPersistPath = path;
-  persistTimer = setTimeout(() => { void persistNow(path); }, SNAPSHOT_DEBOUNCE_MS);
+  persistTimer = setTimeout(() => { void persistNow(path); }, snapshotWriter.metrics().debounceMs);
   (persistTimer as { unref?: () => void }).unref?.();
 }
 
@@ -637,12 +646,15 @@ async function persistNow(path: string, awaitFollowUp = false): Promise<void> {
     persistTimer = null;
   }
   pendingPersistPath = null;
-  let outcome = await writeBoundedSnapshot(path);
+  // Background traffic gets one write per debounce, not four immediate full-file rewrites.
+  // Explicit shutdown flushes retain the existing bounded stabilization contract.
+  const attemptLimit = awaitFollowUp ? MAX_SNAPSHOT_REWRITE_ATTEMPTS : 1;
+  let outcome = await writeBoundedSnapshot(path, attemptLimit);
   if (outcome === "unstable" && awaitFollowUp) {
     if (persistTimer) clearTimeout(persistTimer);
     persistTimer = null;
     pendingPersistPath = null;
-    outcome = await writeBoundedSnapshot(path);
+    outcome = await writeBoundedSnapshot(path, attemptLimit);
   }
   if (outcome === "stable") drainPendingSpillUnlinks();
   else if (outcome === "unstable" && !awaitFollowUp) schedulePersistAt(path, true);
@@ -957,7 +969,7 @@ export function rememberResponseState(
   schedulePersist();
 }
 
-/** Test-only persistence churn hook; invoked after each atomic snapshot rewrite. */
+/** Test-only persistence churn hook; invoked after each write/unchanged-validation attempt. */
 export function setResponseStatePersistAttemptHookForTests(hook: (() => void) | null): void {
   persistAttemptHookForTests = hook;
 }
@@ -986,6 +998,7 @@ export function clearResponseStateMemoryForTests(): void {
   oldestResidentId = undefined;
   oldestResidentAt = null;
   stateRevision = 0;
+  snapshotWriter.reset();
   pendingSpillUnlinks.length = 0;
   spillCounters.writes = 0;
   spillCounters.writeFailures = 0;

package/src/responses/turn-termination.ts

@@ -0,0 +1,108 @@
+import { createHash } from "node:crypto";
+import type { OcxAssistantMessage, OcxMessage, OcxParsedRequest } from "../types";
+
+const DELIVERED_FINAL_ANSWER_TTL_MS = 60 * 60 * 1_000;
+const DELIVERED_FINAL_ANSWER_MAX_ENTRIES = 1_024;
+
+interface DeliveredFinalAnswerRecord {
+  fingerprint: string;
+  createdAt: number;
+}
+
+const scopesByRequest = new WeakMap<OcxParsedRequest, string>();
+const deliveredFinalAnswers = new Map<string, DeliveredFinalAnswerRecord>();
+
+function pruneDeliveredFinalAnswers(at = Date.now()): void {
+  for (const [scope, record] of deliveredFinalAnswers) {
+    if (at - record.createdAt > DELIVERED_FINAL_ANSWER_TTL_MS) deliveredFinalAnswers.delete(scope);
+  }
+  while (deliveredFinalAnswers.size > DELIVERED_FINAL_ANSWER_MAX_ENTRIES) {
+    const oldest = deliveredFinalAnswers.keys().next().value;
+    if (oldest === undefined) break;
+    deliveredFinalAnswers.delete(oldest);
+  }
+}
+
+function textFingerprint(text: string): string {
+  return createHash("sha256").update(text, "utf8").digest("hex");
+}
+
+function assistantText(message: OcxAssistantMessage): string | undefined {
+  if (message.content.some(part => part.type === "toolCall")) return undefined;
+  const text = message.content
+    .filter((part): part is Extract<typeof part, { type: "text" }> => part.type === "text")
+    .map(part => part.text)
+    .join("");
+  return text.trim().length > 0 ? text : undefined;
+}
+
+function deliveredFinalAnswerText(response: unknown): string | undefined {
+  if (!response || typeof response !== "object" || Array.isArray(response)) return undefined;
+  const output = (response as { output?: unknown }).output;
+  if (!Array.isArray(output)) return undefined;
+  for (let index = output.length - 1; index >= 0; index -= 1) {
+    const item = output[index];
+    if (!item || typeof item !== "object" || Array.isArray(item)) continue;
+    const message = item as { type?: unknown; role?: unknown; phase?: unknown; content?: unknown };
+    if (message.type !== "message" || message.role !== "assistant" || message.phase !== "final_answer") continue;
+    if (!Array.isArray(message.content)) return undefined;
+    const text = message.content
+      .filter(part => !!part && typeof part === "object" && !Array.isArray(part)
+        && (part as { type?: unknown }).type === "output_text"
+        && typeof (part as { text?: unknown }).text === "string")
+      .map(part => (part as { text: string }).text)
+      .join("");
+    return text.trim().length > 0 ? text : undefined;
+  }
+  return undefined;
+}
+
+/** Bind only the already-normalized per-conversation digest; raw client ids never enter this map. */
+export function bindTurnTerminationScope(parsed: OcxParsedRequest, scope: string | undefined): void {
+  if (!scope || !/^[0-9a-f]{32}$/.test(scope)) return;
+  scopesByRequest.set(parsed, scope);
+}
+
+/** Remember only a final-answer message the proxy actually emitted for this exact conversation. */
+export function rememberDeliveredFinalAnswer(parsed: OcxParsedRequest, response: unknown): void {
+  const scope = scopesByRequest.get(parsed);
+  if (!scope) return;
+  const text = deliveredFinalAnswerText(response);
+  if (!text) return;
+  const at = Date.now();
+  pruneDeliveredFinalAnswers(at);
+  deliveredFinalAnswers.delete(scope);
+  deliveredFinalAnswers.set(scope, { fingerprint: textFingerprint(text), createdAt: at });
+  pruneDeliveredFinalAnswers(at);
+}
+
+/**
+ * Match only when the remembered assistant answer is still the trailing content-bearing message.
+ * Any later user/tool-result message is new work and must reach Kiro.
+ */
+export function hasRecordedTrailingDeliveredFinalAnswer(
+  parsed: OcxParsedRequest,
+  messages: readonly OcxMessage[],
+): boolean {
+  const scope = scopesByRequest.get(parsed);
+  if (!scope) return false;
+  pruneDeliveredFinalAnswers();
+  const record = deliveredFinalAnswers.get(scope);
+  if (!record) return false;
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message.role !== "assistant") return false;
+    const text = assistantText(message as OcxAssistantMessage);
+    if (text === undefined) {
+      if ((message as OcxAssistantMessage).content.some(part => part.type === "toolCall")) return false;
+      continue;
+    }
+    return textFingerprint(text) === record.fingerprint;
+  }
+  return false;
+}
+
+/** Test-only reset for deterministic cross-test isolation. */
+export function clearDeliveredFinalAnswersForTests(): void {
+  deliveredFinalAnswers.clear();
+}

package/src/responses/xai-custom-tool-compat.ts

@@ -0,0 +1,237 @@
+import type { SsePayloadRewrite } from "../server/sse-payload-rewrite";
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function collectBareCustomToolNames(value: unknown, out: Set<string>): void {
+  if (Array.isArray(value)) {
+    for (const entry of value) collectBareCustomToolNames(entry, out);
+    return;
+  }
+  if (!isPlainObject(value)) return;
+  if (value.type === "custom" && typeof value.name === "string" && typeof value.namespace !== "string") {
+    out.add(value.name);
+  }
+  for (const entry of Object.values(value)) collectBareCustomToolNames(entry, out);
+}
+
+function collectConvertedCallIds(value: unknown, names: ReadonlySet<string>, out: Set<string>): void {
+  if (Array.isArray(value)) {
+    for (const entry of value) collectConvertedCallIds(entry, names, out);
+    return;
+  }
+  if (!isPlainObject(value)) return;
+  if (value.type === "custom_tool_call" && typeof value.name === "string" && names.has(value.name) && typeof value.call_id === "string") {
+    out.add(value.call_id);
+  }
+  for (const entry of Object.values(value)) collectConvertedCallIds(entry, names, out);
+}
+
+function rewriteToolChoiceForUpstream(value: unknown, names: ReadonlySet<string>): unknown {
+  if (!isPlainObject(value)) return value;
+  if ((value.type === "custom" || value.type === "function") && typeof value.name === "string" && names.has(value.name)) {
+    return value.type === "function" ? value : { ...value, type: "function" };
+  }
+  if (value.type === "allowed_tools" && Array.isArray(value.tools)) {
+    let changed = false;
+    const tools = value.tools.map(tool => {
+      if (!isPlainObject(tool) || tool.type !== "custom" || typeof tool.name !== "string" || !names.has(tool.name)) return tool;
+      changed = true;
+      return { ...tool, type: "function" };
+    });
+    return changed ? { ...value, tools } : value;
+  }
+  return value;
+}
+
+function rewriteForUpstream(value: unknown, names: ReadonlySet<string>, callIds: ReadonlySet<string>): unknown {
+  if (Array.isArray(value)) return value.map(entry => rewriteForUpstream(entry, names, callIds));
+  if (!isPlainObject(value)) return value;
+
+  if (value.type === "custom" && typeof value.name === "string" && names.has(value.name)) {
+    const { format: _format, ...rest } = value;
+    return {
+      ...rest,
+      type: "function",
+      parameters: {
+        type: "object",
+        properties: {
+          input: { type: "string", description: "Raw input for this client-executed custom tool." },
+        },
+        required: ["input"],
+        additionalProperties: false,
+      },
+    };
+  }
+
+  if (value.type === "custom_tool_call" && typeof value.name === "string" && names.has(value.name)) {
+    const { input, id: _id, ...rest } = value;
+    return {
+      ...rest,
+      type: "function_call",
+      arguments: JSON.stringify({ input: typeof input === "string" ? input : "" }),
+    };
+  }
+
+  if (value.type === "custom_tool_call_output" && typeof value.call_id === "string" && callIds.has(value.call_id)) {
+    return { ...value, type: "function_call_output" };
+  }
+
+  let changed = false;
+  const next: Record<string, unknown> = {};
+  for (const [key, entry] of Object.entries(value)) {
+    const rewritten = key === "tool_choice"
+      ? rewriteToolChoiceForUpstream(entry, names)
+      : rewriteForUpstream(entry, names, callIds);
+    next[key] = rewritten;
+    changed ||= rewritten !== entry;
+  }
+  return changed ? next : value;
+}
+
+/** Names of bare Responses custom tools that xAI must receive as ordinary functions. */
+export function xaiResponsesCustomToolNames(body: unknown): Set<string> {
+  const names = new Set<string>();
+  collectBareCustomToolNames(body, names);
+  return names;
+}
+
+/** Lower bare Responses custom tools to functions for xAI, preserving enough metadata to restore calls. */
+export function lowerXaiResponsesCustomTools(body: unknown): { body: unknown; names: Set<string> } {
+  const names = xaiResponsesCustomToolNames(body);
+  if (names.size === 0) return { body, names };
+  const callIds = new Set<string>();
+  collectConvertedCallIds(body, names, callIds);
+  return { body: rewriteForUpstream(body, names, callIds), names };
+}
+
+function customItemId(id: unknown): unknown {
+  return typeof id === "string" && id.startsWith("fc_") ? `ctc_${id.slice(3)}` : id;
+}
+
+function unwrapInput(argumentsText: unknown): string {
+  if (typeof argumentsText !== "string") return "";
+  try {
+    const parsed: unknown = JSON.parse(argumentsText);
+    if (isPlainObject(parsed) && typeof parsed.input === "string") return parsed.input;
+  } catch {
+    // Provider may return raw input; preserve it.
+  }
+  return argumentsText;
+}
+
+function restoreItem(item: unknown, names: ReadonlySet<string>): unknown {
+  if (!isPlainObject(item) || (item.type !== "function_call" && item.type !== "custom_tool_call")) return item;
+  if (typeof item.name !== "string" || !names.has(item.name)) return item;
+  const sourceInput = item.type === "function_call" ? item.arguments : item.input;
+  const restored: Record<string, unknown> = {
+    ...item,
+    type: "custom_tool_call",
+    id: customItemId(item.id),
+    input: unwrapInput(sourceInput),
+  };
+  delete restored.arguments;
+  return restored;
+}
+
+function restorePayload(value: unknown, names: ReadonlySet<string>): unknown {
+  if (!isPlainObject(value)) return value;
+  let changed = false;
+  const next: Record<string, unknown> = { ...value };
+
+  if (Array.isArray(value.output)) {
+    const output = value.output.map(item => {
+      const restored = restoreItem(item, names);
+      changed ||= restored !== item;
+      return restored;
+    });
+    if (changed) next.output = output;
+  }
+
+  if ((value.type === "response.output_item.added" || value.type === "response.output_item.done") && isPlainObject(value.item)) {
+    const restored = restoreItem(value.item, names);
+    if (restored !== value.item) {
+      next.item = restored;
+      changed = true;
+    }
+  }
+
+  if (typeof value.type === "string" && value.type.startsWith("response.") && isPlainObject(value.response)) {
+    const restored = restorePayload(value.response, names);
+    if (restored !== value.response) {
+      next.response = restored;
+      changed = true;
+    }
+  }
+  return changed ? next : value;
+}
+
+/** Restore converted calls in a non-streaming Responses JSON body. */
+export function restoreXaiCustomCallsInJson(text: string, names: ReadonlySet<string>): string {
+  if (names.size === 0) return text;
+  try {
+    const parsed = JSON.parse(text) as unknown;
+    const restored = restorePayload(parsed, names);
+    return restored === parsed ? text : JSON.stringify(restored);
+  } catch {
+    return text;
+  }
+}
+
+/**
+ * Client-facing SSE rewrite. Argument deltas stay preview-only: until the `{input:string}` wrapper
+ * becomes valid JSON they are emitted as empty custom-input deltas, then the done frame and final
+ * item carry the authoritative raw input. This avoids leaking wrapper JSON while keeping the event
+ * sequence valid for Codex.
+ */
+export function createXaiCustomToolPayloadRewrite(names: ReadonlySet<string>): SsePayloadRewrite | undefined {
+  if (names.size === 0) return undefined;
+  const itemIds = new Map<string, string>();
+  const convertedItemIds = new Set<string>();
+  return (payload: string): string => {
+    if (payload === "[DONE]") return payload;
+    let value: unknown;
+    try { value = JSON.parse(payload); } catch { return payload; }
+    if (!isPlainObject(value)) return payload;
+
+    if ((value.type === "response.output_item.added" || value.type === "response.output_item.done") && isPlainObject(value.item)) {
+      const item = value.item;
+      if ((item.type === "function_call" || item.type === "custom_tool_call") && typeof item.name === "string" && names.has(item.name)) {
+        const oldId = typeof item.id === "string" ? item.id : undefined;
+        const newId = customItemId(oldId);
+        if (oldId && typeof newId === "string") {
+          itemIds.set(oldId, newId);
+          convertedItemIds.add(oldId);
+        }
+      }
+    }
+
+    if (value.type === "response.function_call_arguments.delta") {
+      const itemId = typeof value.item_id === "string" ? value.item_id : undefined;
+      if (!itemId || !convertedItemIds.has(itemId)) return payload;
+      return JSON.stringify({
+        ...value,
+        type: "response.custom_tool_call_input.delta",
+        ...(itemId ? { item_id: itemIds.get(itemId) ?? customItemId(itemId) } : {}),
+        delta: "",
+      });
+    }
+    if (value.type === "response.function_call_arguments.done") {
+      const itemId = typeof value.item_id === "string" ? value.item_id : undefined;
+      if (!itemId || !convertedItemIds.has(itemId)) return payload;
+      const input = unwrapInput(value.arguments);
+      const next: Record<string, unknown> = {
+        ...value,
+        type: "response.custom_tool_call_input.done",
+        ...(itemId ? { item_id: itemIds.get(itemId) ?? customItemId(itemId) } : {}),
+        input,
+      };
+      delete next.arguments;
+      return JSON.stringify(next);
+    }
+
+    const restored = restorePayload(value, names);
+    return restored === value ? payload : JSON.stringify(restored);
+  };
+}