@jaralabs/codex-bridge 0.2.0 → 0.3.0

package/lib/plugin.ts

@@ -1,28 +1,63 @@
-// codex-bridge OpenCode plugin template.
+// codex-bridge OpenCode plugin.
 //
-// Install: copy this file to ~/.config/opencode/plugins/codex-bridge-models.ts
-//   or run `codex-bridge install-plugin` (TODO).
+// Goals:
+//   1. Register the chatgpt provider pointing at the local bridge
+//      (http://127.0.0.1:11434/v1), pulling the live model list from
+//      ~/.codex/models_cache.json.
+//   2. Register MCP servers (Doop, codegraph, etc.) so they show up in
+//      OpenCode's tool list when the user picks a ChatGPT model.
+//   3. Inject a permission policy (V2 schema) that mirrors ChatGPT Plus:
+//      every MCP tool is `ask`, read-only built-in tools are `allow`.
 //
-// Why a plugin: opencode 2.x doesn't hot-reload provider models when opencode.jsonc
-// changes on disk for short-lived CLI invocations like `opencode run`. In a
-// long-lived TUI server, opencode does reload, and the plugin on `session.created`
-// is purely belt-and-suspenders.
-//
-// The plugin reads ~/.codex/models_cache.json and writes the resulting model list
-// into cfg.provider.chatgpt.models. On TUI restart the change will already be
-// present in opencode.jsonc thanks to lib/sync-cache.mjs running from
-// `codex-bridge start`, so this hook is mostly a no-op.
+// Install: copy this file to ~/.config/opencode/plugins/codex-bridge.ts
+// (or symlink). The bridge does NOT auto-install; that is the user's call.
 
-import { spawnSync } from "node:child_process"
 import { existsSync, readFileSync } from "node:fs"
 import { join } from "node:path"
 
 const CODEX_HOME = process.env.CODEX_HOME || join(process.env.HOME || "/tmp", ".codex")
 const CACHE = join(CODEX_HOME, "models_cache.json")
 const PROVIDER_ID = "chatgpt"
+const BRIDGE_BASE = process.env.CODEX_BRIDGE_BASE || "http://127.0.0.1:11434/v1"
 
 const VISIBLE = new Set(["list", "default", null, undefined])
 
