@chatpanel/bridge 0.10.24 → 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.24",
+  "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/connectors.js

@@ -0,0 +1,100 @@
+// What an agent can already reach, read from its own configuration.
+//
+// A CLI agent brings connectors ChatPanel cannot see: a Slack MCP, a Jira MCP, a filesystem.
+// ChatPanel relays its own tools to that agent and says a great deal about them — all of it
+// restrictive, because each line was written to stop one substitution — so an agent asked
+// about an internal thread read the page, saw the reference, and told the user to go and look
+// it up, while holding a connector that reaches it.
+//
+// Knowing the names turns a guess into a fact. It lets the harness say "you have slack
+// connected — use it" instead of listing connectors the agent may not have, and lets routing
+// treat "can reach Slack" as a capability rather than a hope.
+//
+// NAMES ONLY, AND NEVER THE CREDENTIALS. A server's name is what the agent already knows and
+// what a prompt needs; its URL, argv and env are what a leak would be made of. This reads
+// config files that belong to the user's own agents and returns a list of strings.
+//
+// CONFIGURED, NOT PROVEN. A server listed here may still fail to start. That is honest and
+// useful — it is exactly what the agent itself will try — and probing for real would cost a
+// process spawn per agent on every health poll.
+
+import { readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+/** Read a file and parse it as JSON, or null. Missing and malformed are the same answer. */
+async function readJson(file) {
+  try { return JSON.parse(await readFile(file, 'utf8')); } catch { return null; }
+}
+
+/** Every key of a `{ mcpServers: { name: {...} } }` block, wherever it appears. */
+function fromMcpServers(obj) {
+  const m = obj && typeof obj === 'object' ? obj.mcpServers || obj.mcp_servers : null;
+  return m && typeof m === 'object' ? Object.keys(m) : [];
+}
+
+/**
+ * `[mcp_servers.NAME]` table headers out of a TOML file.
+ *
+ * Deliberately a regex rather than a TOML parser: the bridge is zero-runtime-dependency by
+ * design, and the only thing wanted here is the set of table names. Anything this misses
+ * simply is not reported, which is the safe direction — a missing name costs a sentence in a
+ * prompt, an invented one sends an agent looking for a connector it does not have.
+ */
+function fromToml(text) {
+  const out = [];
+  const re = /^\s*\[\s*mcp_servers\s*\.\s*([A-Za-z0-9._-]+)\s*\]/gm;
+  for (const m of String(text || '').matchAll(re)) out.push(m[1]);
+  return out;
+}
+
+async function readToml(file) {
+  try { return fromToml(await readFile(file, 'utf8')); } catch { return []; }
+}
+
+const home = () => os.homedir();
+const configHome = () => process.env.XDG_CONFIG_HOME || path.join(home(), '.config');
+
+// Where each agent keeps the list. One entry per agent id in the /health registry; an agent
+// with no entry simply reports nothing, which is what an unknown agent should do.
+const SOURCES = {
+  claude: async () => {
+    const [main, project] = await Promise.all([
+      readJson(path.join(home(), '.claude.json')),
+      readJson(path.join(process.cwd(), '.mcp.json')),
+    ]);
+    return [...fromMcpServers(main), ...fromMcpServers(project)];
+  },
+  codex: async () => readToml(path.join(process.env.CODEX_HOME || path.join(home(), '.codex'), 'config.toml')),
+  opencode: async () => {
+    for (const f of [
+      path.join(configHome(), 'opencode', 'opencode.json'),
+      path.join(home(), 'Library', 'Application Support', 'opencode', 'opencode.jsonc'),
+    ]) {
+      const j = await readJson(f);
+      const names = [...fromMcpServers(j), ...(j && j.mcp && typeof j.mcp === 'object' ? Object.keys(j.mcp) : [])];
+      if (names.length) return names;
+    }
+    return [];
+  },
+};
+
+/**
+ * The connector names an agent is configured with — deduped, sorted, and bounded.
+ *
+ * Bounded because this rides in a health response and then into a system prompt: a user with
+ * forty servers should cost a line, not a paragraph. Sorted so the value is stable across
+ * polls and a settings page does not reorder itself.
+ */
+export async function connectorsFor(agentId, { max = 24 } = {}) {
+  const read = SOURCES[agentId];
+  if (!read) return [];
+  try {
+    const names = await read();
+    return [...new Set(names.filter((n) => typeof n === 'string' && n && n.length <= 64))].sort().slice(0, max);
+  } catch {
+    // A config we cannot read is a config we say nothing about. Never a reason to fail a
+    // health check the extension needs in order to show the agent at all.
+    return [];
+  }
+}

package/src/engines/antigravity.js

@@ -16,7 +16,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { findAgentBin } from '../env.js';
 import { buildCliPrompt } from './prompt.js';
-import { killOnAbort } from '../proc.js';
+import { killOnAbort, spawnGroupOpts } from '../proc.js';
 import { pushExtraArgs, FORBIDDEN } from './args.js';
 
 const IDLE_MS = Number(process.env.CHATPANEL_AGY_TIMEOUT_MS) || 180_000;
@@ -110,7 +110,7 @@ export async function chat({ messages, system, options, images }, emit, { signal
   await new Promise((resolve, reject) => {
     let child;
     try {
-      child = spawn('agy', args, { cwd, stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env } });
+      child = spawn('agy', args, { cwd, stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env }, ...spawnGroupOpts });
     } catch (e) {
       cleanup();
       return reject(new Error(`Failed to start agy: ${e.message}`));

package/src/engines/codex.js

@@ -15,7 +15,7 @@
 // the agent to point it at a real project.
 
 import { spawn, spawnSync } from 'node:child_process';
-import { killOnAbort } from '../proc.js';
+import { killOnAbort, spawnGroupOpts } from '../proc.js';
 import { readFile, unlink, writeFile } from 'node:fs/promises';
 import { existsSync, mkdirSync, symlinkSync, readFileSync } from 'node:fs';
 import os from 'node:os';
@@ -180,7 +180,7 @@ export async function chat({ messages, system, options, images }, emit, { signal
   await new Promise((resolve, reject) => {
     let child;
     try {
-      child = spawn('codex', args, { cwd, stdio: ['pipe', 'pipe', 'pipe'], env });
+      child = spawn('codex', args, { cwd, stdio: ['pipe', 'pipe', 'pipe'], env, ...spawnGroupOpts });
     } catch (e) {
       cleanupImages();
       return reject(new Error(`Failed to start codex: ${e.message}`));

package/src/env.js

@@ -6,6 +6,7 @@
 // by (1) asking your login shell for its PATH and (2) adding common bin dirs.
 
 import os from 'node:os';
+import { spawnGroupOpts } from './proc.js';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { readdirSync, readFileSync, existsSync } from 'node:fs';
@@ -236,9 +237,15 @@ export function buildSpawnSpec(spec, args, cwd) {
       if (wslCwd) pre.push('--cd', wslCwd); // else: run in WSL home
     }
     const argv = [...pre, '-e', 'bash', '-lic', `exec ${spec.command} "$@"`, 'chatpanel', ...args];
-    return ['wsl.exe', argv, { stdio: ['pipe', 'pipe', 'pipe'], env: process.env, windowsHide: true }];
+    return ['wsl.exe', argv, { stdio: ['pipe', 'pipe', 'pipe'], env: process.env, windowsHide: true, ...spawnGroupOpts }];
   }
-  const opts = { cwd: cwd || os.homedir(), stdio: ['pipe', 'pipe', 'pipe'], env: process.env, windowsHide: true };
+  // Every spawned CLI leads its own process group, so Stop can signal the whole tree. An
+  // agent CLI is not one process — it runs shell commands and tools of its own — and killing
+  // only the pid we hold leaves those running after the user has stopped the turn.
+  const opts = {
+    cwd: cwd || os.homedir(), stdio: ['pipe', 'pipe', 'pipe'], env: process.env, windowsHide: true,
+    ...spawnGroupOpts,
+  };
   if (spec.kind === 'script') return [process.execPath, [spec.script, ...args], opts];
   if (spec.kind === 'cmd') return ['cmd.exe', ['/d', '/s', '/c', spec.bin, ...args], opts];
   return [spec.bin, args, opts]; // native

package/src/proc.js

@@ -1,18 +1,88 @@
+import { execFileSync } from 'node:child_process';
 // Terminate a spawned CLI child when an AbortSignal fires. The extension's Stop
 // button aborts the /chat request; server.js turns that disconnect into an abort on
 // this signal. Without this, the agent CLI (codex / claude / agy / custom) keeps
 // running to completion in the background after Stop — burning tokens and holding the
 // session — and only the 3-minute idle timer would eventually reap it.
 //
-// SIGTERM first so the CLI can flush + exit cleanly (its own child procs get the
-// signal via the process group where the platform delivers it), then SIGKILL after a
-// short grace if it's still alive. Returns a detach() to drop the listener once the
-// child exits normally.
+// SIGTERM first so the CLI can flush + exit cleanly, then SIGKILL after a short grace if
+// it's still alive. Returns a detach() to drop the listener once the child exits normally.
+//
+// THE SIGNAL MUST REACH THE GRANDCHILDREN. An agent CLI is not one process: codex runs shell
+// commands, claude runs tools, and each of those is a child of the child. `child.kill()`
+// signals exactly one pid, so Stop killed the CLI and left its shell running — a user pressed
+// Stop, watched the panel go quiet, and found the process still going.
+//
+// Signalling the process GROUP fixes that, and only works if the child leads a group of its
+// own — which is what spawnGroupOpts is for. Without that spawn option the child sits in the
+// bridge's own group, and a group kill would signal the bridge.
+
+/**
+ * Spawn options that make a child its own process-group leader, so the whole tree can be
+ * signalled together. No-op on Windows, which has no process groups in this sense — there
+ * the taskkill fallback in killTree covers it.
+ */
+export const spawnGroupOpts = process.platform === 'win32' ? {} : { detached: true };
+
+/**
+ * Every pid descended from `pid`, snapshotted from the process table.
+ *
+ * A process-group kill is not enough on its own. codex runs each shell step in its OWN
+ * process group (`sleep 90` came back with PGID == its own pid), so signalling the group we
+ * created deliberately misses it — and once its parent dies it reparents to init, where
+ * nothing connects it to the run that started it.
+ *
+ * So the tree is read BEFORE anything is signalled. Afterwards the links are gone.
+ */
+function descendantsOf(pid) {
+  if (!pid || process.platform === 'win32') return [];
+  let table = '';
+  try {
+    table = execFileSync('ps', ['-eo', 'pid=,ppid='], { encoding: 'utf8', timeout: 2000 });
+  } catch { return []; }
+  const kids = new Map();
+  for (const line of table.split('\n')) {
+    const [p, pp] = line.trim().split(/\s+/).map(Number);
+    if (!p || !pp) continue;
+    if (!kids.has(pp)) kids.set(pp, []);
+    kids.get(pp).push(p);
+  }
+  const out = [];
+  const walk = (root, depth = 0) => {
+    // A depth cap rather than a visited set: the table is a snapshot of a tree, and a cycle
+    // would mean the kernel lied. The cap is there so a malformed read cannot hang a Stop.
+    if (depth > 20) return;
+    for (const k of kids.get(root) || []) { out.push(k); walk(k, depth + 1); }
+  };
+  walk(pid);
+  return out;
+}
+
+/** Signal a child and everything it spawned. Falls back to the single process. */
+function killTree(child, sig, known = []) {
+  if (!child?.pid) return;
+  // Descendants first, while the parent is still alive to be traced through. Orphaned
+  // grandchildren are the ones the user cannot find or stop afterwards.
+  for (const pid of known.length ? known : descendantsOf(child.pid)) {
+    try { process.kill(pid, sig); } catch { /* already gone */ }
+  }
+  try {
+    // Negative pid = the whole group. Only valid for a detached child; the catch covers a
+    // child spawned without it, which is still better killed alone than not at all.
+    process.kill(-child.pid, sig);
+    return;
+  } catch { /* not a group leader, or already gone */ }
+  try { child.kill(sig); } catch { /* already exited */ }
+}
+
 export function killOnAbort(child, signal, { graceMs = 1500 } = {}) {
   if (!signal || !child) return () => {};
   const onAbort = () => {
-    try { child.kill('SIGTERM'); } catch { /* already exited */ }
-    const t = setTimeout(() => { try { child.kill('SIGKILL'); } catch { /* gone */ } }, graceMs);
+    // Snapshot ONCE, up front: by the time the grace period expires the parent is gone and
+    // the tree cannot be walked, so the escalation would have nothing left to aim at.
+    const tree = descendantsOf(child.pid);
+    killTree(child, 'SIGTERM', tree);
+    const t = setTimeout(() => killTree(child, 'SIGKILL', tree), graceMs);
     if (t.unref) t.unref(); // don't keep the event loop alive just for the grace timer
   };
   if (signal.aborted) { onAbort(); return () => {}; }

package/src/runs.js

@@ -0,0 +1,49 @@
+// Every in-flight run, so Stop is an INSTRUCTION rather than an inference.
+//
+// Cancellation used to depend on Node noticing the client's socket close and firing
+// `req.on('close')`. That is a signal about a socket, not about intent: it can arrive late,
+// and on a request whose body was already consumed it does not reliably arrive at all — so
+// a codex `shell:` step ran on for minutes after Stop with nothing left listening to it.
+//
+// A run registered here can be cancelled by name. The socket-close path stays as a safety
+// net for a panel that is closed or crashes, but the button no longer depends on it.
+const runs = new Map();
+
+export function startRun(id) {
+  const ac = new AbortController();
+  const children = new Set();
+  const run = {
+    id,
+    signal: ac.signal,
+    // Children are tracked as well as signalled, because an agent that spawns sub-agents
+    // spawns processes this module never sees at spawn time. Whoever creates one registers
+    // it, and Stop reaches all of them.
+    track(child) { if (child?.pid) { children.add(child); child.once?.('exit', () => children.delete(child)); } },
+    cancel(reason = 'stopped') {
+      if (run.cancelled) return false;
+      run.cancelled = reason;
+      ac.abort();
+      return true;
+    },
+    cancelled: null,
+    children,
+  };
+  runs.set(id, run);
+  return run;
+}
+
+export function endRun(id) { runs.delete(id); }
+
+export function cancelRun(id, reason = 'stopped') {
+  const run = runs.get(id);
+  return run ? run.cancel(reason) : false;
+}
+
+/** Used on shutdown: leaving a CLI running after the bridge exits is how orphans are made. */
+export function cancelAll(reason = 'shutdown') {
+  let n = 0;
+  for (const run of runs.values()) if (run.cancel(reason)) n += 1;
+  return n;
+}
+
+export const activeRuns = () => runs.size;

package/src/server.js

@@ -3,7 +3,7 @@
 // running on this machine (Claude Code, Codex and Antigravity, each via its CLI) to
 // the ChatPanel Chrome extension. Zero runtime dependencies.
 //
-//   GET  /health  → { ok, version, agents: [...], update: {current,latest,…} }
+//   GET  /health  → { ok, version, agents: [{id,label,available,reason,connectors}], update }
 //   POST /update  → self-update to the latest release (compiled binary installs)
 //   POST /chat    → Server-Sent Events stream of { type, ... }:
 //                     {type:'delta', text}    incremental assistant text
@@ -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
@@ -27,6 +30,7 @@ import * as claude from './engines/claude.js';
 import * as codex from './engines/codex.js';
 import * as antigravity from './engines/antigravity.js';
 import { pi, opencode, kiro, copilot, deepseek } from './engines/cli-agents.js';
+import { connectorsFor } from './connectors.js';
 import * as custom from './engines/custom.js';
 import { installService, uninstallService, serviceStatus, restartService } from './service.js';
 import { AGENT_CLIS, enrichPath, enrichAgentEnv, findAgentBin, resolveCommand } from './env.js';
@@ -34,11 +38,29 @@ import { stripHidden } from './sanitize.js';
 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.24';
+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;
 
@@ -161,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');
 }
 
@@ -217,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);
@@ -230,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',
@@ -238,6 +266,10 @@ const PRIVILEGED_POST = new Set([
   '/agent-check',
   '/update',
   '/tool-result',
+  // Cancelling someone else's run is a denial of service, small but real — and every other
+  // endpoint that touches a run is already guarded. An unauthenticated hole next to nine
+  // guarded neighbours is a hole regardless of how little it grants.
+  '/cancel',
 ]);
 const PRIVILEGED_GET = new Set(['/debug']);
 
@@ -294,13 +326,43 @@ async function handleHealth(res) {
       .filter(([, e]) => !e.hidden)
       .map(async ([id, { engine, label }]) => {
         const a = await engine.available().catch((e) => ({ ok: false, reason: String(e?.message || e) }));
-        return { id, label, available: a.ok, reason: a.reason };
+        // WHAT THIS AGENT CAN ALREADY REACH, so the client stops guessing. A CLI agent brings
+        // its own connectors — a Slack MCP, a Jira MCP — that the extension cannot see, and
+        // an agent that was never told it may use them answers "go and look it up yourself".
+        // NAMES ONLY: a server's name is what a prompt needs; its URL, argv and env are what
+        // a leak would be made of. Additive, so an older extension ignores it.
+        const connectors = await connectorsFor(id).catch(() => []);
+        return { id, label, available: a.ok, reason: a.reason, connectors };
       }),
   );
   const update = await checkForUpdate(VERSION).catch(() => ({ current: VERSION, updateAvailable: false }));
   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) {
@@ -341,10 +403,22 @@ async function handleChat(req, res) {
   // finish in the background. Older engines ignore the signal (harmless); the spawn
   // engines honor it via killOnAbort.
   let closed = false;
-  const ac = new AbortController();
-  req.on('close', () => { closed = true; ac.abort(); });
+  // A run id the client can cancel BY NAME. Emitted first, before anything else, so Stop
+  // works from the first millisecond rather than from whenever the engine gets going.
+  const runId = `run_${Math.random().toString(36).slice(2, 10)}`;
+  const run = startRun(runId);
+  const ac = { signal: run.signal, abort: () => run.cancel('client') };
+  // BOTH close events. On a request whose body was already consumed, req 'close' does not
+  // reliably signal a client disconnect — res 'close' does. Keeping both means a panel that
+  // crashes or is closed still tears the CLI down, while the Stop button no longer depends
+  // on either of them.
+  const onGone = () => { closed = true; run.cancel('disconnected'); };
+  req.on('close', onGone);
+  res.on('close', onGone);
+  res.on('error', onGone);
 
   const safeEmit = (obj) => { if (!closed) emit(obj); };
+  emit({ type: 'run', id: runId });
 
   // Browser-tools relay: when the extension sends page-tool specs, host an MCP
   // server for this turn and tell the engine to point the CLI at it.
@@ -374,11 +448,187 @@ async function handleChat(req, res) {
     log('error', `${body.agent} chat failed: ${e?.message || e}`);
     emit({ type: 'error', error: e?.message || String(e) });
   } finally {
+    endRun(runId);
     if (session) deleteSession(session.id);
     if (!res.writableEnded) res.end();
   }
 }
 
+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.
+ *
+ * Stop is now an instruction, not something inferred from a socket. Answers 200 whether or
+ * not the run was still live: 'already finished' and 'cancelled' are the same outcome to the
+ * caller, and returning 404 would make a harmless race look like a failure.
+ */
+async function handleCancel(req, res) {
+  // readBody already PARSES. Wrapping it in JSON.parse threw on every call, so the id was
+  // always empty and Stop silently cancelled nothing — the unit tests covered the registry
+  // and not the handler that feeds it, which is exactly where this hid.
+  let body = {};
+  try { body = (await readBody(req)) || {}; } catch { /* an empty body cancels nothing */ }
+  const id = String(body.id || '').trim();
+  const cancelled = id ? cancelRun(id, 'stopped') : false;
+  if (cancelled) log('info', `cancel: ${id} stopped by client`);
+  return json(res, 200, { ok: true, cancelled });
+}
+
 // POST /mcp/<session> (per-run, bridge-injected) OR POST /mcp (stable: routes to
 // the active chat — for CLIs configured once, e.g. `opencode mcp add … …/mcp`).
 // JSON-RPC; tools/call relays to the extension and waits for /tool-result.
@@ -728,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
@@ -742,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') {
@@ -754,6 +1012,7 @@ const server = createServer(async (req, res) => {
       if (req.method === 'GET') { res.writeHead(405); return res.end(); } // no server-initiated stream
       if (req.method === 'DELETE') { deleteSession(sid); res.writeHead(204); return res.end(); }
     }
+    if (req.method === 'POST' && url.pathname === '/cancel') return handleCancel(req, res);
     if (req.method === 'POST' && url.pathname === '/tool-result') return handleToolResult(req, res);
     if (req.method === 'POST' && url.pathname === '/mcp-local') return handleMcpLocal(req, res);
     if (req.method === 'POST' && url.pathname === '/mcp-remote') return handleMcpRemote(req, res);
@@ -841,6 +1100,18 @@ function startServer() {
     log('error', `bridge server error: ${e?.message || e}`);
     process.exit(1);
   });
+  // Leaving a CLI running after the bridge exits is how orphans are made — and the user has
+  // no way to find or stop them, because the thing that spawned them is gone.
+  for (const sig of ['SIGINT', 'SIGTERM']) {
+    process.on(sig, () => {
+      const n = cancelAll('shutdown');
+      if (n) log('info', `shutdown: stopped ${n} running agent${n === 1 ? '' : 's'}`);
+      // Give SIGTERM a moment to land before the process goes; killTree escalates on its own.
+      setTimeout(() => process.exit(0), n ? 300 : 0).unref?.();
+      if (!n) process.exit(0);
+    });
+  }
+
   server.listen(PORT, HOST, async () => {
     log('info', `listening on http://${HOST}:${PORT}`);
     // M7: a non-loopback bind disables the anti-DNS-rebinding Host check (hostAllowed