chainlesschain 0.47.6 → 0.47.8

package/src/lib/chat-core.js

@@ -10,11 +10,14 @@
  */
 
 import { BUILT_IN_PROVIDERS } from "./llm-providers.js";
+import { appendTokenUsage } from "../harness/jsonl-session-store.js";
 
 /**
- * Stream a response from Ollama
+ * Stream a response from Ollama.
+ * If `onUsage` is provided, it's called with `{inputTokens, outputTokens}`
+ * derived from Ollama's terminal `prompt_eval_count` / `eval_count` fields.
  */
-export async function streamOllama(messages, model, baseUrl, onToken) {
+export async function streamOllama(messages, model, baseUrl, onToken, onUsage) {
   const response = await fetch(`${baseUrl}/api/chat`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
@@ -47,6 +50,13 @@ export async function streamOllama(messages, model, baseUrl, onToken) {
           fullResponse += json.message.content;
           onToken(json.message.content);
         }
+        if (json.done && onUsage) {
+          const inputTokens = Number(json.prompt_eval_count) || 0;
+          const outputTokens = Number(json.eval_count) || 0;
+          if (inputTokens || outputTokens) {
+            onUsage({ inputTokens, outputTokens });
+          }
+        }
       } catch {
         // Partial JSON, skip
       }
@@ -59,7 +69,14 @@ export async function streamOllama(messages, model, baseUrl, onToken) {
 /**
  * Stream a response from OpenAI-compatible API
  */
-export async function streamOpenAI(messages, model, baseUrl, apiKey, onToken) {
+export async function streamOpenAI(
+  messages,
+  model,
+  baseUrl,
+  apiKey,
+  onToken,
+  onUsage,
+) {
   const response = await fetch(`${baseUrl}/chat/completions`, {
     method: "POST",
     headers: {
@@ -70,6 +87,9 @@ export async function streamOpenAI(messages, model, baseUrl, apiKey, onToken) {
       model,
       messages,
       stream: true,
+      // Opt-in token usage in the terminal chunk (OpenAI-compatible).
+      // Servers that don't understand it simply ignore it.
+      stream_options: { include_usage: true },
     }),
   });
 
@@ -99,6 +119,13 @@ export async function streamOpenAI(messages, model, baseUrl, apiKey, onToken) {
             fullResponse += content;
             onToken(content);
           }
+          if (json.usage && onUsage) {
+            const inputTokens = Number(json.usage.prompt_tokens) || 0;
+            const outputTokens = Number(json.usage.completion_tokens) || 0;
+            if (inputTokens || outputTokens) {
+              onUsage({ inputTokens, outputTokens });
+            }
+          }
         } catch {
           // Partial data
         }
@@ -109,6 +136,99 @@ export async function streamOpenAI(messages, model, baseUrl, apiKey, onToken) {
   return fullResponse;
 }
 
+/**
+ * Stream a response from Anthropic's /v1/messages API.
+ * SSE chunks carry `message_start` (usage.input_tokens) and `message_delta`
+ * (usage.output_tokens). Content comes from `content_block_delta` events.
+ */
+export async function streamAnthropic(
+  messages,
+  model,
+  baseUrl,
+  apiKey,
+  onToken,
+  onUsage,
+) {
+  // Split out a leading system prompt (Anthropic requires it as top-level
+  // `system`, not an OpenAI-style role=system message).
+  let system;
+  const convo = [];
+  for (const m of messages) {
+    if (m.role === "system" && system === undefined) {
+      system = m.content;
+    } else {
+      convo.push(m);
+    }
+  }
+
+  const response = await fetch(`${baseUrl}/messages`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01",
+    },
+    body: JSON.stringify({
+      model,
+      max_tokens: 4096,
+      stream: true,
+      ...(system ? { system } : {}),
+      messages: convo,
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(
+      `Anthropic error: ${response.status} ${response.statusText}`,
+    );
+  }
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let fullResponse = "";
+  let buf = "";
+  let inputTokens = 0;
+  let outputTokens = 0;
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buf += decoder.decode(value, { stream: true });
+    const lines = buf.split("\n");
+    buf = lines.pop() || "";
+    for (const raw of lines) {
+      const line = raw.trim();
+      if (!line || !line.startsWith("data:")) continue;
+      const payload = line.slice(5).trim();
+      if (!payload) continue;
+      try {
+        const obj = JSON.parse(payload);
+        if (obj.type === "content_block_delta") {
+          const delta = obj.delta?.text;
+          if (delta) {
+            fullResponse += delta;
+            onToken(delta);
+          }
+        } else if (obj.type === "message_start") {
+          inputTokens = Number(obj.message?.usage?.input_tokens) || inputTokens;
+          outputTokens =
+            Number(obj.message?.usage?.output_tokens) || outputTokens;
+        } else if (obj.type === "message_delta") {
+          outputTokens = Number(obj.usage?.output_tokens) || outputTokens;
+        }
+      } catch {
+        /* skip malformed */
+      }
+    }
+  }
+
+  if (onUsage && (inputTokens || outputTokens)) {
+    onUsage({ inputTokens, outputTokens });
+  }
+
+  return fullResponse;
+}
+
 /**
  * Async generator that streams a chat response.
  *
@@ -120,17 +240,50 @@ export async function streamOpenAI(messages, model, baseUrl, apiKey, onToken) {
  * @param {object} options - provider, model, baseUrl, apiKey
  */
 export async function* chatStream(messages, options) {
-  const { provider, model, baseUrl, apiKey } = options;
+  const { provider, model, baseUrl, apiKey, sessionId } = options;
 
   const tokens = [];
   const onToken = (token) => {
     tokens.push(token);
   };
 
+  let capturedUsage = null;
+  const onUsage = (u) => {
+    capturedUsage = u;
+  };
+
   let fullResponse;
 
   if (provider === "ollama") {
-    fullResponse = await streamOllama(messages, model, baseUrl, onToken);
+    fullResponse = await streamOllama(
+      messages,
+      model,
+      baseUrl,
+      onToken,
+      onUsage,
+    );
+  } else if (provider === "anthropic") {
+    const providerDef = BUILT_IN_PROVIDERS.anthropic;
+    const url =
+      baseUrl && baseUrl !== "http://localhost:11434"
+        ? baseUrl
+        : providerDef?.baseUrl || "https://api.anthropic.com/v1";
+    const key =
+      apiKey ||
+      (providerDef?.apiKeyEnv ? process.env[providerDef.apiKeyEnv] : null);
+    if (!key) {
+      throw new Error(
+        `API key required for anthropic (set ${providerDef?.apiKeyEnv || "ANTHROPIC_API_KEY"})`,
+      );
+    }
+    fullResponse = await streamAnthropic(
+      messages,
+      model,
+      url,
+      key,
+      onToken,
+      onUsage,
+    );
   } else {
     const providerDef = BUILT_IN_PROVIDERS[provider];
     const url =
@@ -145,7 +298,31 @@ export async function* chatStream(messages, options) {
         `API key required for ${provider} (set ${providerDef?.apiKeyEnv || "API key"})`,
       );
     }
-    fullResponse = await streamOpenAI(messages, model, url, key, onToken);
+    fullResponse = await streamOpenAI(
+      messages,
+      model,
+      url,
+      key,
+      onToken,
+      onUsage,
+    );
+  }
+
+  // Phase J — auto-record token usage to JSONL session store so
+  // `cc session usage` and the `usage.*` WS routes see real data.
+  if (sessionId && capturedUsage) {
+    try {
+      appendTokenUsage(sessionId, {
+        provider,
+        model,
+        usage: {
+          input_tokens: capturedUsage.inputTokens,
+          output_tokens: capturedUsage.outputTokens,
+        },
+      });
+    } catch {
+      // Best-effort — never break the stream because accounting failed.
+    }
   }
 
   // Yield all collected tokens

package/src/lib/cowork/ab-comparator-cli.js

@@ -6,6 +6,7 @@
  */
 
 import { createChatFn } from "../cowork-adapter.js";
+import { runPeerGroup } from "./agent-group-runner.js";
 
 const DEFAULT_CRITERIA = ["quality", "performance", "readability"];
 
@@ -51,33 +52,47 @@ export async function compare({
   const chat = createChatFn(llmOptions);
   const numVariants = Math.min(variants, VARIANT_PROFILES.length);
   const profiles = VARIANT_PROFILES.slice(0, numVariants);
-  const generatedVariants = [];
-
-  // Phase 1: Generate variants
-  for (const profile of profiles) {
-    const messages = [
-      { role: "system", content: profile.system },
-      {
-        role: "user",
-        content: `Provide a solution for the following task. Include code if applicable.\n\nTask: ${prompt}\n\nProvide your solution with:\n1. Approach summary (1-2 sentences)\n2. Implementation (code or detailed steps)\n3. Trade-offs (pros and cons of this approach)`,
-      },
-    ];
-
-    try {
+
+  // Phase 1: Team of peer variant-generators; judge is the coordinator.
+  const peers = profiles.map((profile) => ({
+    agentId: `variant_${profile.name}`,
+    role: profile.name,
+    taskTitle: `Generate variant (${profile.name})`,
+    taskDescription: prompt,
+    payload: { profile },
+  }));
+
+  const runResult = await runPeerGroup({
+    peers,
+    coordinator: { agentId: "judge", role: "Judge" },
+    metadata: { kind: "ab-comparator", prompt },
+    runPeer: async (peer) => {
+      const profile = peer.payload.profile;
+      const messages = [
+        { role: "system", content: profile.system },
+        {
+          role: "user",
+          content: `Provide a solution for the following task. Include code if applicable.\n\nTask: ${prompt}\n\nProvide your solution with:\n1. Approach summary (1-2 sentences)\n2. Implementation (code or detailed steps)\n3. Trade-offs (pros and cons of this approach)`,
+        },
+      ];
       const response = await chat(messages, { maxTokens: 2000 });
-      generatedVariants.push({
+      return {
         name: profile.name,
         profile: profile.system,
         solution: response,
-      });
-    } catch (err) {
-      generatedVariants.push({
-        name: profile.name,
-        profile: profile.system,
-        solution: `Error generating variant: ${err.message}`,
-      });
-    }
-  }
+      };
+    },
+  });
+
+  const generatedVariants = runResult.results.map((r) => {
+    if (r.ok) return r.value;
+    const profile = r.peer.payload.profile;
+    return {
+      name: profile.name,
+      profile: profile.system,
+      solution: `Error generating variant: ${r.error?.message || r.error}`,
+    };
+  });
 
   // Phase 2: Score each variant against criteria
   const scoringPrompt = `You are an impartial judge evaluating ${numVariants} solution variants against these criteria: ${criteria.join(", ")}.
@@ -136,6 +151,12 @@ REASON: (1-2 sentence justification)`;
     ranking,
     winner,
     reason,
+    group: {
+      groupId: runResult.groupId,
+      parentAgentId: runResult.parentAgentId,
+      members: runResult.members,
+      tasks: runResult.tasks,
+    },
   };
 }
 

package/src/lib/cowork/agent-group-runner.js

@@ -0,0 +1,145 @@
+/**
+ * agent-group-runner — thin orchestration helper that wraps any N-peer cowork
+ * flow (debate reviewers, A/B variants, analyzers) with session-core's
+ * AgentGroup + SharedTaskList.
+ *
+ * Managed Agents parity Phase G item #1: cowork debate/compare/analyze must
+ * stop hand-writing team/subagent semantics. All three flows now share this
+ * runner, which makes team(peer) vs coordinator(parent) explicit and gives us
+ * a unified task list snapshot for audit/UI.
+ *
+ * Semantics:
+ *   - peers[]     → added to the AgentGroup as RELATIONSHIPS.PEER members
+ *   - coordinator → optional parent (moderator / judge), stored as
+ *                   `parentAgentId` so peer↔coordinator messages are visible
+ *                   per AgentGroup's rules
+ *   - Each peer gets a task in the SharedTaskList: `claim → run → complete`
+ *     (or `blocked` on error). Errors are captured per peer and do NOT abort
+ *     the group — matches pre-existing debate/compare behavior.
+ */
+
+import {
+  AgentGroup,
+  SharedTaskList,
+  RELATIONSHIPS,
+  TASK_STATUS,
+} from "@chainlesschain/session-core";
+
+/**
+ * Run N peer members in parallel (default) or serial, each claiming a
+ * SharedTaskList entry.
+ *
+ * @param {object} params
+ * @param {Array<{agentId, sessionId?, role?, taskTitle, taskDescription?, payload?}>} params.peers
+ * @param {{agentId, sessionId?, role?}} [params.coordinator]
+ *        Optional moderator/judge — recorded on the group as parentAgentId.
+ * @param {(peer, task, ctx) => Promise<any>} params.runPeer
+ *        Called once per peer after its task is claimed. Return value is
+ *        captured into `results[]`. Throwing marks the task `BLOCKED`.
+ * @param {object} [params.metadata]         Stored on the AgentGroup.
+ * @param {"parallel"|"serial"} [params.mode="parallel"]
+ *
+ * @returns {Promise<{
+ *   groupId: string,
+ *   parentAgentId: string|null,
+ *   members: Array<object>,
+ *   tasks: Array<object>,
+ *   results: Array<{peer, ok, value?, error?}>,
+ *   taskList: SharedTaskList,
+ *   group: AgentGroup,
+ * }>}
+ */
+export async function runPeerGroup({
+  peers,
+  coordinator = null,
+  runPeer,
+  metadata = {},
+  mode = "parallel",
+} = {}) {
+  if (!Array.isArray(peers) || peers.length === 0) {
+    throw new Error("runPeerGroup: peers[] required");
+  }
+  if (typeof runPeer !== "function") {
+    throw new Error("runPeerGroup: runPeer function required");
+  }
+
+  const taskList = new SharedTaskList();
+  const group = new AgentGroup({
+    parentAgentId: coordinator?.agentId || null,
+    sharedTaskList: taskList,
+    metadata,
+  });
+  taskList.groupId = group.groupId;
+
+  // Register peers + create one task per peer (keyed by agentId).
+  const taskByAgent = new Map();
+  for (const peer of peers) {
+    group.addMember({
+      agentId: peer.agentId,
+      sessionId: peer.sessionId || `sess_${peer.agentId}`,
+      relationship: RELATIONSHIPS.PEER,
+      role: peer.role || null,
+    });
+    const task = taskList.add({
+      title: peer.taskTitle || `${peer.agentId} task`,
+      description: peer.taskDescription || "",
+      assignee: peer.agentId,
+      createdBy: coordinator?.agentId || peer.agentId,
+    });
+    taskByAgent.set(peer.agentId, task);
+  }
+
+  const runOne = async (peer) => {
+    const task = taskByAgent.get(peer.agentId);
+    let claimed;
+    try {
+      claimed = taskList.claim(task.id, { agentId: peer.agentId });
+    } catch (err) {
+      return { peer, ok: false, error: err };
+    }
+    try {
+      const value = await runPeer(peer, claimed || task, {
+        group,
+        taskList,
+        coordinator,
+      });
+      taskList.complete(claimed.id, { actor: peer.agentId });
+      return { peer, ok: true, value };
+    } catch (err) {
+      // Mark task blocked so the group snapshot reflects failure mode.
+      const current = taskList.get(claimed.id);
+      try {
+        taskList.update(claimed.id, {
+          rev: current.rev,
+          patch: { status: TASK_STATUS.BLOCKED },
+          actor: peer.agentId,
+        });
+      } catch (_e) {
+        /* swallow — best effort */
+      }
+      return { peer, ok: false, error: err };
+    }
+  };
+
+  let results;
+  if (mode === "serial") {
+    results = [];
+    for (const peer of peers) {
+      results.push(await runOne(peer));
+    }
+  } else {
+    results = await Promise.all(peers.map(runOne));
+  }
+
+  return {
+    groupId: group.groupId,
+    parentAgentId: group.parentAgentId,
+    members: group.listMembers(),
+    tasks: taskList.list(),
+    results,
+    taskList,
+    group,
+  };
+}
+
+export { AgentGroup, SharedTaskList, RELATIONSHIPS, TASK_STATUS };

package/src/lib/cowork/debate-review-cli.js

@@ -6,6 +6,7 @@
  */
 
 import { createChatFn } from "../cowork-adapter.js";
+import { runPeerGroup } from "./agent-group-runner.js";
 
 const DEFAULT_PERSPECTIVES = ["performance", "security", "maintainability"];
 
@@ -54,41 +55,56 @@ export async function startDebate({
   llmOptions = {},
 }) {
   const chat = createChatFn(llmOptions);
-  const reviews = [];
 
-  // Phase 1: Independent reviews from each perspective
-  for (const perspective of perspectives) {
+  // Phase 1: Team of peer reviewers — each perspective is a peer AgentGroup
+  // member, the moderator is the coordinator (parent). SharedTaskList tracks
+  // one review task per perspective.
+  const peers = perspectives.map((perspective) => {
     const config = PERSPECTIVE_PROMPTS[perspective] || {
       role: `${perspective} Reviewer`,
       system: `You are a ${perspective}-focused code reviewer. Provide specific, actionable feedback.`,
     };
+    return {
+      agentId: `reviewer_${perspective}`,
+      role: config.role,
+      taskTitle: `Review (${perspective})`,
+      taskDescription: target,
+      payload: { perspective, config },
+    };
+  });
 
-    const messages = [
-      { role: "system", content: config.system },
-      {
-        role: "user",
-        content: `Review the following code/content.\n\nTarget: ${target}\n\n\`\`\`\n${code}\n\`\`\`\n\nProvide your review as a ${config.role}. Format your response as:\n\n## Issues Found\n- List each issue with severity (HIGH/MEDIUM/LOW)\n\n## Recommendations\n- List specific improvements\n\n## Verdict\nAPPROVE, NEEDS_WORK, or REJECT with a brief reason.`,
-      },
-    ];
-
-    try {
+  const runResult = await runPeerGroup({
+    peers,
+    coordinator: { agentId: "moderator", role: "Moderator" },
+    metadata: { kind: "debate-review", target },
+    runPeer: async (peer) => {
+      const { perspective, config } = peer.payload;
+      const messages = [
+        { role: "system", content: config.system },
+        {
+          role: "user",
+          content: `Review the following code/content.\n\nTarget: ${target}\n\n\`\`\`\n${code}\n\`\`\`\n\nProvide your review as a ${config.role}. Format your response as:\n\n## Issues Found\n- List each issue with severity (HIGH/MEDIUM/LOW)\n\n## Recommendations\n- List specific improvements\n\n## Verdict\nAPPROVE, NEEDS_WORK, or REJECT with a brief reason.`,
+        },
+      ];
       const response = await chat(messages, { maxTokens: 1500 });
-      const verdict = extractVerdict(response);
-      reviews.push({
+      return {
         perspective,
         role: config.role,
         review: response,
-        verdict,
-      });
-    } catch (err) {
-      reviews.push({
-        perspective,
-        role: config.role,
-        review: `Error: ${err.message}`,
-        verdict: "ERROR",
-      });
-    }
-  }
+        verdict: extractVerdict(response),
+      };
+    },
+  });
+
+  const reviews = runResult.results.map((r) => {
+    if (r.ok) return r.value;
+    return {
+      perspective: r.peer.payload.perspective,
+      role: r.peer.payload.config.role,
+      review: `Error: ${r.error?.message || r.error}`,
+      verdict: "ERROR",
+    };
+  });
 
   // Phase 2: Moderator synthesizes final verdict
   // Summarize each reviewer's output to reduce context pollution for the moderator
@@ -136,6 +152,12 @@ export async function startDebate({
     verdict: finalVerdict,
     consensusScore,
     summary,
+    group: {
+      groupId: runResult.groupId,
+      parentAgentId: runResult.parentAgentId,
+      members: runResult.members,
+      tasks: runResult.tasks,
+    },
   };
 }
 

package/src/lib/cowork/project-style-analyzer-cli.js

@@ -7,6 +7,7 @@
 import fs from "fs";
 import path from "path";
 import { createChatFn } from "../cowork-adapter.js";
+import { runPeerGroup } from "./agent-group-runner.js";
 
 const CODE_EXTENSIONS = new Set([
   ".js",
@@ -118,21 +119,47 @@ Be specific with examples from the code samples provided.`,
     },
   ];
 
-  try {
-    const response = await chat(messages, { maxTokens: 2000 });
+  // Single-peer AgentGroup (analyzer) — no coordinator. Keeps cowork
+  // semantics uniform across debate/compare/analyze.
+  const runResult = await runPeerGroup({
+    peers: [
+      {
+        agentId: "style_analyzer",
+        role: "Project Style Analyzer",
+        taskTitle: `Analyze style (${targetPath})`,
+        taskDescription: `${samples.length} samples, ${configFiles.length} config file(s)`,
+      },
+    ],
+    metadata: { kind: "project-style-analyzer", targetPath },
+    runPeer: async () => chat(messages, { maxTokens: 2000 }),
+  });
 
+  const outcome = runResult.results[0];
+  if (outcome.ok) {
+    const response = outcome.value;
     return {
       samplesAnalyzed: samples.length,
       configFilesFound: configFiles.map((c) => c.name),
       analysis: response,
       summary: `Style Analysis for: ${targetPath}\n  Samples: ${samples.length} files\n  Config: ${configFiles.map((c) => c.name).join(", ") || "none found"}\n\n${response}`,
-    };
-  } catch (err) {
-    return {
-      samplesAnalyzed: samples.length,
-      summary: `Style analysis failed: ${err.message}`,
+      group: {
+        groupId: runResult.groupId,
+        parentAgentId: runResult.parentAgentId,
+        members: runResult.members,
+        tasks: runResult.tasks,
+      },
     };
   }
+  return {
+    samplesAnalyzed: samples.length,
+    summary: `Style analysis failed: ${outcome.error?.message || outcome.error}`,
+    group: {
+      groupId: runResult.groupId,
+      parentAgentId: runResult.parentAgentId,
+      members: runResult.members,
+      tasks: runResult.tasks,
+    },
+  };
 }
 
 function collectSampleFiles(dir, maxFiles) {