deepcodex 0.1.0

package/vendor/codex-router/sse-prefix.js

@@ -0,0 +1,115 @@
+// Vendored from duolahypercho/codex-router at 63ec1f3602c28f2a28ccb7e9edaf7b4f7d191c6c.
+// Source: src/sse-prefix.js; MIT license in LICENSE.
+const UTF8_BOM = Buffer.from([0xef, 0xbb, 0xbf]);
+const SSE_FIELD = /^(?:event|data|id|retry)(?::.*)?$/;
+const SSE_FIELDS = ["event", "data", "id", "retry"];
+
+export const HEADERLESS_SSE_SNIFF_BYTES = 512;
+export const HEADERLESS_SSE_SNIFF_MS = 30_000;
+
+function startsWithPartialBom(bytes) {
+  if (bytes.length >= UTF8_BOM.length) return false;
+  for (let index = 0; index < bytes.length; index += 1) {
+    if (bytes[index] !== UTF8_BOM[index]) return false;
+  }
+  return bytes.length > 0;
+}
+
+// Returns `event-stream` only after the prefix proves SSE framing, `other`
+// after it proves a different body shape, and `pending` while more bytes can
+// still settle the question. Leading BOM, comments, and blank dispatches are
+// valid SSE prelude and are intentionally handled before the first field.
+export function classifySsePrefix(value, { end = false } = {}) {
+  let bytes = Buffer.isBuffer(value) ? value : Buffer.from(value || "");
+  if (startsWithPartialBom(bytes)) return end ? "other" : "pending";
+  if (bytes.subarray(0, UTF8_BOM.length).equals(UTF8_BOM)) {
+    bytes = bytes.subarray(UTF8_BOM.length);
+  }
+
+  const text = bytes.toString("utf8");
+  let offset = 0;
+  while (offset < text.length) {
+    const nextCr = text.indexOf("\r", offset);
+    const nextLf = text.indexOf("\n", offset);
+    let newline;
+    if (nextCr === -1) newline = nextLf;
+    else if (nextLf === -1) newline = nextCr;
+    else newline = Math.min(nextCr, nextLf);
+    if (newline === -1) {
+      const line = text.slice(offset);
+      if (line.startsWith(":")) return "event-stream";
+      if (SSE_FIELDS.some((field) => line.startsWith(`${field}:`))) {
+        return "event-stream";
+      }
+      if (!end && SSE_FIELDS.some((field) => field.startsWith(line))) {
+        return "pending";
+      }
+      return end && SSE_FIELD.test(line) ? "event-stream" : "other";
+    }
+
+    const line = text.slice(offset, newline);
+    offset =
+      text[newline] === "\r" && text[newline + 1] === "\n"
+        ? newline + 2
+        : newline + 1;
+    if (!line) continue;
+    if (line.startsWith(":") || SSE_FIELD.test(line)) return "event-stream";
+    return "other";
+  }
+  return end ? "other" : "pending";
+}
+
+// Holds only the undecided prefix. Once framing is known, the exact buffered
+// bytes and any remainder are returned in order for the caller to process
+// normally. A body that cannot prove SSE within the byte limit falls back to
+// the non-SSE path rather than growing memory without bound.
+export class HeaderlessSseDetector {
+  #buffer = Buffer.alloc(0);
+  #decision;
+  #maxBytes;
+
+  constructor({ maxBytes = HEADERLESS_SSE_SNIFF_BYTES } = {}) {
+    this.#maxBytes =
+      Number.isInteger(maxBytes) && maxBytes >= 0
+        ? maxBytes
+        : HEADERLESS_SSE_SNIFF_BYTES;
+  }
+
+  write(chunk) {
+    const bytes = Buffer.from(chunk);
+    if (this.#decision) return { decision: this.#decision, chunks: [bytes] };
+
+    const capacity = Math.max(0, this.#maxBytes - this.#buffer.length);
+    const prefix = bytes.subarray(0, capacity);
+    const remainder = bytes.subarray(prefix.length);
+    if (prefix.length) {
+      this.#buffer = this.#buffer.length
+        ? Buffer.concat([this.#buffer, prefix])
+        : Buffer.from(prefix);
+    }
+    let decision = classifySsePrefix(this.#buffer);
+    if (
+      decision === "pending" &&
+      (this.#buffer.length >= this.#maxBytes || remainder.length)
+    ) {
+      decision = "other";
+    }
+    if (decision === "pending") return { decision, chunks: [] };
+    return this.#settle(decision, remainder);
+  }
+
+  end() {
+    if (this.#decision) return { decision: this.#decision, chunks: [] };
+    const decision = classifySsePrefix(this.#buffer, { end: true });
+    return this.#settle(decision === "event-stream" ? decision : "other");
+  }
+
+  #settle(decision, remainder = Buffer.alloc(0)) {
+    this.#decision = decision;
+    const chunks = [];
+    if (this.#buffer.length) chunks.push(this.#buffer);
+    if (remainder.length) chunks.push(Buffer.from(remainder));
+    this.#buffer = Buffer.alloc(0);
+    return { decision, chunks };
+  }
+}

package/vendor/codex-router/subagent-completion.js

@@ -0,0 +1,261 @@
+// Vendored from duolahypercho/codex-router at 63ec1f3602c28f2a28ccb7e9edaf7b4f7d191c6c.
+// Source: src/subagent-completion.js; MIT license in LICENSE.
+import { randomUUID } from "node:crypto";
+
+// Codex 0.147 keeps a finished child visually Working after FINAL_ANSWER while
+// the parent turn is still live. close_agent is not in the v2 toolset;
+// interrupt_agent is the only model-callable close path. Parents frequently
+// ignore the usage-hint text on long multi-agent turns (San Francisco is the
+// pathological case), so the router injects the missing interrupts itself.
+//
+// This module only decides *what* to inject. The response transform in
+// namespace-relay.js is what splices the calls into the stream without shifting
+// sequence numbers of model-authored items.
+
+const FINAL_ANSWER_HEADER =
+  /Message Type:\s*FINAL_ANSWER\b[\s\S]*?\nSender:\s*(\S+)/gi;
+const NATIVE_ENCRYPTED_TOKEN = /^gAAAAA[A-Za-z0-9_-]+={0,2}$/;
+
+// A close must always name a child. "/root" (and its bare and slashed forms)
+// is the parent itself, and interrupting it would cancel the turn that is
+// still running -- so a sender that resolves to the root is never a target.
+function isRootTarget(target) {
+  if (typeof target !== "string") return true;
+  const normalized = target.replace(/^\/+/, "").replace(/^root\/?/, "");
+  return normalized === "";
+}
+
+function contentPartsText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const part of content) {
+    if (!part || typeof part !== "object") continue;
+    if (
+      (part.type === "input_text" ||
+        part.type === "output_text" ||
+        part.type === "text") &&
+      typeof part.text === "string"
+    ) {
+      parts.push(part.text);
+      continue;
+    }
+    // Routed children store the plaintext handoff under encrypted_content when
+    // the parent never touched the native backend. Native Fernet tokens are
+    // skipped: we cannot read them, and they are not FINAL_ANSWER text.
+    if (
+      part.type === "encrypted_content" &&
+      typeof part.encrypted_content === "string" &&
+      part.encrypted_content.length > 0 &&
+      !NATIVE_ENCRYPTED_TOKEN.test(part.encrypted_content)
+    ) {
+      parts.push(part.encrypted_content);
+    }
+  }
+  return parts.join("");
+}
+
+function itemText(item) {
+  if (!item || typeof item !== "object") return "";
+  if (typeof item.content === "string") return item.content;
+  return contentPartsText(item.content);
+}
+
+export function extractFinalAnswerTargetsFromText(text) {
+  if (typeof text !== "string" || !text) return [];
+  const targets = [];
+  FINAL_ANSWER_HEADER.lastIndex = 0;
+  for (const match of text.matchAll(FINAL_ANSWER_HEADER)) {
+    const sender = match[1]?.trim();
+    if (sender) targets.push(sender);
+  }
+  return targets;
+}
+
+function targetsFromAgentMessage(item) {
+  if (item?.type !== "agent_message") return [];
+  const text = itemText(item);
+  const fromText = extractFinalAnswerTargetsFromText(text);
+  if (fromText.length) return fromText;
+  // Structured author is enough when the envelope declares FINAL_ANSWER, even
+  // if Sender was stripped during relay.
+  if (
+    typeof item.author === "string" &&
+    item.author &&
+    /Message Type:\s*FINAL_ANSWER\b/i.test(text)
+  ) {
+    return [item.author];
+  }
+  return [];
+}
+
+function parseFunctionCallArgs(item) {
+  if (typeof item?.arguments !== "string" || !item.arguments) return undefined;
+  try {
+    const args = JSON.parse(item.arguments);
+    if (args && typeof args === "object" && !Array.isArray(args)) return args;
+  } catch {
+    // Malformed arguments stay unparsed.
+  }
+  return undefined;
+}
+
+export function isInterruptAgentCall(item) {
+  if (!item || item.type !== "function_call") return false;
+  if (item.namespace === "collaboration" && item.name === "interrupt_agent") {
+    return true;
+  }
+  return item.name === "collaboration__interrupt_agent" || item.name === "interrupt_agent";
+}
+
+export function interruptTargetFromCall(item) {
+  if (!isInterruptAgentCall(item)) return undefined;
+  const args = parseFunctionCallArgs(item);
+  const target = args?.target;
+  return typeof target === "string" && target.trim() ? target.trim() : undefined;
+}
+
+export function collaborationToolAvailable(namespaces) {
+  if (!(namespaces instanceof Map)) return false;
+  const names = namespaces.get("collaboration");
+  return names instanceof Set && names.has("interrupt_agent");
+}
+
+// Walk the request input once. Returns every child that has already finished
+// (FINAL_ANSWER seen) and every child the parent has already interrupted, so
+// the response path only injects the missing closes.
+//
+// Evidence of a finished child comes from `agent_message` items only -- the
+// envelope type Codex uses for collaboration traffic on both the native and
+// routed paths. Ordinary `message` items are the operator's and the model's
+// own prose; scanning them meant a turn that merely *quoted* a FINAL_ANSWER
+// envelope (docs, a changelog, this very feature under discussion) had a
+// fabricated interrupt_agent call spliced into its response.
+export function collectFinishedSubagentState(input) {
+  const finished = new Set();
+  const interrupted = new Set();
+  if (!Array.isArray(input)) {
+    return { finished, interrupted, pending: [] };
+  }
+  for (const item of input) {
+    if (!item || typeof item !== "object") continue;
+    if (item.type === "function_call" || item.type === "custom_tool_call") {
+      const target = interruptTargetFromCall(item);
+      if (target) interrupted.add(target);
+      continue;
+    }
+    if (item.type === "agent_message") {
+      for (const target of targetsFromAgentMessage(item)) {
+        if (!isRootTarget(target)) finished.add(target);
+      }
+    }
+  }
+  const pending = [...finished].filter((target) => !interrupted.has(target));
+  return { finished, interrupted, pending };
+}
+
+export function pendingInterruptTargets(
+  input,
+  {
+    namespaces,
+    // Only enforce the tool check when the request actually advertised a
+    // non-empty inventory. Empty/unknown inventories (native deferred tools)
+    // still queue closes for finished children. That bypass is safe only
+    // because detection is scoped to `agent_message` envelopes: an ordinary
+    // turn cannot contain one, so an empty inventory plus quoted envelope
+    // text can no longer manufacture an interrupt.
+    requireCollaborationTool = namespaces instanceof Map && namespaces.size > 0,
+  } = {},
+) {
+  if (
+    requireCollaborationTool &&
+    namespaces &&
+    !collaborationToolAvailable(namespaces)
+  ) {
+    return [];
+  }
+  return collectFinishedSubagentState(input).pending;
+}
+
+function sameTarget(a, b) {
+  if (a === b) return true;
+  if (typeof a !== "string" || typeof b !== "string") return false;
+  // Codex accepts both "/root/child" and "child" forms for interrupt_agent.
+  const normalize = (value) => value.replace(/^\/+/, "").replace(/^root\//, "");
+  return normalize(a) === normalize(b);
+}
+
+export function filterAlreadyInterrupted(pending, interruptedTargets) {
+  if (!Array.isArray(pending) || pending.length === 0) return [];
+  if (!interruptedTargets || interruptedTargets.size === 0) return [...pending];
+  return pending.filter(
+    (target) => ![...interruptedTargets].some((done) => sameTarget(done, target)),
+  );
+}
+
+export function buildInterruptAgentCall(target, { callId, flattened = false } = {}) {
+  if (typeof target !== "string" || !target.trim()) {
+    throw new Error("interrupt_agent target is required");
+  }
+  const id =
+    typeof callId === "string" && callId
+      ? callId
+      : `call_router_interrupt_${randomUUID().replaceAll("-", "")}`;
+  if (flattened) {
+    return {
+      type: "function_call",
+      name: "collaboration__interrupt_agent",
+      call_id: id,
+      arguments: JSON.stringify({ target }),
+    };
+  }
+  return {
+    type: "function_call",
+    name: "interrupt_agent",
+    namespace: "collaboration",
+    call_id: id,
+    arguments: JSON.stringify({ target }),
+  };
+}
+
+// Build the SSE events for one injected interrupt. Sequence numbers are filled
+// by the stream transform once it knows the last model-emitted sequence.
+export function interruptAgentSseEvents(target, { callId, sequenceStart = 1 } = {}) {
+  const item = buildInterruptAgentCall(target, { callId, flattened: false });
+  const addedSeq = sequenceStart;
+  const doneSeq = sequenceStart + 1;
+  return [
+    {
+      event: "response.output_item.added",
+      data: {
+        type: "response.output_item.added",
+        sequence_number: addedSeq,
+        item: {
+          type: "function_call",
+          name: item.name,
+          namespace: item.namespace,
+          call_id: item.call_id,
+          arguments: "",
+        },
+      },
+    },
+    {
+      event: "response.output_item.done",
+      data: {
+        type: "response.output_item.done",
+        sequence_number: doneSeq,
+        item: {
+          type: "function_call",
+          name: item.name,
+          namespace: item.namespace,
+          call_id: item.call_id,
+          arguments: item.arguments,
+        },
+      },
+    },
+  ];
+}
+
+export function formatSseBlock(eventName, data) {
+  return `event: ${eventName}\ndata: ${JSON.stringify(data)}\n\n`;
+}

package/vendor/codex-router/tool-arguments.js

@@ -0,0 +1,111 @@
+// Vendored from duolahypercho/codex-router at 63ec1f3602c28f2a28ccb7e9edaf7b4f7d191c6c.
+// Source: src/tool-arguments.js; MIT license in LICENSE.
+// Codex tool schemas use integer/u64 fields. Some routed models (Grok in
+// particular) emit whole numbers as JSON floats (`20000.0`). Serde then
+// rejects the call before the tool runs.
+//
+// JSON.parse cannot see the difference between 20000 and 20000.0, so this
+// rewrites number tokens in the raw argument string.
+
+const JSON_NUMBER = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/;
+const JSON_NUMBER_PARTS = /^(-)?(0|[1-9]\d*)(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/;
+const PLAIN_INTEGER = /^-?(?:0|[1-9]\d*)$/;
+
+// Decide integrality from the token spelling. JS Number rounds 1e-324 to 0
+// and cannot represent every u64, so it must not be the judge.
+function integerSpelling(token) {
+  const parts = token.match(JSON_NUMBER_PARTS);
+  if (!parts) return undefined;
+  const sign = parts[1] || "";
+  const intPart = parts[2];
+  const fracPart = parts[3] || "";
+  const exp = parts[4] === undefined ? 0 : Number.parseInt(parts[4], 10);
+  if (!Number.isSafeInteger(exp)) return undefined;
+  const digits = intPart + fracPart;
+  const point = intPart.length + exp;
+  if (point > 40) return undefined;
+  for (let i = Math.max(0, point); i < digits.length; i += 1) {
+    if (digits[i] !== "0") return undefined;
+  }
+  let integerDigits;
+  if (point <= 0) integerDigits = "0";
+  else if (point >= digits.length) integerDigits = digits + "0".repeat(point - digits.length);
+  else integerDigits = digits.slice(0, point);
+  integerDigits = integerDigits.replace(/^0+(?=\d)/, "") || "0";
+  if (integerDigits === "0") return "0";
+  return `${sign}${integerDigits}`;
+}
+
+function integerToken(token) {
+  if (PLAIN_INTEGER.test(token) && token !== "-0") return token;
+  return integerSpelling(token) ?? token;
+}
+
+export function rewriteWholeNumberTokens(raw) {
+  if (typeof raw !== "string" || raw.length === 0) return raw;
+  let out = "";
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < raw.length; ) {
+    const ch = raw[i];
+    if (inString) {
+      out += ch;
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      i += 1;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      out += ch;
+      i += 1;
+      continue;
+    }
+    if (ch === "-" || (ch >= "0" && ch <= "9")) {
+      const match = raw.slice(i).match(JSON_NUMBER);
+      if (match) {
+        out += integerToken(match[0]);
+        i += match[0].length;
+        continue;
+      }
+    }
+    out += ch;
+    i += 1;
+  }
+  return out;
+}
+
+export function coerceWholeNumberJson(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => coerceWholeNumberJson(entry));
+  }
+  if (!value || typeof value !== "object") {
+    if (typeof value === "number" && Number.isSafeInteger(value)) {
+      return Object.is(value, -0) ? 0 : value;
+    }
+    return value;
+  }
+  const next = {};
+  for (const [key, entry] of Object.entries(value)) {
+    next[key] = coerceWholeNumberJson(entry);
+  }
+  return next;
+}
+
+export function coerceFunctionCallArguments(raw) {
+  if (typeof raw !== "string") return raw;
+  try {
+    JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+  const rewritten = rewriteWholeNumberTokens(raw);
+  if (rewritten === raw) return raw;
+  try {
+    JSON.parse(rewritten);
+  } catch {
+    return raw;
+  }
+  return rewritten;
+}