thepopebot 1.2.75 → 1.2.76-beta.0

package/bin/sync.js

@@ -271,10 +271,13 @@ function buildDockerImage(projectPath) {
   const version = pkg.version;
   const imageTag = `stephengpope/thepopebot:event-handler-${version}`;
 
-  // Copy web/ to project for Docker build context
+  // Copy web/ and docker/ to project for Docker build context
   const webSrc = path.join(PACKAGE_DIR, 'web');
   const webDest = path.join(projectPath, 'web');
+  const dockerSrc = path.join(PACKAGE_DIR, 'docker');
+  const dockerDest = path.join(projectPath, 'docker');
   fs.cpSync(webSrc, webDest, { recursive: true });
+  fs.cpSync(dockerSrc, dockerDest, { recursive: true });
 
   try {
     execSync(`docker build -f - -t ${imageTag} .`, {
@@ -284,6 +287,7 @@ function buildDockerImage(projectPath) {
     });
   } finally {
     fs.rmSync(webDest, { recursive: true, force: true });
+    fs.rmSync(dockerDest, { recursive: true, force: true });
   }
 
   // Clean up dangling images from previous builds

package/lib/ai/index.js

@@ -7,6 +7,11 @@ import path from 'path';
 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 { getConfig } from '../config.js';
+import { getSdkAdapter } from './sdk-adapters/index.js';
+import { ensureWorkspaceRepo, ensureSkills } from './workspace-setup.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.
@@ -39,6 +44,18 @@ function persistMessage(threadId, role, text, options = {}) {
  * @returns {Promise<string>} AI response text
  */
 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
@@ -136,15 +153,123 @@ async function* chatStream(threadId, message, attachments = [], options = {}) {
     workspaceId = workspaceId || existingChat.codeWorkspaceId;
   }
 
-  const agent = isCodeMode
-    ? await getCodeChat()
-    : await getAgentChat();
+  // ── 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)
   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
+      }
+    }
+
+    // 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);
+        }
+
+        // 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);
+          }
+        }
+
+        yield chunk;
+      }
+    } catch (err) {
+      console.error('[chatStream] error:', err);
+      throw err;
+    } finally {
+      // Flush remaining text
+      if (pendingText) {
+        persistMessage(threadId, 'assistant', pendingText, options);
+      }
+    }
+
+    // Auto-generate title for new chats
+    if (options.userId && message) {
+      autoTitle(threadId, message).catch(() => {});
+    }
+
+    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 = [];
 

package/lib/ai/model.js

@@ -118,6 +118,12 @@ export async function createModel(options = {}) {
       if (!apiKey) throw new Error(LLM_NOT_CONFIGURED);
       return new ChatOpenAI({ modelName, maxTokens, apiKey, configuration: { baseURL: 'https://openrouter.ai/api/v1' } });
     }
+    case 'nvidia': {
+      const { ChatOpenAI } = await import('@langchain/openai');
+      const apiKey = getConfig('NVIDIA_API_KEY');
+      if (!apiKey) throw new Error(LLM_NOT_CONFIGURED);
+      return new ChatOpenAI({ modelName, maxTokens, apiKey, configuration: { baseURL: 'https://integrate.api.nvidia.com/v1' } });
+    }
     default:
       throw new Error(`Unknown LLM provider: ${provider}`);
   }

package/lib/ai/sdk-adapters/claude-code.js

