@chatpanel/bridge 0.1.0

package/.env.example

@@ -0,0 +1,12 @@
+# ChatPanel Bridge configuration (all optional)
+
+# Bind address / port (must match the Bridge URL in ChatPanel Settings).
+CHATPANEL_BRIDGE_HOST=127.0.0.1
+CHATPANEL_BRIDGE_PORT=4319
+
+# Claude: omit to use your local Claude Code login; or set a key explicitly.
+# ANTHROPIC_API_KEY=sk-ant-...
+
+# Safety rails.
+CHATPANEL_MAX_TURNS=20
+CHATPANEL_CODEX_TIMEOUT_MS=180000

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ChatPanel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,70 @@
+# ChatPanel Bridge
+
+A tiny localhost server that lets the ChatPanel Chrome extension talk to the
+coding agents on your machine. A browser extension can't spawn local processes,
+so this bridges the gap.
+
+- **Claude Code** — embedded via `@anthropic-ai/claude-agent-sdk`, using your
+  existing Claude Code login (or `ANTHROPIC_API_KEY`).
+- **Codex** — driven via the `codex exec` CLI, using your `codex login`.
+
+## Run it
+
+```bash
+cd bridge
+npm install      # installs the Claude Agent SDK (Codex just needs the CLI)
+npm start        # → http://127.0.0.1:4319
+```
+
+Prerequisites:
+
+- **Claude Code**: be signed in (`claude`) or set `ANTHROPIC_API_KEY`.
+- **Codex**: `codex` on your `PATH` and `codex login` done.
+
+The extension polls `/health` and shows each agent as available/unavailable.
+
+## API
+
+| Method | Path | Purpose |
+|--------|------|---------|
+| `GET`  | `/health` | `{ ok, version, agents:[{id,label,available,reason}] }` |
+| `POST` | `/chat`   | SSE stream — body `{ agent, system, options, messages }` |
+
+`/chat` streams Server-Sent Events: `{type:'delta',text}` as the answer is
+generated, `{type:'tool',name,summary}` / `{type:'status'}` for activity, and a
+final `{type:'done'}` (or `{type:'error',error}`).
+
+`options` per agent (set in ChatPanel Settings):
+
+```jsonc
+{
+  "workingDir": "/path/to/project",   // where the agent reads/works
+  "permissionMode": "default",         // default | acceptEdits | bypassPermissions
+  "model": ""                          // optional model override
+}
+```
+
+## Safety
+
+- Binds to `127.0.0.1` only; CORS accepts the extension origin and localhost.
+- Claude tools are **read-only by default** (Read/Grep/Glob/WebFetch). Writes and
+  shell only run when an agent's permission mode is `acceptEdits` or
+  `bypassPermissions`.
+- Point each agent at a working directory you trust.
+
+## Run as a background service (optional)
+
+macOS (launchd) example — save to `~/Library/LaunchAgents/app.chatpanel.bridge.plist`:
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<plist version="1.0"><dict>
+  <key>Label</key><string>app.chatpanel.bridge</string>
+  <key>ProgramArguments</key>
+  <array><string>/usr/local/bin/node</string><string>/ABSOLUTE/PATH/chatpanel/bridge/src/server.js</string></array>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+</dict></plist>
+```
+
+Then `launchctl load ~/Library/LaunchAgents/app.chatpanel.bridge.plist`.

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@chatpanel/bridge",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Local bridge that exposes Claude Code (Agent SDK) and Codex (CLI) to the ChatPanel Chrome extension over a localhost SSE endpoint.",
+  "keywords": ["chatpanel", "claude-code", "codex", "chrome-extension", "ai-agents", "bridge"],
+  "homepage": "https://chatpanel.net",
+  "repository": { "type": "git", "url": "git+https://github.com/chatpanel/chatpanel-bridge.git" },
+  "license": "MIT",
+  "bin": { "chatpanel-bridge": "src/server.js" },
+  "files": ["src", "README.md", "LICENSE", ".env.example"],
+  "engines": { "node": ">=18" },
+  "scripts": {
+    "start": "node src/server.js",
+    "dev": "node --watch src/server.js"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.1.0"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  }
+}

package/src/engines/claude.js

@@ -0,0 +1,134 @@
+// Claude Code engine — embeds the Claude Agent SDK using your *local* Claude
+// Code login (or ANTHROPIC_API_KEY). It streams text deltas and surfaces tool
+// use so the extension can show what the agent is doing.
+//
+// By default the agent can READ your code (Read/Grep/Glob/WebFetch) but cannot
+// write or run shell commands unless the agent's permissionMode is set to
+// 'acceptEdits' or 'bypassPermissions' in ChatPanel Settings. The working
+// directory comes from the agent config (defaults to the bridge's cwd).
+
+import path from 'node:path';
+import os from 'node:os';
+
+// Always-on guidance so the coding agent behaves like a browser assistant by
+// default: prefer the page context the extension attaches over scanning files.
+const BASE_GUIDANCE =
+  'You are ChatPanel, an AI assistant living in a browser side panel. When the ' +
+  "user's message includes <context> blocks (extracted web pages or selections), " +
+  'answer primarily from those. Only read or modify local files when the user ' +
+  'explicitly asks about code or a project.';
+
+let sdkPromise = null;
+function loadSdk() {
+  if (!sdkPromise) sdkPromise = import('@anthropic-ai/claude-agent-sdk').catch(() => null);
+  return sdkPromise;
+}
+
+export async function available() {
+  const sdk = await loadSdk();
+  if (!sdk) {
+    return { ok: false, reason: 'Agent SDK not installed (npm i in bridge/)' };
+  }
+  if (!process.env.ANTHROPIC_API_KEY) {
+    // Not fatal — the SDK can use your local Claude Code login.
+    return { ok: true };
+  }
+  return { ok: true };
+}
+
+const READONLY_TOOLS = new Set(['Read', 'Grep', 'Glob', 'WebFetch', 'WebSearch', 'TodoWrite', 'Task']);
+
+// Build a single prompt that carries the conversation history. The bridge is
+// stateless, so we replay the chat each turn.
+function buildPrompt(messages) {
+  const history = messages.slice(0, -1);
+  const last = messages[messages.length - 1];
+  let prompt = '';
+  if (history.length) {
+    prompt += 'Conversation so far:\n';
+    for (const m of history) {
+      prompt += `${m.role === 'user' ? 'User' : 'Assistant'}: ${m.content}\n\n`;
+    }
+    prompt += '---\n\n';
+  }
+  prompt += last ? last.content : '';
+  return prompt;
+}
+
+export async function chat({ messages, system, options }, emit) {
+  const sdk = await loadSdk();
+  if (!sdk) throw new Error('Claude Agent SDK not installed. Run `npm install` in bridge/.');
+  const { query } = sdk;
+
+  const permissionMode = options.permissionMode || 'default';
+  // No project configured → a neutral cwd, so the agent doesn't fixate on
+  // whatever directory the bridge happens to be running in.
+  const cwd = options.workingDir ? path.resolve(options.workingDir) : os.homedir();
+  const writesAllowed = permissionMode === 'acceptEdits' || permissionMode === 'bypassPermissions';
+
+  // Approve read-only tools always; gate writes/shell behind the chosen mode.
+  const canUseTool = async (toolName) => {
+    if (READONLY_TOOLS.has(toolName) || writesAllowed) return { behavior: 'allow', updatedInput: undefined };
+    return { behavior: 'deny', message: `${toolName} blocked — set this agent's permission mode to acceptEdits/bypassPermissions in ChatPanel to enable it.` };
+  };
+
+  let streamedAny = false;
+  let resultText = '';
+
+  const iterator = query({
+    prompt: buildPrompt(messages),
+    options: {
+      cwd,
+      permissionMode,
+      includePartialMessages: true,
+      canUseTool,
+      // Default: load your ~/.claude + project settings so your skills, MCP
+      // servers and CLAUDE.md apply. Turn the agent's "Use my local skills &
+      // config" off to run clean.
+      settingSources: options.useLocalConfig === false ? [] : ['user', 'project'],
+      systemPrompt: {
+        type: 'preset',
+        preset: 'claude_code',
+        append: [BASE_GUIDANCE, system].filter(Boolean).join('\n\n'),
+      },
+      ...(options.model ? { model: options.model } : {}),
+      ...(process.env.CHATPANEL_MAX_TURNS ? { maxTurns: Number(process.env.CHATPANEL_MAX_TURNS) } : {}),
+    },
+  });
+
+  for await (const message of iterator) {
+    if (message.type === 'stream_event') {
+      const ev = message.event;
+      if (ev?.type === 'content_block_delta' && ev.delta?.type === 'text_delta') {
+        streamedAny = true;
+        emit({ type: 'delta', text: ev.delta.text });
+      }
+    } else if (message.type === 'assistant') {
+      for (const block of message.message.content) {
+        if (block.type === 'tool_use') {
+          emit({ type: 'tool', name: block.name, summary: toolSummary(block) });
+        } else if (block.type === 'text' && !streamedAny) {
+          // Partials were unavailable — stream the whole block.
+          streamedAny = true;
+          emit({ type: 'delta', text: block.text });
+        }
+      }
+    } else if (message.type === 'result') {
+      if (message.subtype === 'success') resultText = message.result || '';
+      else if (message.subtype !== 'success') {
+        emit({ type: 'status', text: `(${message.subtype})` });
+      }
+    }
+  }
+
+  emit({ type: 'done', text: streamedAny ? '' : resultText });
+}
+
+function toolSummary(block) {
+  const i = block.input || {};
+  if (i.command) return String(i.command).slice(0, 60);
+  if (i.file_path) return path.basename(i.file_path);
+  if (i.pattern) return i.pattern;
+  if (i.url) return i.url;
+  return '';
+}