+// MCP servers we always want available, even if the user has not added
+// them via `opencode mcp add`. The user can disable any of these by
+// setting the matching env var to "1":
+//   CODEX_BRIDGE_DISABLE_DOOP=1
+//   CODEX_BRIDGE_DISABLE_CODEGRAPH=1
+//   CODEX_BRIDGE_DISABLE_CODEGRAPH_FE=1
+//   CODEX_BRIDGE_DISABLE_ANGECOM=1
+function defaultMcpServers(): Record<string, any> {
+  const out: Record<string, any> = {}
+  if (process.env.CODEX_BRIDGE_DISABLE_DOOP !== "1") {
+    const cmd = process.env.DOOP_MCP_COMMAND || "npx"
+    const args = (process.env.DOOP_MCP_ARGS || "-y @arqora/doop-mcp").split(" ")
+    out["doop"] = { type: "local", command: [cmd, ...args] }
+  }
+  if (process.env.CODEX_BRIDGE_DISABLE_CODEGRAPH !== "1") {
+    out["codegraph"] = { type: "local", command: ["codegraph", "mcp"] }
+  }
+  if (process.env.CODEX_BRIDGE_DISABLE_CODEGRAPH_FE !== "1") {
+    out["codegraph-fe"] = { type: "local", command: ["codegraph-fe", "mcp"] }
+  }
+  if (process.env.CODEX_BRIDGE_DISABLE_ANGECOM !== "1") {
+    // The angecom MCP lives outside this repo; only register it if the
+    // user has it on disk. This keeps the plugin usable from any cwd.
+    const home = process.env.HOME || "/tmp"
+    const candidate = join(home, "workspace/angecom/angecom-mcp/dist/index.js")
+    if (existsSync(candidate)) {
+      out["angecom"] = {
+        type: "local",
+        command: ["node", candidate],
+        cwd: join(home, "workspace/angecom/angecom-mcp"),
+      }
+    }
+  }
+  return out
+}
+
 function readCache(): string[] {
   if (!existsSync(CACHE)) return []
   try {
@@ -63,33 +98,97 @@ function mergeModels(provider: any, slugs: string[]): void {
   if (!same) provider.models = desired
 }
 
-const CodexBridgeModelsPlugin = {
-  id: "codex-bridge-models",
+// V2 permission schema: an array of { action, resource, effect } rules.
+// Order matters: the last matching rule wins, so we put broad allow
+// rules first, then explicit ask rules for state-changing tools, and
+// finally a global "ask" catch-all so anything not listed still prompts.
+//
+// Read-only tools are allow-listed (Plus UX: reads run silently).
+// Anything that mutates state or hits the network prompts the user.
+function basePermissionRules(): any[] {
+  return [
+    // --- Read-only allow rules (built-in) ---
+    { action: "read", resource: "*", effect: "allow" },
+    { action: "glob", resource: "*", effect: "allow" },
+    { action: "grep", resource: "*", effect: "allow" },
+    { action: "list_mcp_resources", resource: "*", effect: "allow" },
+    { action: "read_mcp_resource", resource: "*", effect: "allow" },
+
+    // --- MCP read-only tools (Doop and codegraph both expose several
+    //     of these; the <server>_<tool> action pattern matches them). ---
+    // We list them explicitly so the saved-approval flow can record
+    // each tool separately instead of one broad rule.
+    { action: "doop_list_canvases", resource: "*", effect: "allow" },
+    { action: "doop_get_guidelines", resource: "*", effect: "allow" },
+    { action: "doop_get_reference", resource: "*", effect: "allow" },
+    { action: "doop_get_comments", resource: "*", effect: "allow" },
+    { action: "doop_get_frame", resource: "*", effect: "allow" },
+    { action: "doop_get_frame_screenshot", resource: "*", effect: "allow" },
+    { action: "doop_get_linear_issue", resource: "*", effect: "allow" },
+    { action: "codegraph_codegraph_explore", resource: "*", effect: "allow" },
+    { action: "codegraph-fe_codegraph_explore", resource: "*", effect: "allow" },
+    { action: "angecom_confluence_list_folder", resource: "*", effect: "allow" },
+    { action: "angecom_jira_get_issue", resource: "*", effect: "allow" },
+    { action: "angecom_jira_get_transitions", resource: "*", effect: "allow" },
+    { action: "angecom_jira_list_attachments", resource: "*", effect: "allow" },
+    { action: "angecom_list_workspaces", resource: "*", effect: "allow" },
+    { action: "angecom_list_mcp_resources", resource: "*", effect: "allow" },
+    { action: "opencode_list_mcp_resources", resource: "*", effect: "allow" },
+    { action: "opencode_read_mcp_resource", resource: "*", effect: "allow" },
+
+    // --- Anything state-changing defaults to ask (Plus behavior). ---
+    { action: "*", resource: "*", effect: "ask" },
+  ]
+}
+
+function mergePermissions(current: any): any[] {
+  const base = basePermissionRules()
+  if (!Array.isArray(current)) return base
+  // User-defined rules win. We keep the base array as a fallback and
+  // append the user rules, so the user's specific "allow" overrides
+  // our "ask" catch-all at the bottom.
+  return [...base, ...current]
+}
+
+const CodexBridgePlugin = {
+  id: "codex-bridge",
   async setup(_ctx: unknown) {
     return {
       config: async (cfg: any) => {
-        const slugs = readCache()
-        if (slugs.length === 0) return
+        // --- Provider ---
         if (!cfg.provider) cfg.provider = {}
         if (!cfg.provider[PROVIDER_ID]) {
           cfg.provider[PROVIDER_ID] = {
             npm: "@ai-sdk/openai-compatible",
             name: "ChatGPT Business (codex-bridge)",
-            options: { baseURL: "http://127.0.0.1:11434/v1" },
+            options: { baseURL: BRIDGE_BASE },
             models: {},
           }
         }
-        mergeModels(cfg.provider[PROVIDER_ID], slugs)
+        const slugs = readCache()
+        if (slugs.length > 0) {
+          mergeModels(cfg.provider[PROVIDER_ID], slugs)
+        }
+
+        // --- MCP servers ---
+        if (!cfg.mcp) cfg.mcp = {}
+        if (!cfg.mcp.servers) cfg.mcp.servers = {}
+        const defaults = defaultMcpServers()
+        for (const [name, def] of Object.entries(defaults)) {
+          if (!cfg.mcp.servers[name]) cfg.mcp.servers[name] = def
+        }
+
+        // --- Permission policy (V2 schema) ---
+        cfg.permissions = mergePermissions(cfg.permissions)
       },
       event: async ({ event }: { event: { type?: string } }) => {
         if (event?.type === "session.created") {
-          // Optional: re-sync at session start. The on-disk JSON file is already
-          // kept up to date by lib/sync-cache.mjs when codex-bridge start runs.
+          // No-op: on-disk config is already kept fresh by lib/sync-cache.mjs.
         }
       },
     }
   },
 }
 
-export default CodexBridgeModelsPlugin
-export { CodexBridgeModelsPlugin }
+export default CodexBridgePlugin
+export { CodexBridgePlugin }

package/lib/server.mjs

@@ -1,190 +1,384 @@
 #!/usr/bin/env node
-// codex-bridge: OpenAI-compatible HTTP server that reuses a local ChatGPT
-// Business/Team/Plus session by shelling out to `codex exec --json`.
-// Default port: 11434. Endpoints:
+// codex-bridge: OpenAI-compatible HTTP server that talks to ChatGPT
+// Business/Team/Plus via the OpenAI Responses API directly. We do NOT
+// shell out to `codex exec` because the CLI rejects Plus/Business
+// models when invoked with `-m <slug>` and the auth path is simpler to
+// reproduce here.
+//
+// Endpoints:
 //   GET  /v1/models            -> { object:"list", data:[...] }
 //   POST /v1/chat/completions  -> OpenAI-style streaming or JSON response
+//   GET  /v1/tools             -> list registered MCP tools
+//   POST /v1/tools             -> register a list of tools
+//   DELETE /v1/tools           -> clear registry
+//
+// Auth: reads ~/.codex/auth.json, refreshes access_token via the OAuth
+// refresh_token grant at https://auth.openai.com/oauth/token when
+// expired.
 //
-// Auth: reads ~/.codex/auth.json (refreshes access_token via OpenAI's
-// refresh_token grant when expired). The token is only used so the
-// shell session stays authenticated; codex CLI handles the actual call.
+// Transport: POST https://chatgpt.com/backend-api/codex/responses with
+// Bearer <access_token> and the OpenAI Responses API body shape. We
+// translate Chat Completions <-> Responses for the OpenCode client.
 
 import http from "node:http";
-import { spawn } from "node:child_process";
-import { readFileSync, existsSync, statSync, readdirSync } from "node:fs";
-import { homedir, userInfo } from "node:os";
-import { join, dirname } from "node:path";
+import { readFileSync, existsSync, writeFileSync, appendFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import {
+  registerTool,
+  registerTools,
+  listTools,
+  clearTools,
+  renderToolsSystemBlock,
+} from "./tools-registry.mjs";
 
 const PORT = Number(process.env.PORT || 11434);
 const HOST = process.env.HOST || "127.0.0.1";
-const CODEX_HOME =
-  process.env.CODEX_HOME || join(homedir(), ".codex");
+const CODEX_HOME = process.env.CODEX_HOME || join(homedir(), ".codex");
 const AUTH_PATH = join(CODEX_HOME, "auth.json");
 const MODELS_CACHE = join(CODEX_HOME, "models_cache.json");
+const CHATGPT_BASE = "https://chatgpt.com/backend-api/codex";
+const OAUTH_TOKEN_URL = "https://auth.openai.com/oauth/token";
+const OAUTH_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann"; // public client id used by codex CLI
+const LOG_PATH = process.env.CODEX_BRIDGE_LOG || "/tmp/codex-bridge.log";
 
-const codexBin = (() => {
-  const fromEnv = process.env.CODEX_BIN;
-  if (fromEnv) return fromEnv;
-  try {
-    const which = spawn("which", ["codex"], { stdio: ["ignore", "pipe", "ignore"] });
-    const out = [];
-    which.stdout.on("data", (c) => out.push(c));
-    which.on("close", () => process.stdout.write(""));
-    // Note: ignored; we instead use the env-default path lookup below.
-  } catch {}
-  return "codex";
-})();
-
-// ---- Logging (JSONL to stderr AND to LOG_FILE if set) ----
-const LOG_FILE = process.env.CODEX_BRIDGE_LOG || "";
-function writeLog(line) {
-  try { process.stderr.write(line + "\n"); } catch {}
-  if (LOG_FILE) {
-    try {
-      appendFileSync(LOG_FILE, line + "\n");
-    } catch {}
-  }
-}
 function log(level, msg, extra) {
-  const line = JSON.stringify({ t: new Date().toISOString(), level, msg, ...extra });
-  writeLog(line);
+  const line = JSON.stringify({ t: new Date().toISOString(), level, msg, ...(extra || {}) });
+  try { appendFileSync(LOG_PATH, line + "\n"); } catch {}
+  if (process.env.CODEX_BRIDGE_VERBOSE) {
+    process.stderr.write(line + "\n");
+  }
 }
 
-import { appendFileSync } from "node:fs";
-process.on("SIGPIPE", () => {});
+// ---- auth ----
+let _authCache = null;
+let _authLoadedAt = 0;
+const AUTH_TTL_MS = 30_000; // re-read the file every 30s
 
-// ---- Auth handling ----
-let authCache = null;
 function loadAuth() {
   if (!existsSync(AUTH_PATH)) {
-    throw new Error(`codex-bridge: no auth.json at ${AUTH_PATH}. Run 'codex login' first.`);
+    throw new Error(`auth.json not found at ${AUTH_PATH}; run \`codex login\` first`);
   }
-  const raw = JSON.parse(readFileSync(AUTH_PATH, "utf8"));
-  if (raw.auth_mode !== "chatgpt") {
-    throw new Error(`codex-bridge: auth mode is '${raw.auth_mode}', need 'chatgpt'.`);
+  if (_authCache && Date.now() - _authLoadedAt < AUTH_TTL_MS) return _authCache;
+  const raw = readFileSync(AUTH_PATH, "utf8");
+  const parsed = JSON.parse(raw);
+  if (parsed.auth_mode !== "chatgpt") {
+    throw new Error(`auth.json auth_mode=${parsed.auth_mode}; only chatgpt supported`);
   }
-  if (!raw.tokens?.access_token) throw new Error("codex-bridge: missing tokens.");
-  return raw;
+  _authCache = parsed.tokens;
+  _authLoadedAt = Date.now();
+  return _authCache;
 }
-function getAuth() {
-  if (!authCache) authCache = loadAuth();
-  return authCache;
+
+async function refreshAccessToken(refreshToken) {
+  const body = new URLSearchParams({
+    grant_type: "refresh_token",
+    refresh_token: refreshToken,
+    client_id: OAUTH_CLIENT_ID,
+    scope: "openid profile email offline-access",
+  });
+  const res = await fetch(OAUTH_TOKEN_URL, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body: body.toString(),
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`oauth refresh failed ${res.status}: ${text.slice(0, 300)}`);
+  }
+  const json = await res.json();
+  const updated = {
+    ..._authCache,
+    access_token: json.access_token,
+    refresh_token: json.refresh_token || _authCache.refresh_token,
+    id_token: json.id_token || _authCache.id_token,
+  };
+  // Persist back to auth.json so subsequent runs pick it up.
+  try {
+    const raw = readFileSync(AUTH_PATH, "utf8");
+    const file = JSON.parse(raw);
+    file.tokens = updated;
+    writeFileSync(AUTH_PATH, JSON.stringify(file, null, 2));
+  } catch (e) {
+    log("warn", "could not persist refreshed tokens", { err: String(e) });
+  }
+  _authCache = updated;
+  return updated;
+}
+
+async function getAuth() {
+  const a = loadAuth();
+  // We don't track expiry precisely; the access_token works until the API
+  // returns 401. Refresh preemptively if the token is missing.
+  if (!a.access_token && a.refresh_token) {
+    return refreshAccessToken(a.refresh_token);
+  }
+  return a;
 }
-// Token refresh is delegated to codex itself; we just rely on the CLI.
 
-// ---- Models listing ----
+// ---- models ----
 function listModels() {
-  const slugId = (s) => ({
-    id: s,
-    object: "model",
-    created: 0,
-    owned_by: "openai-chatgpt",
-  });
-  let slugs = [];
-  if (existsSync(MODELS_CACHE)) {
-    try {
-      const cache = JSON.parse(readFileSync(MODELS_CACHE, "utf8"));
-      if (Array.isArray(cache.models)) {
-        slugs = cache.models
-          .filter((m) => m.visibility === "list" || m.visibility == null)
-          .map((m) => m.slug)
-          .filter(Boolean);
-      }
-    } catch (e) {
-      log("warn", "models_cache.json parse failed", { err: String(e) });
-    }
+  if (!existsSync(MODELS_CACHE)) {
+    return { object: "list", data: [] };
   }
-  if (slugs.length === 0) {
-    slugs = ["gpt-6.1-sol", "gpt-6-sol", "gpt-6-luna", "gpt-6-astra"];
+  try {
+    const cache = JSON.parse(readFileSync(MODELS_CACHE, "utf8"));
+    if (!Array.isArray(cache.models)) return { object: "list", data: [] };
+    const data = cache.models
+      .filter((m) => ["list", "default", null, undefined].includes(m.visibility ?? null))
+      .filter((m) => m.supported_in_api !== false)
+      .map((m) => ({ id: m.slug, object: "model", created: 0, owned_by: "openai-chatgpt" }));
+    return { object: "list", data };
+  } catch (e) {
+    log("warn", "listModels failed", { err: String(e) });
+    return { object: "list", data: [] };
   }
-  return { object: "list", data: slugs.map(slugId) };
 }
 
-// ---- codex exec runner ----
-function runCodex({ model, prompt, signal }) {
-  return new Promise((resolve, reject) => {
-    // Ensure auth is fresh enough for codex exec by reading the file (codex
-    // itself will refresh via its internal logic on the next call).
-    getAuth();
-    const args = [
-      "exec",
-      "--json",
-      "--skip-git-repo-check",
-      "-m", model,
-      prompt,
-    ];
-    const child = spawn(codexBin, args, {
-      env: {
-        ...process.env,
-        CODEX_HOME,
-        NO_COLOR: "1",
-        TERM: "dumb",
-      },
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-    let stdout = "";
-    let stderr = "";
-    let aborted = false;
-    const onAbort = () => {
-      aborted = true;
-      try { child.kill("SIGTERM"); } catch {}
-    };
-    if (signal) signal.addEventListener("abort", onAbort, { once: true });
-    child.stdout.on("data", (c) => (stdout += c.toString()));
-    child.stderr.on("data", (c) => (stderr += c.toString()));
-    child.on("error", (e) => reject(e));
-    child.on("close", (code) => {
-      if (signal) signal.removeEventListener("abort", onAbort);
-      if (aborted) return reject(new Error("aborted"));
-      if (code !== 0) {
-        return reject(
-          new Error(`codex exec exited ${code}: ${stderr.slice(0, 400)}`),
-        );
-      }
-      // Parse the last item.completed agent_message + usage.
-      let lastText = "";
-      let usage = null;
-      for (const line of stdout.split("\n")) {
-        const l = line.trim();
-        if (!l.startsWith("{")) continue;
-        let evt;
-        try { evt = JSON.parse(l); } catch { continue; }
-        if (evt.type === "item.completed" && evt.item?.type === "agent_message") {
-          lastText = evt.item.text ?? lastText;
-        }
-        if (evt.type === "turn.completed") {
-          usage = evt.usage ?? null;
+// ---- OpenAI Chat Completions <-> Responses API translation ----
+//
+// Responses API uses a different shape:
+//   input: [{ type: "message", role, content: [{ type: "input_text", text }] }, ...]
+//   tools: [{ type: "function", name, description, parameters, strict: false }]
+//   output is a list of items:
+//     { type: "message", role: "assistant", content: [{ type: "output_text", text }] }
+//     { type: "function_call", call_id, name, arguments }
+//   To feed tool results back, send input items of type
+//     { type: "function_call_output", call_id, output }
+//
+// We translate from Chat Completions on the way in and back on the way out.
+
+function chatToolsToResponsesTools(tools) {
+  if (!Array.isArray(tools) || tools.length === 0) return undefined;
+  return tools
+    .map((t) => {
+      const fn = t.function || t;
+      if (!fn?.name) return null;
+      return {
+        type: "function",
+        name: fn.name,
+        description: fn.description || "",
+        parameters: fn.parameters || { type: "object", properties: {} },
+        strict: false,
+      };
+    })
+    .filter(Boolean);
+}
+
+function chatMessagesToResponsesInput(messages) {
+  // Chat Completions role types we care about: system, user, assistant, tool, developer.
+  // Responses: instructions (system), input (list of message + function_call + function_call_output).
+  let instructions = "";
+  const input = [];
+  for (const m of messages) {
+    if (!m || !m.role) continue;
+    const role = m.role;
+    if (role === "system" || role === "developer") {
+      const txt = textOf(m.content);
+      if (txt) instructions = (instructions ? instructions + "\n\n" : "") + txt;
+      continue;
+    }
+    if (role === "user") {
+      const txt = textOf(m.content);
+      if (txt) input.push({ type: "message", role: "user", content: [{ type: "input_text", text: txt }] });
+      continue;
+    }
+    if (role === "assistant") {
+      // If the assistant produced tool_calls, emit them as function_call items so
+      // the next function_call_output can match.
+      if (Array.isArray(m.tool_calls) && m.tool_calls.length > 0) {
+        for (const tc of m.tool_calls) {
+          const name = tc.function?.name || tc.name;
+          const args = typeof tc.function?.arguments === "string"
+            ? tc.function.arguments
+            : (typeof tc.arguments === "string" ? tc.arguments : JSON.stringify(tc.arguments ?? {}));
+          input.push({ type: "function_call", call_id: tc.id, name, arguments: args });
         }
       }
-      resolve({ text: lastText, usage, stderr });
-    });
-  });
+      const txt = textOf(m.content);
+      if (txt) {
+        input.push({ type: "message", role: "assistant", content: [{ type: "output_text", text: txt }] });
+      }
+      continue;
+    }
+    if (role === "tool") {
+      const callId = m.tool_call_id || m.call_id;
+      const out = textOf(m.content);
+      if (callId) {
+        input.push({ type: "function_call_output", call_id: callId, output: out });
+      }
+      continue;
+    }
+  }
+  return { instructions, input };
+}
+
+function textOf(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((p) => {
+        if (typeof p === "string") return p;
+        if (!p) return "";
+        if (p.type === "text" || p.type === "input_text" || p.type === "output_text") return p.text || "";
+        if (p.type === "image_url" && p.image_url?.url) return `[image: ${p.image_url.url.slice(0, 60)}]`;
+        return "";
+      })
+      .filter(Boolean)
+      .join("\n");
+  }
+  if (content && typeof content === "object") return JSON.stringify(content);
+  return "";
 }
 
-// ---- OpenAI shape helpers ----
 function now() { return Math.floor(Date.now() / 1000); }
 function genId(prefix) {
   return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
 }
+
 function toUsage(u) {
   if (!u) return { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
-  const input = u.input_tokens ?? 0;
-  const output = u.output_tokens ?? 0;
   return {
-    prompt_tokens: input,
-    completion_tokens: output,
-    total_tokens: input + output,
+    prompt_tokens: u.input_tokens ?? 0,
+    completion_tokens: u.output_tokens ?? 0,
+    total_tokens: (u.input_tokens ?? 0) + (u.output_tokens ?? 0),
   };
 }
-function renderTemplate(tmpl, vars) {
-  if (typeof tmpl === "string") return tmpl.replace(/\{\{(\w+)\}\}/g, (_, k) => vars[k] ?? "");
-  // Multimodal array: replace text parts with {{key}} expansion.
-  return tmpl
-    .map((part) =>
-      part?.type === "text"
-        ? { ...part, text: part.text.replace(/\{\{(\w+)\}\}/g, (_, k) => vars[k] ?? "") }
-        : part,
-    );
+
+// ---- HTTP client to ChatGPT ----
+async function callResponses({ model, instructions, input, tools, signal }) {
+  const auth = await getAuth();
+  const url = `${CHATGPT_BASE}/responses`;
+  const body = {
+    model,
+    store: false,
+    stream: true,
+    instructions: instructions || undefined,
+    input,
+    tool_choice: "auto",
+    parallel_tool_calls: true,
+    prompt_cache_key: `codex-bridge-${Date.now()}`,
+  };
+  if (tools && tools.length > 0) body.tools = tools;
+
+  const headers = {
+    "authorization": `Bearer ${auth.access_token}`,
+    "content-type": "application/json",
+    "accept": "text/event-stream",
+    "OpenAI-Beta": "responses=experimental",
+    "chatgpt-account-id": auth.account_id || "",
+  };
+
+  log("info", "responses.request", { model, instructionsLen: (instructions || "").length, inputItems: input.length, tools: (tools || []).length });
+
+  const res = await fetch(url, { method: "POST", headers, body: JSON.stringify(body), signal });
+  if (res.status === 401 && auth.refresh_token) {
+    log("info", "responses.401 refreshing token");
+    const refreshed = await refreshAccessToken(auth.refresh_token);
+    headers.authorization = `Bearer ${refreshed.access_token}`;
+    const retry = await fetch(url, { method: "POST", headers, body: JSON.stringify(body), signal });
+    if (!retry.ok) {
+      const text = await retry.text();
+      throw new Error(`chatgpt ${retry.status}: ${text.slice(0, 400)}`);
+    }
+    return retry;
+  }
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`chatgpt ${res.status}: ${text.slice(0, 400)}`);
+  }
+  return res;
+}
+
+// Parse SSE stream from Responses API. We accumulate:
+//   - text deltas -> final text
+//   - function_call items -> tool calls
+//   - usage at response.completed
+// Returns { text, toolCalls, usage, raw } where toolCalls is OpenAI shape.
+async function readSse(res) {
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder("utf8");
+  let buf = "";
+  let text = "";
+  const toolCalls = new Map(); // call_id -> { id, name, arguments }
+  let usage = null;
+  let currentItem = null; // { type, id?, call_id?, name?, content_index?, delta? }
+
+  function ensureCall(id, name) {
+    if (!toolCalls.has(id)) toolCalls.set(id, { id, name: name || "", arguments: "" });
+    return toolCalls.get(id);
+  }
+
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buf += decoder.decode(value, { stream: true });
+    let idx;
+    while ((idx = buf.indexOf("\n\n")) !== -1) {
+      const block = buf.slice(0, idx);
+      buf = buf.slice(idx + 2);
+      // Parse "event:" and "data:" lines.
+      let event = "";
+      let data = "";
+      for (const line of block.split("\n")) {
+        if (line.startsWith("event: ")) event = line.slice(7).trim();
+        else if (line.startsWith("data:")) data += (data ? "\n" : "") + line.slice(5).trim();
+      }
+      if (!data) continue;
+      if (data === "[DONE]") continue;
+      let json;
+      try { json = JSON.parse(data); } catch { continue; }
+      const t = json.type || event;
+      switch (t) {
+        case "response.output_item.added": {
+          const item = json.item || {};
+          currentItem = { type: item.type, id: item.id, call_id: item.call_id, name: item.name, content_index: 0 };
+          if (item.type === "function_call") {
+            ensureCall(item.call_id, item.name);
+          }
+          break;
+        }
+        case "response.function_call_arguments.delta": {
+          const id = json.call_id || currentItem?.call_id;
+          if (id) {
+            const call = ensureCall(id, currentItem?.name || json.name);
+            call.arguments += json.delta || "";
+          }
+          break;
+        }
+        case "response.function_call_arguments.done": {
+          const id = json.call_id || currentItem?.call_id;
+          if (id && typeof json.arguments === "string") {
+            const call = ensureCall(id, currentItem?.name || json.name);
+            call.arguments = json.arguments;
+          }
+          break;
+        }
+        case "response.output_text.delta": {
+          text += json.delta || "";
+          break;
+        }
+        case "response.completed": {
+          const r = json.response || {};
+          if (r.usage) usage = r.usage;
+          // Synthesize text from output if we missed deltas.
+          if (!text && Array.isArray(r.output)) {
+            for (const item of r.output) {
+              if (item.type === "message") {
+                for (const part of item.content || []) {
+                  if (part.type === "output_text" && part.text) text += part.text;
+                }
+              }
+            }
+          }
+          break;
+        }
+        default:
+          break;
+      }
+    }
+  }
+  return { text, toolCalls: Array.from(toolCalls.values()), usage };
 }
 
 // ---- HTTP server ----
@@ -197,6 +391,22 @@ const server = http.createServer(async (req, res) => {
     if (req.method === "GET" && url.pathname === "/v1/models") {
       return json(res, 200, listModels());
     }
+    if (req.method === "GET" && url.pathname === "/v1/tools") {
+      return json(res, 200, { object: "list", data: listTools() });
+    }
+    if (req.method === "POST" && url.pathname === "/v1/tools") {
+      const body = await readBody(req);
+      let payload;
+      try { payload = JSON.parse(body); } catch { return json(res, 400, { error: { message: "invalid JSON" } }); }
+      if (Array.isArray(payload)) registerTools(payload);
+      else if (Array.isArray(payload?.tools)) registerTools(payload.tools);
+      else return json(res, 400, { error: { message: "expected array or { tools: [...] }" } });
+      return json(res, 200, { object: "list", data: listTools(), count: listTools().length });
+    }
+    if (req.method === "DELETE" && url.pathname === "/v1/tools") {
+      clearTools();
+      return json(res, 200, { object: "list", data: [], count: 0 });
+    }
     if (req.method === "POST" && url.pathname === "/v1/chat/completions") {
       const body = await readBody(req);
       let payload;
@@ -249,98 +459,113 @@ async function handleChatCompletions(payload, req, res) {
     temperature,
     top_p,
     max_tokens,
+    tools,
   } = payload || {};
   if (!model) return json(res, 400, { error: { message: "model is required" } });
   if (!Array.isArray(messages) || messages.length === 0) {
     return json(res, 400, { error: { message: "messages[] required" } });
   }
 
-  // Build prompt: concatenate system/user/assistant turns.
-  const parts = [];
-  let lastRole = null;
-  for (const m of messages) {
-    if (!m || !m.role) continue;
-    let text = "";
-    if (typeof m.content === "string") text = m.content;
-    else if (Array.isArray(m.content)) {
-      text = m.content
-        .filter((p) => p?.type === "text")
-        .map((p) => p.text || "")
-        .join("\n");
-    } else if (m.content) text = String(m.content);
-    if (!text && m.role !== lastRole) parts.push("");
-    if (text) {
-      const tag = m.role.toUpperCase();
-      parts.push(`${tag}: ${text}`);
+  const ac = new AbortController();
+  req.on("close", () => ac.abort());
+
+  // Build the Responses API input. If no `tools` came in, we still inject
+  // a Plus-style system block describing the registered tools so the model
+  // can call them.
+  const responsesTools = chatToolsToResponsesTools(tools);
+  let { instructions, input } = chatMessagesToResponsesInput(messages);
+  if (!(responsesTools && responsesTools.length > 0)) {
+    const block = renderToolsSystemBlock();
+    if (block) {
+      instructions = instructions ? `${instructions}\n\n${block}` : block;
     }
-    lastRole = m.role;
   }
-  parts.push("ASSISTANT:");
-  const prompt = parts.filter(Boolean).join("\n\n");
 
-  const ac = new AbortController();
-  req.on("close", () => ac.abort());
+  log("info", "chat.completions", { model, stream, msgs: messages.length, toolCount: (tools || []).length });
 
-  log("info", "chat.completions", { model, stream, msgs: messages.length });
+  // Single call. We do NOT loop in this implementation: when the model
+  // emits tool_calls, we return finish_reason=tool_calls to OpenCode.
+  // OpenCode will run the tools, send role:"tool" messages back, and the
+  // bridge makes a fresh request that includes those items.
   let result;
   try {
-    result = await runCodex({ model, prompt, signal: ac.signal });
+    const upstream = await callResponses({
+      model,
+      instructions,
+      input,
+      tools: responsesTools,
+      signal: ac.signal,
+    });
+    result = await readSse(upstream);
   } catch (e) {
-    return json(res, 502, { error: { message: String(e.message || e), type: "codex_error" } });
+    return json(res, 502, { error: { message: String(e.message || e), type: "upstream_error" } });
   }
 
   const id = genId("chatcmpl");
   const created = now();
   const usage = toUsage(result.usage);
+  const hasToolCalls = result.toolCalls && result.toolCalls.length > 0;
+  const finishReason = hasToolCalls ? "tool_calls" : "stop";
+  const message = { role: "assistant", content: result.text || "" };
+  if (hasToolCalls) {
+    message.tool_calls = result.toolCalls.map((c, i) => ({
+      index: i,
+      id: c.id,
+      function: { name: c.name, arguments: c.arguments || "" },
+    }));
+  }
 
   if (stream) {
     startSse(res);
-    // First chunk: role.
     sse(res, null, {
-      id, object: "chat.completion.chunk", created,
-      model, choices: [{ index: 0, delta: { role: "assistant" }, finish_reason: null }],
+      id, object: "chat.completion.chunk", created, model,
+      choices: [{ index: 0, delta: { role: "assistant" }, finish_reason: null }],
     });
-    // Content chunk (codex exec doesn't stream per-token; emit as one).
     if (result.text) {
       sse(res, null, {
-        id, object: "chat.completion.chunk", created,
-        model,
-        choices: [{
-          index: 0,
-          delta: { content: result.text },
-          finish_reason: null,
-        }],
+        id, object: "chat.completion.chunk", created, model,
+        choices: [{ index: 0, delta: { content: result.text }, finish_reason: null }],
       });
     }
-    // Final chunk with finish_reason + usage.
-    sse(res, null, {
-      id, object: "chat.completion.chunk", created, model,
-      choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
-    });
+    if (hasToolCalls) {
+      for (let i = 0; i < result.toolCalls.length; i++) {
+        const c = result.toolCalls[i];
+        sse(res, null, {
+          id, object: "chat.completion.chunk", created, model,
+          choices: [{
+            index: 0,
+            delta: {
+              tool_calls: [{
+                index: i,
+                id: c.id,
+                function: { name: c.name, arguments: c.arguments || "" },
+              }],
+            },
+            finish_reason: null,
+          }],
+        });
+      }
+    }
     sse(res, null, {
       id, object: "chat.completion.chunk", created, model,
-      choices: [],
-      usage,
+      choices: [{ index: 0, delta: {}, finish_reason: finishReason }],
     });
+    sse(res, null, { id, object: "chat.completion.chunk", created, model, choices: [], usage });
+    // The "[DONE]" sentinel is the literal string, not a JSON-encoded one.
     res.write("data: [DONE]\n\n");
-    res.end();
-    return;
+    return res.end();
   }
 
   return json(res, 200, {
     id, object: "chat.completion", created, model,
-    choices: [{
-      index: 0,
-      message: { role: "assistant", content: result.text },
-      finish_reason: "stop",
-      logprobs: null,
-    }],
+    choices: [{ index: 0, message, finish_reason: finishReason, logprobs: null }],
     usage,
   });
 }
 
 server.listen(PORT, HOST, () => {
   log("info", "listening", { url: `http://${HOST}:${PORT}`, codex_home: CODEX_HOME });
+  process.stderr.write(`codex-bridge listening on http://${HOST}:${PORT}\n`);
 });
 
 process.on("SIGTERM", () => server.close(() => process.exit(0)));

package/lib/tools-registry.mjs

@@ -0,0 +1,57 @@
+// tools-registry: tracks the list of MCP tools available to the bridge.
+//
+// In a normal ChatGPT Plus setup, the model "knows" about its tools via a
+// system prompt that lists them. OpenCode does NOT inject the live MCP
+// catalog into /v1/chat/completions (it only sends `tools` when the AI SDK
+// explicitly enabled tool calling on the provider). To make the bridge feel
+// like Plus, we maintain a small registry that the OpenCode plugin can
+// populate via /v1/tools, and that handleChatCompletions injects into the
+// system prompt when the model has no other source of tool awareness.
+//
+// The registry is in-memory and process-local. A real deployment would
+// persist this to ~/.codex/tools_cache.json, but the bridge process is
+// short-lived enough (one process per TUI session is overkill; the TUI
+// restarts re-register via the plugin) that the in-memory map is fine.
+
+const tools = new Map(); // name -> { server, description, parameters, serverType, command?, url? }
+
+export function registerTool(name, meta) {
+  if (!name) return;
+  tools.set(name, {
+    server: meta.server || "unknown",
+    description: meta.description || "",
+    parameters: meta.parameters || { type: "object", properties: {} },
+    serverType: meta.serverType || "local",
+    command: meta.command,
+    url: meta.url,
+    registeredAt: Date.now(),
+  });
+}
+
+export function registerTools(list) {
+  if (!Array.isArray(list)) return;
+  for (const t of list) {
+    if (t?.name) registerTool(t.name, t);
+  }
+}
+
+export function listTools() {
+  return Array.from(tools.entries()).map(([name, meta]) => ({ name, ...meta }));
+}
+
+export function clearTools() {
+  tools.clear();
+}
+
+// Render the registry as a system-prompt block. We use a compact format
+// the model can parse: each tool on its own line with a JSON schema.
+export function renderToolsSystemBlock() {
+  if (tools.size === 0) return "";
+  const lines = ["You have access to the following tools. To call one, emit a tool_call with the matching name and JSON arguments."];
+  for (const [name, meta] of tools.entries()) {
+    const params = JSON.stringify(meta.parameters || { type: "object" });
+    const desc = meta.description ? ` — ${meta.description}` : "";
+    lines.push(`- ${name}${desc}  args=${params}`);
+  }
+  return lines.join("\n");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jaralabs/codex-bridge",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "private": false,
   "description": "OpenAI-compatible HTTP bridge that reuses a local ChatGPT Business / Team / Plus session via codex, so OpenCode can list and call those models without paying for the OpenAI API.",
   "type": "module",
@@ -32,7 +32,8 @@
     "status": "bin/codex-bridge status",
     "sync": "bin/codex-bridge sync",
     "logs": "bin/codex-bridge logs",
-    "test": "node test/test.mjs"
+    "test": "node test/test.mjs",
+    "test:tools": "node test/test-tools.mjs"
   },
   "repository": {
     "type": "git",
@@ -51,5 +52,9 @@
     "coding-agent"
   ],
   "author": "Andrew Jaramillo <javamillog1999@outlook.com>",
-  "license": "MIT"
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^26.6.5",
+    "typescript": "^7.0.2"
+  }
 }