thinkpool-pair 0.7.25 → 0.7.27

package/README.md

@@ -98,5 +98,35 @@ npx thinkpool-pair@latest <ROOM> -- claude           # structured Claude, no TTY
 - `resize` — web viewport size → headless PTYs only (the attached terminal
   follows your own TTY).
 
+## Alternative LLM Providers
+
+The bridge can run on **any Anthropic-compatible endpoint** instead of Anthropic
+directly — Z.ai GLM, OpenRouter, your own proxy, etc. **CLI-agent-compatible
+only:** the bridge spawns the `claude` CLI, which talks the Anthropic Messages
+API, so the base url must be a root the SDK can append `/v1/messages` to (an
+OpenAI-style `/v1/chat/completions` endpoint will not work).
+
+```bash
+npx thinkpool-pair provider custom --base <url> --token <key> [--model <name>]
+```
+
+Common base urls (the SDK appends `/v1/messages`):
+
+| Provider      | Base url                          |
+|---------------|-----------------------------------|
+| Z.ai GLM      | `https://api.z.ai/api/anthropic`  |
+| OpenRouter    | `https://openrouter.ai/api`       |
+
+Show the current provider (`npx thinkpool-pair provider`), or reset back to your
+regular Claude login:
+
+```bash
+npx thinkpool-pair provider anthropic
+```
+
+Provider config is stored in `~/.thinkpool-pair/provider.json` (mode 0600) and
+applies to every bridge on the machine. Restart the bridge (or its launchd
+service) after changing it — the choice is read once at startup.
+
 Public anon creds are embedded (the same ones the web app ships). Override with
 `TP_SUPABASE_URL` / `TP_SUPABASE_ANON` if needed. Set `TP_NAME` to label yourself.

package/bridge.mjs

@@ -597,9 +597,16 @@ function openStructured({ id, model, resume, log, commands, mode }) {
       // on the entry so the ANNOUNCE can hand it to clients that connect/reload
       // AFTER init (the one-time code-event would miss them), then re-announce.
       if (evt.kind === 'system' && Array.isArray(evt.commands) && evt.commands.length && !entry.commands) { entry.commands = evt.commands; announce(); persist() }
-      // Chrome events (mode / usage / clear) are transient state, not transcript —
-      // broadcast + print them, but keep them out of the persisted/replayed log.
-      const chrome = evt.kind === 'mode' || evt.kind === 'usage' || evt.kind === 'clear'
+      // Chrome events (mode / usage / clear / compact) are transient state, not
+      // transcript — broadcast + print them but keep out of the persisted/replayed log.
+      const chrome = evt.kind === 'mode' || evt.kind === 'usage' || evt.kind === 'clear' || evt.kind === 'compact'
+      // compact turn finished (or errored) → clear the pulsing indicator.
+      // No "done" ctl line — the SDK's own output in the transcript is the
+      // signal (compact summary on success, AbortError text on abort/too-small).
+      if ((evt.kind === 'result' || evt.kind === 'error') && entry.compacting) {
+        entry.compacting = false
+        bcast('code-event', { term: id, evt: { kind: 'compact', status: 'done', ts: Date.now() } })
+      }
       if (!chrome) {
         entry.log.push(evt)
         if (entry.log.length > STRUCTURED_LOG_MAX) entry.log.shift()
@@ -814,6 +821,16 @@ channel
       ctlLine('context cleared. You can continue with these answers in mind.')
       return
     }
+    // /compact → announce immediately, track so onEvent can emit a done signal when
+    // the SDK turn finishes. No echoYou — the ctl line IS the announcement.
+    if (/^\/compact\b/.test(text)) {
+      ctlLine('◈ compacting context…')
+      s.compacting = true
+      s.compactBy = payload.by
+      bcast('code-event', { term: payload.term, evt: { kind: 'compact', status: 'start', ts: Date.now() } })
+      s.session.sendTurn(text)
+      return
+    }
     s.session.sendTurn(text)
     echoYou()
   })

package/claude-session.mjs

@@ -14,6 +14,7 @@
 
 import { randomUUID } from 'node:crypto'
 import { query } from '@anthropic-ai/claude-agent-sdk'
