feat: integrate Claude Agent SDK capabilities — model/command discovery, effort/thinking, MCP runtime, file rewind, structured output

Systematically integrate high-value SDK capabilities while preserving the
multi-provider architecture:

SDK capability discovery (per-provider cache):
- agent-sdk-capabilities.ts: cache models, commands, account info, MCP status
  per provider via Map<providerId, cache> to prevent cross-provider pollution
- claude-client.ts: fire-and-forget captureCapabilities() after query() init
- providers/models: merge SDK models with static defaults
- skills: merge SDK slash commands with filesystem skills

Query options passthrough:
- thinking (adaptive/enabled/disabled), effort (low/medium/high/max),
  outputFormat, agents, enableFileCheckpointing
- /chat page.tsx: first-message path now includes effort/thinking (was missing)
- stream-session-manager: passes effort/thinking in POST body

Graceful interrupt:
- /api/chat/interrupt: conversation.interrupt() before abort fallback
- stream-session-manager: tries interrupt first, aborts after 2s timeout

MCP runtime management:
- /api/plugins/mcp/status: live status from active Query, auto-resolves
  providerId from session DB record (prevents wrong-provider cache writes)
- /api/plugins/mcp/reconnect + toggle: reconnect/enable/disable servers
- McpManager + McpServerList: runtime status indicators with action buttons

File checkpointing & rewind:
- enableFileCheckpointing=true for code mode by default
- rewind_point SSE: only emitted for prompt-level user messages
  (parent_tool_use_id===null) and skips autoTrigger turns
- /api/chat/rewind: dry-run preview + actual rewind via rewindFiles()
- MessageList: RewindButton with dry-run preview

Structured output:
- /api/chat/structured: reads SDKResultSuccess.structured_output as primary
  path, text fallback only when absent

Account info & thinking config:
- /api/sdk/account: cached account info display
- Settings: thinking_mode in ALLOWED_KEYS, thinking mode selector in UI
- Effort selector in MessageInput with lifted state pattern

New files: 11 route handlers + 2 lib modules + 1 test file
Modified files: 18 (types, client, manager, UI components, i18n)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: 7418

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "codepilot",
-  "version": "0.27.1",
+  "version": "0.28.0",
   "private": true,
   "author": {
     "name": "op7418",

package.json

@@ -0,0 +1,138 @@
+/**
+ * Unit tests for structured output route logic.
+ *
+ * Tests verify that:
+ * 1. structured_output from SDKResultSuccess is preferred over text fallback
+ * 2. Text fallback is used when structured_output is absent
+ * 3. Raw text is returned when JSON.parse fails on fallback
+ */
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+
+// Simulate the extraction logic from the structured route
+// (We can't import Next.js route handlers directly in node:test,
+//  so we test the core logic inline.)
+
+function extractStructuredResult(messages: Array<{ type: string; subtype?: string; structured_output?: unknown; result?: string; message?: unknown }>) {
+  let structuredOutput: unknown = undefined;
+  let resultText = '';
+
+  for (const message of messages) {
+    if (message.type === 'result' && message.subtype === 'success') {
+      if (message.structured_output !== undefined) {
+        structuredOutput = message.structured_output;
+      }
+      if (message.result) {
+        resultText = message.result;
+      }
+    } else if (message.type === 'assistant') {
+      const msg = message.message as { content?: Array<{ type: string; text?: string }> } | string;
+      if (typeof msg === 'string') {
+        resultText += msg;
+      } else if (msg && Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (block.type === 'text' && block.text) {
+            resultText += block.text;
+          }
+        }
+      }
+    }
+  }
+
+  // Prefer structured_output
+  if (structuredOutput !== undefined) {
+    return { result: structuredOutput, source: 'structured_output' };
+  }
+
+  // Fallback: try JSON parse
+  if (resultText) {
+    try {
+      return { result: JSON.parse(resultText), source: 'text_parsed' };
+    } catch {
+      return { result: resultText, source: 'text_raw' };
+    }
+  }
+
+  return { result: null, source: 'empty' };
+}
+
+describe('structured output extraction', () => {
+  it('prefers structured_output from SDK result', () => {
+    const messages = [
+      {
+        type: 'assistant',
+        message: { content: [{ type: 'text', text: '{"name":"from text"}' }] },
+      },
+      {
+        type: 'result',
+        subtype: 'success',
+        structured_output: { name: 'from structured' },
+        result: '{"name":"from text"}',
+      },
+    ];
+
+    const out = extractStructuredResult(messages);
+    assert.equal(out.source, 'structured_output');
+    assert.deepEqual(out.result, { name: 'from structured' });
+  });
+
+  it('falls back to text parsing when structured_output is absent', () => {
+    const messages = [
+      {
+        type: 'assistant',
+        message: { content: [{ type: 'text', text: '{"fallback":true}' }] },
+      },
+      {
+        type: 'result',
+        subtype: 'success',
+        result: '',
+      },
+    ];
+
+    const out = extractStructuredResult(messages);
+    assert.equal(out.source, 'text_parsed');
+    assert.deepEqual(out.result, { fallback: true });
+  });
+
+  it('returns raw text when JSON parse fails', () => {
+    const messages = [
+      {
+        type: 'assistant',
+        message: { content: [{ type: 'text', text: 'not valid json' }] },
+      },
+      {
+        type: 'result',
+        subtype: 'success',
+      },
+    ];
+
+    const out = extractStructuredResult(messages);
+    assert.equal(out.source, 'text_raw');
+    assert.equal(out.result, 'not valid json');
+  });
+
+  it('returns null when no content at all', () => {
+    const messages = [
+      { type: 'result', subtype: 'success' },
+    ];
+
+    const out = extractStructuredResult(messages);
+    assert.equal(out.source, 'empty');
+    assert.equal(out.result, null);
+  });
+
+  it('handles structured_output that is a primitive (e.g. number)', () => {
+    const messages = [
+      {
+        type: 'result',
+        subtype: 'success',
+        structured_output: 42,
+      },
+    ];
+
+    const out = extractStructuredResult(messages);
+    assert.equal(out.source, 'structured_output');
+    assert.equal(out.result, 42);
+  });
+});

