@chatpanel/bridge 0.10.26 → 0.10.27

package/README.md

@@ -87,6 +87,11 @@ npm start                    # → http://127.0.0.1:4319
 |--------|------|---------|
 | `GET`  | `/health` | `{ ok, version, agents:[{id,label,available,reason}] }` |
 | `POST` | `/chat`   | SSE stream — body `{ agent, system, options, messages }` |
+| `GET`  | `/v1/models` | OpenAI-compatible list of available local agents |
+| `POST` | `/v1/chat/completions` | OpenAI-compatible Chat Completions (streaming and non-streaming) |
+| `POST` | `/v1/completions` | OpenAI-compatible legacy text Completions (streaming and non-streaming) |
+| `POST` | `/v1/responses` | OpenAI-compatible Responses API (streaming and non-streaming) |
+| `POST` | `/v1/messages` | Anthropic-compatible Messages API (streaming and non-streaming) |
 
 `/chat` streams Server-Sent Events: `{type:'delta',text}` as the answer is
 generated, `{type:'tool',name,summary}` / `{type:'status'}` for activity, and a
@@ -102,6 +107,57 @@ final `{type:'done'}` (or `{type:'error',error}`).
 }
 ```
 
+### OpenAI and Anthropic SDK compatibility
+
+The compatibility routes run a local coding agent; they do not call a provider
+API. Use the per-install token from `~/.chatpanel/bridge-token` as the SDK API
+key. The token protects endpoints that can start local processes, so do not put
+it in browser-delivered code or share it.
+
+For OpenAI clients, set the base URL to `http://127.0.0.1:4319/v1` and use an
+installed agent id such as `codex` as the model:
+
+```js
+import OpenAI from 'openai';
+import { readFileSync } from 'node:fs';
+
+const client = new OpenAI({
+  apiKey: readFileSync(`${process.env.HOME}/.chatpanel/bridge-token`, 'utf8').trim(),
+  baseURL: 'http://127.0.0.1:4319/v1',
+});
+
+const result = await client.responses.create({
+  model: 'codex',
+  input: 'Explain this project in three bullets.',
+});
+console.log(result.output_text);
+```
+
+`client.chat.completions.create(...)` and legacy `client.completions.create(...)`
+work through the same base URL. For the Anthropic SDK, use
+`http://127.0.0.1:4319` as its base URL and the same token as its API key;
+requests to `/v1/messages` can also use `model: "codex"`.
+
+The model field selects the local agent. `codex/gpt-5.5`, for example, selects
+the Codex agent and passes `gpt-5.5` as its CLI model override. Advanced bridge
+settings can be supplied through an extra `chatpanel` request object:
+
+```jsonc
+{
+  "model": "codex",
+  "messages": [{ "role": "user", "content": "Fix the failing tests." }],
+  "chatpanel": {
+    "working_dir": "/absolute/path/to/project",
+    "permission_mode": "acceptEdits",
+    "use_local_config": true
+  }
+}
+```
+
+The adapter currently covers text conversations. Provider-hosted function tools,
+stored responses, log probabilities, and exact token accounting are not
+available; unsupported tool requests return HTTP 400, and usage counts are zero.
+
 ## Safety
 
 - Binds to `127.0.0.1` only; CORS accepts the extension origin and localhost.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/bridge",
