@opengeni/codex 0.2.10 → 0.2.13

package/dist/mcp-sanitize.d.ts

@@ -25,9 +25,10 @@ export declare function remapToolCallRequestBody(body: string, mapper: ToolNameM
  * to the MCP server's original. Only the POST request/response is buffered; the
  * long-lived GET notification SSE stream is passed through untouched.
  *
- * P4 (Part B.1): an optional `namespaceSink` Set accumulates the ORIGINAL-dotted
+ * An optional `namespaceSink` Set accumulates the ORIGINAL-dotted
  * connector namespaces seen across every tools/list this turn (captured before the
- * dot is sanitized away). The worker reads the (live, by-reference) Set after the
- * turn to cache the serving account's connector set — packages/codex stays db-free.
+ * dot is sanitized away). The runtime reads the live by-reference Set only to keep
+ * this turn's `tool_search` description accurate; it is never persisted or used
+ * for inference selection.
  */
 export declare function codexAppsSanitizingFetch(base?: FetchLike, namespaceSink?: Set<string>): FetchLike;

package/dist/opaque-artifact.d.ts

@@ -0,0 +1,4 @@
+/** Stable, content-hiding identity for one opaque provider artifact. */
+export declare function opaqueProviderArtifactFingerprint(item: unknown): string | null;
+/** Exact opaque artifacts present in one normalized provider input array. */
+export declare function opaqueProviderArtifactFingerprints(input: unknown): string[];

package/dist/request-context.d.ts

@@ -49,6 +49,10 @@ export type CodexModelRequestEvent = {
     status?: number;
     willRetry?: boolean;
 };
