@chatpanel/bridge 0.10.26 → 0.10.28

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.28",
   "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": [
@@ -36,7 +36,9 @@
     "start": "node src/server.js",
     "dev": "node --watch src/server.js",
     "test": "node --test tests/*.test.mjs",
-    "build:bin": "bash scripts/build-binaries.sh"
+    "build:bin": "bash scripts/build-binaries.sh",
+    "sync:events": "node scripts/sync-events.mjs",
+    "test:events-sync": "node scripts/sync-events.mjs --check"
   },
   "dependencies": {},
   "optionalDependencies": {

package/scripts/sync-events.mjs

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+// Vendors the shared contracts the bridge needs from `chatpanel-events`.
+//
+// The bridge has ZERO runtime dependencies on purpose — it is installed by a curl
+// one-liner and compiled into a single binary, and every dependency is a thing that can
+// fail at install time on someone's laptop. So shared contracts arrive the way
+// @chatpanel/pii does: copied in, generated, never hand-edited.
+//
+//   node scripts/sync-events.mjs           refresh src/events/ from the package
+//   node scripts/sync-events.mjs --check   verify they match (CI drift guard); exit 1 if not
+//
+// A hand-copy is how `sanitize.js` could silently diverge from the engine it came from.
+// This makes divergence a failing test instead of a bug report.
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
+
+// Deliberately short. `skill-manifest.js` imports only `scopes.js`, which is why that
+// vocabulary was split out of `capability.js` — vendoring the capability machinery and
+// the event schema to reach a five-element array would defeat the point.
+const FILES = ['scopes.js', 'skill-manifest.js'];
+
+function pkgDir() {
+  return [
+    join(ROOT, 'node_modules', '@chatpanel', 'events'),
+    join(ROOT, '..', 'chatpanel-events'),
+  ].find((d) => existsSync(join(d, 'skill-manifest.js')));
+}
+
+const check = process.argv.includes('--check');
+const src = pkgDir();
+
+if (!src) {
+  const msg = 'chatpanel-events not found (check out ../chatpanel-events).';
+  if (check) { console.error(`sync-events --check: ${msg}`); process.exit(1); }
+  console.warn(`sync-events: ${msg} Leaving src/events as-is.`);
+  process.exit(0);
+}
+
+const outDir = join(ROOT, 'src', 'events');
+if (!check) mkdirSync(outDir, { recursive: true });
+
+const banner = (f) => `// GENERATED — do not edit.\n`
+  + `// Source of truth: chatpanel-events/${f} (npm @chatpanel/events).\n`
+  + `// Edit there, then run: npm run sync:events\n`
+  + `//\n`
+  + `// Vendored rather than depended on: the bridge ships zero runtime dependencies so a\n`
+  + `// curl one-liner install cannot fail on someone's registry, and so the compiled\n`
+  + `// single-file binary has nothing to resolve.\n\n`;
+
+let drift = 0;
+for (const f of FILES) {
+  const want = banner(f) + readFileSync(join(src, f), 'utf8');
+  const dest = join(outDir, f);
+  const have = existsSync(dest) ? readFileSync(dest, 'utf8') : null;
+  if (have === want) continue;
+  if (check) { console.error(`sync-events --check: src/events/${f} differs from chatpanel-events`); drift += 1; continue; }
+  writeFileSync(dest, want);
+  console.log(`sync-events: updated src/events/${f}`);
+}
+
+if (check) {
+  if (drift) { console.error('Run `npm run sync:events` and commit the result.'); process.exit(1); }
+  console.log('sync-events --check: src/events matches chatpanel-events ✓');
+}

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/events/scopes.js

@@ -0,0 +1,20 @@
+// GENERATED — do not edit.
+// Source of truth: chatpanel-events/scopes.js (npm @chatpanel/events).
+// Edit there, then run: npm run sync:events
+//
+// Vendored rather than depended on: the bridge ships zero runtime dependencies so a
+// curl one-liner install cannot fail on someone's registry, and so the compiled
+// single-file binary has nothing to resolve.
+
+// scopes.js — the data-scope vocabulary, on its own so it can travel alone.
+//
+// One list names what anything in ChatPanel may touch. Capabilities declare `reads`
+// and `writes` from it, sources declare `reads`, and a skill package declares `reads`
+// — three declarations, one vocabulary, or "what may this reach" gets three answers.
+//
+// It is a separate module rather than a constant inside capability.js because the
+// consumers have very different weights. The bridge vendors the skill contract and has
+// zero runtime dependencies by design; pulling the capability machinery and the event
+// schema behind it to reach a five-element array would be the transitive-graph mistake
+// the extension's first-paint budget exists to prevent, one repo over.
+export const DATA_SCOPES = Object.freeze(['notes', 'meetings', 'chats', 'page', 'files', 'net']);