-  "version": "0.10.26",
+  "version": "0.10.27",
   "type": "module",
   "description": "Local bridge that exposes the AI coding agents installed on your machine \u2014 Claude Code (CLI), Codex (CLI), and Antigravity CLI (formerly Gemini CLI, which remains available for business/enterprise) \u2014 to the ChatPanel Chrome extension over a localhost SSE endpoint. Bring your own agent.",
   "keywords": [

package/scripts/test-codex-httpie.sh

@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+bridge_url="${CHATPANEL_BRIDGE_URL:-http://127.0.0.1:4319}"
+token_file="${CHATPANEL_BRIDGE_TOKEN_FILE:-${HOME}/.chatpanel/bridge-token}"
+prompt="${*:-Reply with exactly: httpie-codex-ok}"
+
+if ! command -v http >/dev/null 2>&1; then
+  echo 'HTTPie is required. Install it with: brew install httpie' >&2
+  exit 1
+fi
+
+if [[ ! -r "$token_file" ]]; then
+  echo "Bridge token is not readable: $token_file" >&2
+  exit 1
+fi
+
+bridge_token="$(tr -d '\r\n' < "$token_file")"
+if [[ -z "$bridge_token" ]]; then
+  echo "Bridge token is empty: $token_file" >&2
+  exit 1
+fi
+
+response="$({
+  http --check-status --ignore-stdin --body POST "$bridge_url/v1/responses" \
+    Authorization:"Bearer $bridge_token" \
+    model=codex \
+    input="$prompt"
+})"
+
+if command -v jq >/dev/null 2>&1; then
+  jq -r '.output[]?.content[]? | select(.type == "output_text") | .text' <<< "$response"
+else
+  printf '%s\n' "$response"
+fi

package/src/api-compat.js