@@ -0,0 +1,176 @@
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { getConfig } from '../../config.js';
+import { buildAgentAuthEnv } from '../../tools/docker.js';
+
+/**
+ * Claude Agent SDK adapter. Wraps the SDK's query() and yields
+ * the unified chunk format consumed by chatStream/api.js.
+ *
+ * @param {object} opts
+ * @param {string} opts.prompt - User message
+ * @param {string} opts.workspaceDir - Absolute path to workspace (git repo root)
+ * @param {string} [opts.systemPrompt] - System prompt (agent mode only)
+ * @param {string} [opts.sessionId] - Session ID to resume
+ * @param {string} [opts.permissionMode] - 'plan' or 'code'
+ * @param {Array} [opts.attachments] - Image attachments
+ * @yields {{ type: 'text'|'tool-call'|'tool-result'|'meta'|'result'|'unknown', ... }}
+ */
+export async function* claudeCodeStream({ prompt, workspaceDir, systemPrompt, sessionId, permissionMode, attachments }) {
+  // Build a local env object with auth credentials from the settings DB.
+  // Passed via the SDK's `env` option — no process.env mutation needed.
+  const env = { ...process.env };
+  try {
+    const { env: authEnvPairs } = buildAgentAuthEnv('claude-code');
+    for (const pair of authEnvPairs) {
+      const eqIdx = pair.indexOf('=');
+      if (eqIdx > 0) {
+        env[pair.slice(0, eqIdx)] = pair.slice(eqIdx + 1);
+      }
+    }
+
+    // Clear conflicting auth vars so the SDK picks the right credential
+    // Priority: ANTHROPIC_AUTH_TOKEN > CLAUDE_CODE_OAUTH_TOKEN > ANTHROPIC_API_KEY
+    if (env.ANTHROPIC_AUTH_TOKEN) {
+      delete env.ANTHROPIC_API_KEY;
+      delete env.CLAUDE_CODE_OAUTH_TOKEN;
+    } else if (env.CLAUDE_CODE_OAUTH_TOKEN) {
+      delete env.ANTHROPIC_API_KEY;
+    }
+  } catch (err) {
+    console.error('[claude-code-sdk] Failed to resolve auth:', err.message);
+    // Fall through — env may already have the right vars from process.env
+  }
+
+  const options = {
+    cwd: workspaceDir,
+    env,
+    includePartialMessages: true,
+  };
+
+  // Permission mode → allowed tools
+  if (permissionMode === 'code') {
+    options.permissionMode = 'bypassPermissions';
+  }
+
+  if (sessionId) options.resume = sessionId;
+  if (systemPrompt) {
+    options.systemPrompt = { type: 'preset', preset: 'claude_code', append: systemPrompt };
+  }
+
+  // Build prompt — plain string when no attachments, SDKUserMessage with content blocks when there are
+  let sdkPrompt = prompt;
+  if (attachments?.length) {
+    const content = [{ type: 'text', text: prompt }];
+    for (const att of attachments) {
+      if (att.category === 'image') {
+        const data = att.dataUrl
+          ? att.dataUrl.replace(/^data:[^;]+;base64,/, '')
+          : att.data.toString('base64');
+        content.push({
+          type: 'image',
+          source: { type: 'base64', media_type: att.mimeType, data },
+        });
+      }
+    }
+    async function* makePrompt() {
+      yield { type: 'user', message: { role: 'user', content }, parent_tool_use_id: null };
+    }
+    sdkPrompt = makePrompt();
+  }
+
+  // Track tool call state for mapping stream events
+  const activeToolCalls = new Map(); // index → { id, name, argsJson }
+
+  try {
+    for await (const message of query({ prompt: sdkPrompt, options })) {
+      // ── system messages ──
+      if (message.type === 'system') {
+        if (message.subtype === 'init') {
+          yield { type: 'meta', sessionId: message.session_id };
+        }
+        continue;
+      }
+
+      // ── rate limit events ──
+      if (message.type === 'rate_limit_event') continue;
+
+      // ── streaming events ──
+      if (message.type === 'stream_event') {
+        const event = message.event;
+
+        if (event.type === 'content_block_start') {
+          const block = event.content_block;
+          if (block.type === 'tool_use') {
+            activeToolCalls.set(event.index, { id: block.id, name: block.name, argsJson: '' });
+            yield { type: 'tool-call', toolCallId: block.id, toolName: block.name, args: {} };
+          }
+          // Skip 'thinking', 'text' start (deltas handle text)
+          continue;
+        }
+
+        if (event.type === 'content_block_delta') {
+          if (event.delta.type === 'text_delta') {
+            yield { type: 'text', text: event.delta.text };
+          } else if (event.delta.type === 'input_json_delta') {
+            const tc = activeToolCalls.get(event.index);
+            if (tc) tc.argsJson += event.delta.partial_json;
+          }
+          continue;
+        }
+
+        if (event.type === 'content_block_stop') {
+          const tc = activeToolCalls.get(event.index);
+          if (tc && tc.argsJson) {
+            try {
+              const args = JSON.parse(tc.argsJson);
+              yield { type: 'tool-call', toolCallId: tc.id, toolName: tc.name, args };
+            } catch {}
+          }
+          activeToolCalls.delete(event.index);
+          continue;
+        }
+
+        // message_start, message_delta, message_stop — skip
+        continue;
+      }
+
+      // ── user messages (tool results) ──
+      if (message.type === 'user') {
+        const blocks = message.message?.content || [];
+        for (const block of blocks) {
+          if (block.type === 'tool_result') {
+            const content = typeof block.content === 'string'
+              ? block.content
+              : Array.isArray(block.content)
+                ? block.content.map(b => b.type === 'text' ? b.text : JSON.stringify(b)).join('\n')
+                : JSON.stringify(block.content);
+            yield { type: 'tool-result', toolCallId: block.tool_use_id, result: content };
+          }
+        }
+        continue;
+      }
+
+      // ── assistant messages — redundant with streaming, skip ──
+      if (message.type === 'assistant') continue;
+
+      // ── result ──
+      if (message.type === 'result') {
+        console.log(`[claude-code-sdk] ${message.subtype} cost=$${message.total_cost_usd?.toFixed(4)} duration=${message.duration_ms}ms`);
+        yield {
+          type: 'result',
+          text: message.result || '',
+          cost: message.total_cost_usd,
+          duration: message.duration_ms,
+          subtype: message.subtype,
+        };
+        continue;
+      }
+
+      // ── unknown ──
+      yield { type: 'unknown', raw: message };
+    }
+  } catch (err) {
+    console.error('[claude-code-sdk] Stream error:', err);
+    throw err;
+  }
+}

package/lib/ai/sdk-adapters/index.js

@@ -0,0 +1,13 @@
+import { claudeCodeStream } from './claude-code.js';
+
+/**
+ * Returns the SDK stream adapter for the given coding agent type,
+ * or null if no SDK adapter exists (fall back to legacy LangGraph/Docker path).
+ *
+ * @param {string} agentType - e.g. 'claude-code', 'pi-coding-agent', etc.
+ * @returns {Function|null} Async generator function or null
+ */
+export function getSdkAdapter(agentType) {
+  if (agentType === 'claude-code') return claudeCodeStream;
+  return null;
+}