src/__tests__/unit/structured-output.test.ts

@@ -0,0 +1,27 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getConversation } from '@/lib/conversation-registry';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+export async function POST(request: NextRequest) {
+  try {
+    const { sessionId } = await request.json();
+
+    if (!sessionId) {
+      return NextResponse.json({ error: 'sessionId is required' }, { status: 400 });
+    }
+
+    const conversation = getConversation(sessionId);
+    if (!conversation) {
+      return NextResponse.json({ interrupted: false });
+    }
+
+    await conversation.interrupt();
+
+    return NextResponse.json({ interrupted: true });
+  } catch (error) {
+    console.error('[interrupt] Failed to interrupt:', error);
+    return NextResponse.json({ interrupted: false, error: String(error) });
+  }
+}

src/app/api/chat/interrupt/route.ts

@@ -0,0 +1,27 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getConversation } from '@/lib/conversation-registry';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+export async function POST(request: NextRequest) {
+  try {
+    const { sessionId, model } = await request.json();
+
+    if (!sessionId || !model) {
+      return NextResponse.json({ error: 'sessionId and model are required' }, { status: 400 });
+    }
+
+    const conversation = getConversation(sessionId);
+    if (!conversation) {
+      return NextResponse.json({ applied: false });
+    }
+
+    await conversation.setModel(model);
+
+    return NextResponse.json({ applied: true });
+  } catch (error) {
+    console.error('[model] Failed to set model:', error);
+    return NextResponse.json({ applied: false, error: String(error) });
+  }
+}

src/app/api/chat/model/route.ts

@@ -0,0 +1,27 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getConversation } from '@/lib/conversation-registry';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+export async function POST(request: NextRequest) {
+  try {
+    const { sessionId, userMessageId, dryRun } = await request.json();
+
+    if (!sessionId || !userMessageId) {
+      return NextResponse.json({ error: 'sessionId and userMessageId are required' }, { status: 400 });
+    }
+
+    const conversation = getConversation(sessionId);
+    if (!conversation) {
+      return NextResponse.json({ canRewind: false, error: 'No active conversation' });
+    }
+
+    const result = await conversation.rewindFiles(userMessageId, { dryRun: !!dryRun });
+
+    return NextResponse.json(result);
+  } catch (error) {
+    console.error('[rewind] Failed to rewind:', error);
+    return NextResponse.json({ canRewind: false, error: String(error) });
+  }
+}

src/app/api/chat/rewind/route.ts

