clawmoney 0.15.7 → 0.15.9

package/dist/relay/provider.js

@@ -4,7 +4,7 @@ import { homedir } from "node:os";
 import YAML from "yaml";
 import { RelayWsClient } from "./ws-client.js";
 import { callClaudeApi, callClaudeApiPassthrough, preflightClaudeApi, getRateGuardSnapshot as getClaudeRateGuardSnapshot, } from "./upstream/claude-api.js";
-import { callCodexApi, preflightCodexApi, getRateGuardSnapshot as getCodexRateGuardSnapshot, } from "./upstream/codex-api.js";
+import { callCodexApi, callCodexApiPassthrough, preflightCodexApi, getRateGuardSnapshot as getCodexRateGuardSnapshot, } from "./upstream/codex-api.js";
 import { callGeminiApi, preflightGeminiApi, getGeminiRateGuardSnapshot, } from "./upstream/gemini-api.js";
 import { callAntigravityApi, preflightAntigravityApi, getAntigravityRateGuardSnapshot, } from "./upstream/antigravity-api.js";
 /**
@@ -192,11 +192,25 @@ async function executeRelayRequest(request, config, sendChunk) {
         // antigravity → daily-cloudcode-pa). Each handler has its own
         // fingerprint file and rate-guard instance.
         if (cliType === "codex") {
-            parsed = await callCodexApi({
-                prompt,
-                model,
-                maxTokens: max_budget_usd ? undefined : 4096,
-            });
+            // Same two-mode pattern as claude: passthrough when the Hub forwards
+            // a real Responses API body (used by /v1/responses endpoint for
+            // Codex CLI drop-in replacement), template mode otherwise (used by
+            // the OpenAI-compat /v1/chat/completions classic endpoint).
+            if (request.passthrough_body) {
+                parsed = await callCodexApiPassthrough({
+                    clientBody: request.passthrough_body,
+                    model,
+                    onRawEvent: sendChunk,
+                });
+            }
+            else {
+                parsed = await callCodexApi({
+                    prompt,
+                    model,
+                    maxTokens: max_budget_usd ? undefined : 4096,
+                    onRawEvent: sendChunk,
+                });
+            }
         }
         else if (cliType === "gemini") {
             parsed = await callGeminiApi({

package/dist/relay/upstream/codex-api.d.ts

@@ -38,5 +38,12 @@ export interface CallCodexApiOptions {
     prompt: string;
     model: string;
     maxTokens?: number;
+    onRawEvent?: (sse: string) => void;
 }
 export declare function callCodexApi(opts: CallCodexApiOptions): Promise<ParsedOutput>;
+export interface CallCodexApiPassthroughOptions {
+    clientBody: Record<string, unknown>;
+    model: string;
+    onRawEvent?: (sse: string) => void;
+}
+export declare function callCodexApiPassthrough(opts: CallCodexApiPassthroughOptions): Promise<ParsedOutput>;

package/dist/relay/upstream/codex-api.js

@@ -449,6 +449,47 @@ function buildCodexRequestFrame(prompt, model, fingerprint, sessionId, turnMetad
     }
     return frame;
 }
+// Patch a raw ChatGPT WS frame before we forward it to the Hub as SSE.
+// ChatGPT's internal response.completed frames come from a proprietary
+// backend that does NOT populate usage.total_tokens — the Codex CLI Rust
+// parser is strict about this field (stream disconnected before completion:
+// failed to parse ResponseCompleted: missing field `total_tokens`), so we
+// inject it here when we can compute it from input_tokens + output_tokens.
+// Returns the possibly-rewritten frame JSON; on parse/shape error returns
+// the original untouched so a malformed input never turns into a crash.
+function patchCodexFrameForForwarding(raw) {
+    try {
+        const evt = JSON.parse(raw);
+        const type = evt["type"];
+        if (type !== "response.completed" && type !== "response.done") {
+            return raw;
+        }
+        const resp = evt["response"];
+        if (!resp || typeof resp !== "object")
+            return raw;
+        const usage = resp["usage"];
+        if (!usage || typeof usage !== "object")
+            return raw;
+        if (typeof usage["total_tokens"] === "number")
+            return raw;
+        const input = Number(usage["input_tokens"] ?? 0);
+        const output = Number(usage["output_tokens"] ?? 0);
+        usage["total_tokens"] = input + output;
+        // Also ensure the nested *_details objects exist — Codex CLI's
+        // schema checks for them on the response.completed frame.
+        if (!usage["input_tokens_details"] || typeof usage["input_tokens_details"] !== "object") {
+            const cached = Number(usage.cache_read_input_tokens ?? 0);
+            usage["input_tokens_details"] = { cached_tokens: cached };
+        }
+        if (!usage["output_tokens_details"] || typeof usage["output_tokens_details"] !== "object") {
+            usage["output_tokens_details"] = { reasoning_tokens: 0 };
+        }
+        return JSON.stringify(evt);
+    }
+    catch {
+        return raw;
+    }
+}
 function handleFrame(raw, acc) {
     let evt;
     try {
@@ -645,6 +686,12 @@ export async function callCodexApi(opts) {
         configureRateGuard();
     return rateGuard.run(() => doCallCodexApi(opts));
 }
+export async function callCodexApiPassthrough(opts) {
+    configureDispatcher();
+    if (!rateGuard)
+        configureRateGuard();
+    return rateGuard.run(() => doCallCodexApiPassthrough(opts));
+}
 async function doCallCodexApi(opts) {
     const prompt = (opts.prompt ?? "").trim();
     if (!prompt) {
@@ -861,6 +908,26 @@ async function doCallCodexApi(opts) {
                         : Buffer.from(data).toString("utf-8");
                 // Frames are individual JSON objects (no newline framing).
                 const target = phase === "warmup" ? warmupAcc : acc;
+                // Forward raw frames to the caller (when streaming is requested)
+                // only for the real phase — warmup frames are daemon-internal and
+                // never reach the end client. Each frame is re-emitted as an
+                // Anthropic-style SSE block where `event:` is the frame type
+                // (response.output_text.delta, response.completed, etc.), which
+                // matches OpenAI's public Responses API SSE wire format exactly.
+                if (phase === "real" && opts.onRawEvent) {
+                    try {
+                        const parsedFrame = JSON.parse(text);
+                        const frameType = typeof parsedFrame.type === "string" ? parsedFrame.type : "message";
+                        // Inject usage.total_tokens on response.completed frames so
+                        // the end client's strict parser doesn't abort the stream.
+                        const patched = patchCodexFrameForForwarding(text);
+                        opts.onRawEvent(`event: ${frameType}\ndata: ${patched}\n\n`);
+                    }
+                    catch {
+                        // Non-JSON frame — forward as a plain data event.
+                        opts.onRawEvent(`event: message\ndata: ${text}\n\n`);
+                    }
+                }
                 const outcome = handleFrame(text, target);
                 if (outcome.rateLimit && rateGuard) {
                     // Soft hint — record but don't kill this request. Next request will
@@ -939,3 +1006,298 @@ async function doCallCodexApi(opts) {
         return parsed;
     }
 }
+// ── Passthrough frame builder ─────────────────────────────────────────────
+// Build a ChatGPT backend-api/codex/responses WS frame from the buyer's
+// raw Responses API body. Daemon-controlled fields (type, client_metadata,
+// store, stream, include, generate, model) are always overwritten; every
+// other field — input, instructions, tools, tool_choice, reasoning,
+// parallel_tool_calls, etc. — is preserved verbatim so the end client's
+// agentic loop works end-to-end.
+function buildCodexPassthroughFrame(clientBody, model, fingerprint, sessionId, turnMetadataHeader, windowGeneration, warmup) {
+    // Shallow clone so we don't mutate the buyer's dict across retries.
+    const frame = { ...clientBody };
+    // Daemon-controlled envelope fields — always forced.
+    frame.type = "response.create";
+    frame.model = model;
+    frame.store = false;
+    frame.stream = true;
+    // Real CLI sends include: ["reasoning.encrypted_content"] when reasoning
+    // is enabled. We set reasoning below (from client or default), so include
+    // it for fingerprint parity.
+    frame.include = ["reasoning.encrypted_content"];
+    // Daemon fingerprint injection — client_metadata is how the upstream
+    // ties traffic to a device+window identity. Buyers never see this
+    // field; always set it from our fingerprint.
+    frame.client_metadata = {
+        "x-codex-installation-id": fingerprint.installation_id,
+        "x-codex-window-id": `${sessionId}:${windowGeneration}`,
+        "x-codex-turn-metadata": turnMetadataHeader,
+    };
+    // Reasoning: if buyer sent their own reasoning config, preserve it;
+    // otherwise inject the real-CLI default `{effort: "medium", summary: "auto"}`
+    // so the request shape matches typical CLI traffic.
+    if (!frame.reasoning || typeof frame.reasoning !== "object") {
+        frame.reasoning = { effort: "medium", summary: "auto" };
+    }
+    // Ensure tools is an array (real CLI always sends tools, even if empty).
+    if (!Array.isArray(frame.tools)) {
+        frame.tools = [];
+    }
+    // Default tool_choice if not set.
+    if (frame.tool_choice === undefined || frame.tool_choice === null) {
+        frame.tool_choice = "auto";
+    }
+    // Default parallel_tool_calls to false (matches current template).
+    if (frame.parallel_tool_calls === undefined) {
+        frame.parallel_tool_calls = false;
+    }
+    // Instructions: if buyer didn't send one, fall back to the template
+    // mode's RELAY_INSTRUCTIONS so the model still has guidance.
+    if (typeof frame.instructions !== "string" || !frame.instructions) {
+        frame.instructions = RELAY_INSTRUCTIONS;
+    }
+    if (warmup) {
+        // Real CLI's prewarm flow: first frame of each turn has generate:false.
+        frame.generate = false;
+    }
+    else {
+        // Explicitly unset any leftover generate:false (buyer's body shouldn't
+        // carry it, but defensive).
+        delete frame.generate;
+    }
+    return frame;
+}
+// ── Passthrough entry point ───────────────────────────────────────────────
+//
+// Copy-pasted from doCallCodexApi (with frame-building swapped for
+// buildCodexPassthroughFrame). Duplicated rather than refactored so we
+// can iterate on passthrough-specific bugs without risking a regression
+// in the battle-tested template path. When passthrough stabilizes we
+// can merge the two via a frame-builder parameter.
+async function doCallCodexApiPassthrough(opts) {
+    // Minimal body validation — we need at least `input` (array) and the
+    // model. Everything else is optional per the Responses API spec.
+    const input = opts.clientBody.input;
+    if (!Array.isArray(input) || input.length === 0) {
+        throw new Error("Passthrough body missing `input` array");
+    }
+    const fingerprint = loadCodexFingerprint();
+    const sessionId = getMaskedSessionId();
+    let transientAttempt = 0;
+    let hasRefreshed = false;
+    const windowGeneration = 0;
+    while (true) {
+        const creds = await getFreshCreds();
+        const platformSandboxTag = process.platform === "darwin"
+            ? "seatbelt"
+            : process.platform === "linux"
+                ? "seccomp"
+                : process.platform === "win32"
+                    ? "windows_sandbox"
+                    : "none";
+        const turnMetadata = JSON.stringify({
+            session_id: sessionId,
+            turn_id: randomUUID(),
+            sandbox: platformSandboxTag,
+        });
+        const warmupFrame = buildCodexPassthroughFrame(opts.clientBody, opts.model, fingerprint, sessionId, turnMetadata, windowGeneration, 
+        /*warmup*/ true);
+        const realFrame = buildCodexPassthroughFrame(opts.clientBody, opts.model, fingerprint, sessionId, turnMetadata, windowGeneration, 
+        /*warmup*/ false);
+        const warmupFrameJson = JSON.stringify(warmupFrame);
+        const realFrameJson = JSON.stringify(realFrame);
+        const windowId = `${sessionId}:${windowGeneration}`;
+        const headers = {
+            "authorization": `Bearer ${creds.accessToken}`,
+            "originator": fingerprint.originator,
+            "openai-beta": fingerprint.openai_beta,
+            "session_id": sessionId,
+            "x-client-request-id": sessionId,
+            "x-codex-window-id": windowId,
+            "x-codex-turn-metadata": turnMetadata,
+        };
+        if (fingerprint.user_agent) {
+            headers["user-agent"] = fingerprint.user_agent;
+        }
+        let dialed;
+        try {
+            dialed = await dialCodexWebSocket(headers);
+        }
+        catch (err) {
+            if (err instanceof WsDialError) {
+                const status = err.statusCode;
+                if (status === 429) {
+                    const cooldown = cooldownFromHttpHeaders(err.headers);
+                    if (cooldown && rateGuard) {
+                        rateGuard.triggerCooldown(cooldown.ms, cooldown.reason);
+                    }
+                    else if (rateGuard) {
+                        rateGuard.triggerCooldown(Date.now() + 5 * 60_000, "fallback 5m (no reset header)");
+                    }
+                    throw new Error(`Codex 429 rate-limited: ${err.bodySnippet.slice(0, 300)}`);
+                }
+                if (status === 401 && !hasRefreshed) {
+                    logger.warn("[codex-api] 401 from upgrade (passthrough), refreshing token + retry");
+                    hasRefreshed = true;
+                    cachedCreds = null;
+                    continue;
+                }
+                const isTransient = status >= 500 && status <= 599;
+                if (isTransient && transientAttempt < MAX_TRANSIENT_RETRIES) {
+                    const backoffMs = 500 * Math.pow(2, transientAttempt) + Math.random() * 500;
+                    logger.warn(`[codex-api] upgrade ${status} (passthrough attempt ${transientAttempt + 1}/${MAX_TRANSIENT_RETRIES + 1}), retrying in ${Math.round(backoffMs)}ms — ${err.bodySnippet.slice(0, 200)}`);
+                    await new Promise((r) => setTimeout(r, backoffMs));
+                    transientAttempt++;
+                    continue;
+                }
+                throw new Error(`Codex upgrade ${status}: ${err.bodySnippet.slice(0, 400)}`);
+            }
+            if (transientAttempt < MAX_TRANSIENT_RETRIES) {
+                const backoffMs = 500 * Math.pow(2, transientAttempt) + Math.random() * 500;
+                logger.warn(`[codex-api] transport error (passthrough attempt ${transientAttempt + 1}/${MAX_TRANSIENT_RETRIES + 1}), retrying in ${Math.round(backoffMs)}ms — ${err.message}`);
+                await new Promise((r) => setTimeout(r, backoffMs));
+                transientAttempt++;
+                continue;
+            }
+            throw err;
+        }
+        const { ws } = dialed;
+        const acc = {
+            text: "",
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheReadTokens: 0,
+            model: opts.model,
+            terminal: false,
+        };
+        let resolved = false;
+        const result = await new Promise((resolve) => {
+            let phase = "warmup";
+            const finish = (r) => {
+                if (resolved)
+                    return;
+                resolved = true;
+                clearTimeout(timer);
+                try {
+                    ws.close(1000, "done");
+                }
+                catch {
+                    // ignore
+                }
+                resolve(r);
+            };
+            const timer = setTimeout(() => {
+                finish({
+                    ok: false,
+                    retriable: false,
+                    error: new Error(`Codex WS timed out after ${WS_OVERALL_TIMEOUT_MS}ms waiting for response.completed`),
+                });
+            }, WS_OVERALL_TIMEOUT_MS);
+            const warmupAcc = {
+                text: "",
+                inputTokens: 0,
+                outputTokens: 0,
+                cacheReadTokens: 0,
+                model: opts.model,
+                terminal: false,
+            };
+            const sendFrame = (frameJson) => {
+                try {
+                    ws.send(frameJson, (sendErr) => {
+                        if (sendErr) {
+                            finish({ ok: false, retriable: true, error: sendErr });
+                        }
+                    });
+                }
+                catch (err) {
+                    finish({ ok: false, retriable: true, error: err });
+                }
+            };
+            ws.on("message", (data, _isBinary) => {
+                const text = Buffer.isBuffer(data)
+                    ? data.toString("utf-8")
+                    : Array.isArray(data)
+                        ? Buffer.concat(data).toString("utf-8")
+                        : Buffer.from(data).toString("utf-8");
+                const target = phase === "warmup" ? warmupAcc : acc;
+                // Forward raw frames to the Hub for real-time SSE streaming to
+                // the end client. Same rules as template mode — only real phase,
+                // wrap as `event: <type>\ndata: <json>\n\n`.
+                if (phase === "real" && opts.onRawEvent) {
+                    try {
+                        const parsedFrame = JSON.parse(text);
+                        const frameType = typeof parsedFrame.type === "string" ? parsedFrame.type : "message";
+                        const patched = patchCodexFrameForForwarding(text);
+                        opts.onRawEvent(`event: ${frameType}\ndata: ${patched}\n\n`);
+                    }
+                    catch {
+                        opts.onRawEvent(`event: message\ndata: ${text}\n\n`);
+                    }
+                }
+                const outcome = handleFrame(text, target);
+                if (outcome.rateLimit && rateGuard) {
+                    rateGuard.triggerCooldown(outcome.rateLimit.ms, outcome.rateLimit.reason);
+                }
+                if (outcome.terminal) {
+                    if (outcome.error) {
+                        finish({
+                            ok: false,
+                            retriable: false,
+                            error: new Error(`Codex upstream error: ${outcome.error}`),
+                        });
+                        return;
+                    }
+                    if (phase === "warmup") {
+                        phase = "real";
+                        sendFrame(realFrameJson);
+                        return;
+                    }
+                    acc.terminal = true;
+                    finish({ ok: true });
+                }
+            });
+            ws.on("close", (code, reason) => {
+                if (acc.terminal)
+                    return;
+                finish({
+                    ok: false,
+                    retriable: true,
+                    error: new Error(`Codex WS closed early (code=${code}, reason=${reason.toString().slice(0, 200)})`),
+                });
+            });
+            ws.on("error", (err) => {
+                finish({ ok: false, retriable: true, error: err });
+            });
+            sendFrame(warmupFrameJson);
+        });
+        if (!result.ok) {
+            if (result.retriable && transientAttempt < MAX_TRANSIENT_RETRIES) {
+                const backoffMs = 500 * Math.pow(2, transientAttempt) + Math.random() * 500;
+                logger.warn(`[codex-api] mid-session ws error (passthrough attempt ${transientAttempt + 1}/${MAX_TRANSIENT_RETRIES + 1}), retrying in ${Math.round(backoffMs)}ms — ${result.error.message}`);
+                await new Promise((r) => setTimeout(r, backoffMs));
+                transientAttempt++;
+                continue;
+            }
+            throw result.error;
+        }
+        const parsed = {
+            text: acc.text,
+            sessionId,
+            usage: {
+                input_tokens: acc.inputTokens,
+                output_tokens: acc.outputTokens,
+                cache_creation_tokens: 0,
+                cache_read_tokens: acc.cacheReadTokens,
+            },
+            model: acc.model,
+            costUsd: 0,
+        };
+        if (rateGuard) {
+            const cost = calculateCost(opts.model, parsed.usage.input_tokens, parsed.usage.output_tokens, parsed.usage.cache_creation_tokens, parsed.usage.cache_read_tokens);
+            rateGuard.recordSpend(cost.apiCost);
+            parsed.costUsd = cost.apiCost;
+        }
+        logger.info(`[codex-api] passthrough OK model=${acc.model} in=${acc.inputTokens} out=${acc.outputTokens} cache_read=${acc.cacheReadTokens}`);
+        return parsed;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawmoney",
-  "version": "0.15.7",
+  "version": "0.15.9",
   "description": "ClawMoney CLI -- Earn rewards with your AI agent",
   "type": "module",
   "bin": {