package/src/engines/codex.js

@@ -0,0 +1,196 @@
+// Codex engine — drives the Codex CLI (`codex exec`) using your local Codex login.
+//
+// Two modes, chosen per-agent in ChatPanel Settings ("Use my local skills & config"):
+//
+//   useLocalConfig: true  (DEFAULT) — your real CODEX_HOME loads, so your skills,
+//      MCP servers and config.toml all work. Best for "it should behave like my
+//      Codex." Can be slower if your global skills do a lot of work.
+//
+//   useLocalConfig: false — run against an ISOLATED CODEX_HOME (just a symlink to
+//      your auth so you stay logged in). Skips your global AGENTS.md / skills, so
+//      it answers fast and never crawls files (~9x faster in practice).
+//
+// In BOTH modes we run in an EMPTY scratch dir for general chat, so Codex never
+// references the bridge's own code or an unrelated project. Set a working dir on
+// the agent to point it at a real project.
+
+import { spawn, spawnSync } from 'node:child_process';
+import { readFile, unlink } from 'node:fs/promises';
+import { existsSync, mkdirSync, symlinkSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const TIMEOUT_MS = Number(process.env.CHATPANEL_CODEX_TIMEOUT_MS) || 180_000;
+const REASONING = process.env.CHATPANEL_CODEX_EFFORT ?? 'low'; // '' → respect config
+
+const SCRATCH = path.join(os.tmpdir(), 'chatpanel-codex-scratch');
+const ISO_HOME = path.join(os.homedir(), '.chatpanel', 'codex-home');
+
+function ensureScratch() {
+  try {
+    mkdirSync(SCRATCH, { recursive: true });
+  } catch {
+    /* best effort */
+  }
+}
+
+// Build (once) an isolated CODEX_HOME that has only a link to your auth, so the
+// global skills/config don't load. Returns the path, or null on failure.
+let isoReady = false;
+function ensureIsolatedHome() {
+  if (!isoReady) {
+    try {
+      mkdirSync(ISO_HOME, { recursive: true });
+      const realAuth = path.join(os.homedir(), '.codex', 'auth.json');
+      const linkAuth = path.join(ISO_HOME, 'auth.json');
+      if (existsSync(realAuth) && !existsSync(linkAuth)) {
+        try {
+          symlinkSync(realAuth, linkAuth);
+        } catch {
+          /* auth errors surface clearly downstream */
+        }
+      }
+      isoReady = true;
+    } catch {
+      return null;
+    }
+  }
+  return ISO_HOME;
+}
+
+const BASE_GUIDANCE =
+  'You are ChatPanel, an AI assistant in a browser side panel. Answer the ' +
+  "user's question using the <context> blocks provided (web pages or selections). " +
+  'Do NOT search the filesystem or read local files for general questions — ' +
+  'everything you need is in the prompt. Only inspect files if the user explicitly ' +
+  'asks about local code or a project. When asked for a table, return GitHub-' +
+  'flavored Markdown.';
+
+let installed = null;
+export async function available() {
+  if (installed === null) {
+    try {
+      const r = spawnSync('codex', ['--version'], { stdio: 'ignore', timeout: 5000 });
+      installed = r.status === 0 || (r.status === null && r.error === undefined);
+    } catch {
+      installed = false;
+    }
+  }
+  return installed
+    ? { ok: true }
+    : { ok: false, reason: 'codex not found on PATH. Install it and run `codex login`.' };
+}
+
+function buildPrompt(messages, system) {
+  let p = `${[BASE_GUIDANCE, system].filter(Boolean).join('\n\n')}\n\n`;
+  const history = messages.slice(0, -1);
+  const last = messages[messages.length - 1];
+  if (history.length) {
+    p += 'Conversation so far:\n';
+    for (const m of history) p += `${m.role === 'user' ? 'User' : 'Assistant'}: ${m.content}\n\n`;
+    p += '---\n\n';
+  }
+  p += last ? last.content : '';
+  return p;
+}
+
+export async function chat({ messages, system, options }, emit) {
+  ensureScratch();
+  const tag = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  const outFile = path.join(os.tmpdir(), `chatpanel-codex-${tag}.txt`);
+
+  const cwd = options.workingDir ? path.resolve(options.workingDir) : SCRATCH;
+  const sandbox =
+    options.permissionMode === 'bypassPermissions'
+      ? 'danger-full-access'
+      : options.permissionMode === 'acceptEdits'
+        ? 'workspace-write'
+        : 'read-only';
+
+  const args = ['exec', '--json', '--skip-git-repo-check', '-s', sandbox, '-o', outFile];
+  // Headless exec has no human to approve commands. Auto-run within the sandbox
+  // so skill/startup reads don't get "approval declined" (and skills can load in
+  // local-config mode). The sandbox above still bounds what can actually happen.
+  args.push('-c', 'approval_policy=never');
+  if (REASONING) args.push('-c', `model_reasoning_effort=${REASONING}`);
+  if (options.model) args.push('-m', options.model);
+  args.push('-');
+
+  // Default: use the user's skills/config. Opt-out → isolated home.
+  const useLocal = options.useLocalConfig !== false;
+  const env = { ...process.env };
+  if (!useLocal) {
+    const home = ensureIsolatedHome();
+    if (home) env.CODEX_HOME = home;
+  }
+
+  await new Promise((resolve, reject) => {
+    let child;
+    try {
+      child = spawn('codex', args, { cwd, stdio: ['pipe', 'pipe', 'pipe'], env });
+    } catch (e) {
+      return reject(new Error(`Failed to start codex: ${e.message}`));
+    }
+
+    let stdout = '';
+    let stderr = '';
+    const timer = setTimeout(() => {
+      child.kill('SIGKILL');
+      reject(new Error(`Codex timed out after ${Math.round(TIMEOUT_MS / 1000)}s.`));
+    }, TIMEOUT_MS);
+
+    child.stdout.on('data', (d) => {
+      stdout += d.toString();
+      let nl;
+      while ((nl = stdout.indexOf('\n')) >= 0) {
+        const line = stdout.slice(0, nl).trim();
+        stdout = stdout.slice(nl + 1);
+        if (!line.startsWith('{')) continue;
+        try {
+          forwardEvent(JSON.parse(line), emit);
+        } catch {
+          /* not a JSON event line */
+        }
+      }
+    });
+    child.stderr.on('data', (d) => (stderr += d.toString()));
+    child.on('error', (e) => {
+      clearTimeout(timer);
+      reject(e);
+    });
+    child.on('close', async (code) => {
+      clearTimeout(timer);
+      let text = '';
+      try {
+        text = (await readFile(outFile, 'utf8')).trim();
+      } catch {
+        /* no message file */
+      }
+      unlink(outFile).catch(() => {});
+      if (code === 0) {
+        emit({ type: 'delta', text: text || '(no output)' });
+        emit({ type: 'done', text: '' });
+        resolve();
+      } else {
+        reject(new Error(`Codex exited ${code}: ${stderr.trim() || 'failed'}`));
+      }
+    });
+
+    child.stdin.write(buildPrompt(messages, system));
+    child.stdin.end();
+  });
+}
+
+function forwardEvent(ev, emit) {
+  const t = ev.type || '';
+  const item = ev.item || {};
+  if (item.type === 'command_execution' || t.includes('command')) {
+    emit({ type: 'tool', name: 'shell', summary: (item.command || '').slice(0, 60) });
+  } else if (item.type === 'reasoning' || t.includes('reasoning')) {
+    emit({ type: 'reasoning' });
+  } else if (item.type === 'file_change' || t.includes('patch')) {
+    emit({ type: 'tool', name: 'edit', summary: '' });
+  } else if (t === 'turn.started' || t === 'thread.started') {
+    emit({ type: 'status', text: 'Codex working' });
+  }
+}

package/src/server.js

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+// ChatPanel Bridge — a tiny localhost server that exposes the coding agents
+// running on this machine (Claude Code via the Agent SDK, Codex via its CLI) to
+// the ChatPanel Chrome extension. Zero runtime dependencies beyond the optional
+// Claude Agent SDK.
+//
+//   GET  /health  → { ok, version, agents: [{id,label,available,reason}] }
+//   POST /chat    → Server-Sent Events stream of { type, ... }:
+//                     {type:'delta', text}    incremental assistant text
+//                     {type:'tool',  name, summary}
+//                     {type:'status'|'reasoning', text?}
+//                     {type:'done',  text?}    (text only if not streamed)
+//                     {type:'error', error}
+//
+// Binds to 127.0.0.1 only and accepts requests from the extension origin.
+
+import { createServer } from 'node:http';
+import * as claude from './engines/claude.js';
+import * as codex from './engines/codex.js';
+
+const VERSION = '0.1.0';
+const HOST = process.env.CHATPANEL_BRIDGE_HOST || '127.0.0.1';
+const PORT = Number(process.env.CHATPANEL_BRIDGE_PORT) || 4319;
+
+const ENGINES = {
+  claude: { engine: claude, label: 'Claude Code' },
+  codex: { engine: codex, label: 'Codex' },
+};
+
+// --------------------------------------------------------------------------
+// CORS — allow the extension (chrome-extension://…) and localhost dev origins.
+// --------------------------------------------------------------------------
+function cors(req, res) {
+  const origin = req.headers.origin || '';
+  const allow =
+    !origin ||
+    origin.startsWith('chrome-extension://') ||
+    origin.startsWith('moz-extension://') ||
+    origin.startsWith('http://localhost') ||
+    origin.startsWith('http://127.0.0.1');
+  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');
+}
+
+function json(res, code, obj) {
+  res.writeHead(code, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify(obj));
+}
+
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    let data = '';
+    req.on('data', (c) => {
+      data += c;
+      if (data.length > 50 * 1024 * 1024) reject(new Error('Body too large'));
+    });
+    req.on('end', () => {
+      try {
+        resolve(data ? JSON.parse(data) : {});
+      } catch (e) {
+        reject(e);
+      }
+    });
+    req.on('error', reject);
+  });
+}
+
+// --------------------------------------------------------------------------
+// Routes
+// --------------------------------------------------------------------------
+async function handleHealth(res) {
+  const agents = await Promise.all(
+    Object.entries(ENGINES).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 };
+    }),
+  );
+  json(res, 200, { ok: true, version: VERSION, agents });
+}
+
+async function handleChat(req, res) {
+  let body;
+  try {
+    body = await readBody(req);
+  } catch (e) {
+    return json(res, 400, { error: 'Bad JSON: ' + e.message });
+  }
+  const target = ENGINES[body.agent];
+  if (!target) return json(res, 404, { error: `Unknown agent "${body.agent}"` });
+
+  // Open the SSE stream.
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache',
+    Connection: 'keep-alive',
+  });
+  const emit = (obj) => {
+    if (!res.writableEnded) res.write(`data: ${JSON.stringify(obj)}\n\n`);
+  };
+
+  // If the client disconnects, stop caring about late writes.
+  let closed = false;
+  req.on('close', () => (closed = true));
+
+  try {
+    await target.engine.chat(
+      {
+        messages: Array.isArray(body.messages) ? body.messages : [],
+        system: body.system || '',
+        options: body.options || {},
+      },
+      (obj) => {
+        if (!closed) emit(obj);
+      },
+    );
+  } catch (e) {
+    log('error', `${body.agent} chat failed: ${e?.message || e}`);
+    emit({ type: 'error', error: e?.message || String(e) });
+  } finally {
+    if (!res.writableEnded) res.end();
+  }
+}
+
+const server = createServer(async (req, res) => {
+  cors(req, res);
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204);
+    return res.end();
+  }
+  const url = new URL(req.url, `http://${req.headers.host}`);
+  try {
+    if (req.method === 'GET' && url.pathname === '/health') return handleHealth(res);
+    if (req.method === 'POST' && url.pathname === '/chat') return handleChat(req, res);
+    json(res, 404, { error: 'Not found' });
+  } catch (e) {
+    json(res, 500, { error: e?.message || String(e) });
+  }
+});
+
+function log(level, msg) {
+  const fn = level === 'error' ? console.error : console.log;
+  fn(`[chatpanel-bridge] ${msg}`);
+}
+
+server.listen(PORT, HOST, async () => {
+  log('info', `listening on http://${HOST}:${PORT}`);
+  for (const [id, { engine, label }] of Object.entries(ENGINES)) {
+    const a = await engine.available().catch(() => ({ ok: false }));
+    log('info', `  ${a.ok ? '✓' : '✕'} ${label}${a.ok ? '' : ' — ' + (a.reason || 'unavailable')}`);
+  }
+  log('info', 'Open the ChatPanel side panel; Claude Code & Codex will appear as agents.');
+});