@@ -0,0 +1,292 @@
+// OpenAI + Anthropic wire-format adapters for ChatPanel's local agent engines.
+//
+// This intentionally implements the text conversation subset shared by coding
+// agents. Provider-hosted features (token accounting, stored responses, remote
+// function tools, logprobs, etc.) cannot be reproduced by a local CLI runner and
+// are rejected when accepting them would produce misleading behavior.
+
+import { randomUUID } from 'node:crypto';
+
+const AGENT_IDS = new Set(['claude', 'codex', 'antigravity', 'pi', 'opencode', 'kiro', 'copilot', 'deepseek']);
+
+export class CompatError extends Error {
+  constructor(message, status = 400, param = null) {
+    super(message);
+    this.status = status;
+    this.param = param;
+  }
+}
+
+function textOf(content) {
+  if (content == null) return '';
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return String(content);
+  return content.map((part) => {
+    if (typeof part === 'string') return part;
+    if (!part || typeof part !== 'object') return '';
+    if (typeof part.text === 'string') return part.text;
+    if (typeof part.content === 'string') return part.content;
+    if (part.type === 'tool_result') return textOf(part.content);
+    return '';
+  }).filter(Boolean).join('\n');
+}
+
+function assertTextContent(content, param) {
+  if (content == null || typeof content === 'string') return;
+  if (!Array.isArray(content)) throw new CompatError(`${param} must contain text`, 400, param);
+  for (const part of content) {
+    if (typeof part === 'string') continue;
+    const type = part?.type;
+    if (part && typeof part === 'object' && (!type || ['text', 'input_text', 'output_text'].includes(type)) && typeof part.text === 'string') continue;
+    if (type === 'tool_result') {
+      assertTextContent(part.content, param);
+      continue;
+    }
+    throw new CompatError(`${param} contains unsupported non-text content`, 400, param);
+  }
+}
+
+function normalizeMessages(items = []) {
+  return items.map((item) => ({
+    role: item?.role === 'assistant' ? 'assistant' : 'user',
+    content: textOf(item?.content),
+  })).filter((item) => item.content);
+}
+
+function resolveTarget(model, chatpanel = {}) {
+  const requested = String(model || 'codex').trim() || 'codex';
+  const slash = requested.indexOf('/');
+  const prefix = slash < 0 ? requested : requested.slice(0, slash);
+  const explicitAgent = String(chatpanel.agent || '').trim();
+  const agent = explicitAgent || (AGENT_IDS.has(prefix) ? prefix : 'codex');
+  if (!AGENT_IDS.has(agent)) throw new CompatError(`Unknown ChatPanel agent "${agent}"`, 400, 'model');
+
+  let engineModel = String(chatpanel.model || '').trim();
+  if (!engineModel && slash >= 0 && AGENT_IDS.has(prefix)) engineModel = requested.slice(slash + 1);
+  if (!engineModel && !AGENT_IDS.has(requested)) engineModel = requested;
+
+  const permissionMode = chatpanel.permission_mode || chatpanel.permissionMode || 'default';
+  if (!['default', 'acceptEdits', 'bypassPermissions'].includes(permissionMode)) {
+    throw new CompatError('chatpanel.permission_mode must be default, acceptEdits, or bypassPermissions', 400, 'chatpanel.permission_mode');
+  }
+  return {
+    agent,
+    requestedModel: requested,
+    options: {
+      workingDir: chatpanel.working_dir || chatpanel.workingDir || process.env.CHATPANEL_API_WORKING_DIR || '',
+      permissionMode,
+      useLocalConfig: chatpanel.use_local_config ?? chatpanel.useLocalConfig ?? true,
+      ...(engineModel ? { model: engineModel } : {}),
+    },
+  };
+}
+
+export function parseChatCompletion(body = {}) {
+  if (!Array.isArray(body.messages) || !body.messages.length) {
+    throw new CompatError('messages must be a non-empty array', 400, 'messages');
+  }
+  if (body.tools?.length) throw new CompatError('OpenAI tool calling is not supported by the bridge adapter', 400, 'tools');
+  for (const message of body.messages) {
+    if (!['system', 'developer', 'user', 'assistant'].includes(message?.role)) {
+      throw new CompatError(`Unsupported message role "${message?.role || ''}"`, 400, 'messages');
+    }
+    assertTextContent(message.content, 'messages');
+  }
+  const system = body.messages
+    .filter((m) => m?.role === 'system' || m?.role === 'developer')
+    .map((m) => textOf(m.content)).filter(Boolean).join('\n\n');
+  const messages = normalizeMessages(body.messages.filter((m) => m?.role !== 'system' && m?.role !== 'developer'));
+  if (!messages.length) throw new CompatError('messages must contain user or assistant text', 400, 'messages');
+  return { ...resolveTarget(body.model, body.chatpanel), system, messages, stream: body.stream === true };
+}
+
+export function parseCompletion(body = {}) {
+  if (Array.isArray(body.prompt)) {
+    for (const prompt of body.prompt) assertTextContent(prompt, 'prompt');
+  } else {
+    assertTextContent(body.prompt, 'prompt');
+  }
+  const prompt = Array.isArray(body.prompt) ? body.prompt.map(textOf).join('\n') : textOf(body.prompt);
+  if (!prompt) throw new CompatError('prompt must contain text', 400, 'prompt');
+  return {
+    ...resolveTarget(body.model, body.chatpanel),
+    system: '',
+    messages: [{ role: 'user', content: prompt }],
+    stream: body.stream === true,
+  };
+}
+
+export function parseResponse(body = {}) {
+  if (body.tools?.length) throw new CompatError('Responses API tool calling is not supported by the bridge adapter', 400, 'tools');
+  let input = body.input;
+  if (typeof input === 'string') input = [{ role: 'user', content: input }];
+  if (!Array.isArray(input) || !input.length) throw new CompatError('input must be a string or non-empty array', 400, 'input');
+  assertTextContent(body.instructions, 'instructions');
+  for (const item of input) {
+    if (!['system', 'developer', 'user', 'assistant'].includes(item?.role)) {
+      throw new CompatError('input currently supports only text message items', 400, 'input');
+    }
+    assertTextContent(item.content, 'input');
+  }
+  const systemParts = [textOf(body.instructions)];
+  for (const item of input) {
+    if (item?.role === 'system' || item?.role === 'developer') systemParts.push(textOf(item.content));
+  }
+  const messages = normalizeMessages(input.filter((item) => item?.role !== 'system' && item?.role !== 'developer'));
+  if (!messages.length) throw new CompatError('input must contain user or assistant text', 400, 'input');
+  return {
+    ...resolveTarget(body.model, body.chatpanel),
+    system: systemParts.filter(Boolean).join('\n\n'),
+    messages,
+    stream: body.stream === true,
+  };
+}
+
+export function parseAnthropicMessage(body = {}) {
+  if (!Array.isArray(body.messages) || !body.messages.length) {
+    throw new CompatError('messages must be a non-empty array', 400, 'messages');
+  }
+  if (body.tools?.length) throw new CompatError('Anthropic tool use is not supported by the bridge adapter', 400, 'tools');
+  assertTextContent(body.system, 'system');
+  for (const message of body.messages) {
+    if (!['user', 'assistant'].includes(message?.role)) {
+      throw new CompatError(`Unsupported message role "${message?.role || ''}"`, 400, 'messages');
+    }
+    assertTextContent(message.content, 'messages');
+  }
+  const messages = normalizeMessages(body.messages);
+  if (!messages.length) throw new CompatError('messages must contain text', 400, 'messages');
+  return {
+    ...resolveTarget(body.model, body.chatpanel),
+    system: textOf(body.system),
+    messages,
+    stream: body.stream === true,
+  };
+}
+
+export function openAIError(error) {
+  return {
+    error: {
+      message: error?.message || String(error),
+      type: error instanceof CompatError ? 'invalid_request_error' : 'api_error',
+      param: error?.param || null,
+      code: null,
+    },
+  };
+}
+
+export function anthropicError(error) {
+  return {
+    type: 'error',
+    error: {
+      type: error instanceof CompatError ? 'invalid_request_error' : 'api_error',
+      message: error?.message || String(error),
+    },
+  };
+}
+
+const zeroUsage = () => ({ prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 });
+const responseUsage = () => ({ input_tokens: 0, input_tokens_details: { cached_tokens: 0 }, output_tokens: 0, output_tokens_details: { reasoning_tokens: 0 }, total_tokens: 0 });
+
+export function createChatCompletion(model, text, { id = `chatcmpl-${randomUUID()}`, created = Math.floor(Date.now() / 1000) } = {}) {
+  return {
+    id, object: 'chat.completion', created, model,
+    choices: [{ index: 0, message: { role: 'assistant', content: text, refusal: null }, logprobs: null, finish_reason: 'stop' }],
+    usage: zeroUsage(),
+  };
+}
+
+export function createCompletion(model, text, { id = `cmpl-${randomUUID()}`, created = Math.floor(Date.now() / 1000) } = {}) {
+  return {
+    id, object: 'text_completion', created, model,
+    choices: [{ text, index: 0, logprobs: null, finish_reason: 'stop' }],
+    usage: zeroUsage(),
+  };
+}
+
+export function completionStream(model, onWrite, { id = `cmpl-${randomUUID()}`, created = Math.floor(Date.now() / 1000) } = {}) {
+  const chunk = (text, finish_reason = null) => ({
+    id, object: 'text_completion', created, model,
+    choices: [{ text, index: 0, logprobs: null, finish_reason }],
+  });
+  return {
+    delta(text) { if (text) onWrite(chunk(text)); },
+    done() { onWrite(chunk('', 'stop')); },
+  };
+}
+
+export function chatCompletionStream(model, onWrite, { id = `chatcmpl-${randomUUID()}`, created = Math.floor(Date.now() / 1000) } = {}) {
+  const chunk = (delta, finish_reason = null) => ({
+    id, object: 'chat.completion.chunk', created, model,
+    choices: [{ index: 0, delta, logprobs: null, finish_reason }],
+  });
+  let started = false;
+  return {
+    delta(text) {
+      if (!started) { onWrite(chunk({ role: 'assistant', content: '' })); started = true; }
+      if (text) onWrite(chunk({ content: text }));
+    },
+    done() {
+      if (!started) onWrite(chunk({ role: 'assistant', content: '' }));
+      onWrite(chunk({}, 'stop'));
+    },
+  };
+}
+
+function responseObject(model, text, { id, created, status = 'completed' }) {
+  const itemId = `msg_${id.slice(-24)}`;
+  return {
+    id, object: 'response', created_at: created, status, error: null, incomplete_details: null,
+    instructions: null, max_output_tokens: null, model,
+    output: status === 'completed' ? [{ id: itemId, type: 'message', status: 'completed', role: 'assistant', content: [{ type: 'output_text', text, annotations: [], logprobs: [] }] }] : [],
+    parallel_tool_calls: false, previous_response_id: null, reasoning: { effort: null, summary: null }, store: false,
+    temperature: null, text: { format: { type: 'text' } }, tool_choice: 'none', tools: [], top_p: null,
+    truncation: 'disabled', usage: status === 'completed' ? responseUsage() : null, user: null, metadata: {},
+  };
+}
+
+export function createResponse(model, text, { id = `resp_${randomUUID()}`, created = Math.floor(Date.now() / 1000) } = {}) {
+  return responseObject(model, text, { id, created });
+}
+
+export function responseStream(model, onWrite, { id = `resp_${randomUUID()}`, created = Math.floor(Date.now() / 1000) } = {}) {
+  const itemId = `msg_${id.slice(-24)}`;
+  let sequence = 0;
+  let text = '';
+  onWrite({ type: 'response.created', sequence_number: sequence++, response: responseObject(model, '', { id, created, status: 'in_progress' }) });
+  onWrite({ type: 'response.in_progress', sequence_number: sequence++, response: responseObject(model, '', { id, created, status: 'in_progress' }) });
+  onWrite({ type: 'response.output_item.added', sequence_number: sequence++, output_index: 0, item: { id: itemId, type: 'message', status: 'in_progress', role: 'assistant', content: [] } });
+  onWrite({ type: 'response.content_part.added', sequence_number: sequence++, item_id: itemId, output_index: 0, content_index: 0, part: { type: 'output_text', text: '', annotations: [], logprobs: [] } });
+  return {
+    delta(value) {
+      if (!value) return;
+      text += value;
+      onWrite({ type: 'response.output_text.delta', sequence_number: sequence++, item_id: itemId, output_index: 0, content_index: 0, delta: value, logprobs: [] });
+    },
+    done() {
+      onWrite({ type: 'response.output_text.done', sequence_number: sequence++, item_id: itemId, output_index: 0, content_index: 0, text, logprobs: [] });
+      const part = { type: 'output_text', text, annotations: [], logprobs: [] };
+      onWrite({ type: 'response.content_part.done', sequence_number: sequence++, item_id: itemId, output_index: 0, content_index: 0, part });
+      const item = { id: itemId, type: 'message', status: 'completed', role: 'assistant', content: [part] };
+      onWrite({ type: 'response.output_item.done', sequence_number: sequence++, output_index: 0, item });
+      onWrite({ type: 'response.completed', sequence_number: sequence++, response: responseObject(model, text, { id, created }) });
+    },
+  };
+}
+
+export function createAnthropicMessage(model, text, { id = `msg_${randomUUID()}` } = {}) {
+  return { id, type: 'message', role: 'assistant', model, content: [{ type: 'text', text }], stop_reason: 'end_turn', stop_sequence: null, usage: { input_tokens: 0, output_tokens: 0 } };
+}
+
+export function anthropicStream(model, onWrite, { id = `msg_${randomUUID()}` } = {}) {
+  onWrite('message_start', { type: 'message_start', message: { id, type: 'message', role: 'assistant', model, content: [], stop_reason: null, stop_sequence: null, usage: { input_tokens: 0, output_tokens: 0 } } });
+  onWrite('content_block_start', { type: 'content_block_start', index: 0, content_block: { type: 'text', text: '' } });
+  return {
+    delta(text) { if (text) onWrite('content_block_delta', { type: 'content_block_delta', index: 0, delta: { type: 'text_delta', text } }); },
+    done() {
+      onWrite('content_block_stop', { type: 'content_block_stop', index: 0 });
+      onWrite('message_delta', { type: 'message_delta', delta: { stop_reason: 'end_turn', stop_sequence: null }, usage: { output_tokens: 0 } });
+      onWrite('message_stop', { type: 'message_stop' });
+    },
+  };
+}

