thepopebot 1.2.76-beta.2 → 1.2.76-beta.21

package/lib/ai/index.js

@@ -1,26 +1,22 @@
-import { HumanMessage } from '@langchain/core/messages';
-import { createChannel, mergeAsyncIterables } from './async-channel.js';
+import { randomUUID } from 'crypto';
 import { z } from 'zod';
-import { getAgentChat, getCodeChat } from './agent.js';
-import { createModel } from './model.js';
 import path from 'path';
+import { existsSync } from 'fs';
+import { callHelperLlm, callHelperLlmStructured } from './helper-llm.js';
 import { PROJECT_ROOT } from '../paths.js';
 import { render_md } from '../utils/render-md.js';
-import { getChatById, createChat, saveMessage, updateChatTitle, linkChatToWorkspace } from '../db/chats.js';
+import { buildCodingAgentSystemPrompt } from './system-prompt.js';
+import { getChatById, createChat, updateChatTitle, linkChatToWorkspace, saveMessage } from '../db/chats.js';
 import { getConfig } from '../config.js';
 import { getSdkAdapter } from './sdk-adapters/index.js';
-import { ensureWorkspaceRepo, ensureSkills } from './workspace-setup.js';
+import { ensureWorkspaceRepo } from './workspace-setup.js';
+import { resolveAgentScope } from './scope.js';
 import { readSessionId, writeSessionId } from './session-manager.js';
 import { workspaceDir as getWorkspaceDir } from '../tools/docker.js';
 
 /**
  * Ensure a chat exists in the DB and save a message.
  * Centralized so every channel gets persistence automatically.
- *
- * @param {string} threadId - Chat/thread ID
- * @param {string} role - 'user' or 'assistant'
- * @param {string} text - Message text
- * @param {object} [options] - { userId, chatTitle }
  */
 function persistMessage(threadId, role, text, options = {}) {
   try {
@@ -34,98 +30,26 @@ function persistMessage(threadId, role, text, options = {}) {
 }
 
 /**
- * Process a chat message through the LangGraph agent.
- * Saves user and assistant messages to the DB automatically.
- *
- * @param {string} threadId - Conversation thread ID (from channel adapter)
- * @param {string} message - User's message text
- * @param {Array} [attachments=[]] - Normalized attachments from adapter
- * @param {object} [options] - { userId, chatTitle } for DB persistence
- * @returns {Promise<string>} AI response text
+ * Collect streamed text for channels that don't stream (e.g. Telegram one-shot).
+ * Delegates to chatStream — single source of truth.
  */
 async function chat(threadId, message, attachments = [], options = {}) {
-  // SDK path: delegate to chatStream and collect text
-  const sdkAdapter = getSdkAdapter(getConfig('CODING_AGENT'));
-
-  if (sdkAdapter) {
-    let fullText = '';
-    for await (const chunk of chatStream(threadId, message, attachments, options)) {
-      if (chunk.type === 'text') fullText += chunk.text;
-    }
-    return fullText;
-  }
-
-  // Legacy LangGraph path
-  const agent = await getAgentChat();
-
-  // Save user message to DB
-  persistMessage(threadId, 'user', message || '[attachment]', options);
-
-  // Build content blocks: text + any image attachments as base64 vision
-  const content = [];
-
-  if (message) {
-    content.push({ type: 'text', text: message });
-  }
-
-  for (const att of attachments) {
-    if (att.category === 'image') {
-      content.push({
-        type: 'image_url',
-        image_url: {
-          url: `data:${att.mimeType};base64,${att.data.toString('base64')}`,
-        },
-      });
-    }
-    // Documents: future handling
-  }
-
-  // If only text and no attachments, simplify to a string
-  const messageContent = content.length === 1 && content[0].type === 'text'
-    ? content[0].text
-    : content;
-
-  const result = await agent.invoke(
-    { messages: [new HumanMessage({ content: messageContent })] },
-    { configurable: { thread_id: threadId } }
-  );
-
-  const lastMessage = result.messages[result.messages.length - 1];
-
-  // LangChain message content can be a string or an array of content blocks
-  let response;
-  if (typeof lastMessage.content === 'string') {
-    response = lastMessage.content;
-  } else {
-    response = lastMessage.content
-      .filter((block) => block.type === 'text')
-      .map((block) => block.text)
-      .join('\n');
-  }
-
-  // Save assistant response to DB
-  persistMessage(threadId, 'assistant', response, options);
-
-  // Auto-generate title for new chats
-  if (options.userId && message) {
-    autoTitle(threadId, message).catch(() => {});
+  let fullText = '';
+  for await (const chunk of chatStream(threadId, message, attachments, options)) {
+    if (chunk.type === 'text') fullText += chunk.text;
   }
-
-  return response;
+  return fullText;
 }
 
 /**
- * Process a chat message with streaming (for channels that support it).
+ * Process a chat message with streaming.
  * Saves user and assistant messages to the DB automatically.
  *
- * @param {string} threadId - Conversation thread ID
- * @param {string} message - User's message text
- * @param {Array} [attachments=[]] - Image/PDF attachments: { category, mimeType, dataUrl }
- * @param {object} [options] - { userId, chatTitle, skipUserPersist } for DB persistence
- * @returns {AsyncIterableIterator<string>} Stream of text chunks
+ * Two paths share identical chunk shape and persistence patterns:
+ *   - SDK path: in-process @anthropic-ai/claude-agent-sdk (claude-code only)
+ *   - Direct path: headless Docker container running the configured coding agent
  */
 async function* chatStream(threadId, message, attachments = [], options = {}) {
-  // Resolve agent and workspace context
   const isCodeMode = !!options.codeMode;
   const existingChat = getChatById(threadId);
   let workspaceId = options.workspaceId;
@@ -133,369 +57,329 @@ async function* chatStream(threadId, message, attachments = [], options = {}) {
   const branch = options.branch;
   const codeModeType = options.codeModeType || 'plan';
 
+  // Resolve workspace — for existing chats, read scope from DB (client may not resend it after refresh)
+  let resolvedScope = options.scope || null;
+
   if (!existingChat) {
-    // Create workspace if not already provided
     if (!workspaceId) {
+      // Resolve repo + branch on the server. Agent mode uses configured GH_OWNER/GH_REPO
+      // and always detects the default branch. Code mode uses user-picked repo and falls
+      // back to detection only if no branch was provided.
+      let resolvedRepo = repo;
+      if (!isCodeMode) {
+        const ghOwner = getConfig('GH_OWNER');
+        const ghRepo = getConfig('GH_REPO');
+        if (ghOwner && ghRepo) resolvedRepo = `${ghOwner}/${ghRepo}`;
+      }
+      let resolvedBranch = branch;
+      if (resolvedRepo && (!isCodeMode || !resolvedBranch)) {
+        try {
+          const { getDefaultBranch } = await import('../tools/github.js');
+          const detected = await getDefaultBranch(resolvedRepo);
+          if (detected) resolvedBranch = detected;
+        } catch {}
+      }
+
       const { createCodeWorkspace, updateFeatureBranch } = await import('../db/code-workspaces.js');
       const workspace = createCodeWorkspace(options.userId || 'unknown', {
-        repo: repo,
-        branch: branch,
+        repo: resolvedRepo,
+        branch: resolvedBranch,
+        scope: resolvedScope,
       });
       workspaceId = workspace.id;
-      const { generateRandomName } = await import('../utils/random-name.js');
-      const shortId = workspaceId.replace(/-/g, '').slice(0, 8);
-      const featureBranch = `thepopebot/${generateRandomName()}-${shortId}`;
-      updateFeatureBranch(workspaceId, featureBranch);
+      const branchMode = getConfig(isCodeMode ? 'CODE_MODE_BRANCH' : 'AGENT_MODE_BRANCH');
+      if (branchMode === 'dynamic') {
+        const { generateRandomName } = await import('../utils/random-name.js');
+        const shortId = workspaceId.replace(/-/g, '').slice(0, 8);
+        const featureBranch = `thepopebot/${generateRandomName()}-${shortId}`;
+        updateFeatureBranch(workspaceId, featureBranch);
+      } else {
+        // Default branch mode — featureBranch mirrors the working branch so
+        // downstream prompts never see an empty value.
+        if (resolvedBranch) updateFeatureBranch(workspaceId, resolvedBranch);
+      }
     }
     createChat(options.userId || 'unknown', 'New Chat', threadId, { chatMode: isCodeMode ? 'code' : 'agent' });
     linkChatToWorkspace(threadId, workspaceId);
   } else {
     workspaceId = workspaceId || existingChat.codeWorkspaceId;
+    if (!resolvedScope && workspaceId) {
+      const { getCodeWorkspaceById } = await import('../db/code-workspaces.js');
+      const ws = getCodeWorkspaceById(workspaceId);
+      if (ws?.scope) resolvedScope = ws.scope;
+    }
   }
 
-  // ── SDK path: direct in-process SDK call (no LangGraph, no Docker) ──
-  const sdkAdapter = getSdkAdapter(getConfig('CODING_AGENT'));
-  const useSDK = !!sdkAdapter;
-
-  // Save user message to DB (skip on regeneration — message already exists)
+  // Save user message (skip on regeneration — message already exists)
   if (!options.skipUserPersist) {
     persistMessage(threadId, 'user', message || '[attachment]', options);
   }
 
-  if (useSDK) {
-    // 1. Workspace setup (idempotent — skips if .git exists)
-    const wsBaseDir = getWorkspaceDir(workspaceId);
-    const repoDir = path.join(wsBaseDir, 'workspace');
-
-    const { getCodeWorkspaceById } = await import('../db/code-workspaces.js');
-    const workspace = getCodeWorkspaceById(workspaceId);
-    const featureBranch = workspace?.featureBranch;
-
-    const setupToolCallId = `setup-${workspaceId.slice(0, 8)}`;
-    const setupArgs = { repo, branch, featureBranch };
-    yield { type: 'tool-call', toolCallId: setupToolCallId, toolName: 'set_up_workspace', args: setupArgs };
-
-    try {
-      await ensureWorkspaceRepo({ workspaceDir: repoDir, repo, branch, featureBranch });
-      ensureSkills(repoDir, isCodeMode ? 'code' : 'agent');
-      yield { type: 'tool-result', toolCallId: setupToolCallId, result: JSON.stringify({ result: `Workspace ready on ${featureBranch || branch}` }) };
-    } catch (err) {
-      yield { type: 'tool-result', toolCallId: setupToolCallId, result: JSON.stringify({ result: `Setup failed: ${err.message}` }) };
-      throw err;
-    }
-
-    // 2. Session continuity
-    const sessionId = readSessionId(wsBaseDir);
-
-    // 3. System prompt (agent mode: SOUL.md + SYSTEM.md, code mode: none)
-    let systemPrompt = null;
-    if (!isCodeMode) {
-      const soulPath = path.join(PROJECT_ROOT, 'agent-job/SOUL.md');
-      const systemPath = path.join(PROJECT_ROOT, 'agent-job/SYSTEM.md');
-      try {
-        const soul = render_md(soulPath) || '';
-        const system = render_md(systemPath) || '';
-        systemPrompt = [soul, system].filter(Boolean).join('\n\n') || null;
-      } catch {
-        // Files may not exist — proceed without system prompt
-      }
+  const wsBaseDir = getWorkspaceDir(workspaceId);
+  const repoDir = path.join(wsBaseDir, 'workspace');
+  const codingAgent = getConfig('CODING_AGENT') || 'claude-code';
+  const sdkAdapter = getSdkAdapter(codingAgent);
+
+  // Read the resolved repo + branch from the workspace record (set at creation time).
+  const { getCodeWorkspaceById } = await import('../db/code-workspaces.js');
+  const workspace = getCodeWorkspaceById(workspaceId);
+  const featureBranch = workspace?.featureBranch;
+
+  // Resolve agent-mode-specific vs code-mode-specific values used by both paths
+  let effectiveRepo, effectiveBranch, systemPrompt, injectSecrets;
+  if (isCodeMode) {
+    effectiveRepo = workspace?.repo || repo;
+    effectiveBranch = workspace?.branch || branch;
+    systemPrompt = buildCodingAgentSystemPrompt('code');
+    injectSecrets = false;
+  } else {
+    const ghOwner = getConfig('GH_OWNER');
+    const ghRepo = getConfig('GH_REPO');
+    if (!ghOwner || !ghRepo) {
+      const msg = 'GH_OWNER or GH_REPO not configured';
+      yield { type: 'error', message: msg };
+      persistMessage(threadId, 'assistant', JSON.stringify({ type: 'error', message: msg }), options);
+      return;
     }
+    effectiveRepo = `${ghOwner}/${ghRepo}`;
+    effectiveBranch = workspace?.branch || null;
+    const { skillsDir } = resolveAgentScope(repoDir, resolvedScope || null);
+    systemPrompt = buildCodingAgentSystemPrompt('agent', skillsDir, resolvedScope || null);
+    injectSecrets = true;
+  }
 
-    // 4. Stream from SDK adapter
-    let pendingText = '';
-    const pendingToolCalls = new Map();
-
-    try {
-      for await (const chunk of sdkAdapter({
-        prompt: message,
-        workspaceDir: repoDir,
-        systemPrompt,
-        sessionId,
-        permissionMode: codeModeType,
-        attachments,
-      })) {
-        // Write session ID on first meta chunk
-        if (chunk.type === 'meta' && chunk.sessionId) {
-          writeSessionId(wsBaseDir, chunk.sessionId);
-        }
+  // Workspace setup — visible to user as a `workspace` tool-call the first time
+  const needsSetup = !existsSync(path.join(repoDir, '.git'));
+  const setupToolCallId = `setup-${workspaceId.slice(0, 8)}`;
+  const setupArgs = { repo: effectiveRepo, branch: effectiveBranch, featureBranch };
 
-        // DB persistence
-        if (chunk.type === 'text') {
-          pendingText += chunk.text;
-        } else if (chunk.type === 'tool-call') {
-          // Flush accumulated text before tool call
-          if (pendingText) {
-            persistMessage(threadId, 'assistant', pendingText, options);
-            pendingText = '';
-          }
-          pendingToolCalls.set(chunk.toolCallId, { toolName: chunk.toolName, args: chunk.args });
-        } else if (chunk.type === 'tool-result') {
-          const tc = pendingToolCalls.get(chunk.toolCallId);
-          if (tc) {
-            persistMessage(threadId, 'assistant', JSON.stringify({
-              type: 'tool-invocation',
-              toolCallId: chunk.toolCallId,
-              toolName: tc.toolName,
-              state: 'output-available',
-              input: tc.args,
-              output: chunk.result,
-            }), options);
-            pendingToolCalls.delete(chunk.toolCallId);
-          }
-        }
+  if (needsSetup) {
+    yield { type: 'tool-call', toolCallId: setupToolCallId, toolName: 'workspace', args: setupArgs };
+  }
 
-        yield chunk;
-      }
-    } catch (err) {
-      console.error('[chatStream] error:', err);
-      throw err;
-    } finally {
-      // Flush remaining text
-      if (pendingText) {
-        persistMessage(threadId, 'assistant', pendingText, options);
-      }
+  try {
+    const setupOutput = await ensureWorkspaceRepo({ workspaceDir: repoDir, repo: effectiveRepo, branch: effectiveBranch, featureBranch });
+    if (needsSetup) {
+      const result = setupOutput || `Workspace ready on ${featureBranch || effectiveBranch}`;
+      yield { type: 'tool-result', toolCallId: setupToolCallId, result };
+      persistMessage(threadId, 'assistant', JSON.stringify({
+        type: 'tool-invocation',
+        toolCallId: setupToolCallId,
+        toolName: 'workspace',
+        state: 'output-available',
+        input: setupArgs,
+        output: result,
+      }), options);
     }
-
-    // Auto-generate title for new chats
-    if (options.userId && message) {
-      autoTitle(threadId, message).catch(() => {});
+  } catch (err) {
+    const msg = err.message || 'Workspace setup failed';
+    if (needsSetup) {
+      yield { type: 'tool-result', toolCallId: setupToolCallId, result: `Setup failed: ${msg}` };
     }
-
+    yield { type: 'error', message: msg };
+    persistMessage(threadId, 'assistant', JSON.stringify({ type: 'error', message: msg }), options);
     return;
   }
 
-  // ── Legacy path: LangGraph + Docker (non-claude-code agents + job mode) ──
-
-  const agent = isCodeMode
-    ? await getCodeChat()
-    : await getAgentChat();
-
-  // Build content blocks: text + any image/PDF attachments as vision
-  const content = [];
-
-  if (message) {
-    content.push({ type: 'text', text: message });
+  // Fork on SDK availability
+  if (sdkAdapter) {
+    yield* streamViaSdk({ threadId, message, attachments, options, wsBaseDir, repoDir, resolvedScope, isCodeMode, codeModeType, systemPrompt, workspaceId, sdkAdapter });
+  } else {
+    yield* streamViaContainer({ threadId, message, options, codingAgent, workspaceId, featureBranch, effectiveRepo, effectiveBranch, systemPrompt, injectSecrets, codeModeType, resolvedScope });
   }
 
-  for (const att of attachments) {
-    if (att.category === 'image') {
-      // Support both dataUrl (web) and Buffer (Telegram) formats
-      const url = att.dataUrl
-        ? att.dataUrl
-        : `data:${att.mimeType};base64,${att.data.toString('base64')}`;
-      content.push({
-        type: 'image_url',
-        image_url: { url },
-      });
-    }
+  // Auto-generate title for new chats (runs once after either path completes)
+  if (options.userId && message) {
+    autoTitle(threadId, message).catch(() => {});
   }
+}
 
-  // If only text and no attachments, simplify to a string
-  let messageContent = content.length === 1 && content[0].type === 'text'
-    ? content[0].text
-    : content;
-
-  // Append chat mode for agent chats so the LLM sees the user's selected mode
-  if (!isCodeMode) {
-    if (typeof messageContent === 'string') {
-      messageContent += `\n\n[chat mode: ${codeModeType}]`;
-    } else if (Array.isArray(messageContent)) {
-      const textBlock = messageContent.find(b => b.type === 'text');
-      if (textBlock) textBlock.text += `\n\n[chat mode: ${codeModeType}]`;
-    }
-  }
+/**
+ * SDK path — in-process @anthropic-ai/claude-agent-sdk.
+ * Used only when a registered SDK adapter exists for the active coding agent.
+ */
+async function* streamViaSdk({ threadId, message, attachments, options, wsBaseDir, repoDir, resolvedScope, isCodeMode, codeModeType, systemPrompt, workspaceId, sdkAdapter }) {
+  const chatMode = isCodeMode ? 'code' : 'agent';
+  const { workingDir } = resolveAgentScope(repoDir, resolvedScope);
+  const sessionId = readSessionId(wsBaseDir);
 
-  // Side channel: bridges the tool's live container output to this generator
-  const sideChannel = createChannel();
-  const streamCallback = (chunk) => {
-    if (chunk === null) sideChannel.done();
-    else sideChannel.push(chunk);
-  };
+  let pendingText = '';
+  const pendingToolCalls = new Map();
 
   try {
-    const stream = await agent.stream(
-      { messages: [new HumanMessage({ content: messageContent })] },
-      { configurable: { thread_id: threadId, workspaceId, repo, branch, codeModeType, streamCallback }, streamMode: 'messages' }
-    );
-
-    const toolCallNames = {};
-    const pendingToolCalls = new Map();
-
-    // Accumulate raw tool call arg fragments across streaming chunks.
-    // Each AIMessageChunk only carries its own delta — the first chunk
-    // (content_block_start) has id+index+name with args "", subsequent
-    // chunks (input_json_delta) have only index with the partial JSON delta.
-    const toolCallRawArgs = {};     // tool_call_id → accumulated args string
-    const indexToToolCallId = {};   // chunk index → tool_call_id
-    const toolCallArgsEmitted = new Set(); // tool_call_ids whose complete args have been yielded
-
-    // Headless container streaming state
-    const headlessPendingToolCalls = new Map();
-    let pendingText = '';       // channel text, flushed to DB at tool boundaries
-    let llmTextAccum = '';      // langgraph text (direct response or LLM follow-up after container)
-
-    // Tag helper so mergeAsyncIterables can tell the two sources apart.
-    // The LangGraph wrapper also closes sideChannel when the agent stream
-    // finishes — this prevents a deadlock when no tool calls streamCallback.
-    async function* tagged(iter, source) {
-      for await (const item of iter) yield { _src: source, item };
-      if (source === 'lg') sideChannel.done();
-    }
+    for await (const chunk of sdkAdapter({
+      prompt: message,
+      workspaceDir: workingDir,
+      systemPrompt,
+      sessionId,
+      permissionMode: codeModeType,
+      attachments,
+      workspaceId,
+      chatMode,
+    })) {
+      if (chunk.type === 'meta' && chunk.sessionId) {
+        writeSessionId(wsBaseDir, chunk.sessionId);
+      }
 
-    try {
-      for await (const { _src, item } of mergeAsyncIterables(
-        tagged(stream, 'lg'),
-        tagged(sideChannel, 'ch')
-      )) {
-        if (_src === 'lg') {
-          // ── LangGraph agent stream ────────────────────────────────────────
-          const msg = Array.isArray(item) ? item[0] : item;
-          const msgType = msg._getType?.();
-
-          if (msgType === 'ai') {
-            // Tool calls — AIMessage.tool_calls is an array of { id, name, args }
-            if (msg.tool_calls?.length > 0) {
-              for (const tc of msg.tool_calls) {
-                toolCallNames[tc.id] = tc.name;
-                pendingToolCalls.set(tc.id, { toolName: tc.name, args: tc.args });
-                yield {
-                  type: 'tool-call',
-                  toolCallId: tc.id,
-                  toolName: tc.name,
-                  args: tc.args,
-                };
-              }
-            }
-
-            // Accumulate raw tool call arg strings from streaming chunks
-            if (msg.tool_call_chunks?.length > 0) {
-              for (const c of msg.tool_call_chunks) {
-                if (c.id) {
-                  indexToToolCallId[c.index] = c.id;
-                  toolCallRawArgs[c.id] = (toolCallRawArgs[c.id] || '') + (c.args || '');
-                } else if (c.index != null && indexToToolCallId[c.index]) {
-                  const id = indexToToolCallId[c.index];
-                  toolCallRawArgs[id] = (toolCallRawArgs[id] || '') + (c.args || '');
-                }
-              }
-              // Re-yield tool-call with complete args once the JSON is fully streamed
-              for (const c of msg.tool_call_chunks) {
-                const id = c.id || indexToToolCallId[c.index];
-                if (id && toolCallRawArgs[id] && !toolCallArgsEmitted.has(id)) {
-                  try {
-                    const parsed = JSON.parse(toolCallRawArgs[id]);
-                    toolCallArgsEmitted.add(id);
-                    const tc = pendingToolCalls.get(id);
-                    if (tc) {
-                      tc.args = parsed;
-                      yield { type: 'tool-call', toolCallId: id, toolName: tc.toolName, args: parsed };
-                    }
-                  } catch {} // args not complete yet, keep accumulating
-                }
-              }
-            }
-
-            // Text content (wrapped in structured object)
-            let text = '';
-            if (typeof msg.content === 'string') {
-              text = msg.content;
-            } else if (Array.isArray(msg.content)) {
-              text = msg.content
-                .filter((b) => b.type === 'text' && b.text)
-                .map((b) => b.text)
-                .join('');
-            }
-
-            if (text) {
-              llmTextAccum += text;
-              yield { type: 'text', text };
-            }
-          } else if (msgType === 'tool') {
-            // Parse complete args from accumulated raw fragments
-            const tc = pendingToolCalls.get(msg.tool_call_id);
-            const rawArgs = toolCallRawArgs[msg.tool_call_id];
-            let completeArgs;
-            try { completeArgs = rawArgs ? JSON.parse(rawArgs) : {}; } catch { completeArgs = {}; }
-
-            // Tool result — ToolMessage has tool_call_id and content
-            yield {
-              type: 'tool-result',
-              toolCallId: msg.tool_call_id,
-              toolName: tc?.toolName,
-              args: completeArgs,
-              result: msg.content,
-            };
-
-            // Save complete tool invocation as JSON
-            if (tc) {
-              persistMessage(threadId, 'assistant', JSON.stringify({
-                type: 'tool-invocation',
-                toolCallId: msg.tool_call_id,
-                toolName: tc.toolName,
-                state: 'output-available',
-                input: completeArgs,
-                output: msg.content,
-              }), options);
-              pendingToolCalls.delete(msg.tool_call_id);
-            }
-          }
-          // Skip other message types (human, system)
-
-        } else {
-          // ── Side channel: headless container chunks ───────────────────────
-          const chunk = item;
-
-          if (chunk.type === 'text') {
-            pendingText += chunk.text;
-            yield chunk;
-          } else if (chunk.type === 'tool-call') {
-            // Flush accumulated text before tool call
-            if (pendingText) {
-              persistMessage(threadId, 'assistant', pendingText, options);
-              pendingText = '';
-            }
-            headlessPendingToolCalls.set(chunk.toolCallId, { toolName: chunk.toolName, args: chunk.args });
-            yield chunk;
-          } else if (chunk.type === 'tool-result') {
-            // Enrich with args from matching tool-call (required by api.js tool-input-available update)
-            const htc = headlessPendingToolCalls.get(chunk.toolCallId);
-            const enriched = htc ? { ...chunk, args: htc.args, toolName: htc.toolName } : chunk;
-            yield enriched;
-            if (htc) {
-              persistMessage(threadId, 'assistant', JSON.stringify({
-                type: 'tool-invocation',
-                toolCallId: chunk.toolCallId,
-                toolName: htc.toolName,
-                state: 'output-available',
-                input: htc.args,
-                output: chunk.result,
-              }), options);
-              headlessPendingToolCalls.delete(chunk.toolCallId);
-            }
-          } else {
-            // unknown/meta events pass through unchanged
-            yield chunk;
-          }
+      if (chunk.type === 'text') {
+        pendingText += chunk.text;
+      } else if (chunk.type === 'tool-call') {
+        if (pendingText) {
+          persistMessage(threadId, 'assistant', pendingText, options);
+          pendingText = '';
+        }
+        pendingToolCalls.set(chunk.toolCallId, { toolName: chunk.toolName, args: chunk.args });
+      } else if (chunk.type === 'tool-result') {
+        const tc = pendingToolCalls.get(chunk.toolCallId);
+        if (tc) {
+          persistMessage(threadId, 'assistant', JSON.stringify({
+            type: 'tool-invocation',
+            toolCallId: chunk.toolCallId,
+            toolName: tc.toolName,
+            state: 'output-available',
+            input: tc.args,
+            output: chunk.result,
+          }), options);
+          pendingToolCalls.delete(chunk.toolCallId);
         }
       }
-    } finally {
-      // Ensure no dangling promise when tool was never called
-      sideChannel.done();
-    }
 
-    // Flush remaining channel text
+      yield chunk;
+    }
+  } catch (err) {
+    const msg = err.message || 'SDK stream failed';
+    console.error('[streamViaSdk] error:', err);
+    yield { type: 'error', message: msg };
+    persistMessage(threadId, 'assistant', JSON.stringify({ type: 'error', message: msg }), options);
+  } finally {
     if (pendingText) {
       persistMessage(threadId, 'assistant', pendingText, options);
     }
+  }
+}
+
+/**
+ * Direct headless path — spawn the coding agent in an ephemeral Docker container,
+ * stream its output via parseHeadlessStream, and yield normalized chunks.
+ *
+ * Replaces the former LangGraph React agent + `coding_agent` tool — there is no
+ * LLM layer between the user's message and the container. Multi-turn memory
+ * lives in the agent's own session files inside the volume-mounted workspace
+ * (see docker/coding-agent/CLAUDE.md § Session Tracking).
+ */
+async function* streamViaContainer({ threadId, message, options, codingAgent, workspaceId, featureBranch, effectiveRepo, effectiveBranch, systemPrompt, injectSecrets, codeModeType, resolvedScope }) {
+  const containerName = `${codingAgent}-headless-${randomUUID().slice(0, 8)}`;
+  const mode = codeModeType === 'code' ? 'dangerous' : 'plan';
+  const { runHeadlessContainer, tailContainerLogs, waitForContainer, removeContainer } = await import('../tools/docker.js');
+  const { parseHeadlessStream } = await import('./headless-stream.js');
+
+  // Synthetic coding_agent wrapper — bracketing tool-call/tool-result pair so the
+  // user can see that the direct-container path ran (the SDK path has no wrapper).
+  // Inner container chunks stream as top-level parts alongside it; AI SDK parts
+  // are flat, so this is a visual anchor, not a container for nested content.
+  const wrapperId = `coding-agent-${randomUUID().slice(0, 8)}`;
+  const providerKeys = {
+    'claude-code': 'CODING_AGENT_CLAUDE_CODE_BACKEND',
+    'pi-coding-agent': 'CODING_AGENT_PI_PROVIDER',
+    'gemini-cli': 'CODING_AGENT_GEMINI_CLI_PROVIDER',
+    'codex-cli': 'CODING_AGENT_CODEX_CLI_PROVIDER',
+    'opencode': 'CODING_AGENT_OPENCODE_PROVIDER',
+    'kimi-cli': 'CODING_AGENT_KIMI_CLI_PROVIDER',
+  };
+  const backendApi = getConfig(providerKeys[codingAgent]) || 'anthropic';
+  const wrapperArgs = { prompt: message, codingAgent, backendApi };
+
+  yield { type: 'tool-call', toolCallId: wrapperId, toolName: 'coding_agent', args: wrapperArgs };
+
+  let pendingText = '';
+  const pendingToolCalls = new Map();
+  let started = false;
+  let wrapperClosed = false;
+
+  const closeWrapper = (result) => {
+    if (wrapperClosed) return null;
+    wrapperClosed = true;
+    persistMessage(threadId, 'assistant', JSON.stringify({
+      type: 'tool-invocation',
+      toolCallId: wrapperId,
+      toolName: 'coding_agent',
+      state: 'output-available',
+      input: wrapperArgs,
+      output: result,
+    }), options);
+    return { type: 'tool-result', toolCallId: wrapperId, result };
+  };
 
-    // Persist LLM text (direct response with no tool, or LLM follow-up after container)
-    if (llmTextAccum) {
-      persistMessage(threadId, 'assistant', llmTextAccum, options);
+  try {
+    await runHeadlessContainer({
+      containerName,
+      repo: effectiveRepo,
+      branch: effectiveBranch,
+      featureBranch,
+      workspaceId,
+      taskPrompt: message,
+      mode,
+      systemPrompt,
+      injectSecrets,
+      scope: resolvedScope || undefined,
+    });
+    started = true;
+
+    const logStream = await tailContainerLogs(containerName);
+
+    for await (const chunk of parseHeadlessStream(logStream, codingAgent)) {
+      if (chunk.type === 'text') {
+        pendingText += chunk.text;
+      } else if (chunk.type === 'tool-call') {
+        if (pendingText) {
+          persistMessage(threadId, 'assistant', pendingText, options);
+          pendingText = '';
+        }
+        pendingToolCalls.set(chunk.toolCallId, { toolName: chunk.toolName, args: chunk.args });
+      } else if (chunk.type === 'tool-result') {
+        const tc = pendingToolCalls.get(chunk.toolCallId);
+        if (tc) {
+          persistMessage(threadId, 'assistant', JSON.stringify({
+            type: 'tool-invocation',
+            toolCallId: chunk.toolCallId,
+            toolName: tc.toolName,
+            state: 'output-available',
+            input: tc.args,
+            output: chunk.result,
+          }), options);
+          pendingToolCalls.delete(chunk.toolCallId);
+        }
+      }
+
+      yield chunk;
     }
 
+    const exitCode = await waitForContainer(containerName);
+    await removeContainer(containerName);
+
+    const closeResult = exitCode === 0 ? 'Completed' : `Exited with code ${exitCode}`;
+    const closeChunk = closeWrapper(closeResult);
+    if (closeChunk) yield closeChunk;
+
+    if (exitCode !== 0) {
+      const msg = `Coding agent exited with code ${exitCode}`;
+      yield { type: 'error', message: msg };
+      persistMessage(threadId, 'assistant', JSON.stringify({ type: 'error', message: msg }), options);
+    }
   } catch (err) {
-    console.error('[chatStream] error:', err);
-    throw err;
+    const msg = err.message || 'Coding agent failed';
+    console.error('[streamViaContainer] error:', err);
+    const closeChunk = closeWrapper(`Error: ${msg}`);
+    if (closeChunk) yield closeChunk;
+    yield { type: 'error', message: msg };
+    persistMessage(threadId, 'assistant', JSON.stringify({ type: 'error', message: msg }), options);
+    if (started) {
+      try { await removeContainer(containerName); } catch {}
+    }
+  } finally {
+    if (pendingText) {
+      persistMessage(threadId, 'assistant', pendingText, options);
+    }
   }
 }
 
@@ -508,15 +392,16 @@ async function autoTitle(threadId, firstMessage) {
     const chat = getChatById(threadId);
     if (!chat || chat.title !== 'New Chat') return;
 
-    const model = await createModel({ maxTokens: 250 });
-    const response = await model.withStructuredOutput(z.object({ title: z.string() })).invoke([
-      ['system', 'Title this chat in 2-5 words. Name the subject matter only. Never start with "User". Never describe what the user is doing — just the topic. Always produce a title, even for vague messages — infer the likely topic.'],
-      ['human', firstMessage],
-    ]);
-    if (response.title.trim()) {
-      updateChatTitle(threadId, response.title.trim());
-
-      return response.title.trim();
+    const result = await callHelperLlmStructured({
+      system: 'Title this chat in 2-5 words. Name the subject matter only. Never start with "User". Never describe what the user is doing — just the topic. Always produce a title, even for vague messages — infer the likely topic.',
+      user: firstMessage,
+      schema: z.object({ title: z.string() }),
+      maxTokens: 250,
+    });
+    const title = result?.title?.trim();
+    if (title) {
+      updateChatTitle(threadId, title);
+      return title;
     }
   } catch (err) {
     console.error('[autoTitle] Failed to generate title:', err.message);
@@ -527,13 +412,9 @@ async function autoTitle(threadId, firstMessage) {
 /**
  * One-shot summarization with a different system prompt and no memory.
  * Used for agent job completion summaries sent via GitHub webhook.
- *
- * @param {object} results - Agent job results from webhook payload
- * @returns {Promise<string>} Summary text
  */
 async function summarizeAgentJob(results) {
   try {
-    const model = await createModel({ maxTokens: 1024 });
     const summaryMdPath = path.join(PROJECT_ROOT, 'event-handler/SUMMARY.md');
     const systemPrompt = render_md(summaryMdPath);
 
@@ -556,22 +437,11 @@ async function summarizeAgentJob(results) {
 
     console.log(`[summarizeAgentJob] System prompt: ${systemPrompt.length} chars, user message: ${userMessage.length} chars`);
 
-    const response = await model.invoke([
-      ['system', systemPrompt],
-      ['human', userMessage],
-    ]);
-
-    const text =
-      typeof response.content === 'string'
-        ? response.content
-        : response.content
-            .filter((block) => block.type === 'text')
-            .map((block) => block.text)
-            .join('\n');
+    const text = await callHelperLlm({ system: systemPrompt, user: userMessage, maxTokens: 1024 });
 
     console.log(`[summarizeAgentJob] Result: ${text.length} chars — ${text.slice(0, 200)}`);
 
-    return text.trim() || 'Agent job finished.';
+    return text || 'Agent job finished.';
   } catch (err) {
     console.error('[summarizeAgentJob] Failed to summarize agent job:', err);
     return 'Agent job finished.';