+export type CodexRequestOpaqueArtifacts = {
+    requestId: string;
+    fingerprints: readonly string[];
+};
 export type CodexRequestContext = {
     clientVersion: string;
     /**
@@ -81,6 +85,8 @@ export type CodexRequestContext = {
     responseTimeoutPolicy?: Partial<CodexResponseTimeoutPolicy>;
     /** Worker-owned durable audit sink; payloads never contain request bodies or auth. */
     onModelRequestEvent?: (event: CodexModelRequestEvent) => Promise<void> | void;
+    /** Exact opaque artifacts on the normalized wire request, never their ciphertext. */
+    onRequestOpaqueArtifacts?: (artifacts: CodexRequestOpaqueArtifacts) => void;
     /** Stable request identity supplied by the owning durable execution. */
     nextRequestId?: () => string;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/codex",
-  "version": "0.2.10",
+  "version": "0.2.13",
   "description": "ChatGPT/Codex subscription auth + transport: device-code login, token refresh, and the Responses-backend fetch. Pure HTTP + transforms; no database dependency.",
   "license": "Apache-2.0",
   "repository": {

package/src/fetch.ts

@@ -13,6 +13,7 @@
 import { randomUUID } from "node:crypto";
 import { CODEX_ORIGINATOR } from "./constants";
 import { normalizeCodexRequestBody } from "./normalize";
+import { opaqueProviderArtifactFingerprints } from "./opaque-artifact";
 import {
   codexRequestStorage,
   type CodexModelRequestEvent,
@@ -489,6 +490,7 @@ export function codexSubscriptionFetch(base: FetchLike = globalThis.fetch): Fetc
       // summarizer) still gets a single JSON Response back.
       let callerWantsStream = true;
       let model: string | undefined;
+      let requestOpaqueArtifacts: string[] = [];
       const nextInit: RequestInit = { ...init, headers };
       if (typeof init?.body === "string") {
         try {
@@ -497,26 +499,23 @@ export function codexSubscriptionFetch(base: FetchLike = globalThis.fetch): Fetc
           const normalized = normalizeCodexRequestBody(parsed, ctx.resolveModel);
           model = typeof normalized.model === "string" ? normalized.model : undefined;
           nextInit.body = JSON.stringify(normalized);
+          requestOpaqueArtifacts = opaqueProviderArtifactFingerprints(normalized.input);
         } catch {
           /* leave unparseable bodies untouched (already copied from init) */
         }
       }
+      ctx.onRequestOpaqueArtifacts?.({ requestId, fingerprints: requestOpaqueArtifacts });
       headers.set(
         "Idempotency-Key",
         authenticationAttempt === 0 ? requestId : `${requestId}:auth-${authenticationAttempt}`,
       );
       if (process.env.CODEX_DEBUG) {
-        let keys: string[] = [];
-        if (typeof nextInit.body === "string") {
-          try {
-            keys = Object.keys(JSON.parse(nextInit.body) as Record<string, unknown>);
-          } catch {
-            /* an unparseable body is already passed through unchanged above */
-          }
-        }
-        console.error(
-          `[codex-debug] POST ${rewritten} stream=${callerWantsStream} bodyKeys=[${keys.join(",")}]`,
-        );
+        console.error("[codex-debug] request dispatched", {
+          method: "POST",
+          origin: "codex-subscription",
+          route: "codex_responses",
+          stream: callerWantsStream,
+        });
       }
       let res: Response;
       transportAttempt += 1;
@@ -583,12 +582,13 @@ export function codexSubscriptionFetch(base: FetchLike = globalThis.fetch): Fetc
         ctx.onUsageHeaders?.(usage);
       }
       if (process.env.CODEX_DEBUG && !res.ok) {
-        // Never log provider bodies: they can contain request-derived content or
-        // account details. Status + request id is sufficient to correlate with
-        // the structured worker failure telemetry.
-        console.error(
-          `[codex-debug] <- ${res.status} requestId=${res.headers.get("x-request-id") ?? "unknown"}`,
-        );
+        // Never log provider bodies, identifiers, or headers: they can contain
+        // request-derived or account content. A bounded status is sufficient.
+        console.error("[codex-debug] request failed", {
+          origin: "codex-subscription",
+          route: "codex_responses",
+          status: res.status,
+        });
       }
       // The codex backend leaves the terminal event's response.output empty and
       // delivers the assistant items via output_item.done events instead. The
@@ -1012,9 +1012,9 @@ function codexSseFailureProjection(
  * A provider terminal carried inside an accepted HTTP-200 stream. The OpenAI
  * SDK cannot turn that late terminal into a non-2xx APIError because headers
  * have already been accepted, so the body transform throws this equivalent
- * bounded shape. Provider-supplied message/param text is intentionally absent:
- * the worker may persist Error.message, while identifiers/classifications are
- * sufficient for retry, compaction, and incident diagnostics.
+ * bounded shape. Provider-supplied message/param text remains exact within the
+ * explicit terminal-field byte contract; retry classification is additive and
+ * never substitutes for the source diagnostic.
  */
 export class CodexStreamingTerminalError extends Error {
   readonly status: number;
@@ -1026,8 +1026,8 @@ export class CodexStreamingTerminalError extends Error {
   readonly headers: Headers;
   readonly error: Record<string, unknown>;
 
-  constructor(projection: CodexSseFailureProjection, publicMessage: string) {
-    super(publicMessage);
+  constructor(projection: CodexSseFailureProjection) {
+    super(projection.error.message);
     this.name = "CodexStreamingTerminalError";
     this.status = projection.status;
     this.code = projection.error.code;
@@ -1045,6 +1045,8 @@ export class CodexStreamingTerminalError extends Error {
     this.error = {
       type: projection.error.type,
       code: projection.error.code,
+      message: projection.error.message,
+      ...(projection.error.param ? { param: projection.error.param } : {}),
       ...(projection.error.event_type ? { event_type: projection.error.event_type } : {}),
       ...(projection.error.response_id ? { response_id: projection.error.response_id } : {}),
       ...(projection.error.response_status
@@ -1068,7 +1070,6 @@ function codexSseFailureError(
 ): CodexStreamingTerminalError {
   return new CodexStreamingTerminalError(
     codexSseFailureProjection(source, rawError, fallbackCode, publicMessage, metadata),
-    publicMessage,
   );
 }
 

package/src/index.ts

@@ -11,5 +11,6 @@ export * from "./response-timeout";
 export * from "./fetch";
 export * from "./mcp-sanitize";
 export * from "./model-output-truncation";
+export * from "./opaque-artifact";
 export * from "./realtime";
 export * from "./realtime-v3";

package/src/mcp-sanitize.ts

@@ -105,7 +105,7 @@ export class ToolNameMapper {
 /**
  * Drop bad outputSchemas + sanitize tool names on a JSON-RPC tools/list result, in place.
  *
- * P4 (Part B.1): when `namespaceSink` is provided, accumulate each tool's ORIGINAL
+ * When `namespaceSink` is provided, accumulate each tool's ORIGINAL
  * connector namespace (the segment BEFORE the first dot, e.g. `github` from
  * `github.create_issue`) into it — captured HERE because this pass sees the original
  * dotted name BEFORE mapper.sanitize rewrites the dot away. Only dotted names carry a
@@ -169,8 +169,10 @@ function sanitizeToolsInRpcMessage(
  * leaving the original content untouched.
  *
  * No-op when there is no `structuredContent` — so a tools/list response (or any
- * result without it) passes through unchanged. Runs alongside (after) the empty
- * outputSchema drop, which is what stops the MCP SDK -32602ing this same result.
+ * result without it) passes through unchanged. Valid object payloads stay intact
+ * for protocol-aware consumers. Invalid optional values (such as null) are removed
+ * after any useful value is copied into `content`, because the MCP client validates
+ * this field as an object before the tool can return. Runs after the outputSchema drop.
  */
 function inlineStructuredContentInRpcMessage(message: unknown): void {
   if (!message || typeof message !== "object") {
@@ -185,13 +187,15 @@ function inlineStructuredContentInRpcMessage(message: unknown): void {
     return;
   }
   const structured = record.structuredContent;
-  if (structured === undefined || structured === null) {
-    return;
+  if (structured !== undefined && structured !== null) {
+    const text = typeof structured === "string" ? structured : JSON.stringify(structured);
+    const content = Array.isArray(record.content) ? [...record.content] : [];
+    content.push({ type: "text", text });
+    record.content = content;
+  }
+  if (typeof structured !== "object" || structured === null || Array.isArray(structured)) {
+    delete record.structuredContent;
   }
-  const text = typeof structured === "string" ? structured : JSON.stringify(structured);
-  const content = Array.isArray(record.content) ? [...record.content] : [];
-  content.push({ type: "text", text });
-  record.content = content;
 }
 
 /** Sanitize a single JSON body (application/json MCP response). */
@@ -264,10 +268,11 @@ export function remapToolCallRequestBody(body: string, mapper: ToolNameMapper):
  * to the MCP server's original. Only the POST request/response is buffered; the
  * long-lived GET notification SSE stream is passed through untouched.
  *
- * P4 (Part B.1): an optional `namespaceSink` Set accumulates the ORIGINAL-dotted
+ * An optional `namespaceSink` Set accumulates the ORIGINAL-dotted
  * connector namespaces seen across every tools/list this turn (captured before the
- * dot is sanitized away). The worker reads the (live, by-reference) Set after the
- * turn to cache the serving account's connector set — packages/codex stays db-free.
+ * dot is sanitized away). The runtime reads the live by-reference Set only to keep
+ * this turn's `tool_search` description accurate; it is never persisted or used
+ * for inference selection.
  */
 export function codexAppsSanitizingFetch(
   base: FetchLike = globalThis.fetch,

package/src/normalize.ts

@@ -69,7 +69,7 @@ export function normalizeCodexRequestBody(
   // strip every item id; PRESERVE call_id. spec §1.6 / verdict §0(b)
   // (This also covers tool_search items: the backend accepts an id-less
   // tool_search_call/output pair correlated by call_id — verified live — and
-  // stripping the account-bound `tsc_…` id here sanitizes BOTH replay paths.)
+  // stripping the provider-stored `tsc_…` id here sanitizes BOTH replay paths.)
   if (Array.isArray(body.input)) {
     for (const item of body.input as unknown[]) {
       if (!item || typeof item !== "object") {

package/src/opaque-artifact.ts

@@ -0,0 +1,29 @@
+import { createHash } from "node:crypto";
+
+/** Stable, content-hiding identity for one opaque provider artifact. */
+export function opaqueProviderArtifactFingerprint(item: unknown): string | null {
+  if (!item || typeof item !== "object") return null;
+  const record = item as Record<string, unknown>;
+  if (record.type !== "reasoning" && record.type !== "compaction") return null;
+  const providerData =
+    record.providerData && typeof record.providerData === "object"
+      ? (record.providerData as Record<string, unknown>)
+      : null;
+  const ciphertext =
+    (typeof record.encrypted_content === "string" && record.encrypted_content) ||
+    (typeof record.encryptedContent === "string" && record.encryptedContent) ||
+    (typeof providerData?.encrypted_content === "string" && providerData.encrypted_content) ||
+    (typeof providerData?.encryptedContent === "string" && providerData.encryptedContent) ||
+    null;
+  if (!ciphertext) return null;
+  return `${record.type}:${createHash("sha256").update(ciphertext).digest("hex")}`;
+}
+
+/** Exact opaque artifacts present in one normalized provider input array. */
+export function opaqueProviderArtifactFingerprints(input: unknown): string[] {
+  if (!Array.isArray(input)) return [];
+  return input.flatMap((item) => {
+    const fingerprint = opaqueProviderArtifactFingerprint(item);
+    return fingerprint ? [fingerprint] : [];
+  });
+}

package/src/request-context.ts

@@ -62,6 +62,11 @@ export type CodexModelRequestEvent = {
   willRetry?: boolean;
 };
 
+export type CodexRequestOpaqueArtifacts = {
+  requestId: string;
+  fingerprints: readonly string[];
+};
+
 export type CodexRequestContext = {
   clientVersion: string;
   /**
@@ -94,6 +99,8 @@ export type CodexRequestContext = {
   responseTimeoutPolicy?: Partial<CodexResponseTimeoutPolicy>;
   /** Worker-owned durable audit sink; payloads never contain request bodies or auth. */
   onModelRequestEvent?: (event: CodexModelRequestEvent) => Promise<void> | void;
+  /** Exact opaque artifacts on the normalized wire request, never their ciphertext. */
+  onRequestOpaqueArtifacts?: (artifacts: CodexRequestOpaqueArtifacts) => void;
   /** Stable request identity supplied by the owning durable execution. */
   nextRequestId?: () => string;
   /**