clawmoney 0.12.0 → 0.12.2

package/dist/relay/provider.js

@@ -4,7 +4,9 @@ import { homedir } from "node:os";
 import YAML from "yaml";
 import { RelayWsClient } from "./ws-client.js";
 import { spawnCli, buildCliArgs, parseCliOutput, ensureEmptyMcpConfig, ensureSandboxDir, } from "./executor.js";
-import { callClaudeApi, preflightClaudeApi } from "./upstream/claude-api.js";
+import { callClaudeApi, preflightClaudeApi, getRateGuardSnapshot } from "./upstream/claude-api.js";
+import { callCodexApi, preflightCodexApi } from "./upstream/codex-api.js";
+import { callGeminiApi, preflightGeminiApi } from "./upstream/gemini-api.js";
 import { calculateCost } from "./pricing.js";
 import { relayLogger as logger } from "./logger.js";
 const CONFIG_DIR = join(homedir(), ".clawmoney");
@@ -106,8 +108,10 @@ async function executeRelayRequest(request, config) {
     const model = request.model ?? config.relay.model;
     const stateful = request.stateful ?? false;
     const cliSessionId = request.cli_session_id ?? undefined;
-    // api mode is currently claude-only; everything else falls back to spawn CLI.
-    const useApiMode = config.relay.execution_mode === "api" && cliType === "claude";
+    // api mode is supported for claude / codex / gemini; anything else falls
+    // back to spawning the local CLI subprocess.
+    const useApiMode = config.relay.execution_mode === "api" &&
+        (cliType === "claude" || cliType === "codex" || cliType === "gemini");
     // Build prompt from messages
     const prompt = request.messages
         ? messagesToPrompt(request.messages)
@@ -130,13 +134,32 @@ async function executeRelayRequest(request, config) {
         const startMs = Date.now();
         let parsed;
         if (useApiMode) {
-            // Direct /v1/messages call — no subprocess, no sandbox needed because
-            // the only thing the upstream sees is the prompt text we pass in.
-            parsed = await callClaudeApi({
-                prompt,
-                model,
-                maxTokens: max_budget_usd ? undefined : 4096,
-            });
+            // Direct upstream HTTPS call — no subprocess, no sandbox needed because
+            // the only thing the upstream sees is the prompt text we pass in. The
+            // right handler is picked by cli_type (claude → Anthropic, codex →
+            // chatgpt.com, gemini → 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,
+                });
+            }
+            else if (cliType === "gemini") {
+                parsed = await callGeminiApi({
+                    prompt,
+                    model,
+                    maxTokens: max_budget_usd ? undefined : 8192,
+                });
+            }
+            else {
+                parsed = await callClaudeApi({
+                    prompt,
+                    model,
+                    maxTokens: max_budget_usd ? undefined : 4096,
+                });
+            }
         }
         else {
             // In stateful mode, pass cli_session_id so buildCliArgs adds --resume
@@ -159,6 +182,22 @@ async function executeRelayRequest(request, config) {
         logger.info(`  │ Cost:   input=$${cost.inputCost.toFixed(4)} cache_w=$${cost.cacheCreationCost.toFixed(4)} cache_r=$${cost.cacheReadCost.toFixed(4)} output=$${cost.outputCost.toFixed(4)}`);
         logger.info(`  │ Total:  API $${cost.apiCost.toFixed(4)} → Relay $${cost.relayCost.toFixed(4)} → Earn $${cost.providerEarn.toFixed(4)}`);
         logger.info(`  └─ Done`);
+        // When we're running in api mode, piggy-back the provider's current 5h
+        // session-window snapshot onto the response so the Hub can use it for
+        // predictive claim scheduling (avoid routing fresh work to a provider
+        // whose window is already 90%+ saturated). Only populated if upstream
+        // actually surfaced the headers this turn.
+        let sessionWindowTelemetry;
+        if (useApiMode) {
+            const snap = getRateGuardSnapshot();
+            if (snap?.sessionWindow) {
+                sessionWindowTelemetry = {
+                    reset_at_ms: snap.sessionWindow.endMs,
+                    utilization: snap.sessionWindow.utilization,
+                    status: snap.sessionWindow.status,
+                };
+            }
+        }
         return {
             event: "relay_response",
             request_id,
@@ -167,6 +206,7 @@ async function executeRelayRequest(request, config) {
             usage: parsed.usage,
             model_used: parsed.model || model,
             cost_usd: parsed.costUsd || undefined,
+            session_window: sessionWindowTelemetry,
         };
     }
     catch (err) {
@@ -192,12 +232,23 @@ export function runRelayProvider(cliOverride) {
     ensureEmptyMcpConfig();
     ensureSandboxDir();
     // If the operator picked api mode, validate the OAuth token + fingerprint
-    // up-front so we fail fast instead of on the first inbound request.
-    if (config.relay.execution_mode === "api" && config.relay.cli_type === "claude") {
-        preflightClaudeApi(config.relay.rate_guard).catch((err) => {
-            logger.error(`Claude API preflight failed — falling back to CLI mode: ${err.message}`);
-            config.relay.execution_mode = "cli";
-        });
+    // up-front so we fail fast instead of on the first inbound request. Each
+    // cli_type has its own preflight path (different credential file, different
+    // fingerprint schema, different rate-guard instance).
+    if (config.relay.execution_mode === "api") {
+        const preflightFn = config.relay.cli_type === "codex"
+            ? preflightCodexApi
+            : config.relay.cli_type === "gemini"
+                ? preflightGeminiApi
+                : config.relay.cli_type === "claude"
+                    ? preflightClaudeApi
+                    : null;
+        if (preflightFn) {
+            preflightFn(config.relay.rate_guard).catch((err) => {
+                logger.error(`${config.relay.cli_type} API preflight failed — falling back to CLI mode: ${err.message}`);
+                config.relay.execution_mode = "cli";
+            });
+        }
     }
     const activeTasks = new Set();
     // Create WS client

package/dist/relay/types.d.ts

@@ -24,6 +24,11 @@ export interface RelayErrorEvent {
     message: string;
 }
 export type RelayIncomingEvent = RelayRequest | RelayConnectedEvent | RelayErrorEvent;
+export interface RelayResponseSessionWindow {
+    reset_at_ms: number;
+    utilization?: number;
+    status?: string;
+}
 export interface RelayResponse {
     event: "relay_response";
     request_id: string;
@@ -39,6 +44,7 @@ export interface RelayResponse {
     model_used?: string;
     cost_usd?: number;
     error?: string;
+    session_window?: RelayResponseSessionWindow;
 }
 export type RelayOutgoingEvent = RelayResponse;
 export interface ParsedOutput {

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

@@ -0,0 +1,42 @@
+/**
+ * Direct chatgpt.com upstream for Codex (ChatGPT Plus/Pro) OAuth subscriptions.
+ *
+ * Mirrors claude-api.ts structure exactly: same export shape, same error types,
+ * same RateGuard integration, same OAuth refresh + persist-back pattern, same
+ * fingerprint file loading, same 5xx retry path, same preflight function.
+ *
+ * IMPORTANT — wire format: codex-cli 0.118+ migrated from HTTP POST+SSE to a
+ * WebSocket-based Responses API. The endpoint is accessed as
+ *   wss://chatgpt.com/backend-api/codex/responses
+ * with the handshake headers shown below, and after the upgrade the client
+ * sends a single `{type:"response.create", ...}` JSON frame. The server
+ * replies with a stream of JSON frames that mirror the old SSE event names
+ * (`response.created`, `response.output_text.delta`, `response.completed`,
+ * `response.failed`, `response.error`, etc.). We accumulate text deltas +
+ * the terminal event, close cleanly, and return ParsedOutput — exactly the
+ * same contract the caller sees for HTTP Claude.
+ *
+ * Key differences from claude-api.ts:
+ *  - Token source: ~/.codex/auth.json (written by the Codex CLI)
+ *  - Upstream transport: WebSocket to chatgpt.com/backend-api/codex/responses
+ *  - Handshake header `openai-beta: responses_websockets=2026-02-06`
+ *  - Handshake header `version: <codex cli version>`
+ *  - Handshake header `chatgpt-account-id` from ~/.codex/auth.json tokens.account_id
+ *  - First frame is a JSON `response.create` — request body is OpenAI Responses
+ *    API shape (input[], instructions, model, store, stream) with `type` added
+ *  - Session headers: session_id + conversation_id (not x-claude-code-session-id)
+ *  - Rate-limit headers surface on the upgrade response or via `rate_limits` /
+ *    `response.failed` frames — we parse both
+ */
+import type { ParsedOutput, RelayRateGuardConfig } from "../types.js";
+import { RateGuard, RateGuardBudgetExceededError, RateGuardCooldownError } from "./rate-guard.js";
+export { RateGuardBudgetExceededError, RateGuardCooldownError };
+export declare function configureRateGuard(config?: RelayRateGuardConfig): void;
+export declare function getRateGuardSnapshot(): ReturnType<RateGuard["currentLoad"]> | null;
+export declare function preflightCodexApi(config?: RelayRateGuardConfig): Promise<void>;
+export interface CallCodexApiOptions {
+    prompt: string;
+    model: string;
+    maxTokens?: number;
+}
+export declare function callCodexApi(opts: CallCodexApiOptions): Promise<ParsedOutput>;