loom-agent 1.2.0

package/bin/loom-tui.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+// Loom Code — TUI launcher. Prefers bun for the TSX/JSX pipeline; falls back to
+// plain node for environments without bun (the TUI will tell the user to install
+// bun first).
+const { spawnSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+function findBun() {
+  const candidates = [
+    // Common install locations
+    path.join(os.homedir(), '.bun', 'bin', 'bun.exe'),
+    path.join(os.homedir(), '.bun', 'bin', 'bun'),
+    '/usr/local/bin/bun',
+    '/opt/homebrew/bin/bun',
+    path.join(os.homedir(), 'bin', 'bun'),
+    path.join(os.homedir(), '.local', 'bin', 'bun'),
+  ];
+  for (const p of candidates) { try { if (fs.existsSync(p)) return p; } catch {} }
+  // PATH lookup (fast)
+  try {
+    const out = require('child_process').execSync('bun --version', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true }).trim();
+    if (out) return 'bun';
+  } catch {}
+  return null;
+}
+
+const entry = path.join(__dirname, '..', 'src', 'tui-open.tsx');
+const bun = findBun();
+
+if (bun) {
+  const result = spawnSync(bun, ['run', entry, ...process.argv.slice(2)], {
+    stdio: 'inherit',
+    cwd: process.cwd(),
+    env: process.env,
+  });
+  process.exit(result.status ?? 0);
+}
+
+console.log('Loom TUI requires bun (https://bun.sh) to run the TSX/JSX pipeline.');
+console.log('Install bun first, then use: bun run ' + entry);
+process.exit(1);

package/bin/loom.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+// Loom Code — CLI entry point. Works with Node directly (runtime is plain JS).
+require('dotenv').config();
+const { main } = require('../src/core/cli');
+const { updateCheck } = require('../src/core/update');
+const { LoomError } = require('../src/core/errors');
+
+process.title = 'loom-code';
+process.on('uncaughtException', (err) => {
+  if (err instanceof LoomError) { console.error(`\n[Loom Error] ${err.message}`); process.exit(1); }
+  console.error(`\n[Unexpected Error] ${err.message}`);
+  if (process.env.LOOM_DEBUG) console.error(err.stack);
+  process.exit(1);
+});
+process.on('unhandledRejection', (reason) => {
+  console.error(`\n[Unhandled Promise]`, reason);
+  if (process.env.LOOM_DEBUG) console.error(reason?.stack);
+  process.exit(1);
+});
+(async () => {
+  const sub = process.argv.slice(2)[0];
+  if (sub === 'acp') {
+    // ACP subprocess mode: JSON-RPC over stdio for editor integration.
+    require('../src/acp/acp-server').main();
+    return;
+  }
+  if (sub === 'web') {
+    // Browser interface: HTTP server on 127.0.0.1, opens the browser.
+    require('../src/web/web-server').main();
+    return;
+  }
+  if (sub === 'attach') {
+    // Terminal client for a running `loom web` server.
+    require('../src/web/attach').main();
+    return;
+  }
+  try {
+    await updateCheck();
+    await main();
+  } catch (err) {
+    console.error(err?.message || err);
+    process.exit(1);
+  }
+})();

package/docs/acp.md

