@cohortapp/agent-sdk 2.16.0 → 2.18.4

package/scripts/huddle/huddle-server.mjs

@@ -33,11 +33,12 @@ import { readFileSync, appendFileSync, mkdirSync, existsSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createServer } from "node:http";
-import { execFile as execFileCb } from "node:child_process";
-import { promisify } from "node:util";
-import Anthropic from "@anthropic-ai/sdk";
-
-const execFileAsync = promisify(execFileCb);
+// Every model call goes through the runtime seam (conformance row 36): the CLI
+// lane through buildSpawn with the seat's engine, the API lane through the
+// Anthropic SDK on a claude seat or the engine wire to cohort-llm on an
+// engine-cohort seat. This file never names a binary or an SDK.
+import { runHuddleCli, runHuddleApiTurn, buildHuddleCliPrompt, createAnthropicClientFactory, huddleLlmModeLabel } from "./huddle-llm.mjs";
+import { readSeatEngine } from "../../lib/runtime/adapter.mjs";
 import { HuddleController } from "./huddle-controller.mjs";
 import { AudioBridge } from "./audio-bridge.mjs";
 import { OpenAIRealtimeHuddleBridge } from "./openai-realtime-bridge.mjs";
@@ -68,14 +69,14 @@ const AGENT_SLUG = (loadAgent().firstName || "agent").toLowerCase();
 // Configuration
 // ---------------------------------------------------------------------------
 
-const MAX_TOKENS = 300;
-const MAX_TOOL_ROUNDS = 3;
 const HUDDLE_EVENTS_PORT = parseInt(process.env.HUDDLE_EVENTS_PORT || "3200", 10);
 
-// Use Claude Code CLI (Max subscription) instead of API calls.
-// Falls back to API if claude CLI is not available.
+// The CLI lane (the runtime adapter's "huddle" lane) by default; the direct API
+// lane with HUDDLE_USE_API=1. Either follows the seat's runtime.engine per call
+// (scripts/huddle/huddle-llm.mjs). The Anthropic client is built on first use,
+// on a claude seat only.
 const USE_CLAUDE_CLI = process.env.HUDDLE_USE_API !== "1";
-const anthropic = USE_CLAUDE_CLI ? null : new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+const anthropicClient = createAnthropicClientFactory(process.env);
 
 // ---------------------------------------------------------------------------
 // Maestro action executor + tool definitions (colocated under lib/ since
@@ -185,7 +186,7 @@ class HuddleServer extends EventEmitter {
       process.exit(1);
     }
     console.log("[INIT] Audio devices verified");
-    console.log(`[INIT] LLM mode: ${USE_CLAUDE_CLI ? "Claude Code CLI (Max subscription)" : "Anthropic API (pay-per-token)"}`);
+    console.log(`[INIT] LLM mode: ${huddleLlmModeLabel({ useCli: USE_CLAUDE_CLI, engine: readSeatEngine(AGENT_REPO_DIR) })}`);
 
     // Connect to Slack via CDP
     this._wireControllerEvents();
