hydramcp 1.0.3 → 1.0.5

package/dist/providers/subscription.d.ts

@@ -2,15 +2,19 @@
  * Subscription Provider — use your monthly subscriptions as an API.
  *
  * Reads OAuth tokens stored by CLI tools (Claude Code, Gemini CLI, Codex CLI)
- * and makes direct HTTP requests to provider APIs. No subprocess spawning.
+ * and makes direct HTTP requests to provider-internal APIs.
  *
  * Token locations:
  *   Claude  → ~/.claude/.credentials.json
  *   Gemini  → ~/.gemini/oauth_creds.json
  *   Codex   → ~/.codex/auth.json
  *
+ * Endpoints (from CLIProxyAPI & Gemini CLI source):
+ *   Gemini  → https://cloudcode-pa.googleapis.com/v1internal:generateContent
+ *   Codex   → https://chatgpt.com/backend-api/codex/responses (SSE)
+ *   Claude  → CLI subprocess (api.anthropic.com rejects OAuth without TLS fingerprint)
+ *
  * Approach learned from CLIProxyAPI (github.com/router-for-me/CLIProxyAPI).
- * 100% our code. Zero external dependencies.
  */
 import { Provider, ModelInfo, QueryOptions, QueryResponse } from "./provider.js";
 export declare class SubscriptionProvider implements Provider {
@@ -18,10 +22,6 @@ export declare class SubscriptionProvider implements Provider {
     private backends;
     private modelToBackend;
     private tokenCache;
-    /**
-     * Detect which subscription tokens exist on disk.
-     * Returns the number of backends with valid tokens.
-     */
     detect(): Promise<number>;
     healthCheck(): Promise<boolean>;
     listModels(): Promise<ModelInfo[]>;

package/dist/providers/subscription.js

@@ -2,20 +2,28 @@
  * Subscription Provider — use your monthly subscriptions as an API.
  *
  * Reads OAuth tokens stored by CLI tools (Claude Code, Gemini CLI, Codex CLI)
- * and makes direct HTTP requests to provider APIs. No subprocess spawning.
+ * and makes direct HTTP requests to provider-internal APIs.
  *
  * Token locations:
  *   Claude  → ~/.claude/.credentials.json
  *   Gemini  → ~/.gemini/oauth_creds.json
  *   Codex   → ~/.codex/auth.json
  *
+ * Endpoints (from CLIProxyAPI & Gemini CLI source):
+ *   Gemini  → https://cloudcode-pa.googleapis.com/v1internal:generateContent
+ *   Codex   → https://chatgpt.com/backend-api/codex/responses (SSE)
+ *   Claude  → CLI subprocess (api.anthropic.com rejects OAuth without TLS fingerprint)
+ *
  * Approach learned from CLIProxyAPI (github.com/router-for-me/CLIProxyAPI).
- * 100% our code. Zero external dependencies.
  */
 import { readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
+import { spawn } from "node:child_process";
 import { logger } from "../utils/logger.js";
+// ---------------------------------------------------------------------------
+// Token file readers
+// ---------------------------------------------------------------------------
 function readClaudeTokens() {
     try {
         const raw = readFileSync(join(homedir(), ".claude", ".credentials.json"), "utf-8");
@@ -56,18 +64,18 @@ function readCodexTokens() {
         const tokens = data.tokens;
         if (!tokens?.access_token || !tokens?.refresh_token)
             return null;
-        // Codex access_token is a JWT — extract exp from payload
         let expiresAt = 0;
         try {
             const payload = JSON.parse(Buffer.from(tokens.access_token.split(".")[1], "base64").toString());
             if (payload.exp)
-                expiresAt = payload.exp * 1000; // sec → ms
+                expiresAt = payload.exp * 1000;
         }
-        catch { /* non-JWT or malformed — treat as no expiry */ }
+        catch { /* non-JWT or malformed */ }
         return {
             accessToken: tokens.access_token,
             refreshToken: tokens.refresh_token,
             expiresAt,
+            accountId: tokens.account_id ?? undefined,
         };
     }
     catch {
@@ -96,7 +104,6 @@ async function refreshClaudeToken(refreshToken) {
         const expiresIn = data.expires_in ?? 86400;
         if (!accessToken)
             return null;
-        // Write back to credentials file
         try {
             const credPath = join(homedir(), ".claude", ".credentials.json");
             const existing = JSON.parse(readFileSync(credPath, "utf-8"));
@@ -105,7 +112,7 @@ async function refreshClaudeToken(refreshToken) {
             existing.claudeAiOauth.expiresAt = Date.now() + expiresIn * 1000;
             writeFileSync(credPath, JSON.stringify(existing), "utf-8");
         }
-        catch { /* non-fatal — token still works for this session */ }
+        catch { /* non-fatal */ }
         return {
             accessToken,
             refreshToken: newRefresh || refreshToken,
@@ -136,7 +143,6 @@ async function refreshGeminiToken(refreshToken) {
         const expiresIn = data.expires_in ?? 3600;
         if (!accessToken)
             return null;
-        // Write back
         try {
             const credPath = join(homedir(), ".gemini", "oauth_creds.json");
             const existing = JSON.parse(readFileSync(credPath, "utf-8"));
@@ -149,7 +155,7 @@ async function refreshGeminiToken(refreshToken) {
         catch { /* non-fatal */ }
         return {
             accessToken,
-            refreshToken, // Google doesn't rotate refresh tokens
+            refreshToken,
             expiresAt: Date.now() + expiresIn * 1000,
         };
     }
@@ -178,10 +184,11 @@ async function refreshCodexToken(refreshToken) {
         const expiresIn = data.expires_in ?? 864000;
         if (!accessToken)
             return null;
-        // Write back
+        let accountId;
         try {
             const credPath = join(homedir(), ".codex", "auth.json");
             const existing = JSON.parse(readFileSync(credPath, "utf-8"));
+            accountId = existing.tokens?.account_id;
             existing.tokens.access_token = accessToken;
             existing.tokens.refresh_token = newRefresh || refreshToken;
             if (data.id_token)
@@ -194,58 +201,159 @@ async function refreshCodexToken(refreshToken) {
             accessToken,
             refreshToken: newRefresh || refreshToken,
             expiresAt: Date.now() + expiresIn * 1000,
+            accountId,
         };
     }
     catch {
         return null;
     }
 }
-async function queryOpenAI(token, model, prompt, options) {
-    const startTime = Date.now();
-    const body = {
-        model,
-        messages: [
-            ...(options?.system_prompt ? [{ role: "system", content: options.system_prompt }] : []),
-            { role: "user", content: prompt },
-        ],
-        stream: false,
-    };
-    if (options?.temperature !== undefined)
-        body.temperature = options.temperature;
-    if (options?.max_tokens !== undefined)
-        body.max_tokens = options.max_tokens;
-    const res = await fetch("https://api.openai.com/v1/chat/completions", {
+// ---------------------------------------------------------------------------
+// Gemini project ID — resolved via Cloud Code Assist loadCodeAssist API
+// ---------------------------------------------------------------------------
+let cachedGeminiProjectId = null;
+async function getGeminiProjectId(token) {
+    if (cachedGeminiProjectId)
+        return cachedGeminiProjectId;
+    const res = await fetch("https://cloudcode-pa.googleapis.com/v1internal:loadCodeAssist", {
         method: "POST",
         headers: {
             "Content-Type": "application/json",
             "Authorization": `Bearer ${token}`,
+            "User-Agent": "google-api-nodejs-client/9.15.1",
+            "X-Goog-Api-Client": "gl-node/22.17.0",
         },
-        body: JSON.stringify(body),
+        body: JSON.stringify({
+            metadata: {
+                ideType: "IDE_UNSPECIFIED",
+                platform: "PLATFORM_UNSPECIFIED",
+                pluginType: "GEMINI",
+            },
+        }),
     });
     if (!res.ok) {
         const err = await res.text();
-        throw new Error(`OpenAI subscription query failed (${res.status}): ${err}`);
+        throw new Error(`Gemini loadCodeAssist failed (${res.status}): ${err}`);
     }
     const data = (await res.json());
-    const choices = data.choices;
-    const choice = choices?.[0];
-    const message = choice?.message;
-    const usage = data.usage;
+    let projectId = null;
+    if (typeof data.cloudaicompanionProject === "string") {
+        projectId = data.cloudaicompanionProject;
+    }
+    else if (data.cloudaicompanionProject &&
+        typeof data.cloudaicompanionProject === "object" &&
+        typeof data.cloudaicompanionProject.id === "string") {
+        projectId = data.cloudaicompanionProject.id;
+    }
+    if (!projectId && Array.isArray(data.allowedTiers)) {
+        const defaultTier = data.allowedTiers.find((t) => t.isDefault === true);
+        if (typeof defaultTier?.id === "string") {
+            projectId = defaultTier.id;
+        }
+    }
+    if (!projectId) {
+        throw new Error("Gemini: no project ID from loadCodeAssist. Run `gemini` CLI once to set up your account.");
+    }
+    cachedGeminiProjectId = projectId;
+    logger.info(`Gemini project ID resolved: ${projectId}`);
+    return projectId;
+}
+// ---------------------------------------------------------------------------
+// Query: Codex — chatgpt.com/backend-api/codex SSE streaming
+// ---------------------------------------------------------------------------
+async function queryCodex(tokens, model, prompt, options) {
+    const startTime = Date.now();
+    const input = [];
+    if (options?.system_prompt) {
+        input.push({ role: "developer", content: options.system_prompt });
+    }
+    input.push({ role: "user", content: prompt });
+    const body = {
+        model,
+        instructions: "",
+        input,
+        stream: true,
+        store: false,
+    };
+    // Note: chatgpt.com/backend-api/codex does NOT support temperature or
+    // max_output_tokens for Codex reasoning models. Omitting these params.
+    const headers = {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${tokens.accessToken}`,
+        "Accept": "text/event-stream",
+        "Version": "0.98.0",
+        "Openai-Beta": "responses=experimental",
+        "User-Agent": "codex_cli_rs/0.98.0",
+        "Originator": "codex_cli_rs",
+        "Connection": "Keep-Alive",
+    };
+    if (tokens.accountId) {
+        headers["Chatgpt-Account-Id"] = tokens.accountId;
+    }
+    const res = await fetch("https://chatgpt.com/backend-api/codex/responses", { method: "POST", headers, body: JSON.stringify(body) });
+    if (!res.ok) {
+        const err = await res.text();
+        throw new Error(`Codex subscription query failed (${res.status}): ${err}`);
+    }
+    // Parse SSE stream — look for response.completed event
+    const text = await res.text();
+    const lines = text.split("\n");
+    let content = "";
+    let usage;
+    let finishReason;
+    for (const line of lines) {
+        if (!line.startsWith("data: "))
+            continue;
+        try {
+            const event = JSON.parse(line.slice(6));
+            if (event.type === "response.output_text.done") {
+                content += event.text ?? "";
+            }
+            else if (event.type === "response.completed") {
+                const resp = event.response;
+                if (resp?.usage)
+                    usage = resp.usage;
+                finishReason = resp?.status;
+                // Also extract content from completed response if not yet captured
+                if (!content && resp?.output) {
+                    for (const item of resp.output) {
+                        if (item.type === "message" && item.content) {
+                            for (const block of item.content) {
+                                if (block.type === "output_text")
+                                    content += block.text ?? "";
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch { /* skip non-JSON lines */ }
+    }
     return {
         model,
-        content: message?.content ?? "",
-        usage,
+        content,
+        usage: usage
+            ? {
+                prompt_tokens: usage.input_tokens ?? 0,
+                completion_tokens: usage.output_tokens ?? 0,
+                total_tokens: usage.total_tokens ?? 0,
+            }
+            : undefined,
         latency_ms: Date.now() - startTime,
-        finish_reason: choice?.finish_reason ?? undefined,
+        finish_reason: finishReason,
     };
 }
-async function queryGemini(token, model, prompt, options) {
+// ---------------------------------------------------------------------------
+// Query: Gemini — Cloud Code Assist direct HTTP
+// ---------------------------------------------------------------------------
+async function queryGemini(tokens, model, prompt, options) {
     const startTime = Date.now();
-    const body = {
+    const projectId = await getGeminiProjectId(tokens.accessToken);
+    const request = {
         contents: [{ role: "user", parts: [{ text: prompt }] }],
     };
     if (options?.system_prompt) {
-        body.systemInstruction = { parts: [{ text: options.system_prompt }] };
+        request.systemInstruction = { parts: [{ text: options.system_prompt }] };
     }
     const genConfig = {};
     if (options?.temperature !== undefined)
@@ -253,12 +361,17 @@ async function queryGemini(token, model, prompt, options) {
     if (options?.max_tokens !== undefined)
         genConfig.maxOutputTokens = options.max_tokens;
     if (Object.keys(genConfig).length > 0)
-        body.generationConfig = genConfig;
-    const res = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`, {
+        request.generationConfig = genConfig;
+    const body = { model, project: projectId, request };
+    const res = await fetch("https://cloudcode-pa.googleapis.com/v1internal:generateContent", {
         method: "POST",
         headers: {
             "Content-Type": "application/json",
-            "Authorization": `Bearer ${token}`,
+            "Accept": "application/json",
+            "Authorization": `Bearer ${tokens.accessToken}`,
+            "User-Agent": "google-api-nodejs-client/9.15.1",
+            "X-Goog-Api-Client": "gl-node/22.17.0",
+            "Client-Metadata": "ideType=IDE_UNSPECIFIED,platform=PLATFORM_UNSPECIFIED,pluginType=GEMINI",
         },
         body: JSON.stringify(body),
     });
@@ -266,74 +379,111 @@ async function queryGemini(token, model, prompt, options) {
         const err = await res.text();
         throw new Error(`Gemini subscription query failed (${res.status}): ${err}`);
     }
+    // Cloud Code Assist wraps the standard Gemini response in a "response" field
     const data = (await res.json());
-    const candidates = data.candidates;
+    const inner = (data.response ?? data);
+    const candidates = inner.candidates;
     const parts = candidates?.[0]?.content?.parts;
     const content = parts?.map((p) => p.text ?? "").join("") ?? "";
-    const meta = data.usageMetadata;
+    const meta = inner.usageMetadata;
     return {
         model,
         content,
-        usage: meta ? {
-            prompt_tokens: meta.promptTokenCount ?? 0,
-            completion_tokens: meta.candidatesTokenCount ?? 0,
-            total_tokens: meta.totalTokenCount ?? 0,
-        } : undefined,
+        usage: meta
+            ? {
+                prompt_tokens: meta.promptTokenCount ?? 0,
+                completion_tokens: meta.candidatesTokenCount ?? 0,
+                total_tokens: meta.totalTokenCount ?? 0,
+            }
+            : undefined,
         latency_ms: Date.now() - startTime,
         finish_reason: candidates?.[0]?.finishReason ?? undefined,
     };
 }
-async function queryAnthropic(token, model, prompt, options) {
-    const startTime = Date.now();
-    const body = {
-        model,
-        max_tokens: options?.max_tokens ?? 4096,
-        messages: [{ role: "user", content: prompt }],
-    };
-    if (options?.system_prompt)
-        body.system = options.system_prompt;
-    if (options?.temperature !== undefined)
-        body.temperature = options.temperature;
-    const res = await fetch("https://api.anthropic.com/v1/messages", {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            "Authorization": `Bearer ${token}`,
-            "anthropic-version": "2023-06-01",
-        },
-        body: JSON.stringify(body),
+// ---------------------------------------------------------------------------
+// Query: Claude — CLI subprocess (api.anthropic.com requires TLS fingerprint
+// bypass for OAuth tokens, which needs Go's utls library. Node.js can't do it
+// natively, so we use the Claude CLI as a subprocess.)
+// ---------------------------------------------------------------------------
+function execCLI(command, args, stdinData, timeoutMs = 120_000) {
+    return new Promise((resolve) => {
+        const isWin = process.platform === "win32";
+        const proc = spawn(command, args, {
+            shell: isWin,
+            env: { ...process.env },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        const timer = setTimeout(() => {
+            proc.kill();
+            resolve({ stdout, stderr: stderr + "\n[TIMEOUT]", code: 124 });
+        }, timeoutMs);
+        proc.stdout.on("data", (d) => { stdout += d.toString(); });
+        proc.stderr.on("data", (d) => { stderr += d.toString(); });
+        proc.on("close", (code) => {
+            clearTimeout(timer);
+            resolve({ stdout, stderr, code: code ?? 1 });
+        });
+        proc.on("error", (err) => {
+            clearTimeout(timer);
+            resolve({ stdout, stderr: err.message, code: 1 });
+        });
+        if (stdinData && proc.stdin) {
+            proc.stdin.write(stdinData);
+            proc.stdin.end();
+        }
     });
-    if (!res.ok) {
-        const err = await res.text();
-        throw new Error(`Anthropic subscription query failed (${res.status}): ${err}`);
+}
+async function queryClaude(_tokens, model, prompt, options) {
+    const startTime = Date.now();
+    const args = [
+        "--output-format", "json",
+        "-p", "-", // Read prompt from stdin
+        "--model", model,
+    ];
+    if (options?.max_tokens)
+        args.push("--max-tokens", String(options.max_tokens));
+    const result = await execCLI("claude", args, prompt, 120_000);
+    if (result.code !== 0) {
+        throw new Error(`Claude CLI failed (code ${result.code}): ${result.stderr.substring(0, 200)}`);
+    }
+    // Parse JSON output from claude --output-format json
+    let content = "";
+    try {
+        const data = JSON.parse(result.stdout);
+        if (typeof data.result === "string") {
+            content = data.result;
+        }
+        else if (typeof data.content === "string") {
+            content = data.content;
+        }
+        else if (Array.isArray(data.content)) {
+            content = data.content
+                .filter((b) => b.type === "text")
+                .map((b) => b.text ?? "")
+                .join("");
+        }
+        else {
+            content = result.stdout;
+        }
+    }
+    catch {
+        content = result.stdout;
     }
-    const data = (await res.json());
-    const contentBlocks = data.content;
-    const text = contentBlocks?.filter((b) => b.type === "text").map((b) => b.text ?? "").join("") ?? "";
-    const usage = data.usage;
     return {
         model,
-        content: text,
-        usage: usage ? {
-            prompt_tokens: usage.input_tokens,
-            completion_tokens: usage.output_tokens,
-            total_tokens: usage.input_tokens + usage.output_tokens,
-        } : undefined,
+        content,
         latency_ms: Date.now() - startTime,
-        finish_reason: data.stop_reason ?? undefined,
     };
 }
-// ---------------------------------------------------------------------------
-// Backend configs
-// ---------------------------------------------------------------------------
 const CLAUDE_BACKEND = {
     id: "claude-sub",
     displayName: "Claude (subscription)",
     readTokens: readClaudeTokens,
     refreshTokens: refreshClaudeToken,
-    query: queryAnthropic,
+    query: queryClaude,
     models: [
-        { id: "claude-opus-4-6", name: "Claude Opus 4.6" },
         { id: "claude-sonnet-4-5-20250929", name: "Claude Sonnet 4.5" },
         { id: "claude-haiku-4-5-20251001", name: "Claude Haiku 4.5" },
     ],
@@ -355,11 +505,11 @@ const CODEX_BACKEND = {
     displayName: "Codex (subscription)",
     readTokens: readCodexTokens,
     refreshTokens: refreshCodexToken,
-    query: queryOpenAI,
+    query: queryCodex,
     models: [
-        { id: "gpt-4o", name: "GPT-4o" },
-        { id: "o3", name: "o3" },
-        { id: "o4-mini", name: "o4-mini" },
+        { id: "gpt-5.3-codex", name: "GPT-5.3 Codex" },
+        { id: "gpt-5.2-codex", name: "GPT-5.2 Codex" },
+        { id: "gpt-5.1-codex-mini", name: "GPT-5.1 Codex Mini" },
     ],
 };
 const ALL_BACKENDS = [CLAUDE_BACKEND, GEMINI_BACKEND, CODEX_BACKEND];
@@ -371,10 +521,6 @@ export class SubscriptionProvider {
     backends = [];
     modelToBackend = new Map();
     tokenCache = new Map();
-    /**
-     * Detect which subscription tokens exist on disk.
-     * Returns the number of backends with valid tokens.
-     */
     async detect() {
         for (const backend of ALL_BACKENDS) {
             const tokens = backend.readTokens();
@@ -402,7 +548,6 @@ export class SubscriptionProvider {
     async query(model, prompt, options) {
         const backend = this.modelToBackend.get(model);
         if (!backend) {
-            // Partial match fallback
             const match = this.backends.find((b) => b.models.some((m) => model.includes(m.id) || m.id.includes(model)));
             if (!match) {
                 throw new Error(`No subscription handles model "${model}". ` +
@@ -433,6 +578,6 @@ export class SubscriptionProvider {
                 logger.warn(`Subscription: ${backend.displayName} token refresh failed, trying existing token`);
             }
         }
-        return backend.query(tokens.accessToken, model, prompt, options);
+        return backend.query(tokens, model, prompt, options);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hydramcp",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Multi-model MCP server — compare, vote, and synthesize across GPT, Gemini, Claude, and local models from one terminal",
   "type": "module",
   "main": "dist/index.js",