@@ -0,0 +1,151 @@
+# Editor integration via the Agent Client Protocol (ACP)
+
+Loom can be driven as a **background coding agent by any editor that speaks the
+[Agent Client Protocol (ACP)](https://agentclientprotocol.com)** — the same open
+standard that powers opencode, Claude Code, and Gemini CLI integrations. You
+don't need a Loom plugin or a Loom-owned editor: the editor spawns `loom acp`
+as a subprocess, and the two sides exchange JSON-RPC messages over stdio.
+
+> New in v1.3.0 — implemented in `src/acp/acp-server.js` (protocol tests in
+> `src/acp/acp-server.test.js`).
+
+## How it works
+
+- **Transport:** newline-delimited JSON-RPC 2.0 over stdio. The editor writes
+  requests to stdin; Loom answers on stdout and queues agent events that the
+  client pulls with `fetchAgentEvent`. Loom never writes protocol data to
+  stdout outside responses, so the stream stays parseable.
+- **Launch:** `loom acp` starts the server and prints a readiness line to
+  **stderr** (never stdout): `[loom acp] started — provider: …, config: …`.
+- **Lifecycle:** the editor sends `initialize` → `connect` (creates a session,
+  chooses `plan`/`chat`/`build` mode, optional instruction block) →
+  `sendChatRequest` → polls `fetchAgentEvent` → `cancelCurrentTask` when asked.
+
+## Prerequisites
+
+- Loom installed (provides the `loom` command) — or run `bun src/acp/acp-server.js`
+  from a checkout.
+- An API key for at least one provider (the same config used by the TUI;
+  provider is chosen automatically from `~/.loom/config.json` or `LOOM_CONFIG_DIR`).
+
+## Configure an editor
+
+### Zed
+
+Zed hosts ACP agents in its Agent Panel as **External Agents**. Add Loom as a
+custom agent in `~/.config/zed/settings.json`:
+
+```json
+{
+  "agent_servers": {
+    "Loom Code": {
+      "type": "custom",
+      "command": "loom",
+      "args": ["acp"],
+      "env": {}
+    }
+  }
+}
+```
+
+Then open the Command Palette and run **`agent: new thread`**, pick *Loom Code*,
+and chat. To bind a key (open the Agent Panel / start a thread):
+
+```json
+{
+  "bindings": {
+    "cmd-alt-o": ["agent::NewExternalAgentThread", {
+      "agent": { "custom": { "name": "Loom Code", "command": { "command": "loom", "args": ["acp"] } } }
+    }]
+  }
+}
+```
+
+Prefer pointing `command` at the full path to `loom` (`which loom`) so Zed can
+find it.
+
+### JetBrains IDEs (IntelliJ / PyCharm / WebStorm …)
+
+JetBrains co-developed ACP with Zed. In the JetBrains **Agent** integration,
+set the ACP provider command to `loom acp` (same shape as the Zed entry above:
+command `loom`, arguments `acp`).
+
+### Neovim
+
+Point an ACP-capable completion plugin’s custom adapter at `loom acp`:
+
+- **Avante.nvim** — add a provider with `custom_api = "acp"` and make the
+  command run `loom acp`.
+- **CodeCompanion.nvim** — add an ACP adapter whose command is `loom acp`.
+
+If your plugin needs the agent to reachable on `PATH`, install Loom globally
+(`npm i -g .` / `npm link` from the repo, or publish) or use the absolute path.
+
+## Implemented ACP methods
+
+| Method                | Notes                                                                 |
+|-----------------------|-----------------------------------------------------------------------|
+| `initialize`          | Returns `protocolVersion: 1`, capabilities (`openai`, `customInstructions`), and the full OpenAI-style `toolSchemas` + `builtInTools`. |
+| `connect`             | Creates a session/task. Accepts `agentConfig.mode` (`plan`/`chat`/`build`) and `agentConfig.instructions` (injected into the agent prompt). Emits `session.updated: created`; returns `{ taskId }`. |
+| `storeMessage`        | Persists a user/assistant message into the session before/after requests. |
+| `sendChatRequest`     | Starts an async turn; returns `{ requestId }` immediately. Streams `agent.message` (text + reasoning), `tool.use`, `tool.result`, then `request.completed` / `request.error`. |
+| `fetchAgentEvent`     | Poll with `{ taskId, cursor }`; returns `{ events, cursor }`. Increment the cursor and keep polling until `request.completed`/`request.error`. |
+| `cancelCurrentTask`   | Interrupts the active request (maps to session interrupt / abort). |
+| `updateAgentConfig`   | Replaces the session instruction block.                                |
+| `changeDefaultMode`   | Switches mode between `plan`/`chat`/`build` mid-session.               |
+| `enableToolUse` / `disposeTool` | Accepted; all built-in + MCP tools are enabled by default (no gating). |
+
+## Events (retrieved via `fetchAgentEvent`)
+
+`session.updated` (`created`/`expanded`), `agent.message` (`type: text` /
+`type: reasoning`), `agent.message.completed`, `tool.use`, `tool.result`,
+`request.completed`, `request.error`.
+
+## Try it without an editor
+
+Pipe newline-delimited JSON into `loom acp` — initialize and create a task:
+
+```bash
+printf '%s\n' \
+  '{"jsonrpc":"2.0","id":1,"method":"initialize"}' \
+  '{"jsonrpc":"2.0","id":2,"method":"connect","params":{}}' \
+  | loom acp
+```
+
+Or run the bundled self-test client against a real model turn:
+
+```bash
+node scripts/acp-smoke.js                # spawns `node bin/loom.js acp`, chats
+node scripts/acp-smoke.js "explain this"' # custom prompt
+node scripts/acp-smoke.js --cancel        # demonstrate cancelCurrentTask
+```
+
+`scripts/acp-smoke.js` requires a configured provider key and exits non-zero on
+protocol error, so it doubles as a CI/diagnostic ping after any ACP change.
+
+## Publishing to the ACP Registry
+
+To make Loom installable with **one click** in ACP-aware editors (like Zed’s
+`zed: acp registry`, or the JetBrains ACP marketplace), publish a listing on the
+[Agent Client Protocol registry](https://agentclientprotocol.com):
+
+- **Command:** `loom acp` (runs the stdio server; no extra flags).
+- **Runtime note:** the agent needs a provider API key — same setup as the TUI.
+- **Repository/release:** link the Loom repo, README, and npm package.
+
+A registry listing is pure metadata — the agent code is already ACP-compatible,
+so no code changes are required to publish.
+
+## Troubleshooting
+
+- **The editor gets no response / broken JSON** — make sure nothing writes to
+  stdout before/around the server. The readiness line goes to stderr by design;
+  external logging must go to stderr too, or set `LOOM_DEBUG` and check
+  `~/.loom/debug`.
+- **`sendChatRequest` errors with “Task already has an active request”** — the
+  client must wait for `request.completed`/`request.error` (or cancel) before
+  the next request.
+- **`fetchAgentEvent` returns no new events** — keep polling with the returned
+  `cursor`; events only flush on fetch.
+- **“API key is invalid” / quota errors surface as `request.error`** — configure
+  the provider key exactly as you would for the TUI.

package/docs/web.md

@@ -0,0 +1,205 @@
+# Web — running Loom in your browser
+
+Loom can run as a **web application** in your browser, giving you the same
+multi-provider coding agent without a terminal. It uses a small Node `http`
+server (no framework, no build step) that serves a single-page UI and drives
+the **same core Session loop** as the TUI and ACP — so any provider/model,
+tool, MCP server, or saved session works identically.
+
+## Getting started
+
+Start the web interface:
+
+```bash
+loom web
+```
+
+This starts a local server on `127.0.0.1`, picks a random available port,
+prints the URL(s), and **opens your default browser** automatically.
+
+> **Caution — security.** If `LOOM_SERVER_PASSWORD` is not set, the server is
+> **unsecured**. That's fine for local single-user use but **must** be set
+> before binding to a network interface (`--hostname 0.0.0.0` / `--mdns`).
+> HTTP credentials and the `loom_token` cookie travel **unencrypted** — plain
+> HTTP is only safe on a trusted network; for access from anything else, use a
+> VPN or a TLS-terminating reverse proxy.
+
+> **Windows.** `loom web` works from PowerShell, but if you want full terminal
+> parity run it from WSL — same advice opencode gives for filesystem access.
+
+## Configuration
+
+You can configure the server with **command-line flags** or the `server` block
+in your config (`~/.loom/config.json`). CLI flags take precedence.
+
+### Port
+
+By default Loom picks an available port. Pin one with:
+
+```bash
+loom web --port 4096
+```
+
+### Hostname
+
+By default the server binds to `127.0.0.1` (localhost only). Make it reachable
+on your network:
+
+```bash
+loom web --hostname 0.0.0.0
+```
+
+With `0.0.0.0`, Loom prints both local and network addresses, e.g.:
+
+```
+  Local access:       http://localhost:4096
+  Network access:     http://192.168.1.100:4096
+```
+
+### mDNS
+
+Advertise the server on the local network (sets hostname to `0.0.0.0` and
+publishes it as `loom.local` via [bonjour-service](https://www.npmjs.com/package/bonjour-service)):
+
+```bash
+loom web --mdns
+```
+
+Run multiple instances on the same network with a custom domain name:
+
+```bash
+loom web --mdns --mdns-domain myproject.local
+```
+
+### CORS
+
+Allow additional origins for custom frontends:
+
+```bash
+loom web --cors https://example.com         # one origin
+loom web --cors https://a.com,https://b.com # several
+loom web --cors '*'                          # any
+```
+
+### Authentication
+
+Protect access with a password environment variable:
+
+```bash
+LOOM_SERVER_PASSWORD=secret loom web
+```
+
+> Setting the password via the command line (or passing `--password` to
+> `loom attach`) can leave the literal value in shell history and process
+> metadata — prefer the `LOOM_SERVER_PASSWORD` environment variable (or a
+> `.env` file) where possible.
+
+The username defaults to `loom` and can be changed with
+`LOOM_SERVER_USERNAME`. When a password is set, the browser shows a login
+screen; API endpoints return `401` until you log in.
+
+### Skip the auto-open
+
+```bash
+loom web --no-open
+```
+
+## Using the web interface
+
+Once started, the homepage lists your **saved sessions** (from
+`~/.loom/sessions/`), showing provider, model, and message count. Click a
+session to view its transcript; **Send a message** to continue it (or pick
+**New chat** to start fresh). Responses stream live (Server-Sent Events) with
+inline tool-use and reasoning.
+
+### See Servers
+
+Click **See Servers** in the header to view your configured MCP servers and
+their enabled/disabled status (the same `/mcp` view the TUI shows).
+
+## Attaching a terminal
+
+You can attach a terminal client to a running web server — the two share the
+same sessions and state:
+
+```bash
+# Terminal A — start the web server
+loom web --port 4096
+
+# Terminal B — attach to it
+loom attach http://localhost:4096
+```
+
+`loom attach` is a **line-mode** terminal client (the SolidJS OpenTUI runs
+in-process today and isn't rewired to a remote server). It lets you:
+
+- **pick** or **create** a session (shares the server's session list),
+- print a session's transcript,
+- chat with live streaming, and
+- send **Ctrl+C** to cancel the current request.
+
+For password-protected servers:
+
+```bash
+LOOM_SERVER_PASSWORD=secret loom attach http://localhost:4096
+# or inline:
+loom attach http://localhost:4096 --username loom --password secret
+```
+
+Resume a specific session without prompting:
+
+```bash
+loom attach http://localhost:4096 --session web-abc123
+```
+
+## Config file
+
+You can put the same server settings in your `~/.loom/config.json` under a
+`server` key:
+
+```json
+{
+  "server": {
+    "port": 4096,
+    "hostname": "0.0.0.0",
+    "mdns": true,
+    "cors": ["https://example.com"]
+  }
+}
+```
+
+**Command-line flags take precedence** over config-file settings.
+
+## API (for custom clients)
+
+The UI talks to a small JSON API over the same HTTP server — feel free to use
+it from your own client or script. (Set `LOOM_SERVER_PASSWORD` and send
+`Cookie: loom_token=…` to authenticate; get the token from `POST /api/auth`.)
+
+| Endpoint | Method | Notes |
+|---|---|---|
+| `GET /api/health` | GET | `{ ok: true }` |
+| `GET /api/auth` | GET | `{ required, username }` |
+| `POST /api/auth` | POST | `{ username, password }` → sets `loom_token` cookie |
+| `GET /api/sessions` | GET | List saved sessions |
+| `GET /api/sessions/:id` | GET | Load a session transcript |
+| `POST /api/sessions` | POST | `{ mode }` → `{ id, mode }` (new web session) |
+| `POST /api/chat` | POST | `{ id?, message, mode? }` → `text/event-stream` of `{type, …}` |
+| `POST /api/cancel` | POST | `{ id }` interrupts the active request |
+| `GET /api/servers` | GET | MCP server list + status |
+| `GET /api/config` | GET | Provider/model/version banner data |
+
+SSE event `type`s: `delta`, `reasoning`, `tool.use`, `tool.result`,
+`message.completed`, `request.completed`, `request.error`, `session.updated`,
+`done`.
+
+## Troubleshooting
+
+- **"Authentication required"** — set `LOOM_SERVER_PASSWORD` (and optionally
+  `LOOM_SERVER_USERNAME`) before starting the server.
+- **Tail of `--cors`** — separate multiple origins with a comma: `--cors a,b`.
+- **mDNS not advertised on Windows** — `bonjour-service` is pure JS but mDNS
+  is best-effort on the OS; if it fails, an error is printed and the HTTP
+  server still works at the printed URLs.
+- **"session is busy" from a client** — you must wait for `request.completed`
+  / `request.error` (or call `/api/cancel`) before sending the next message.

package/package.json

@@ -0,0 +1,97 @@
+{
+  "name": "loom-agent",
+  "version": "1.2.0",
+  "repository": { "type": "git", "url": "git+https://github.com/toshalkumbhar8979-design/loomcode.git" },
+  "homepage": "https://github.com/toshalkumbhar8979-design/loomcode#readme",
+  "bugs": { "url": "https://github.com/toshalkumbhar8979-design/loomcode/issues" },
+  "description": "Loom Code — AI-powered coding agent for the terminal. Multi-provider support including NVIDIA. OpenTUI interface.",
+  "main": "src/index.js",
+  "bin": {
+    "loom": "bin/loom.js",
+    "loom-tui": "bin/loom-tui.js"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "dev": "node --watch src/index.js",
+    "setup": "node src/setup.js",
+    "test": "bun run src/tui/test-interactive.tsx && bun run test:unit && bun run lint:core",
+    "test:unit": "bun test src/core/agents.test.js src/core/hooks.test.js src/core/custom-commands.test.js src/core/background-tasks.test.js src/core/memory.test.js src/core/subagent-log.test.js src/core/session.test.js src/tools/index.test.js src/providers/providers.test.js src/providers/caching.test.js src/providers/caching-thinking.test.js src/providers/registry.test.js src/mcp/mcp-client.test.js src/mcp/mcp-manager.test.js src/core/session-store.test.js src/skills/skills-manager.test.js src/core/usage.test.js src/core/permissions.test.js src/core/format.test.js src/acp/acp-server.test.js src/web/web-server.test.js src/tui/keybinds.test.ts",
+    "lint:core": "node node_modules/typescript/bin/tsc -p tsconfig.core.json",
+    "smoke:acp": "node scripts/acp-smoke.js",
+    "tui": "node bin/loom-tui.js",
+    "tui:win": "\"%USERPROFILE%\\..\\bun\\bin\\bun.exe\" run src/tui-open.tsx",
+    "prepublishOnly": "npm test",
+    "lint": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.37.0",
+    "@opentui/core": "^0.5.1",
+    "@opentui/solid": "^0.5.1",
+    "@shikijs/themes": "4.4.3",
+    "bonjour-service": "^1.4.4",
+    "boxen": "^8.0.0",
+    "chalk": "^5.3.0",
+    "cli-spinners": "^3.2.0",
+    "commander": "^12.1.0",
+    "dayjs": "^1.11.0",
+    "diff": "^7.0.0",
+    "dotenv": "^16.4.0",
+    "glob": "^11.0.0",
+    "inquirer": "^12.1.0",
+    "openai": "^4.73.0",
+    "ora": "^8.0.0",
+    "shell-quote": "^1.8.1",
+    "solid-js": "^1.9.14",
+    "strip-ansi": "^7.1.0",
+    "tiktoken": "^1.0.22",
+    "uuid": "^11.0.0",
+    "wrap-ansi": "^9.0.0"
+  },
+  "optionalDependencies": {
+    "@opentui/core-win32-x64": "^0.5.1",
+    "@opentui/core-darwin-arm64": "^0.5.1",
+    "@opentui/core-darwin-x64": "^0.5.1",
+    "@opentui/core-linux-x64": "^0.5.1",
+    "@opentui/core-linux-arm64": "^0.5.1"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.2.0",
+    "typescript": "^5.7.3"
+  },
+  "files": [
+    "bin/loom.js",
+    "bin/loom-tui.js",
+    "src/**/*.js",
+    "src/**/*.tsx",
+    "src/**/*.ts",
+    "!src/**/test-*",
+    "!src/**/*.test.*",
+    "!src/test-loop.js",
+    "!src/test-tools.js",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    ".env.example",
+    "LOOM.md",
+    "docs/acp.md",
+    "scripts/acp-smoke.js",
+    "docs/web.md",
+    "src/web/index.html",
+    "src/web/graph-view.html"
+  ],
+  "keywords": [
+    "ai",
+    "cli",
+    "coding-agent",
+    "loom-code",
+    "anthropic",
+    "openai",
+    "nvidia",
+    "terminal",
+    "opentui"
+  ],
+  "engines": {
+    "node": ">=18.0.0",
+    "bun": ">=1.0.0"
+  }
+}

package/scripts/acp-smoke.js

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+// ACP smoke-test client — drives `loom acp` the way an editor would and prints
+// the resulting event stream. Verifies the protocol end-to-end (initialize ->
+// connect -> sendChatRequest -> fetchAgentEvent -> cancel/complete).
+//
+//   node scripts/acp-smoke.js [prompt] [--cancel] [--mode plan|chat|build]
+//
+// Requires a configured provider key (same as the TUI). Exits 0 on a clean
+// request.completed, non-zero on protocol error / request.error / timeout.
+'use strict';
+
+const { spawn } = require('child_process');
+const readline = require('readline');
+const path = require('path');
+
+const args = process.argv.slice(2);
+const cancel = args.includes('--cancel');
+const modeIdx = args.indexOf('--mode');
+const mode = modeIdx !== -1 && args[modeIdx + 1] ? args[modeIdx + 1] : 'build';
+const prompt = args.filter((a) => a !== '--cancel' && a !== '--mode' && (modeIdx === -1 || a !== args[modeIdx + 1]))[0]
+  || 'Say hello, then list up to five files in this repository.';
+
+const root = path.resolve(__dirname, '..');
+const child = spawn(process.execPath, [path.join('bin', 'loom.js'), 'acp'], {
+  cwd: root,
+  stdio: ['pipe', 'pipe', 'pipe'],
+  env: { ...process.env, LOOM_MCP_NO_WARM: '1', LOOM_MEM_AUTO: '0' },
+});
+
+const pending = new Map();
+let seq = 0;
+let stderrBuf = '';
+let sawEvent = false;
+
+child.stderr.on('data', (d) => { stderrBuf += d.toString(); });
+readline.createInterface({ input: child.stdout }).on('line', (line) => {
+  const trimmed = String(line).trim();
+  if (!trimmed) return;
+  let msg;
+  try { msg = JSON.parse(trimmed); } catch { return; }
+  if (msg.id != null && pending.has(msg.id)) {
+    const h = pending.get(msg.id);
+    pending.delete(msg.id);
+    clearTimeout(h.t);
+    h.resolve(msg);
+  }
+});
+child.on('error', (e) => { console.error('[spawn error]', e.message); process.exit(1); });
+child.on('exit', (code) => { if (pending.size && !finishing) { console.error('[server exited early] code=' + code + ' stderr=' + stderrBuf.slice(-400)); process.exit(1); } });
+
+function send(method, params) {
+  return new Promise((resolve, reject) => {
+    const rid = ++seq;
+    const t = setTimeout(() => { pending.delete(rid); reject(new Error('timeout waiting for ' + method)); }, 30000);
+    pending.set(rid, { t, resolve });
+    child.stdin.write(JSON.stringify({ jsonrpc: '2.0', id: rid, method, params: params || {} }) + '\n');
+  });
+}
+
+let finishing = false;
+function finish(code) {
+  finishing = true;
+  try { child.stdin.end(); } catch {}
+  setTimeout(() => { try { child.kill(); } catch {} process.exit(code); }, 100).unref();
+}
+
+function show(e) {
+  sawEvent = true;
+  switch (e.event) {
+    case 'agent.message':
+      console.log('  ' + (e.content && e.content.type === 'reasoning' ? '(reasoning) ' : '') + (e.content && e.content.content != null ? String(e.content.content) : ''));
+      break;
+    case 'tool.use':
+      console.log('[tool.use] ' + e.toolName + ' ' + safeJSON(e.input));
+      break;
+    case 'tool.result': {
+      const r = e.result;
+      const s = typeof r === 'string' ? r : safeJSON(r);
+      console.log('[tool.result] ' + e.toolName + ' ' + s.slice(0, 160) + (s.length > 160 ? '…' : ''));
+      break;
+    }
+    case 'request.completed':
+      console.log('[request.completed] ' + (e.response && e.response.text ? String(e.response.text) : ''));
+      break;
+    case 'request.error':
+      console.log('[request.error] ' + (e.message || ''));
+      break;
+    case 'session.updated':
+      console.log('[session.updated:' + e.type + ']');
+      break;
+    default:
+      console.log('[' + e.event + ']');
+  }
+}
+
+function safeJSON(v) {
+  if (v == null) return String(v);
+  if (typeof v !== 'object') return String(v);
+  try { const s = JSON.stringify(v); return s && s.length > 400 ? s.slice(0, 400) + '…' : s; } catch { return String(v); }
+}
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+(async () => {
+  const init = await send('initialize');
+  if (init.error) throw new Error('initialize failed: ' + JSON.stringify(init.error) + '\nstderr: ' + stderrBuf.slice(-300));
+  console.log('provider ok — protocolVersion ' + init.result.protocolVersion + ', tools ' + init.result.toolSchemas.length + ', builtin ' + init.result.agentConfig.builtInTools.length);
+
+  const conn = await send('connect', { agentConfig: { mode, instructions: 'You are connected to a smoke-test client. Keep replies brief.' } });
+  if (conn.error) throw new Error('connect failed: ' + JSON.stringify(conn.error));
+  const taskId = conn.result.taskId;
+
+  const req = await send('sendChatRequest', { taskId, message: { content: prompt } });
+  if (req.error) throw new Error('sendChatRequest failed: ' + JSON.stringify(req.error));
+  console.log('prompt: ' + prompt);
+  console.log('mode: ' + mode + (cancel ? ' (cancel demo)' : ''));
+
+  let cursor = 0;
+  let state = 'running';
+  const cancelTimer = cancel ? setTimeout(() => {
+    if (state === 'running') { state = 'cancelling'; console.log('[cancelling]'); send('cancelCurrentTask', { taskId }).catch(() => {}); }
+  }, 3000) : null;
+
+  const started = Date.now();
+  while (state === 'running' || state === 'cancelling') {
+    if (Date.now() - started > 120000) { console.error('[timeout] no terminal event within 120s'); finish(1); return; }
+    const resp = await send('fetchAgentEvent', { taskId, cursor });
+    if (resp.error) throw new Error('fetchAgentEvent failed: ' + JSON.stringify(resp.error));
+    for (const e of resp.result.events) show(e);
+    cursor = resp.result.cursor;
+    const terminal = resp.result.events.find((e) => e.event === 'request.completed' || e.event === 'request.error');
+    if (terminal) {
+      const ok = terminal.event === 'request.completed' || (cancel && /interrupt/i.test(terminal.message || ''));
+      console.log(ok ? '[PASS]' : '[FAIL] request ended with ' + terminal.event + (terminal.message ? ': ' + terminal.message : ''));
+      if (cancelTimer) clearTimeout(cancelTimer);
+      finish(ok ? 0 : 1);
+      return;
+    }
+    await sleep(120);
+  }
+  if (cancelTimer) clearTimeout(cancelTimer);
+  finish(sawEvent ? 0 : 1);
+})().catch((e) => {
+  console.error('[smoke error]', e.message);
+  finish(1);
+});