package/src/server.js

@@ -11,6 +11,9 @@
 //                     {type:'status'|'reasoning', text?}
 //                     {type:'done',  text?}    (text only if not streamed)
 //                     {type:'error', error}
+//   POST /v1/chat/completions, /v1/completions, /v1/responses
+//                 → OpenAI-compatible text adapters for the local agents
+//   POST /v1/messages → Anthropic-compatible text adapter for the local agents
 //
 // Binds to 127.0.0.1 only. A request guard (see `guard()`) enforces a loopback
 // Host (anti DNS-rebinding) and an allowlisted Origin; the command-spawning
@@ -36,11 +39,28 @@ import { checkForUpdate, selfUpdate } from './update.js';
 import { callLocalMcp } from './mcp-local.js';
 import { assertPublicHttpUrl, assertPublicWebUrl } from './ssrf.js';
 import { startRun, endRun, cancelRun, cancelAll, activeRuns } from './runs.js';
+import {
+  CompatError,
+  anthropicError,
+  anthropicStream,
+  chatCompletionStream,
+  completionStream,
+  createAnthropicMessage,
+  createChatCompletion,
+  createCompletion,
+  createResponse,
+  openAIError,
+  parseAnthropicMessage,
+  parseChatCompletion,
+  parseCompletion,
+  parseResponse,
+  responseStream,
+} from './api-compat.js';
 
 // Hardcoded (not read from package.json) so it survives Bun's single-file
 // --compile, where package.json isn't on a readable FS. CI fails the publish if
 // this drifts from package.json, so the two can't silently diverge.
