codex-multi-auth 2.17.0 → 2.17.3

package/dist/lib/request/helpers/tool-utils.d.ts

@@ -13,4 +13,3 @@ import type { RequestToolDefinition } from "../../types.js";
  * @returns Cleaned array of tool definitions
  */
 export declare function cleanupToolDefinitions(tools: RequestToolDefinition[] | undefined): RequestToolDefinition[] | undefined;
-//# sourceMappingURL=tool-utils.d.ts.map

package/dist/lib/request/helpers/tool-utils.js

@@ -1,7 +1,393 @@
 import { isRecord } from "../../utils.js";
+const hasOwn = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
 function cloneRecord(value) {
     return JSON.parse(JSON.stringify(value));
 }
+/**
+ * Defines an own enumerable property on a clone output object. A plain
+ * `clone["__proto__"] = v` assignment would silently rewrite the clone's
+ * prototype instead of creating the own property `JSON.parse` produces.
+ */
+const setCloneProp = (out, key, child) => {
+    if (key === "__proto__") {
+        Object.defineProperty(out, key, {
+            value: child,
+            writable: true,
+            enumerable: true,
+            configurable: true,
+        });
+    }
+    else {
+        out[key] = child;
+    }
+};
+/**
+ * Deep-clones a tree already proven to be plain JSON data by
+ * {@link inspectSchema}. Produces the same result as
+ * `JSON.parse(JSON.stringify(value))` for that input class without building
+ * an intermediate string.
+ */
+function clonePlainValue(value) {
+    if (value === null || typeof value !== "object")
+        return value;
+    if (Array.isArray(value)) {
+        const clone = new Array(value.length);
+        for (let i = 0; i < value.length; i++) {
+            clone[i] = clonePlainValue(value[i]);
+        }
+        return clone;
+    }
+    const clone = {};
+    for (const key of Object.keys(value)) {
+        setCloneProp(clone, key, clonePlainValue(value[key]));
+    }
+    return clone;
+}
+/**
+ * Values that are schema nodes (a `properties` entry, an `items` schema) get
+ * the fused clone+clean; everything else is a plain JSON clone. Mirrors
+ * cleanupSchema only recursing through `properties` values and `items`.
+ */
+function cloneSchemaChild(value) {
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+        return cloneAndCleanSchema(value);
+    }
+    return clonePlainValue(value);
+}
+function clonePropertiesMap(rawProps) {
+    if (Array.isArray(rawProps)) {
+        const out = new Array(rawProps.length);
+        for (let i = 0; i < rawProps.length; i++) {
+            out[i] = cloneSchemaChild(rawProps[i]);
+        }
+        return out;
+    }
+    const out = {};
+    for (const key of Object.keys(rawProps)) {
+        setCloneProp(out, key, cloneSchemaChild(rawProps[key]));
+    }
+    return out;
+}
+/**
+ * The node-local half of {@link cleanupSchema}: steps 1-4 plus the unsupported
+ * keyword drops (step 5). Step 0 (undefined `properties` values) is skipped
+ * because this only runs on trees {@link inspectSchema} verified contain no
+ * `undefined` values. Child recursion is already done by the fused clone.
+ */
+function applySchemaTransforms(out) {
+    // 1. Flatten Unions (anyOf -> enum)
+    if (Array.isArray(out.anyOf)) {
+        const anyOf = out.anyOf;
+        const allConst = anyOf.every((opt) => "const" in opt);
+        if (allConst && anyOf.length > 0) {
+            const enumValues = anyOf.map((opt) => opt.const);
+            out.enum = enumValues;
+            delete out.anyOf;
+            if (!out.type) {
+                const firstVal = enumValues[0];
+                if (typeof firstVal === "string")
+                    out.type = "string";
+                else if (typeof firstVal === "number")
+                    out.type = "number";
+                else if (typeof firstVal === "boolean")
+                    out.type = "boolean";
+            }
+        }
+    }
+    // 2. Flatten Nullable Types (["string", "null"] -> "string")
+    if (Array.isArray(out.type)) {
+        const types = out.type;
+        const isNullable = types.includes("null");
+        const nonNullTypes = types.filter((t) => t !== "null");
+        if (nonNullTypes.length > 0) {
+            out.type = nonNullTypes[0];
+            if (isNullable) {
+                const desc = out.description || "";
+                if (!desc.toLowerCase().includes("nullable")) {
+                    out.description = desc ? `${desc} (nullable)` : "(nullable)";
+                }
+            }
+        }
+    }
+    // 3. Filter 'required' array
+    if (Array.isArray(out.required) &&
+        out.properties &&
+        typeof out.properties === "object") {
+        const properties = out.properties;
+        const required = out.required;
+        const validRequired = required.filter((key) => hasOwn(properties, key));
+        if (validRequired.length === 0) {
+            delete out.required;
+        }
+        else if (validRequired.length !== required.length) {
+            out.required = validRequired;
+        }
+    }
+    // 4. Handle empty object parameters
+    if (out.type === "object" &&
+        (!out.properties || Object.keys(out.properties).length === 0)) {
+        out.properties = {
+            _placeholder: {
+                type: "boolean",
+                description: "This property is a placeholder and should be ignored.",
+            },
+        };
+    }
+}
+/**
+ * Fused clone+clean: produces exactly `cleanupSchema(JSON.clone(node))` in a
+ * single pass for trees {@link inspectSchema} verified as plain JSON data.
+ * The unsupported keywords are dropped during the key copy (equivalent to
+ * step-5 deletes); node-level rewrites then run in cleanupSchema's order, and
+ * they never observe child-cleaned state, so children can be cleaned eagerly
+ * while copying.
+ */
+function cloneAndCleanSchema(node) {
+    const out = {};
+    for (const key of Object.keys(node)) {
+        // Read once — and before the keyword skip — exactly like
+        // JSON.stringify reads every enumerable value: a throwing get trap on
+        // a dropped keyword must still fail (and fall back) here.
+        const value = node[key];
+        if (key === "additionalProperties" ||
+            key === "const" ||
+            key === "title" ||
+            key === "$schema") {
+            continue;
+        }
+        if (key === "properties" && value !== null && typeof value === "object") {
+            setCloneProp(out, key, clonePropertiesMap(value));
+        }
+        else if (key === "items" && value !== null && typeof value === "object") {
+            setCloneProp(out, key, cloneSchemaChild(value));
+        }
+        else {
+            setCloneProp(out, key, clonePlainValue(value));
+        }
+    }
+    applySchemaTransforms(out);
+    return out;
+}
+/**
+ * Read-only mirror of {@link cleanupSchema}'s mutation conditions at a single
+ * schema node. Mirrors the same short-circuit cascade: a node counts as dirty
+ * iff cleanupSchema would delete, inject, or rewrite anything on it.
+ * Recursion into `properties`/`items` is handled by {@link inspectSchema}.
+ */
+function schemaWouldChange(schema) {
+    const rawProps = schema.properties;
+    const propsObject = !!rawProps && typeof rawProps === "object";
+    // Step 0/3/4 helper state: own enumerable `properties` keys with a defined
+    // value — exactly the keys the cleaned clone still has after the
+    // undefined-value deletions (non-enumerable keys never survive the clone).
+    const definedPropKeys = propsObject ? new Set() : null;
+    if (definedPropKeys !== null) {
+        for (const key of Object.keys(rawProps)) {
+            if (rawProps[key] === undefined) {
+                return true;
+            }
+            definedPropKeys.add(key);
+        }
+    }
+    // 1. anyOf of all-`const` options flattens into `enum`.
+    if (Array.isArray(schema.anyOf) &&
+        schema.anyOf.length > 0 &&
+        schema.anyOf.every((opt) => "const" in opt)) {
+        return true;
+    }
+    // 2. A type array holding at least one non-"null" member collapses.
+    if (Array.isArray(schema.type)) {
+        for (const member of schema.type) {
+            if (member !== "null")
+                return true;
+        }
+    }
+    // 3. `required` is rewritten when any entry is not a surviving property
+    // key (evaluated after the step-0 undefined deletions).
+    if (Array.isArray(schema.required) &&
+        propsObject &&
+        definedPropKeys !== null) {
+        let valid = 0;
+        for (const key of schema.required) {
+            // hasOwnProperty coerces non-string entries; mirror that for the Set lookup.
+            if (definedPropKeys.has(typeof key === "string" ? key : String(key))) {
+                valid += 1;
+            }
+        }
+        // cleanupSchema deletes `required` whenever zero entries survive —
+        // including an empty `required: []`, which is a mutation, not a no-op.
+        if (valid === 0 || valid !== schema.required.length)
+            return true;
+    }
+    // 4. `type: "object"` with no surviving properties gains a placeholder.
+    // Only reachable when step 2 left `type` as a non-array.
+    if (schema.type === "object") {
+        const empty = !rawProps
+            ? true
+            : propsObject && definedPropKeys !== null
+                ? definedPropKeys.size === 0
+                : Object.keys(rawProps).length === 0;
+        if (empty)
+            return true;
+    }
+    // 5. Unsupported keywords are deleted unconditionally.
+    if (hasOwn(schema, "additionalProperties") ||
+        hasOwn(schema, "const") ||
+        hasOwn(schema, "title") ||
+        hasOwn(schema, "$schema")) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Walks a parameters schema once, answering two questions at the same time:
+ *
+ * - `needsCleanup`: would {@link cleanupSchema} mutate anything? Mirrors its
+ *   traversal (schema nodes are the root, `properties` values, and `items`).
+ * - `jsonSerializable`: is the tree plain JSON data such that
+ *   `JSON.parse(JSON.stringify(tree))` is the identity transform on values?
+ *   Anything the round-trip would rewrite or reject (cycles, bigint,
+ *   `undefined` properties, `toJSON` hooks, exotic prototypes, sparse arrays,
+ *   non-finite numbers) makes cleanup semantics depend on the actual clone,
+ *   so such trees must stay on the legacy path for identical results.
+ */
+// Legitimate JSON Schemas are never this deep; deeper nesting means either a
+// cycle (JSON.stringify would throw) or a pathological tree the legacy path
+// can evaluate correctly. Bounding the walk keeps cycle detection free.
+const MAX_SCHEMA_DEPTH = 512;
+function inspectSchema(root) {
+    let jsonSerializable = true;
+    // Mode-1 schema nodes are collected during the walk but only evaluated
+    // afterwards: schemaWouldChange reads one level into children
+    // (properties values, required/type/anyOf elements), which is only safe
+    // once the whole tree is verified free of accessors.
+    const schemaNodes = [];
+    // mode 0: not a schema node (walked only for serializability)
+    // mode 1: schema node (root / properties values / items)
+    // mode 2: properties container (its VALUES are schema nodes)
+    const walk = (value, mode, depth) => {
+        if (!jsonSerializable)
+            return;
+        if (value === null || typeof value === "string" || typeof value === "boolean") {
+            return;
+        }
+        if (typeof value === "number") {
+            // JSON.stringify emits non-finite numbers (and -0) differently.
+            if (!Number.isFinite(value) || Object.is(value, -0)) {
+                jsonSerializable = false;
+            }
+            return;
+        }
+        if (typeof value !== "object" || depth > MAX_SCHEMA_DEPTH) {
+            // bigint/symbol/function/undefined: JSON.stringify throws or drops.
+            // Over-depth: cycle or pathological nesting — stay on legacy path.
+            jsonSerializable = false;
+            return;
+        }
+        const isArr = Array.isArray(value);
+        const proto = Object.getPrototypeOf(value);
+        if (isArr
+            ? proto !== Array.prototype
+            : proto !== Object.prototype && proto !== null) {
+            jsonSerializable = false;
+            return;
+        }
+        // ownKeys covers non-enumerable + symbol keys that JSON.stringify and
+        // the fast clone both skip; extra own keys mean the views diverge.
+        const ownKeyCount = Reflect.ownKeys(value).length;
+        // Values are read through property descriptors so accessors are never
+        // invoked: a getter is stateful — it can return a different value than
+        // the single read JSON.stringify performs, or throw on a later call —
+        // so any accessor (or a descriptor a proxy withholds) routes the tree
+        // to the legacy path before any getter can run.
+        const descs = Object.getOwnPropertyDescriptors(value);
+        if (isArr) {
+            // Arrays own `length` plus their indices; sparse slots or extra
+            // named keys serialize differently.
+            if (ownKeyCount !== value.length + 1) {
+                jsonSerializable = false;
+                return;
+            }
+            // An array used as a `properties` map has its elements cleaned as
+            // schemas by cleanupSchema's `for key in props` recursion.
+            const childMode = mode === 2 ? 1 : 0;
+            for (let i = 0; i < value.length; i++) {
+                const desc = descs[i];
+                if (!desc || "get" in desc || "set" in desc) {
+                    jsonSerializable = false;
+                    return;
+                }
+                const child = desc.value;
+                if (child === undefined) {
+                    // JSON.stringify rewrites undefined array elements to null.
+                    jsonSerializable = false;
+                    return;
+                }
+                walk(child, childMode, depth + 1);
+                if (!jsonSerializable)
+                    return;
+            }
+        }
+        else {
+            const keys = Object.keys(value);
+            if (ownKeyCount !== keys.length) {
+                jsonSerializable = false;
+                return;
+            }
+            const childKeys = [];
+            const childValues = [];
+            for (const key of keys) {
+                const desc = descs[key];
+                if (!desc || "get" in desc || "set" in desc) {
+                    jsonSerializable = false;
+                    return;
+                }
+                childKeys.push(key);
+                childValues.push(desc.value);
+            }
+            if (typeof value.toJSON === "function") {
+                // JSON.stringify would call it and serialize the result instead.
+                jsonSerializable = false;
+                return;
+            }
+            if (mode === 1) {
+                schemaNodes.push(value);
+            }
+            for (const [i, key] of childKeys.entries()) {
+                const child = childValues[i];
+                if (child === undefined) {
+                    // JSON.stringify drops undefined-valued keys entirely.
+                    jsonSerializable = false;
+                    return;
+                }
+                walk(child, childSchemaMode(mode, key), depth + 1);
+                if (!jsonSerializable)
+                    return;
+            }
+        }
+    };
+    walk(root, 1, 0);
+    if (!jsonSerializable) {
+        return { needsCleanup: false, jsonSerializable };
+    }
+    for (const node of schemaNodes) {
+        if (schemaWouldChange(node)) {
+            return { needsCleanup: true, jsonSerializable };
+        }
+    }
+    return { needsCleanup: false, jsonSerializable };
+}
+function childSchemaMode(mode, key) {
+    if (mode === 2)
+        return 1;
+    if (mode === 1) {
+        if (key === "properties")
+            return 2;
+        if (key === "items")
+            return 1;
+    }
+    return 0;
+}
 /**
  * Cleans up tool definitions to ensure strict JSON Schema compliance.
  *
@@ -44,15 +430,46 @@ function cleanupFunctionTool(tool) {
     if (!isRecord(parameters)) {
         return tool;
     }
-    // Clone only the schema tree we mutate to avoid heavy deep cloning of entire tools.
-    let cleanedParameters;
+    // Read-only pre-check: a schema that needs no cleanup skips the deep clone
+    // entirely. The check also verifies the tree is plain JSON data, because
+    // clone semantics (and therefore cleanup outcomes) only differ from
+    // observable behavior on inputs JSON.stringify would rewrite or reject.
+    // Any failure here just falls back to the exact legacy path.
+    let inspection = null;
     try {
-        cleanedParameters = cloneRecord(parameters);
+        inspection = inspectSchema(parameters);
     }
     catch {
+        inspection = null;
+    }
+    if (inspection?.jsonSerializable && !inspection.needsCleanup) {
         return tool;
     }
-    cleanupSchema(cleanedParameters);
+    // Clone only the schema tree we mutate to avoid heavy deep cloning of entire tools.
+    // Verified-JSON trees get the fused single-pass clone+clean; everything
+    // else keeps the exact JSON round-trip + in-place cleanup so throw/rewrite
+    // semantics on exotic inputs stay identical. If the fused pass still hits a
+    // value that lies about being plain data (e.g. a proxy whose get trap throws
+    // after reporting data descriptors), retry through the legacy clone rather
+    // than adding a new failure mode — the input tree is never mutated.
+    let cleanedParameters = null;
+    if (inspection?.jsonSerializable) {
+        try {
+            cleanedParameters = cloneAndCleanSchema(parameters);
+        }
+        catch {
+            cleanedParameters = null;
+        }
+    }
+    if (cleanedParameters === null) {
+        try {
+            cleanedParameters = cloneRecord(parameters);
+        }
+        catch {
+            return tool;
+        }
+        cleanupSchema(cleanedParameters);
+    }
     return {
         ...tool,
         function: {

package/dist/lib/request/index.d.ts

@@ -2,4 +2,3 @@ export * from "./failure-policy.js";
 export * from "./fetch-helpers.js";
 export * from "./rate-limit-backoff.js";
 export * from "./request-transformer.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/lib/request/rate-limit-backoff.d.ts

@@ -54,4 +54,3 @@ export interface RateLimitBackoffWithReasonParams {
 export declare function getRateLimitBackoffWithReason(params: RateLimitBackoffWithReasonParams): RateLimitBackoffResult;
 export declare function getRateLimitBackoffWithReason(accountIndex: number, quotaKey: string, serverRetryAfterMs: number | null | undefined, reason?: RateLimitReason, stableAccountKey?: StableAccountKey): RateLimitBackoffResult;
 export {};
-//# sourceMappingURL=rate-limit-backoff.d.ts.map

package/dist/lib/request/rate-limit-decision.d.ts

@@ -69,4 +69,3 @@ export interface PinnedUnavailableContext {
     now?: number;
 }
 export declare function buildPinnedUnavailableErrorBody(pinnedIndex: number | null | undefined, accountSkipReasons: ReadonlyMap<number, string>, context?: PinnedUnavailableContext): PinnedUnavailableErrorBody;
-//# sourceMappingURL=rate-limit-decision.d.ts.map

package/dist/lib/request/request-attempt-budget.d.ts

@@ -21,4 +21,3 @@ export declare function computeOutboundRequestAttemptBudget(params: {
  * most one alternate account to avoid broad replay fan-out.
  */
 export declare function buildStreamFailoverCandidateOrder(primaryIndex: number, accountIndices: number[]): number[];
-//# sourceMappingURL=request-attempt-budget.d.ts.map

package/dist/lib/request/request-init.d.ts

@@ -1,3 +1,2 @@
 export declare function normalizeRequestInit(requestInput: Request | string | URL, requestInit: RequestInit | undefined): Promise<RequestInit | undefined>;
 export declare function parseRequestBodyFromInit(body: unknown, logWarn: (message: string) => void): Promise<Record<string, unknown>>;
-//# sourceMappingURL=request-init.d.ts.map

package/dist/lib/request/request-resilience.d.ts

@@ -7,4 +7,3 @@ export declare function recordServerBurstFailure(accountIndex: number, now?: num
 export declare function clearServerBurstCooldown(): void;
 export declare function buildAdaptiveStreamFailoverCandidateOrder(primaryIndex: number, accounts: Array<Pick<ManagedAccount, "index" | "lastUsed" | "enabled" | "coolingDownUntil" | "rateLimitResetTimes">>, now?: number): number[];
 export declare function resetRequestResilienceStateForTests(): void;
-//# sourceMappingURL=request-resilience.d.ts.map

package/dist/lib/request/request-transformer.d.ts

@@ -127,4 +127,3 @@ export declare function addToolRemapMessage(input: InputItem[] | undefined, hasT
  */
 export declare function transformRequestBody(params: TransformRequestBodyParams): Promise<RequestBody>;
 export declare function transformRequestBody(body: RequestBody, codexInstructions: string, userConfig?: UserConfig, codexMode?: boolean, fastSession?: boolean, fastSessionStrategy?: FastSessionStrategy, fastSessionMaxInputItems?: number, deferFastSessionInputTrimming?: boolean, allowBackgroundResponses?: boolean): Promise<RequestBody>;
-//# sourceMappingURL=request-transformer.d.ts.map

package/dist/lib/request/request-transformer.js

@@ -409,25 +409,33 @@ export function filterInput(input, options) {
     if (!Array.isArray(input))
         return input;
     const stripIds = options?.stripIds ?? true;
-    const filtered = [];
-    for (const item of input) {
-        if (!item || typeof item !== "object") {
-            continue;
-        }
-        // Remove AI SDK constructs not supported by Codex API.
-        if (item.type === "item_reference") {
+    // Copy-on-write: items pass through by reference until the first drop or
+    // ID strip, so inputs with no ids never allocate a clone per item.
+    let filtered = null;
+    for (let i = 0; i < input.length; i++) {
+        const item = input[i];
+        if (!item || typeof item !== "object" || item.type === "item_reference") {
+            // Drop AI SDK constructs not supported by Codex API (and holes).
+            if (filtered === null) {
+                filtered = input.slice(0, i);
+            }
             continue;
         }
         // Strip IDs from all items (Codex API stateless mode).
         if (stripIds && "id" in item) {
             const { id: _omit, ...itemWithoutId } = item;
             void _omit;
+            if (filtered === null) {
+                filtered = input.slice(0, i);
+            }
             filtered.push(itemWithoutId);
             continue;
         }
-        filtered.push(item);
+        if (filtered !== null) {
+            filtered.push(item);
+        }
     }
-    return filtered;
+    return filtered ?? input;
 }
 /**
  * Trim long stateless histories for low-latency sessions.
@@ -512,6 +520,15 @@ export function trimInputForFastSession(input, maxItems, options) {
         ...trimmed.slice(trimmed.length - tailBudget),
     ];
 }
+// `[^\S\n]` is every whitespace except newline: `\s` between the anchor and the
+// marker could span blank lines, and on whitespace-heavy multi-MB payloads the
+// `^|\n` + `\s*` combination backtracked per position (a >20s stall observed on
+// an all-whitespace body). Confining the run to a single line keeps the scan
+// linear while matching the same "line starts with a list marker" shapes.
+const MARKDOWN_LIST_ITEM_PATTERN = /(^|\n)[^\S\n]*(?:[-*]|\d+\.)[^\S\n]+\S/;
+function hasMarkdownListItem(text) {
+    return MARKDOWN_LIST_ITEM_PATTERN.test(text);
+}
 function isTrivialLatestPrompt(text) {
     const normalized = text.trim();
     if (!normalized)
@@ -522,7 +539,7 @@ function isTrivialLatestPrompt(text) {
         return false;
     if (normalized.includes("```"))
         return false;
-    if (/(^|\n)\s*(?:[-*]|\d+\.)\s+\S/m.test(normalized))
+    if (hasMarkdownListItem(normalized))
         return false;
     if (/https?:\/\//i.test(normalized))
         return false;
@@ -539,7 +556,7 @@ function isStructurallyComplexPrompt(text) {
     const lineCount = normalized.split(/\r?\n/).filter(Boolean).length;
     if (lineCount >= 3)
         return true;
-    if (/(^|\n)\s*(?:[-*]|\d+\.)\s+\S/m.test(normalized))
+    if (hasMarkdownListItem(normalized))
         return true;
     if (/\|.+\|/.test(normalized))
         return true;
@@ -791,10 +808,12 @@ export async function transformRequestBody(bodyOrParams, codexInstructions, user
                     preferLatestUserOnly: fastSessionInputTrimPlan.trim?.preferLatestUserOnly ?? false,
                 }) ?? inputItems;
         }
-        // Debug: Log original input message IDs before filtering
-        const originalIds = inputItems
-            .filter((item) => item.id)
-            .map((item) => item.id);
+        // Debug: collect original input message IDs before filtering (single pass).
+        const originalIds = [];
+        for (const item of inputItems) {
+            if (item?.id)
+                originalIds.push(item.id);
+        }
         if (originalIds.length > 0) {
             logDebug(`Filtering ${originalIds.length} message IDs from input:`, originalIds);
         }
@@ -802,16 +821,22 @@ export async function transformRequestBody(bodyOrParams, codexInstructions, user
             stripIds: !backgroundModeRequested,
         }) ?? inputItems;
         body.input = inputItems;
-        // istanbul ignore next -- filterInput always removes IDs in stateless mode; this is defensive debug code
-        const remainingIds = (body.input || [])
-            .filter((item) => item.id)
-            .map((item) => item.id);
-        // istanbul ignore if -- filterInput always removes IDs in stateless mode; background mode intentionally preserves them
-        if (remainingIds.length > 0 && !backgroundModeRequested) {
-            logWarn(`WARNING: ${remainingIds.length} IDs still present after filtering:`, remainingIds);
-        }
-        else if (originalIds.length > 0) {
-            logDebug(`Successfully removed all ${originalIds.length} message IDs`);
+        // IDs surviving the filter are always a subset of the originals, so the
+        // second scan only runs when an ID was present beforehand. In stateless
+        // mode filterInput removes every ID, so the warn branch stays defensive.
+        if (originalIds.length > 0) {
+            const remainingIds = [];
+            for (const item of body.input) {
+                if (item?.id)
+                    remainingIds.push(item.id);
+            }
+            // istanbul ignore next -- filterInput always removes IDs in stateless mode; this is defensive debug code
+            if (remainingIds.length > 0 && !backgroundModeRequested) {
+                logWarn(`WARNING: ${remainingIds.length} IDs still present after filtering:`, remainingIds);
+            }
+            else {
+                logDebug(`Successfully removed all ${originalIds.length} message IDs`);
+            }
         }
         if (resolvedCodexMode) {
             // CODEX_MODE: Remove host system prompt, add bridge prompt

package/dist/lib/request/response-compaction.d.ts

@@ -18,4 +18,3 @@ export interface ApplyResponseCompactionParams {
 }
 export declare function applyResponseCompaction(params: ApplyResponseCompactionParams): Promise<ResponseCompactionResult>;
 export {};
-//# sourceMappingURL=response-compaction.d.ts.map

package/dist/lib/request/response-handler.d.ts

@@ -24,4 +24,3 @@ export declare function ensureContentType(headers: Headers): Headers;
  */
 export declare function isEmptyResponse(body: unknown): boolean;
 export declare function attachResponseIdCapture(response: Response, headers: Headers, onResponseId?: (responseId: string) => void, onUsage?: (usage: UsageTokenCounts) => void): Response;
-//# sourceMappingURL=response-handler.d.ts.map

package/dist/lib/request/response-metadata.d.ts

@@ -1,3 +1,2 @@
 export declare function parseRetryAfterHintMs(headers: Headers): number | null;
 export declare function sanitizeResponseHeadersForLog(headers: Headers): Record<string, string>;
-//# sourceMappingURL=response-metadata.d.ts.map

package/dist/lib/request/response-outcome.d.ts

@@ -22,4 +22,3 @@ export declare class ResponseOutcome {
      */
     finish(): StreamCompletion;
 }
-//# sourceMappingURL=response-outcome.d.ts.map

package/dist/lib/request/stream-failover-runtime.d.ts

@@ -15,4 +15,3 @@ export declare function forwardStreamingResponse(upstream: Response, res: Server
 onChunk?: (chunk: Uint8Array) => void, 
 /** Additional response headers, applied after (so they can override) the forwarded upstream ones. */
 extraHeaders?: Record<string, string>, completion?: () => StreamCompletion): Promise<boolean>;
-//# sourceMappingURL=stream-failover-runtime.d.ts.map

package/dist/lib/request/stream-failover.d.ts

@@ -22,4 +22,3 @@ export interface StreamFailoverOptions {
  * @returns A new Response that streams data from the initial response but may switch to fallback responses on stall/error, preserving the original status, statusText, and content-type header.
  */
 export declare function withStreamingFailover(initialResponse: Response, getFallbackResponse: (attempt: number, emittedBytes: number) => Promise<Response | null>, options?: StreamFailoverOptions): Response;
-//# sourceMappingURL=stream-failover.d.ts.map