package/lib/ai/session-manager.js

@@ -0,0 +1,33 @@
+import { readFileSync, writeFileSync, mkdirSync } from 'fs';
+import path from 'path';
+
+/**
+ * Read the Claude Code session ID from the workspace volume.
+ * Returns null if no session file exists.
+ *
+ * @param {string} workspaceBaseDir - The workspace base dir (parent of workspace/)
+ * @param {number} [port=7681] - ttyd port (7681 = primary tab)
+ * @returns {string|null} Session ID or null
+ */
+export function readSessionId(workspaceBaseDir, port = 7681) {
+  try {
+    const filePath = path.join(workspaceBaseDir, '.claude-ttyd-sessions', String(port));
+    return readFileSync(filePath, 'utf8').trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Write a session ID to the workspace volume so the interactive
+ * container can resume it.
+ *
+ * @param {string} workspaceBaseDir - The workspace base dir (parent of workspace/)
+ * @param {string} sessionId - Claude Code session ID
+ * @param {number} [port=7681] - ttyd port (7681 = primary tab)
+ */
+export function writeSessionId(workspaceBaseDir, sessionId, port = 7681) {
+  const dir = path.join(workspaceBaseDir, '.claude-ttyd-sessions');
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(path.join(dir, String(port)), sessionId + '\n');
+}

package/lib/ai/tools.js

@@ -51,7 +51,7 @@ const agentChatCodingTool = tool(
       const featureBranch = workspace?.featureBranch;
       const mode = codeModeType === 'code' ? 'dangerous' : 'plan';
 
-      const codingAgent = getConfig('CODING_AGENT') || 'claude-code';
+      const codingAgent = getConfig('CODING_AGENT');
       const containerName = `${codingAgent}-headless-${randomUUID().slice(0, 8)}`;
 
       const { runHeadlessContainer, tailContainerLogs, waitForContainer, removeContainer } = await import('../tools/docker.js');
@@ -117,7 +117,7 @@ const codeChatCodingTool = tool(
       const mode = codeModeType === 'code' ? 'dangerous' : 'plan';
 
       const { runHeadlessContainer, tailContainerLogs, waitForContainer, removeContainer } = await import('../tools/docker.js');
-      const codingAgent = getConfig('CODING_AGENT') || 'claude-code';
+      const codingAgent = getConfig('CODING_AGENT');
       const containerName = `${codingAgent}-headless-${randomUUID().slice(0, 8)}`;
 
       const { backendApi } = await runHeadlessContainer({

package/lib/ai/workspace-setup.js

@@ -0,0 +1,130 @@
+import { execFile as execFileCb } from 'child_process';
+import { promisify } from 'util';
+import { existsSync, mkdirSync, symlinkSync, unlinkSync, lstatSync } from 'fs';
+import path from 'path';
+import { getConfig } from '../config.js';
+
+const execFile = promisify(execFileCb);
+
+/**
+ * Run a command and return stdout. Rejects on non-zero exit.
+ */
+async function run(cmd, args, opts) {
+  const { stdout } = await execFile(cmd, args, opts);
+  return stdout.trim();
+}
+
+/**
+ * Ensure workspace directory exists and contains the git repo
+ * on the correct branch. Idempotent — safe to call on every message.
+ *
+ * Replaces Docker entrypoint scripts: setup-git.sh, clone.sh, feature-branch.sh.
+ *
+ * @param {object} opts
+ * @param {string} opts.workspaceDir - Absolute path to workspace directory (the git repo root)
+ * @param {string} opts.repo - GitHub owner/repo (e.g. "owner/repo")
+ * @param {string} opts.branch - Base branch (e.g. "main")
+ * @param {string} [opts.featureBranch] - Feature branch to create/checkout
+ */
+export async function ensureWorkspaceRepo({ workspaceDir, repo, branch, featureBranch }) {
+  const ghToken = getConfig('GH_TOKEN');
+  const env = { ...process.env };
+  if (ghToken) env.GH_TOKEN = ghToken;
+
+  const execOpts = { cwd: workspaceDir, env };
+
+  // 1. Create workspace directory
+  mkdirSync(workspaceDir, { recursive: true });
+
+  // 2. Configure git to use GH_TOKEN for GitHub HTTPS URLs (mirrors setup-git.sh)
+  if (ghToken) {
+    await run('gh', ['auth', 'setup-git'], execOpts);
+  }
+
+  // 3. Clone if not already a git repo
+  const hasGit = existsSync(path.join(workspaceDir, '.git'));
+  if (!hasGit) {
+    if (!repo) throw new Error('ensureWorkspaceRepo: repo is required for initial clone');
+    await run('git', ['clone', '--branch', branch || 'main', `https://github.com/${repo}`, '.'], execOpts);
+  }
+
+  // 3. Git identity (only if not already configured)
+  try {
+    await run('git', ['config', 'user.name'], execOpts);
+  } catch {
+    // Not configured — derive from GitHub token
+    if (ghToken) {
+      try {
+        const userJson = await run('gh', ['api', 'user', '-q', '{name: .name, login: .login, email: .email, id: .id}'], execOpts);
+        const user = JSON.parse(userJson);
+        const name = user.name || user.login;
+        const email = user.email || `${user.id}+${user.login}@users.noreply.github.com`;
+        await run('git', ['config', 'user.name', name], execOpts);
+        await run('git', ['config', 'user.email', email], execOpts);
+      } catch (err) {
+        console.error('[workspace-setup] Failed to set git identity:', err.message);
+      }
+    }
+  }
+
+  // 4. Feature branch checkout
+  if (!featureBranch) return;
+
+  // Already on the right branch locally?
+  try {
+    await run('git', ['rev-parse', '--verify', featureBranch], execOpts);
+    // Branch exists locally — make sure we're on it
+    const current = await run('git', ['rev-parse', '--abbrev-ref', 'HEAD'], execOpts);
+    if (current !== featureBranch) {
+      await run('git', ['checkout', featureBranch], execOpts);
+    }
+    return;
+  } catch {
+    // Branch doesn't exist locally — check remote
+  }
+
+  try {
+    const remoteCheck = await run('git', ['ls-remote', '--heads', 'origin', featureBranch], execOpts);
+    if (remoteCheck) {
+      // Remote branch exists — checkout tracking it
+      await run('git', ['checkout', '-B', featureBranch, `origin/${featureBranch}`], execOpts);
+    } else {
+      // Create new branch and push
+      await run('git', ['checkout', '-b', featureBranch], execOpts);
+      await run('git', ['push', '-u', 'origin', featureBranch], execOpts);
+    }
+  } catch (err) {
+    console.error('[workspace-setup] Feature branch error:', err.message);
+    throw err;
+  }
+}
+
+/**
+ * Activate agent-job-secrets skill in the workspace when in agent chatMode.
+ * Mirrors Docker setup.sh: ln -sfn ../library/agent-job-secrets skills/active/agent-job-secrets
+ * Idempotent — skips if library skill doesn't exist.
+ *
+ * @param {string} workspaceDir - Absolute path to workspace (git repo root)
+ * @param {string} chatMode - 'agent' or 'code'
+ */
+export function ensureSkills(workspaceDir, chatMode) {
+  if (chatMode !== 'agent') return;
+
+  const librarySkill = path.join(workspaceDir, 'skills', 'library', 'agent-job-secrets');
+  if (!existsSync(librarySkill)) return;
+
+  const activeDir = path.join(workspaceDir, 'skills', 'active');
+  mkdirSync(activeDir, { recursive: true });
+
+  const link = path.join(activeDir, 'agent-job-secrets');
+
+  // ln -sfn: remove existing symlink/file before creating (force + no-deref)
+  try {
+    const stat = lstatSync(link);
+    if (stat) unlinkSync(link);
+  } catch {
+    // doesn't exist — fine
+  }
+
+  symlinkSync('../library/agent-job-secrets', link);
+}

package/lib/chat/actions.js

@@ -942,10 +942,28 @@ export async function getChatSettings() {
     const maxTokens = getConfigValue('LLM_MAX_TOKENS') || '4096';
     const agentBackend = getConfigValue('AGENT_BACKEND') || '';
 
+    // Check if the current coding agent has an in-process SDK adapter
+    const { getConfig } = await import('../config.js');
+    const { getSdkAdapter } = await import('../ai/sdk-adapters/index.js');
+    const codingAgent = getConfig('CODING_AGENT');
+    const sdkAgentActive = !!getSdkAdapter(codingAgent);
+
+    // Human-readable agent names
+    const agentNames = {
+      'claude-code': 'Claude Code',
+      'pi-coding-agent': 'Pi Coding Agent',
+      'gemini-cli': 'Gemini CLI',
+      'codex-cli': 'Codex CLI',
+      'opencode': 'OpenCode',
+      'kimi-cli': 'Kimi CLI',
+    };
+
     return {
       builtinProviders: BUILTIN_PROVIDERS,
       credentialStatuses,
       customProviders,
+      sdkAgentActive,
+      defaultAgent: agentNames[codingAgent] || codingAgent,
       active: {
         provider: activeProvider,
         model: activeModel,

package/lib/chat/api.js

@@ -153,6 +153,9 @@ export async function POST(request) {
             output: chunk.result,
           });
 
+        } else if (chunk.type === 'meta' || chunk.type === 'result') {
+          // Internal events — no SSE output needed
+
         } else if (chunk.type === 'unknown') {
           // Close any open text block before unknown event
           if (textStarted) {

package/lib/chat/components/chats-page.js

@@ -244,23 +244,14 @@ function ChatRow({ chat, onNavigate, onDelete, onStar, onRename }) {
     setEditTitle(chat.title || "");
   };
   return /* @__PURE__ */ jsxs(
-    "a",
+    "div",
     {
-      href: chat.codeWorkspaceId && chat.containerName ? `/code/${chat.codeWorkspaceId}` : `/chat/${chat.id}`,
       className: "relative group flex items-center gap-3 px-3 py-3 cursor-pointer hover:bg-muted/50 rounded-md",
-      style: { textDecoration: "inherit", color: "inherit" },
       onMouseEnter: () => setHovered(true),
       onMouseLeave: () => setHovered(false),
       onClick: (e) => {
-        if (editing) {
-          e.preventDefault();
-          return;
-        }
-        if (menuRef.current && menuRef.current.contains(e.target)) {
-          e.preventDefault();
-          return;
-        }
-        e.preventDefault();
+        if (editing) return;
+        if (menuRef.current && menuRef.current.contains(e.target)) return;
         if (chat.codeWorkspaceId && chat.containerName) {
           window.location.href = `/code/${chat.codeWorkspaceId}`;
         } else {

package/lib/chat/components/chats-page.jsx

@@ -297,16 +297,13 @@ function ChatRow({ chat, onNavigate, onDelete, onStar, onRename }) {
   };
 
   return (
-    <a
-      href={chat.codeWorkspaceId && chat.containerName ? `/code/${chat.codeWorkspaceId}` : `/chat/${chat.id}`}
+    <div
       className="relative group flex items-center gap-3 px-3 py-3 cursor-pointer hover:bg-muted/50 rounded-md"
-      style={{ textDecoration: 'inherit', color: 'inherit' }}
       onMouseEnter={() => setHovered(true)}
       onMouseLeave={() => setHovered(false)}
       onClick={(e) => {
-        if (editing) { e.preventDefault(); return; }
-        if (menuRef.current && menuRef.current.contains(e.target)) { e.preventDefault(); return; }
-        e.preventDefault();
+        if (editing) return;
+        if (menuRef.current && menuRef.current.contains(e.target)) return;
         if (chat.codeWorkspaceId && chat.containerName) {
           window.location.href = `/code/${chat.codeWorkspaceId}`;
         } else {
@@ -410,6 +407,6 @@ function ChatRow({ chat, onNavigate, onDelete, onStar, onRename }) {
         }}
         onCancel={() => setConfirmDelete(false)}
       />
-    </a>
+    </div>
   );
 }

package/lib/chat/components/index.js

@@ -10,7 +10,7 @@ export { SettingsLayout } from './settings-layout.js';
 export { SubTabLayout, ApiKeysLayout, EventHandlerLayout, ChatSettingsLayout, GitHubSettingsLayout, SecretsLayout } from './settings-secrets-layout.js';
 export { ApiKeysListPage, ApiKeysVoicePage, ApiKeysTelegramPage, SettingsSecretsPage } from './settings-secrets-page.js';
 export { SettingsUsersPage } from './settings-users-page.js';
-export { ChatConfigPage, ChatProvidersPage, ChatLlmPage, SettingsChatPage } from './settings-chat-page.js';
+export { ChatConfigPage, ChatProvidersPage, SettingsChatPage } from './settings-chat-page.js';
 export { ChatProvidersPage as LlmsPage } from './settings-chat-page.js';
 export { CodingAgentsPage } from './settings-coding-agents-page.js';
 export { JobsPage } from './settings-jobs-page.js';

package/lib/chat/components/settings-chat-page.js

@@ -40,12 +40,18 @@ function ChatConfigPage() {
   if (settings?.error) {
     return /* @__PURE__ */ jsx("p", { className: "text-sm text-destructive", children: settings.error });
   }
+  const sdkAgentActive = settings?.sdkAgentActive;
+  const defaultAgent = settings?.defaultAgent;
   return /* @__PURE__ */ jsxs("div", { children: [
+    sdkAgentActive && /* @__PURE__ */ jsx("div", { className: "rounded-lg border border-destructive/30 bg-destructive/5 px-4 py-3 mb-4", children: /* @__PURE__ */ jsxs("p", { className: "text-sm text-destructive", children: [
+      defaultAgent,
+      " manages its own LLM directly. These settings only apply when using a coding agent without built-in SDK support."
+    ] }) }),
     /* @__PURE__ */ jsxs("div", { className: "mb-4", children: [
       /* @__PURE__ */ jsx("h2", { className: "text-base font-medium", children: "Configuration" }),
       /* @__PURE__ */ jsx("p", { className: "text-sm text-muted-foreground", children: "Select the LLM provider and model for chat. Only providers with configured API keys appear in the dropdown." })
     ] }),
-    /* @__PURE__ */ jsx(ActiveConfig, { settings, onSave: handleSaveActive })
+    /* @__PURE__ */ jsx("div", { className: sdkAgentActive ? "opacity-50 pointer-events-none" : "", children: /* @__PURE__ */ jsx(ActiveConfig, { settings, onSave: handleSaveActive }) })
   ] });
 }
 function ActiveConfig({ settings, onSave }) {
@@ -731,127 +737,11 @@ function CustomProviderDialog({ open, initial, onSave, onCancel }) {
     ] })
   ] });
 }
-function ChatLlmPage() {
-  const [settings, setSettings] = useState(null);
-  const [loading, setLoading] = useState(true);
-  const [showDialog, setShowDialog] = useState(false);
-  const [editingProvider, setEditingProvider] = useState(null);
-  const loadSettings = async () => {
-    try {
-      const result = await getChatSettings();
-      setSettings(result);
-    } catch {
-    } finally {
-      setLoading(false);
-    }
-  };
-  useEffect(() => {
-    loadSettings();
-  }, []);
-  const handleSaveActive = async (provider, model, maxTokens) => {
-    const result = await setActiveLlm(provider, model, maxTokens);
-    if (result?.success) await loadSettings();
-    return result;
-  };
-  const handleUpdateCredential = async (credKey, value) => {
-    await updateProviderCredential(credKey, value);
-    await loadSettings();
-  };
-  const handleAddCustom = async (config) => {
-    await addCustomProvider(config);
-    setShowDialog(false);
-    await loadSettings();
-  };
-  const handleEditCustom = async (config) => {
-    if (editingProvider) {
-      await updateCustomProvider(editingProvider.key, config);
-      setEditingProvider(null);
-      setShowDialog(false);
-      await loadSettings();
-    }
-  };
-  const handleRemoveCustom = async (key) => {
-    await removeCustomProvider(key);
-    await loadSettings();
-  };
-  const openAdd = () => {
-    setEditingProvider(null);
-    setShowDialog(true);
-  };
-  const openEdit = (provider) => {
-    setEditingProvider(provider);
-    setShowDialog(true);
-  };
-  const closeDialog = () => {
-    setShowDialog(false);
-    setEditingProvider(null);
-  };
-  if (loading) {
-    return /* @__PURE__ */ jsx("div", { className: "h-48 animate-pulse rounded-md bg-border/50" });
-  }
-  if (settings?.error) {
-    return /* @__PURE__ */ jsx("p", { className: "text-sm text-destructive", children: settings.error });
-  }
-  return /* @__PURE__ */ jsxs("div", { className: "space-y-6", children: [
-    /* @__PURE__ */ jsxs("div", { children: [
-      /* @__PURE__ */ jsxs("div", { className: "mb-4", children: [
-        /* @__PURE__ */ jsx("h2", { className: "text-base font-medium", children: "Default Provider" }),
-        /* @__PURE__ */ jsx("p", { className: "text-sm text-muted-foreground", children: "Select the LLM provider and model for chat. Only providers with configured API keys appear in the dropdown." })
-      ] }),
-      /* @__PURE__ */ jsx(ActiveConfig, { settings, onSave: handleSaveActive })
-    ] }),
-    /* @__PURE__ */ jsxs("div", { children: [
-      /* @__PURE__ */ jsxs("div", { className: "mb-4", children: [
-        /* @__PURE__ */ jsx("h2", { className: "text-base font-medium", children: "Providers" }),
-        /* @__PURE__ */ jsx("p", { className: "text-sm text-muted-foreground", children: "Configure API keys and credentials for each LLM provider." })
-      ] }),
-      settings?.builtinProviders && /* @__PURE__ */ jsxs("div", { className: "mb-6", children: [
-        /* @__PURE__ */ jsx("h4", { className: "text-xs font-medium text-muted-foreground uppercase tracking-wider mb-3", children: "Built-in" }),
-        /* @__PURE__ */ jsx("div", { className: "space-y-8", children: Object.entries(settings.builtinProviders).map(([slug, prov]) => /* @__PURE__ */ jsx(
-          ProviderCard,
-          {
-            slug,
-            name: prov.name,
-            credentials: prov.credentials,
-            credentialStatuses: settings.credentialStatuses || [],
-            onUpdateCredential: handleUpdateCredential
-          },
-          slug
-        )) })
-      ] }),
-      /* @__PURE__ */ jsxs("div", { className: "space-y-8", children: [
-        /* @__PURE__ */ jsx("h4", { className: "text-xs font-medium text-muted-foreground uppercase tracking-wider", children: "Custom (OpenAI Compatible API)" }),
-        settings?.customProviders?.map((cp) => /* @__PURE__ */ jsx(CustomProviderCard, { provider: cp, onEdit: openEdit, onRemove: handleRemoveCustom }, cp.key)),
-        /* @__PURE__ */ jsxs(
-          "button",
-          {
-            onClick: openAdd,
-            className: "w-full rounded-lg border border-dashed p-4 text-sm text-muted-foreground hover:text-foreground hover:border-foreground/30 transition-colors flex items-center justify-center gap-2",
-            children: [
-              /* @__PURE__ */ jsx(PlusIcon, { size: 14 }),
-              "Add OpenAI Compatible API"
-            ]
-          }
-        )
-      ] }),
-      /* @__PURE__ */ jsx(
-        CustomProviderDialog,
-        {
-          open: showDialog,
-          initial: editingProvider,
-          onSave: editingProvider ? handleEditCustom : handleAddCustom,
-          onCancel: closeDialog
-        }
-      )
-    ] })
-  ] });
-}
 function SettingsChatPage() {
   return /* @__PURE__ */ jsx(ChatConfigPage, {});
 }
 export {
   ChatConfigPage,
-  ChatLlmPage,
   ChatProvidersPage,
   SettingsChatPage
 };

package/lib/chat/components/settings-chat-page.jsx

@@ -52,13 +52,25 @@ export function ChatConfigPage() {
     return <p className="text-sm text-destructive">{settings.error}</p>;
   }
 
+  const sdkAgentActive = settings?.sdkAgentActive;
+  const defaultAgent = settings?.defaultAgent;
+
   return (
     <div>
+      {sdkAgentActive && (
+        <div className="rounded-lg border border-destructive/30 bg-destructive/5 px-4 py-3 mb-4">
+          <p className="text-sm text-destructive">
+            {defaultAgent} manages its own LLM directly. These settings only apply when using a coding agent without built-in SDK support.
+          </p>
+        </div>
+      )}
       <div className="mb-4">
         <h2 className="text-base font-medium">Configuration</h2>
         <p className="text-sm text-muted-foreground">Select the LLM provider and model for chat. Only providers with configured API keys appear in the dropdown.</p>
       </div>
-      <ActiveConfig settings={settings} onSave={handleSaveActive} />
+      <div className={sdkAgentActive ? 'opacity-50 pointer-events-none' : ''}>
+        <ActiveConfig settings={settings} onSave={handleSaveActive} />
+      </div>
     </div>
   );
 }
@@ -763,137 +775,6 @@ function CustomProviderDialog({ open, initial, onSave, onCancel }) {
   );
 }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// Combined LLM page — Default Provider + Providers
-// ─────────────────────────────────────────────────────────────────────────────
-
-export function ChatLlmPage() {
-  const [settings, setSettings] = useState(null);
-  const [loading, setLoading] = useState(true);
-  const [showDialog, setShowDialog] = useState(false);
-  const [editingProvider, setEditingProvider] = useState(null);
-
-  const loadSettings = async () => {
-    try {
-      const result = await getChatSettings();
-      setSettings(result);
-    } catch {
-      // ignore
-    } finally {
-      setLoading(false);
-    }
-  };
-
-  useEffect(() => {
-    loadSettings();
-  }, []);
-
-  // Default Provider handlers
-  const handleSaveActive = async (provider, model, maxTokens) => {
-    const result = await setActiveLlm(provider, model, maxTokens);
-    if (result?.success) await loadSettings();
-    return result;
-  };
-
-  // Providers handlers
-  const handleUpdateCredential = async (credKey, value) => {
-    await updateProviderCredential(credKey, value);
-    await loadSettings();
-  };
-
-  const handleAddCustom = async (config) => {
-    await addCustomProvider(config);
-    setShowDialog(false);
-    await loadSettings();
-  };
-
-  const handleEditCustom = async (config) => {
-    if (editingProvider) {
-      await updateCustomProvider(editingProvider.key, config);
-      setEditingProvider(null);
-      setShowDialog(false);
-      await loadSettings();
-    }
-  };
-
-  const handleRemoveCustom = async (key) => {
-    await removeCustomProvider(key);
-    await loadSettings();
-  };
-
-  const openAdd = () => { setEditingProvider(null); setShowDialog(true); };
-  const openEdit = (provider) => { setEditingProvider(provider); setShowDialog(true); };
-  const closeDialog = () => { setShowDialog(false); setEditingProvider(null); };
-
-  if (loading) {
-    return <div className="h-48 animate-pulse rounded-md bg-border/50" />;
-  }
-
-  if (settings?.error) {
-    return <p className="text-sm text-destructive">{settings.error}</p>;
-  }
-
-  return (
-    <div className="space-y-6">
-      {/* Default Provider section */}
-      <div>
-        <div className="mb-4">
-          <h2 className="text-base font-medium">Default Provider</h2>
-          <p className="text-sm text-muted-foreground">Select the LLM provider and model for chat. Only providers with configured API keys appear in the dropdown.</p>
-        </div>
-        <ActiveConfig settings={settings} onSave={handleSaveActive} />
-      </div>
-
-      {/* Providers section */}
-      <div>
-        <div className="mb-4">
-          <h2 className="text-base font-medium">Providers</h2>
-          <p className="text-sm text-muted-foreground">Configure API keys and credentials for each LLM provider.</p>
-        </div>
-
-        {settings?.builtinProviders && (
-          <div className="mb-6">
-            <h4 className="text-xs font-medium text-muted-foreground uppercase tracking-wider mb-3">Built-in</h4>
-            <div className="space-y-8">
-              {Object.entries(settings.builtinProviders).map(([slug, prov]) => (
-                <ProviderCard
-                  key={slug}
-                  slug={slug}
-                  name={prov.name}
-                  credentials={prov.credentials}
-                  credentialStatuses={settings.credentialStatuses || []}
-                  onUpdateCredential={handleUpdateCredential}
-                />
-              ))}
-            </div>
-          </div>
-        )}
-
-        <div className="space-y-8">
-          <h4 className="text-xs font-medium text-muted-foreground uppercase tracking-wider">Custom (OpenAI Compatible API)</h4>
-          {settings?.customProviders?.map((cp) => (
-            <CustomProviderCard key={cp.key} provider={cp} onEdit={openEdit} onRemove={handleRemoveCustom} />
-          ))}
-          <button
-            onClick={openAdd}
-            className="w-full rounded-lg border border-dashed p-4 text-sm text-muted-foreground hover:text-foreground hover:border-foreground/30 transition-colors flex items-center justify-center gap-2"
-          >
-            <PlusIcon size={14} />
-            Add OpenAI Compatible API
-          </button>
-        </div>
-
-        <CustomProviderDialog
-          open={showDialog}
-          initial={editingProvider}
-          onSave={editingProvider ? handleEditCustom : handleAddCustom}
-          onCancel={closeDialog}
-        />
-      </div>
-    </div>
-  );
-}
-
 // Backwards compat
 export function SettingsChatPage() {
   return <ChatConfigPage />;

package/lib/chat/components/settings-secrets-layout.js

@@ -28,8 +28,8 @@ const API_KEYS_TABS = [
 ];
 const EVENT_HANDLER_TABS = [
   { id: "llms", label: "LLMs", href: "/admin/event-handler/llms" },
-  { id: "chat", label: "Chat", href: "/admin/event-handler/chat" },
   { id: "coding-agents", label: "Coding Agents", href: "/admin/event-handler/coding-agents" },
+  { id: "chat", label: "Chat", href: "/admin/event-handler/chat" },
   { id: "agent-secrets", label: "Agent Secrets", href: "/admin/event-handler/agent-secrets" },
   { id: "webhooks", label: "Webhooks", href: "/admin/event-handler/webhooks" },
   { id: "telegram", label: "Telegram", href: "/admin/event-handler/telegram" },

package/lib/chat/components/settings-secrets-layout.jsx

@@ -50,8 +50,8 @@ const API_KEYS_TABS = [
 
 const EVENT_HANDLER_TABS = [
   { id: 'llms', label: 'LLMs', href: '/admin/event-handler/llms' },
-  { id: 'chat', label: 'Chat', href: '/admin/event-handler/chat' },
   { id: 'coding-agents', label: 'Coding Agents', href: '/admin/event-handler/coding-agents' },
+  { id: 'chat', label: 'Chat', href: '/admin/event-handler/chat' },
   { id: 'agent-secrets', label: 'Agent Secrets', href: '/admin/event-handler/agent-secrets' },
   { id: 'webhooks', label: 'Webhooks', href: '/admin/event-handler/webhooks' },
   { id: 'telegram', label: 'Telegram', href: '/admin/event-handler/telegram' },

package/lib/config.js

@@ -24,6 +24,7 @@ const SECRET_KEYS = new Set([
   'MISTRAL_API_KEY',
   'XAI_API_KEY',
   'OPENROUTER_API_KEY',
+  'NVIDIA_API_KEY',
   'TELEGRAM_BOT_TOKEN',
   'TELEGRAM_WEBHOOK_SECRET',
   'ASSEMBLYAI_API_KEY',

package/lib/llm-providers.js

@@ -127,6 +127,14 @@ export const BUILTIN_PROVIDERS = {
     anthropicEndpoint: 'https://openrouter.ai/api',
     models: [],
   },
+  nvidia: {
+    name: 'NVIDIA',
+    litellmProxy: true, litellmPrefix: 'nvidia_nim',
+    credentials: [
+      { type: 'api_key', key: 'NVIDIA_API_KEY', label: 'API Key' },
+    ],
+    models: [],
+  },
 };
 
 /**

package/lib/tools/docker.js

@@ -347,7 +347,7 @@ function buildAgentAuthEnv(agent) {
     const model = getConfig(`${configPrefix}_MODEL`);
     if (model) env.push(`LLM_MODEL=${model}`);
 
-    const builtinKeyMap = { anthropic: 'ANTHROPIC_API_KEY', openai: 'OPENAI_API_KEY', google: 'GOOGLE_API_KEY', deepseek: 'DEEPSEEK_API_KEY', minimax: 'MINIMAX_API_KEY', mistral: 'MISTRAL_API_KEY', xai: 'XAI_API_KEY', openrouter: 'OPENROUTER_API_KEY' };
+    const builtinKeyMap = { anthropic: 'ANTHROPIC_API_KEY', openai: 'OPENAI_API_KEY', google: 'GOOGLE_API_KEY', deepseek: 'DEEPSEEK_API_KEY', minimax: 'MINIMAX_API_KEY', mistral: 'MISTRAL_API_KEY', xai: 'XAI_API_KEY', openrouter: 'OPENROUTER_API_KEY', nvidia: 'NVIDIA_API_KEY' };
     if (builtinKeyMap[provider]) {
       const key = getConfig(builtinKeyMap[provider]);
       if (key) env.push(`${builtinKeyMap[provider]}=${key}`);
@@ -927,6 +927,7 @@ async function runAgentJobContainer({ agentJobId, repo, branch, title, descripti
 }
 
 export {
+  CODING_AGENT_UID,
   DockerFrameParser,
   runInteractiveContainer,
   runHeadlessContainer,
@@ -951,4 +952,5 @@ export {
   createVolume,
   removeVolume,
   restartLitellm,
+  buildAgentAuthEnv,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thepopebot",
-  "version": "1.2.75",
+  "version": "1.2.76-beta.0",
   "type": "module",
   "description": "Create autonomous AI agents with a two-layer architecture: Next.js Event Handler + Docker Agent.",
   "bin": {
@@ -68,6 +68,7 @@
   "license": "MIT",
   "dependencies": {
     "@ai-sdk/react": "^2.0.0",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.92",
     "@clack/prompts": "^0.10.0",
     "@dnd-kit/core": "^6.3.1",
     "@dnd-kit/modifiers": "^9.0.0",