@@ -606,130 +607,54 @@ class HuddleServer extends EventEmitter {
   }
 
   /**
-   * Get a response via Claude Code CLI (uses Max subscription).
-   * Constructs a prompt from system + conversation history and pipes
-   * it through `claude --print`.
+   * Get a response via the runtime adapter's "huddle" lane: the claude binary
+   * (resolved by claude-bin) on a claude seat, the Cohort Engine on an
+   * engine-cohort seat. The prompt is the system prompt plus the conversation.
    */
   async _getClaudeResponseCLI(messages) {
-    const systemPrompt = this._buildSystemPrompt();
-
-    // Build a single prompt from system + conversation history
-    const parts = [`[System]\n${systemPrompt}\n`];
-    for (const msg of messages) {
-      const role = msg.role === "assistant" ? (loadAgent().firstName || "Agent") : "Participant";
-      const content = typeof msg.content === "string"
-        ? msg.content
-        : msg.content?.map((b) => b.text || "").join("") || "";
-      if (content.trim()) {
-        parts.push(`[${role}]\n${content}`);
-      }
-    }
-    parts.push(`[${loadAgent().firstName || "Agent"}]`);
-
-    const prompt = parts.join("\n\n");
-
-    const { stdout } = await execFileAsync("claude", [
-      "--print",
-      "--model", "sonnet",
-      "-p", prompt,
-    ], {
-      timeout: 30000,
-      maxBuffer: 1024 * 1024,
-      env: { ...process.env, TERM: "dumb" },
-    });
-
-    return (stdout || "").trim();
+    const prompt = buildHuddleCliPrompt(this._buildSystemPrompt(), messages, loadAgent().firstName || "Agent");
+    const r = await runHuddleCli({ agentRoot: AGENT_REPO_DIR, prompt, env: process.env });
+    if (!r.ok) throw new Error(r.error.message);
+    return r.text;
   }
 
   /**
-   * Get a response via Anthropic API (pay-per-token fallback).
-   * Supports tool use with multi-round execution.
+   * Get a response via the direct API lane (HUDDLE_USE_API=1), with tool use
+   * over up to three rounds: the Anthropic API on a claude seat, cohort-llm with
+   * the seat token on an engine-cohort seat.
    */
   async _getClaudeResponseAPI(messages) {
-    const systemPrompt = this._buildSystemPrompt();
     const accessLevel = this.session?.accessLevel || "default";
     const tools = getToolsForAccessLevel ? getToolsForAccessLevel(accessLevel) : [];
 
-    const apiParams = {
-      model: "claude-sonnet-4-20250514",
-      max_tokens: MAX_TOKENS,
-      system: systemPrompt,
-      messages: [...messages],
-    };
-
-    if (tools.length > 0) {
-      apiParams.tools = tools;
-    }
-
-    let fullResponse = "";
-    let round = 0;
-
-    while (round < MAX_TOOL_ROUNDS) {
-      round++;
-      const response = await anthropic.messages.create(apiParams);
-
-      const textParts = [];
-      const toolUseBlocks = [];
-
-      for (const block of response.content) {
-        if (block.type === "text") {
-          textParts.push(block.text);
-        } else if (block.type === "tool_use") {
-          toolUseBlocks.push(block);
-        }
-      }
-
-      const roundText = textParts.join("");
-      fullResponse += roundText;
-
-      if (toolUseBlocks.length === 0) break;
-
-      if (roundText.trim()) {
-        const filler = roundText.replace(/\s*END_HUDDLE\s*/g, "").trim();
-        if (filler) {
-          await this.bridge.speak(filler);
-          if (this.session) {
-            this.session.transcript.push({ speaker: AGENT_SLUG, text: filler, ts: Date.now() });
-          }
+    const r = await runHuddleApiTurn({
+      agentRoot: AGENT_REPO_DIR,
+      systemPrompt: this._buildSystemPrompt(),
+      messages,
+      tools,
+      onFiller: async (filler) => {
+        await this.bridge.speak(filler);
+        if (this.session) {
+          this.session.transcript.push({ speaker: AGENT_SLUG, text: filler, ts: Date.now() });
         }
-      }
-
-      const assistantContent = [];
-      if (roundText.trim()) {
-        assistantContent.push({ type: "text", text: roundText });
-      }
-      for (const tb of toolUseBlocks) {
-        assistantContent.push({ type: "tool_use", id: tb.id, name: tb.name, input: tb.input });
-      }
-      apiParams.messages.push({ role: "assistant", content: assistantContent });
-
-      const toolResults = [];
-      for (const tb of toolUseBlocks) {
+      },
+      runTool: async (tb) => {
         console.log(`[TOOL] Executing: ${tb.name}`);
         this._logEvent("tool-call", { tool: tb.name, input: tb.input });
 
-        if (executeAction) {
-          const callerInfo = {
-            slug: this.session?.callerSlug || "huddle-participant",
-            name: this.session?.callerName || "Huddle Participant",
-            accessLevel,
-          };
-          const result = await executeAction(tb.name, tb.input, callerInfo, `huddle-${Date.now()}`);
-          toolResults.push({ type: "tool_result", tool_use_id: tb.id, content: result.result });
-          console.log(`[TOOL] ${tb.name}: ${result.success ? "OK" : "FAILED"}`);
-        } else {
-          toolResults.push({
-            type: "tool_result",
-            tool_use_id: tb.id,
-            content: "Tool execution not available in this session.",
-          });
-        }
-      }
-
-      apiParams.messages.push({ role: "user", content: toolResults });
-    }
-
-    return fullResponse.trim();
+        if (!executeAction) return "Tool execution not available in this session.";
+        const callerInfo = {
+          slug: this.session?.callerSlug || "huddle-participant",
+          name: this.session?.callerName || "Huddle Participant",
+          accessLevel,
+        };
+        const result = await executeAction(tb.name, tb.input, callerInfo, `huddle-${Date.now()}`);
+        console.log(`[TOOL] ${tb.name}: ${result.success ? "OK" : "FAILED"}`);
+        return result.result;
+      },
+    }, { anthropicClient });
+    if (!r.ok) throw new Error(r.error.message);
+    return r.text;
   }
 
   // -------------------------------------------------------------------------