+import { sanitizeSession } from './transcript-sanitize.mjs'
 
 // ── risk classification — the accent/danger tier of the permission card ──
 // low (read-only) · medium (writes/runs) · network (leaves the machine) ·
@@ -290,6 +291,16 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
   if (resume) opts.resume = resume
   if (env) opts.env = env
 
+  // Before the SDK replays this transcript, heal any cross-provider tool blocks
+  // it left behind (e.g. a room that ran on Z.ai GLM, now back on anthropic).
+  // Anthropic 400s on a `server_tool_use` block carrying a foreign id/name, which
+  // wedges the room on every send. Reclassifying those to plain `tool_use` clears
+  // it; idempotent + no-op on clean transcripts. See transcript-sanitize.mjs.
+  if (resume) {
+    const healed = sanitizeSession(cwd || process.cwd(), resume)
+    if (healed.blocks) process.stderr.write(`\n  ◆ healed ${healed.blocks} cross-provider tool block(s) in the transcript before resume.\n`)
+  }
+
   ;(async () => {
     try {
       q = query({ prompt: input.stream, options: opts })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.25",
+  "version": "0.7.27",
   "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
   "type": "module",
   "bin": {
@@ -9,6 +9,7 @@
   "files": [
     "bridge.mjs",
     "claude-session.mjs",
+    "transcript-sanitize.mjs",
     "session-store.mjs",
     "service.mjs",
     "account.mjs",

package/provider.mjs

@@ -1,12 +1,12 @@
 /* ─────────────────────────────────────────────────────────────
    provider.mjs — per-machine LLM provider choice for the ThinkPool
-   bridge. Lets a Code room run on GLM (Z.ai's Anthropic-compatible
-   endpoint) instead of plain Anthropic, INDEPENDENT of the launching
-   shell. Why this exists: the launchd service does NOT source ~/.zshrc,
-   so a shell `export ANTHROPIC_*` can never reach a serviced bridge —
-   its spawned Claude children fall back to the host's claude.ai login
-   and hit the Anthropic spend wall. provider.json is the bridge's OWN
-   source of truth.
+   bridge. Lets a Code room run on ANY Anthropic-compatible endpoint
+   (Z.ai GLM, OpenRouter, a local proxy, …) instead of plain Anthropic,
+   INDEPENDENT of the launching shell. Why this exists: the launchd
+   service does NOT source ~/.zshrc, so a shell `export ANTHROPIC_*` can
+   never reach a serviced bridge — its spawned Claude children fall back
+   to the host's claude.ai login and hit the Anthropic spend wall.
+   provider.json is the bridge's OWN source of truth.
 
    applyProviderEnv() runs once at the top of bridge.mjs (the universal
    entry point), BEFORE any child is spawned. It sets ANTHROPIC_BASE_URL
@@ -16,11 +16,17 @@
    every code session with no other change. Default (no file, or
    provider:"anthropic") = the host's regular Claude login, untouched.
 
+   CLI-agent-compatible ONLY. The bridge spawns the `claude` CLI, which
+   talks the Anthropic Messages API — so the base url MUST be an
+   Anthropic-compatible root (the SDK appends /v1/messages). An OpenAI-
+   style /v1/chat/completions endpoint will NOT work. Common roots:
+     Z.ai GLM    → https://api.z.ai/api/anthropic
+     OpenRouter  → https://openrouter.ai/api
+
    CLI (dispatched from bridge.mjs):
-     npx thinkpool-pair provider                         # show current
-     npx thinkpool-pair provider glm --token <zai_…>     # use GLM (Z.ai)
-     npx thinkpool-pair provider custom --base <url> --token <key>
-     npx thinkpool-pair provider anthropic               # reset to Claude
+     npx thinkpool-pair provider                                            # show current
+     npx thinkpool-pair provider custom --base <url> --token <key> [--model <m>]   # any Anthropic-compatible endpoint
+     npx thinkpool-pair provider anthropic                                  # reset to Claude
    ───────────────────────────────────────────────────────────── */
 import os from 'node:os'
 import fs from 'node:fs'
@@ -29,10 +35,6 @@ import path from 'node:path'
 const DIR = path.join(os.homedir(), '.thinkpool-pair')
 const FILE = path.join(DIR, 'provider.json')
 
-// The pre-baked GLM/Z.ai preset. --token is always required (never bake a key
-// into source); --base / --model override these if the endpoint ever moves.
-const GLM = { baseUrl: 'https://api.z.ai/api/anthropic', model: 'glm-5.2' }
-
 function ensureDir() { try { fs.mkdirSync(DIR, { recursive: true }) } catch { /* noop */ } }
 function opt(args, flag) { const i = args.indexOf(flag); return i >= 0 ? args[i + 1] : undefined }
 
@@ -46,11 +48,15 @@ export function saveProvider(p) {
 }
 
 /**
- * Merge the persisted provider choice (or TP_PROVIDER* env overrides) into
+ * Merge the persisted provider choice (or TP_* env overrides) into
  * process.env. Call once at startup, before spawning any child. Idempotent.
- * A no-op for the default Anthropic provider — we only ever SET the GLM/custom
+ * A no-op for the default Anthropic provider — we only ever SET the custom
  * vars, never clobber a host's real Claude login env. Env vars win over the
  * file so a one-off launch can flip providers without writing anything.
+ *
+ * Provider-name-agnostic: any provider saved to provider.json (glm, custom,
+ * a leftover openrouter file, …) is handled by one branch that only cares
+ * that baseUrl/authToken are present.
  * @returns {{provider:string,baseUrl?:string,model?:string,source:string}}
  */
 export function applyProviderEnv() {
@@ -58,11 +64,11 @@ export function applyProviderEnv() {
   const provider = (process.env.TP_PROVIDER || cfg.provider || 'anthropic').toLowerCase()
   if (provider === 'anthropic' || !provider) return { provider: 'anthropic', source: 'default' }
 
-  const baseUrl = process.env.TP_ANTHROPIC_BASE_URL || cfg.baseUrl
+  const baseUrl   = process.env.TP_ANTHROPIC_BASE_URL   || cfg.baseUrl
   const authToken = process.env.TP_ANTHROPIC_AUTH_TOKEN || cfg.authToken
-  const model = process.env.TP_ANTHROPIC_MODEL || cfg.model
+  const model     = process.env.TP_ANTHROPIC_MODEL      || cfg.model
   if (!baseUrl || !authToken) {
-    process.stderr.write(`\n  ◇ provider "${provider}" is set but is missing baseUrl/authToken.\n    Finish setup:  npx thinkpool-pair provider ${provider} --token <key>\n    Falling back to regular Claude for now.\n`)
+    process.stderr.write(`\n  ◇ provider "${provider}" is set but is missing baseUrl/authToken.\n    Finish setup:  npx thinkpool-pair provider custom --base <url> --token <key>\n    Falling back to regular Claude for now.\n`)
     return { provider: 'anthropic', source: 'incomplete' }
   }
   process.env.ANTHROPIC_BASE_URL = baseUrl
@@ -93,28 +99,34 @@ export async function runProvider(args) {
     return
   }
 
-  // ── GLM (Z.ai) preset ──
-  if (sub === 'glm') {
-    const token = opt(args, '--token') || opt(args, '--key')
-    const baseUrl = opt(args, '--base') || opt(args, '--base-url') || GLM.baseUrl
-    const model = opt(args, '--model') || GLM.model
-    if (!token) { console.error('\n  ✗ glm needs --token <zai_…>. Get one at https://z.ai/\n'); process.exit(1) }
-    saveProvider({ provider: 'glm', baseUrl, authToken: token, model, savedAt: Date.now() })
-    console.error(`\n  ✓ provider set to glm (Z.ai).\n    base url: ${baseUrl}\n    model:    ${model}\n    token:    ${token.slice(0, 8)}…\n    Restart the bridge (or its launchd service) to apply.\n`)
-    return
-  }
-
-  // ── arbitrary Anthropic-compatible endpoint ──
+  // ── any Anthropic-compatible endpoint ──
   if (sub === 'custom') {
-    const token = opt(args, '--token') || opt(args, '--key')
-    const baseUrl = opt(args, '--base') || opt(args, '--base-url')
-    const model = opt(args, '--model')
-    if (!token || !baseUrl) { console.error('\n  ✗ custom needs --base <url> and --token <key>.\n'); process.exit(1) }
+    const token   = opt(args, '--token') || opt(args, '--key')
+    const baseUrl = opt(args, '--base')  || opt(args, '--base-url')
+    const model   = opt(args, '--model')
+    if (!token || !baseUrl) {
+      console.error(
+        '\n  ✗ custom needs --base <url> and --token <key>. [--model <name>] is optional.\n' +
+        '    The base url is the Anthropic-compatible root the SDK appends /v1/messages to:\n' +
+        '      Z.ai GLM    → https://api.z.ai/api/anthropic\n' +
+        '      OpenRouter  → https://openrouter.ai/api\n' +
+        '    Restart the bridge (or its launchd service) to apply.\n'
+      )
+      process.exit(1)
+    }
     saveProvider({ provider: 'custom', baseUrl, authToken: token, model: model || undefined, savedAt: Date.now() })
-    console.error(`\n  ✓ provider set to custom (${baseUrl}).\n    Restart the bridge to apply.\n`)
+    console.error(`\n  ✓ provider set to custom.\n    base url: ${baseUrl}\n    model:    ${model || '(default)'}\n    token:    ${token.slice(0, 8)}…\n    Restart the bridge (or its launchd service) to apply.\n`)
     return
   }
 
-  console.error('\n  usage:\n    npx thinkpool-pair provider                              # show current\n    npx thinkpool-pair provider glm --token <zai_…> [--model glm-5.2]\n    npx thinkpool-pair provider custom --base <url> --token <key> [--model <m>]\n    npx thinkpool-pair provider anthropic                      # reset to Claude\n')
+  console.error(
+    '\n  usage:\n' +
+    '    npx thinkpool-pair provider                                            # show current\n' +
+    '    npx thinkpool-pair provider custom --base <url> --token <key> [--model <m>]   # any Anthropic-compatible endpoint\n' +
+    '    npx thinkpool-pair provider anthropic                                  # reset to Claude\n\n' +
+    '  common base urls (SDK appends /v1/messages):\n' +
+    '    Z.ai GLM    → https://api.z.ai/api/anthropic\n' +
+    '    OpenRouter  → https://openrouter.ai/api\n'
+  )
   process.exit(1)
 }

package/transcript-sanitize.mjs

@@ -0,0 +1,132 @@
+/* ─────────────────────────────────────────────────────────────
+   transcript-sanitize.mjs — heal cross-provider tool blocks in a
+   Claude Code transcript before the SDK replays it.
+
+   THE BUG IT PREVENTS (failure: feedback_bridge_provider_swap_srvtoolu):
+   When a room runs on a non-Anthropic provider (Z.ai GLM, any
+   OpenAI-compatible endpoint), Claude Code persists that provider's
+   custom server-side tools into the transcript as `server_tool_use`
+   blocks — but with that provider's tool ids/names (e.g. an OpenAI
+   `call_<hex>` id, a name like `webReader` / `analyze_image`). Swap the
+   provider back to `anthropic` and the next turn replays the whole
+   transcript; Anthropic STRICTLY validates server_tool_use blocks and
+   400s on the first illegal one:
+     messages.N.content.M.server_tool_use.id:   String should match '^srvtoolu_…'
+     messages.N.content.M.server_tool_use.name: Input should be 'web_search', …
+   The room is then wedged — every send re-hits message N and fails.
+
+   THE FIX: reclassify each illegal block from `server_tool_use` to a
+   plain `tool_use`. Anthropic only enforces the id-pattern and the
+   name-enum on SERVER tools; a regular tool_use replays with ANY id and
+   ANY name (the transcript's own `call_*` client tools — Bash, Edit,
+   WebSearch — prove this; they never error). The block keeps its id, so
+   it stays paired with its existing tool_result. This clears BOTH the
+   id and the name error in one move and is the universally-valid form,
+   so it's safe to run regardless of which provider wrote the history.
+
+   NB: do NOT "fix" this by renaming the id to `srvtoolu_…` — that leaves
+   the bogus tool NAME, so the name-enum error survives and the room
+   stays stuck. (That half-fix is the documented trap.)
+
+   Idempotent, crash-safe (atomic rename), and a cheap string pre-check
+   means it's a no-op on clean transcripts. Never throws into the caller.
+   ───────────────────────────────────────────────────────────── */
+
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+// Anthropic's real server-tool names. A `server_tool_use` block whose name
+// is NOT in this set came from another provider and must be reclassified.
+const ANTHROPIC_SERVER_TOOLS = new Set([
+  'web_search',
+  'web_fetch',
+  'code_execution',
+  'bash_code_execution',
+  'text_editor_code_execution',
+  'tool_search_tool_regex',
+  'tool_search_tool_bm25',
+])
+
+const MARKER = '"server_tool_use"'
+
+/**
+ * Resolve a session's transcript path the same way Claude Code names it:
+ * ~/.claude/projects/<cwd with [/\.:] → '-'>/<sessionId>.jsonl
+ */
+export function transcriptPath(cwd, sessionId) {
+  const slug = path.resolve(cwd || process.cwd()).replace(/[/\\.:]/g, '-')
+  return path.join(os.homedir(), '.claude', 'projects', slug, `${sessionId}.jsonl`)
+}
+
+// Flip illegal server_tool_use blocks in one content array. Returns count flipped.
+function fixContent(content) {
+  if (!Array.isArray(content)) return 0
+  let n = 0
+  for (const b of content) {
+    if (b && b.type === 'server_tool_use' && !ANTHROPIC_SERVER_TOOLS.has(b.name)) {
+      b.type = 'tool_use'
+      n++
+    }
+  }
+  return n
+}
+
+/**
+ * Sanitize one transcript file in place. Returns { lines, blocks } counting the
+ * transcript lines rewritten and the individual blocks flipped. A missing,
+ * unreadable, or already-clean file is a silent no-op ({ lines: 0, blocks: 0 }).
+ */
+export function sanitizeTranscript(file) {
+  let raw
+  try {
+    raw = fs.readFileSync(file, 'utf8')
+  } catch {
+    return { lines: 0, blocks: 0 } // no transcript yet (fresh session) — nothing to do
+  }
+  if (!raw.includes(MARKER)) return { lines: 0, blocks: 0 } // fast path: nothing illegal possible
+
+  const rows = raw.split('\n')
+  let lines = 0
+  let blocks = 0
+  for (let i = 0; i < rows.length; i++) {
+    const row = rows[i]
+    if (!row || !row.includes(MARKER)) continue
+    let obj
+    try {
+      obj = JSON.parse(row)
+    } catch {
+      continue // never touch a line we can't parse — leave it byte-identical
+    }
+    let n = 0
+    if (obj.message && typeof obj.message === 'object') n += fixContent(obj.message.content)
+    n += fixContent(obj.content)
+    if (n > 0) {
+      rows[i] = JSON.stringify(obj)
+      lines++
+      blocks += n
+    }
+  }
+
+  if (!blocks) return { lines: 0, blocks: 0 } // every server_tool_use was already a legal Anthropic one
+
+  // Atomic write — a crash mid-write must never leave a truncated transcript.
+  const tmp = `${file}.tp-sanitize.tmp`
+  fs.writeFileSync(tmp, rows.join('\n'))
+  fs.renameSync(tmp, file)
+  return { lines, blocks }
+}
+
+/**
+ * Resolve cwd+sessionId to a path and sanitize. Wrapped so a sanitize failure
+ * can never block session start — worst case the room behaves as it did before.
+ * Returns the same shape as sanitizeTranscript.
+ */
+export function sanitizeSession(cwd, sessionId) {
+  if (!sessionId) return { lines: 0, blocks: 0 }
+  try {
+    return sanitizeTranscript(transcriptPath(cwd, sessionId))
+  } catch {
+    return { lines: 0, blocks: 0 }
+  }
+}