-const VERSION = '0.10.26';
+const VERSION = '0.10.27';
 const HOST = process.env.CHATPANEL_BRIDGE_HOST || '127.0.0.1';
 const PORT = Number(process.env.CHATPANEL_BRIDGE_PORT) || 4319;
 
@@ -163,7 +183,7 @@ function cors(req, res) {
   const allow = originAllowed(origin);
   res.setHeader('Access-Control-Allow-Origin', allow ? origin || '*' : 'null');
   res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-  res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-ChatPanel-Token');
+  res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-Api-Key, Anthropic-Version, X-ChatPanel-Token');
   res.setHeader('Vary', 'Origin');
 }
 
@@ -219,7 +239,9 @@ function ensureToken() {
 function tokenOk(req) {
   if (!AUTH_TOKEN) return false;
   const h = String(req.headers['authorization'] || '');
-  const provided = (h.startsWith('Bearer ') ? h.slice(7) : String(req.headers['x-chatpanel-token'] || '')).trim();
+  const provided = (h.startsWith('Bearer ')
+    ? h.slice(7)
+    : String(req.headers['x-api-key'] || req.headers['x-chatpanel-token'] || '')).trim();
   if (!provided) return false;
   const a = Buffer.from(provided);
   const b = Buffer.from(AUTH_TOKEN);
@@ -232,6 +254,10 @@ function tokenOk(req) {
 // local coding-agent CLIs connect to them with no Origin header by design.
 const PRIVILEGED_POST = new Set([
   '/chat',
+  '/v1/chat/completions',
+  '/v1/completions',
+  '/v1/responses',
+  '/v1/messages',
   '/mcp-local',
   '/mcp-remote',
   '/fetch-title',
@@ -313,6 +339,30 @@ async function handleHealth(res) {
   json(res, 200, { ok: true, version: VERSION, agents, update });
 }
 
+async function compatibleModels() {
+  const rows = await Promise.all(
+    Object.entries(ENGINES)
+      .filter(([, entry]) => !entry.hidden)
+      .map(async ([id, entry]) => ({
+        id,
+        object: 'model',
+        created: 0,
+        owned_by: 'chatpanel',
+        available: !!(await entry.engine.available().catch(() => ({ ok: false }))).ok,
+      })),
+  );
+  return rows.filter((row) => row.available).map(({ available, ...row }) => row);
+}
+
+async function handleCompatibleModels(res, modelId = '') {
+  const models = await compatibleModels();
+  if (modelId) {
+    const model = models.find((row) => row.id === modelId);
+    return model ? json(res, 200, model) : json(res, 404, openAIError(new CompatError(`Model "${modelId}" not found`, 404, 'model')));
+  }
+  return json(res, 200, { object: 'list', data: models });
+}
+
 // POST /update — self-update (compiled-binary installs). Swaps the binary, replies,
 // then restarts the service into the new version. npm installs get instructions.
 async function handleUpdate(res) {
@@ -404,6 +454,162 @@ async function handleChat(req, res) {
   }
 }
 
+async function runCompatibleAgent(config, onDelta, res) {
+  const target = ENGINES[config.agent];
+  if (!target || target.hidden) throw new CompatError(`Unknown ChatPanel agent "${config.agent}"`, 400, 'model');
+  const availability = await target.engine.available().catch((e) => ({ ok: false, reason: e?.message || String(e) }));
+  if (!availability.ok) throw new CompatError(availability.reason || `${config.agent} is unavailable`, 503, 'model');
+
+  const runId = `run_${Math.random().toString(36).slice(2, 10)}`;
+  const run = startRun(runId);
+  const onGone = () => run.cancel('disconnected');
+  res.on('close', onGone);
+  let output = '';
+  try {
+    await target.engine.chat(
+      { messages: config.messages, system: config.system, options: config.options, images: [] },
+      (event) => {
+        if (event?.type === 'delta' && event.text) {
+          output += event.text;
+          onDelta(event.text);
+        } else if (event?.type === 'done' && event.text && !output) {
+          output = event.text;
+          onDelta(event.text);
+        }
+      },
+      { signal: run.signal },
+    );
+    return output;
+  } finally {
+    res.off('close', onGone);
+    endRun(runId);
+  }
+}
+
+function beginSse(res) {
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache',
+    Connection: 'keep-alive',
+  });
+}
+
+function writeData(res, value) {
+  if (!res.writableEnded) res.write(`data: ${typeof value === 'string' ? value : JSON.stringify(value)}\n\n`);
+}
+
+function writeNamedEvent(res, name, value) {
+  if (!res.writableEnded) res.write(`event: ${name}\ndata: ${JSON.stringify(value)}\n\n`);
+}
+
+async function compatibleBody(req, res, parser, errorShape) {
+  try {
+    return parser(await readBody(req));
+  } catch (error) {
+    json(res, error?.status || 400, errorShape(error?.message?.startsWith('Unexpected') ? new CompatError(`Bad JSON: ${error.message}`) : error));
+    return null;
+  }
+}
+
+async function handleOpenAIChatCompletions(req, res) {
+  const config = await compatibleBody(req, res, parseChatCompletion, openAIError);
+  if (!config) return;
+  if (!config.stream) {
+    try {
+      const text = await runCompatibleAgent(config, () => {}, res);
+      return json(res, 200, createChatCompletion(config.requestedModel, text));
+    } catch (error) {
+      if (!res.writableEnded) return json(res, error?.status || 500, openAIError(error));
+      return;
+    }
+  }
+
+  beginSse(res);
+  const stream = chatCompletionStream(config.requestedModel, (event) => writeData(res, event));
+  try {
+    await runCompatibleAgent(config, (text) => stream.delta(text), res);
+    stream.done();
+  } catch (error) {
+    writeData(res, openAIError(error));
+  }
+  writeData(res, '[DONE]');
+  res.end();
+}
+
+async function handleOpenAICompletions(req, res) {
+  const config = await compatibleBody(req, res, parseCompletion, openAIError);
+  if (!config) return;
+  if (!config.stream) {
+    try {
+      const text = await runCompatibleAgent(config, () => {}, res);
+      return json(res, 200, createCompletion(config.requestedModel, text));
+    } catch (error) {
+      if (!res.writableEnded) return json(res, error?.status || 500, openAIError(error));
+      return;
+    }
+  }
+
+  beginSse(res);
+  const stream = completionStream(config.requestedModel, (event) => writeData(res, event));
+  try {
+    await runCompatibleAgent(config, (text) => stream.delta(text), res);
+    stream.done();
+  } catch (error) {
+    writeData(res, openAIError(error));
+  }
+  writeData(res, '[DONE]');
+  res.end();
+}
+
+async function handleOpenAIResponses(req, res) {
+  const config = await compatibleBody(req, res, parseResponse, openAIError);
+  if (!config) return;
+  if (!config.stream) {
+    try {
+      const text = await runCompatibleAgent(config, () => {}, res);
+      return json(res, 200, createResponse(config.requestedModel, text));
+    } catch (error) {
+      if (!res.writableEnded) return json(res, error?.status || 500, openAIError(error));
+      return;
+    }
+  }
+
+  beginSse(res);
+  const stream = responseStream(config.requestedModel, (event) => writeNamedEvent(res, event.type, event));
+  try {
+    await runCompatibleAgent(config, (text) => stream.delta(text), res);
+    stream.done();
+  } catch (error) {
+    const event = { type: 'error', sequence_number: 0, ...openAIError(error) };
+    writeNamedEvent(res, 'error', event);
+  }
+  res.end();
+}
+
+async function handleAnthropicMessages(req, res) {
+  const config = await compatibleBody(req, res, parseAnthropicMessage, anthropicError);
+  if (!config) return;
+  if (!config.stream) {
+    try {
+      const text = await runCompatibleAgent(config, () => {}, res);
+      return json(res, 200, createAnthropicMessage(config.requestedModel, text));
+    } catch (error) {
+      if (!res.writableEnded) return json(res, error?.status || 500, anthropicError(error));
+      return;
+    }
+  }
+
+  beginSse(res);
+  const stream = anthropicStream(config.requestedModel, (name, event) => writeNamedEvent(res, name, event));
+  try {
+    await runCompatibleAgent(config, (text) => stream.delta(text), res);
+    stream.done();
+  } catch (error) {
+    writeNamedEvent(res, 'error', anthropicError(error));
+  }
+  res.end();
+}
+
 /**
  * POST /cancel { id } — stop a run by name.
  *
@@ -772,6 +978,10 @@ const server = createServer(async (req, res) => {
   if (blocked) return json(res, 403, { error: blocked });
   try {
     if (req.method === 'GET' && url.pathname === '/health') return handleHealth(res);
+    if (req.method === 'GET' && url.pathname === '/v1/models') return handleCompatibleModels(res);
+    if (req.method === 'GET' && url.pathname.startsWith('/v1/models/')) {
+      return handleCompatibleModels(res, decodeURIComponent(url.pathname.slice('/v1/models/'.length)));
+    }
     if (req.method === 'GET' && url.pathname === '/debug') {
       // L6: by default expose only version + agent AVAILABILITY (a boolean) — enough
       // to diagnose "is codex installed?". The full home dir, $PATH, and resolved
@@ -786,6 +996,10 @@ const server = createServer(async (req, res) => {
       });
     }
     if (req.method === 'POST' && url.pathname === '/chat') return handleChat(req, res);
+    if (req.method === 'POST' && url.pathname === '/v1/chat/completions') return handleOpenAIChatCompletions(req, res);
+    if (req.method === 'POST' && url.pathname === '/v1/completions') return handleOpenAICompletions(req, res);
+    if (req.method === 'POST' && url.pathname === '/v1/responses') return handleOpenAIResponses(req, res);
+    if (req.method === 'POST' && url.pathname === '/v1/messages') return handleAnthropicMessages(req, res);
     // Stable endpoint: routes to the active chat. For CLIs configured once with a
     // fixed URL (e.g. `opencode mcp add chatpanel --url http://127.0.0.1:4319/mcp`).
     if (url.pathname === '/mcp') {