@@ -2,21 +2,42 @@ import { NextRequest } from 'next/server';
 import { streamClaude } from '@/lib/claude-client';
 import { addMessage, getMessages, getSession, updateSessionTitle, updateSdkSessionId, updateSessionModel, updateSessionProvider, updateSessionProviderId, getSetting, getProvider, getDefaultProviderId, acquireSessionLock, renewSessionLock, releaseSessionLock, setSessionRuntimeStatus, syncSdkTasks } from '@/lib/db';
 import { notifySessionStart, notifySessionComplete, notifySessionError } from '@/lib/telegram-bot';
-import type { SendMessageRequest, SSEEvent, TokenUsage, MessageContentBlock, FileAttachment } from '@/types';
+import type { SendMessageRequest, SSEEvent, TokenUsage, MessageContentBlock, FileAttachment, ClaudeStreamOptions } from '@/types';
 import crypto from 'crypto';
 import fs from 'fs';
 import path from 'path';
+import os from 'os';
+import type { MCPServerConfig } from '@/types';
 
 export const runtime = 'nodejs';
 export const dynamic = 'force-dynamic';
 
+/** Read MCP server configs from ~/.claude.json and ~/.claude/settings.json */
+function loadMcpServers(): Record<string, MCPServerConfig> | undefined {
+  try {
+    const readJson = (p: string): Record<string, unknown> => {
+      if (!fs.existsSync(p)) return {};
+      try { return JSON.parse(fs.readFileSync(p, 'utf-8')); } catch { return {}; }
+    };
+    const userConfig = readJson(path.join(os.homedir(), '.claude.json'));
+    const settings = readJson(path.join(os.homedir(), '.claude', 'settings.json'));
+    const merged = {
+      ...((userConfig.mcpServers || {}) as Record<string, MCPServerConfig>),
+      ...((settings.mcpServers || {}) as Record<string, MCPServerConfig>),
+    };
+    return Object.keys(merged).length > 0 ? merged : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 export async function POST(request: NextRequest) {
   let activeSessionId: string | undefined;
   let activeLockId: string | undefined;
 
   try {
-    const body: SendMessageRequest & { files?: FileAttachment[]; toolTimeout?: number; provider_id?: string; systemPromptAppend?: string; autoTrigger?: boolean } = await request.json();
-    const { session_id, content, model, mode, files, toolTimeout, provider_id, systemPromptAppend, autoTrigger } = body;
+    const body: SendMessageRequest & { files?: FileAttachment[]; toolTimeout?: number; provider_id?: string; systemPromptAppend?: string; autoTrigger?: boolean; thinking?: unknown; effort?: string; enableFileCheckpointing?: boolean } = await request.json();
+    const { session_id, content, model, mode, files, toolTimeout, provider_id, systemPromptAppend, autoTrigger, thinking, effort, enableFileCheckpointing } = body;
 
     console.log('[chat API] content length:', content.length, 'first 200 chars:', content.slice(0, 200));
     console.log('[chat API] systemPromptAppend:', systemPromptAppend ? `${systemPromptAppend.length} chars` : 'none');
@@ -292,6 +313,10 @@ Start by greeting the user and asking the first question.
       content: m.content,
     }));
 
+    // Load MCP servers from Claude config files so the SDK knows about them
+    // even when settingSources skips 'user' (custom provider scenario).
+    const mcpServers = loadMcpServers();
+
     // Stream Claude response, using SDK session ID for resume if available
     console.log('[chat API] streamClaude params:', {
       promptLength: content.length,
@@ -313,8 +338,13 @@ Start by greeting the user and asking the first question.
       imageAgentMode: !!systemPromptAppend,
       toolTimeoutSeconds: toolTimeout || 300,
       provider: resolvedProvider,
+      mcpServers,
       conversationHistory: historyMsgs,
       bypassPermissions: session.permission_profile === 'full_access',
+      thinking: thinking as ClaudeStreamOptions['thinking'],
+      effort: effort as ClaudeStreamOptions['effort'],
+      enableFileCheckpointing: enableFileCheckpointing ?? (effectiveMode === 'code'),
+      autoTrigger: !!autoTrigger,
       onRuntimeStatusChange: (status: string) => {
         try { setSessionRuntimeStatus(session_id, status); } catch { /* best effort */ }
       },