@hienlh/ppm 0.1.3 → 0.1.6

package/docs/codebase-summary.md

@@ -25,6 +25,7 @@ ppm/
 │   │   ├── middleware/
 │   │   │   └── auth.ts              # Token validation middleware
 │   │   ├── routes/
+│   │   │   ├── settings.ts          # GET/PUT /api/settings/ai (AI provider config)
 │   │   │   ├── projects.ts          # GET/POST /api/projects, DELETE /:name
 │   │   │   ├── project-scoped.ts    # Mount chat, git, files under /api/project/:name/*
 │   │   │   ├── chat.ts              # GET/POST/DELETE sessions, GET messages, usage, slash-items
@@ -36,13 +37,10 @@ ppm/
 │   │   └── ws/
 │   │       ├── chat.ts              # WebSocket chat streaming (220 LOC)
 │   │       └── terminal.ts          # WebSocket terminal I/O (terminal.service.ts integration)
-│   ├── providers/                   # AI Provider adapters (7 files, 1444 LOC)
+│   ├── providers/                   # AI Provider adapters (3 files, 574 LOC)
 │   │   ├── provider.interface.ts    # AIProvider interface (createSession, sendMessage, onToolApproval)
-│   │   ├── claude-agent-sdk.ts      # Primary: @anthropic-ai/claude-agent-sdk (444 LOC)
-│   │   ├── claude-code-cli.ts       # Fallback: claude CLI binary (412 LOC)
-│   │   ├── mock-provider.ts         # Test provider
-│   │   ├── claude-binary-finder.ts  # Find claude CLI in PATH
-│   │   ├── claude-process-registry.ts # Track running claude processes
+│   │   ├── claude-agent-sdk.ts      # Primary: @anthropic-ai/claude-agent-sdk. Reads config from configService.
+│   │   ├── mock-provider.ts         # Test provider (ignores config)
 │   │   └── registry.ts              # ProviderRegistry (singleton, router to active provider)
 │   ├── services/                    # Business logic (9 files, 1561 LOC)
 │   │   ├── chat.service.ts          # Session lifecycle, message streaming, streaming to clients
@@ -74,8 +72,9 @@ ppm/
 │       │   ├── use-websocket.ts     # Generic WebSocket adapter
 │       │   ├── use-terminal.ts      # Terminal I/O over WebSocket
 │       │   └── use-url-sync.ts      # Sync state to URL (project, tab, file selections)
-│       ├── lib/                     # Utilities (4 files, 264 LOC)
+│       ├── lib/                     # Utilities (5 files, 290 LOC)
 │       │   ├── api-client.ts        # Fetch wrapper with auth token
+│       │   ├── api-settings.ts      # AI settings API client (GET/PUT /api/settings/ai)
 │       │   ├── ws-client.ts         # WebSocket wrapper
 │       │   ├── file-support.ts      # File type detection (language -> icon)
 │       │   └── utils.ts             # Utility functions (clsx, classname merging)
@@ -108,7 +107,7 @@ ppm/
 │           │   ├── mobile-nav.tsx   # Mobile hamburger navigation
 │           │   └── mobile-drawer.tsx # Offcanvas drawer
 │           ├── projects/            # Project management (339 LOC, 2 files)
-│           ├── settings/            # Settings panel (57 LOC)
+│           ├── settings/            # Settings panel (theme + AI provider config UI)
 │           ├── terminal/            # xterm.js wrapper (143 LOC, 2 files)
 │           └── ui/                  # Radix + shadcn primitives (1018 LOC, 10 files)
 │               └── button.tsx, dialog.tsx, dropdown-menu.tsx, ... (base components)
@@ -176,13 +175,12 @@ ppm/
 - **Pattern:** Singleton services, dependency injection via imports
 
 ### Provider Layer (src/providers/)
-- **Responsibility:** AI model abstraction
+- **Responsibility:** AI model abstraction, config-driven initialization
 - **Providers:**
-  - **claude-agent-sdk** — Primary (official SDK, streaming, tool use)
-  - **claude-code-cli** — Fallback (subprocess-based)
-  - **mock** — Test provider
+  - **claude-agent-sdk** — Primary (official SDK, streaming, tool use). Reads model/effort/maxTurns/budget/thinking from config.
+  - **mock** — Test provider (ignores config)
 - **Interface:** Async generator streaming, tool approval callback
-- **Pattern:** Registry pattern for pluggable AI providers
+- **Pattern:** Registry pattern for pluggable AI providers. Config read fresh per query (configService integration).
 
 ### Frontend Layer (src/web/)
 - **Responsibility:** React UI for project management, chat, terminal, editor

package/docs/lessons-learned.md

@@ -0,0 +1,58 @@
+# Lessons Learned
+
+Knowledge and gotchas discovered during PPM development.
+
+---
+
+## Claude Agent SDK
+
+### .env poisoning via project cwd
+
+**Problem**: SDK spawns a CLI process in the project's `cwd`. The CLI auto-loads `.env` via dotenv. If the project has `ANTHROPIC_API_KEY=dummy` or `ANTHROPIC_BASE_URL=http://localhost:...`, the CLI uses those instead of the user's subscription → "Invalid API key" or empty responses with no tool execution.
+
+**Symptoms**:
+- Model returns empty response, no text or tool_use events
+- `result.subtype === "error_during_execution"`
+- Text response: "Invalid API key · Fix external API key"
+- `totalCostUsd: 0` in usage
+
+**Fix**: Neutralize `ANTHROPIC_*` env vars by setting them to empty string (not deleting — dotenv won't override existing vars):
+```ts
+env: {
+  ...process.env,
+  ANTHROPIC_API_KEY: "",
+  ANTHROPIC_BASE_URL: "",
+  ANTHROPIC_AUTH_TOKEN: "",
+},
+```
+
+**File**: `src/providers/claude-agent-sdk.ts`
+
+---
+
+### Project-local Claude settings restrict tools
+
+**Problem**: Projects may have `.claude/settings.local.json` with restrictive `permissions.allow` lists (e.g., only `Bash(python:*)`, `Bash(ls:*)`). Even with `permissionMode: "bypassPermissions"`, the SDK CLI still reads these and restricts available tools.
+
+**Fix**: Override with explicit empty settings and no setting sources:
+```ts
+settings: { permissions: { allow: [], deny: [] } },
+settingSources: [],
+```
+
+---
+
+## WebSocket Chat Architecture
+
+### Event flow: SDK → Provider → WS → Frontend
+
+1. SDK emits: `system` → `stream_event`* → `assistant` → `rate_limit_event` → `user` (tool_result) → `result`
+2. Provider extracts text from `stream_event.event.delta.text` and tool_use from `assistant.message.content`
+3. Provider yields: `text`, `tool_use`, `tool_result`, `usage`, `done`
+4. WS handler sends JSON to frontend
+
+Key: `stream_event` contains raw API events (`content_block_delta` with `text_delta`). The `assistant` event contains the full message with all content blocks.
+
+### tool_result lives in `user` events
+
+SDK returns tool results as `user` type messages (not `assistant`). Provider fetches them via `getSessionMessages()` after detecting `pendingToolCount > 0`.

package/docs/system-architecture.md

@@ -45,6 +45,8 @@
 │  │ ppm.yaml         │  │ Git Repos        │  │ Session Storage │    │
 │  │ (projects list)  │  │ (local disk)     │  │ (in-memory only)│    │
 │  │ (auth token)     │  │                  │  │                 │    │
+│  │ (AI provider     │  │                  │  │                 │    │
+│  │  settings)       │  │                  │  │                 │    │
 │  └──────────────────┘  └──────────────────┘  └─────────────────┘    │
 └──────────────────────────────────────────────────────────────────────┘
         ↓↑
@@ -93,6 +95,8 @@
 ```
 GET    /api/health              → Health check
 GET    /api/auth/check          → Verify auth token
+GET    /api/settings/ai         → Get AI provider settings
+PUT    /api/settings/ai         → Update AI provider settings
 POST   /api/projects            → Create project
 GET    /api/projects            → List projects
 DELETE /api/projects/:name      → Delete project
@@ -157,9 +161,9 @@ interface AIProvider {
 ```
 
 **Implementations:**
-- **claude-agent-sdk** (Primary) — @anthropic-ai/claude-agent-sdk, streaming, tool use
-- **claude-code-cli** (Fallback) — Claude CLI subprocess, for offline environments
+- **claude-agent-sdk** (Primary) — @anthropic-ai/claude-agent-sdk, streaming, tool use. Reads model/effort/maxTurns/budget/thinking from `ppm.yaml` AI config. Settings refreshed per query.
 - **mock-provider** (Testing) — Returns canned responses
+- **Note:** CLI provider removed (v2); agent SDK now sole AI provider
 
 ---
 
@@ -279,6 +283,78 @@ For each API request:
 
 ---
 
+## AI Provider Configuration
+
+PPM exposes AI settings as global configuration (not per-session) via REST API and Settings UI. Configuration is stored in `ppm.yaml` and read fresh per query.
+
+### Configuration Shape
+```yaml
+ai:
+  default_provider: claude
+  providers:
+    claude:
+      type: agent-sdk
+      api_key_env: ANTHROPIC_API_KEY
+      model: claude-sonnet-4-6
+      effort: high
+      max_turns: 100
+      max_budget_usd: 2.00
+      thinking_budget_tokens: 10000
+```
+
+**Fields:**
+- `default_provider`: Active provider name (e.g., `claude`)
+- `type`: Provider type (`agent-sdk` or `mock`)
+- `api_key_env`: Environment variable containing API key
+- `model`: Model ID (e.g., `claude-sonnet-4-6`, `claude-opus-4-6`)
+- `effort`: Processing level (`low`, `medium`, `high`, `max`)
+- `max_turns`: Maximum interaction turns (1-500, default 100)
+- `max_budget_usd`: Spending limit in USD (optional)
+- `thinking_budget_tokens`: Extended thinking budget in tokens (optional, 0=disabled)
+
+### API Endpoints
+
+**GET /api/settings/ai** — Fetch current AI config
+```json
+{
+  "ok": true,
+  "data": {
+    "default_provider": "claude",
+    "providers": { "claude": {...} }
+  }
+}
+```
+
+**PUT /api/settings/ai** — Update AI config (shallow merge per provider)
+```json
+{
+  "providers": {
+    "claude": {
+      "model": "claude-opus-4-6",
+      "max_turns": 50
+    }
+  }
+}
+```
+Returns full updated config. Validates ranges/enums before writing.
+
+### How Provider Uses Settings
+
+1. **SDK Provider (`sendMessage`)**
+   - Calls `getProviderConfig()` to read fresh config from `configService`
+   - Maps snake_case config to camelCase SDK options
+   - Passes `model`, `effort`, `maxTurns`, `maxBudgetUsd`, `thinkingBudgetTokens` to `query()`
+   - Falls back to defaults if fields not set
+
+2. **Mock Provider**
+   - Ignores AI settings (always returns canned responses for testing)
+
+3. **Changes Take Effect**
+   - Immediately on next query (config read fresh each time)
+   - No active queries affected (config mid-flight not re-evaluated)
+
+---
+
 ## Chat Streaming Flow
 
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hienlh/ppm",
-  "version": "0.1.3",
+  "version": "0.1.6",
   "description": "Personal Project Manager — mobile-first web IDE with AI assistance",
   "module": "src/index.ts",
   "type": "module",
@@ -48,6 +48,7 @@
     "@xterm/addon-web-links": "^0.12.0",
     "@xterm/xterm": "^6.0.0",
     "ccburn": "^0.6.0",
+    "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "codemirror": "^6.0.2",
     "commander": "^14.0.3",

package/schemas/ppm-config.schema.json

@@ -0,0 +1,87 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "PPM Configuration",
+  "description": "Configuration file for PPM (Project & Process Manager)",
+  "type": "object",
+  "properties": {
+    "port": {
+      "type": "integer",
+      "default": 8080,
+      "description": "Server port"
+    },
+    "host": {
+      "type": "string",
+      "default": "0.0.0.0",
+      "description": "Server bind address"
+    },
+    "auth": {
+      "type": "object",
+      "properties": {
+        "enabled": { "type": "boolean", "default": true },
+        "token": { "type": "string" }
+      }
+    },
+    "projects": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "path": { "type": "string" },
+          "name": { "type": "string" }
+        },
+        "required": ["path", "name"]
+      }
+    },
+    "ai": {
+      "type": "object",
+      "properties": {
+        "default_provider": { "type": "string", "default": "claude" },
+        "providers": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/$defs/AIProviderConfig"
+          }
+        }
+      }
+    }
+  },
+  "$defs": {
+    "AIProviderConfig": {
+      "type": "object",
+      "properties": {
+        "type": {
+          "type": "string",
+          "enum": ["agent-sdk", "mock"]
+        },
+        "api_key_env": { "type": "string" },
+        "model": {
+          "type": "string",
+          "description": "Model ID (e.g. claude-sonnet-4-6, claude-opus-4-6)",
+          "examples": ["claude-sonnet-4-6", "claude-opus-4-6", "claude-haiku-4-5"]
+        },
+        "effort": {
+          "type": "string",
+          "enum": ["low", "medium", "high", "max"],
+          "default": "high"
+        },
+        "max_turns": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 500,
+          "default": 100
+        },
+        "max_budget_usd": {
+          "type": "number",
+          "minimum": 0.01,
+          "maximum": 50
+        },
+        "thinking_budget_tokens": {
+          "type": "integer",
+          "minimum": 0,
+          "description": "0 = disabled"
+        }
+      },
+      "required": ["type"]
+    }
+  }
+}

package/src/providers/claude-agent-sdk.ts

@@ -12,6 +12,7 @@ import type {
   ChatMessage,
   UsageInfo,
 } from "./provider.interface.ts";
+import { configService } from "../services/config.service.ts";
 
 /**
  * Pending approval: canUseTool callback creates a promise,
@@ -39,6 +40,13 @@ export class ClaudeAgentSdkProvider implements AIProvider {
   /** Latest known usage/rate-limit info (shared across all sessions) */
   private latestUsage: UsageInfo = {};
 
+  /** Read current provider config from yaml (fresh each call) */
+  private getProviderConfig(): Partial<import("../types/config.ts").AIProviderConfig> {
+    const ai = configService.get("ai");
+    const providerId = ai.default_provider ?? "claude";
+    return ai.providers[providerId] ?? {};
+  }
+
   async createSession(config: SessionConfig): Promise<Session> {
     const id = crypto.randomUUID();
     const meta: Session = {
@@ -176,9 +184,17 @@ export class ClaudeAgentSdkProvider implements AIProvider {
 
       const requestId = crypto.randomUUID();
 
+      const APPROVAL_TIMEOUT_MS = 60_000;
       const approvalPromise = new Promise<{ approved: boolean; data?: unknown }>(
         (resolve) => {
           this.pendingApprovals.set(requestId, { resolve });
+          // Auto-deny after timeout if FE doesn't respond
+          setTimeout(() => {
+            if (this.pendingApprovals.has(requestId)) {
+              this.pendingApprovals.delete(requestId);
+              resolve({ approved: false });
+            }
+          }, APPROVAL_TIMEOUT_MS);
         },
       );
 
@@ -191,7 +207,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       });
       approvalNotify?.();
 
-      // Wait for FE to send back answers
+      // Wait for FE to send back answers (or timeout)
       const result = await approvalPromise;
 
       if (result.approved && result.data) {
@@ -204,21 +220,46 @@ export class ClaudeAgentSdkProvider implements AIProvider {
     };
 
     let assistantContent = "";
+    let resultSubtype: string | undefined;
+    let resultNumTurns: number | undefined;
 
     try {
+      const providerConfig = this.getProviderConfig();
+
       const q = query({
         prompt: message,
         options: {
           sessionId: isFirstMessage ? sessionId : undefined,
           resume: isFirstMessage ? undefined : sessionId,
           cwd: meta.projectPath,
-          settingSources: meta.projectPath ? ["project"] : undefined,
+          // Use full Claude Code system prompt (coding guidelines, security, response style)
+          systemPrompt: { type: "preset", preset: "claude_code" },
+          // Load project CLAUDE.md, skills, and hooks from project directory
+          settingSources: ["project"],
+          // Neutralize Anthropic env vars so SDK uses subscription, not project .env keys.
+          env: {
+            ...process.env,
+            ANTHROPIC_API_KEY: "",
+            ANTHROPIC_BASE_URL: "",
+            ANTHROPIC_AUTH_TOKEN: "",
+          },
+          // Override project-local Claude settings that may restrict tool permissions
+          settings: { permissions: { allow: [], deny: [] } },
           allowedTools: [
             "Read", "Write", "Edit", "Bash", "Glob", "Grep",
             "WebSearch", "WebFetch", "AskUserQuestion",
+            "Agent", "Skill", "TodoWrite", "ToolSearch",
           ],
           permissionMode: "bypassPermissions",
           allowDangerouslySkipPermissions: true,
+          // Config-driven values from ppm.yaml
+          ...(providerConfig.model && { model: providerConfig.model }),
+          ...(providerConfig.effort && { effort: providerConfig.effort }),
+          maxTurns: providerConfig.max_turns ?? 100,
+          ...(providerConfig.max_budget_usd && { maxBudgetUsd: providerConfig.max_budget_usd }),
+          ...(providerConfig.thinking_budget_tokens != null && {
+            thinkingBudgetTokens: providerConfig.thinking_budget_tokens,
+          }),
           canUseTool,
           includePartialMessages: true,
         } as any,
@@ -232,11 +273,27 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       let pendingToolCount = 0;
 
       for await (const msg of q) {
+        // Debug: log all SDK events to understand flow
+
         // Yield any queued approval events
         while (approvalEvents.length > 0) {
           yield approvalEvents.shift()!;
         }
 
+        // Capture SDK session metadata from init message
+        if (msg.type === "system" && (msg as any).subtype === "init") {
+          const initMsg = msg as any;
+          // SDK may assign a different session_id than our UUID
+          if (initMsg.session_id && initMsg.session_id !== sessionId) {
+            // Update our mapping so resume works with SDK's actual ID
+            const oldMeta = this.activeSessions.get(sessionId);
+            if (oldMeta) {
+              this.activeSessions.set(initMsg.session_id, { ...oldMeta, id: initMsg.session_id });
+            }
+          }
+          continue;
+        }
+
         // When tools were pending and a new assistant/stream_event arrives,
         // the SDK has finished executing tools. Fetch tool_results from session history.
         if (pendingToolCount > 0 && (msg.type === "assistant" || (msg as any).type === "partial" || (msg as any).type === "stream_event")) {
@@ -369,12 +426,31 @@ export class ClaudeAgentSdkProvider implements AIProvider {
           }
 
           const result = msg as any;
+          const subtype = result.subtype as string | undefined;
+
           // Yield final cost + any rate limit info from result
           const usage: Record<string, unknown> = {};
           if (result.total_cost_usd != null) usage.totalCostUsd = result.total_cost_usd;
           if (Object.keys(usage).length > 0) {
             yield { type: "usage", usage };
           }
+
+          // Surface non-success subtypes as errors so FE can display them
+          if (subtype && subtype !== "success") {
+            const errorMessages: Record<string, string> = {
+              error_max_turns: "Agent reached maximum turn limit.",
+              error_max_budget_usd: "Agent reached budget limit.",
+              error_during_execution: "Agent encountered an error during execution.",
+            };
+            yield {
+              type: "error",
+              message: errorMessages[subtype] ?? `Agent stopped: ${subtype}`,
+            };
+          }
+
+          // Store subtype and numTurns for the done event
+          resultSubtype = subtype;
+          resultNumTurns = result.num_turns as number | undefined;
           break;
         }
       }
@@ -393,7 +469,12 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       this.activeQueries.delete(sessionId);
     }
 
-    yield { type: "done", sessionId };
+    yield {
+      type: "done",
+      sessionId,
+      resultSubtype: resultSubtype as any,
+      numTurns: resultNumTurns,
+    };
   }
 
   /** Get latest cached usage/rate-limit info */

package/src/providers/registry.ts

@@ -1,6 +1,5 @@
 import type { AIProvider } from "./provider.interface.ts";
 import { MockProvider } from "./mock-provider.ts";
-import { ClaudeCodeCliProvider } from "./claude-code-cli.ts";
 import { ClaudeAgentSdkProvider } from "./claude-agent-sdk.ts";
 
 export interface ProviderInfo {
@@ -41,5 +40,4 @@ class ProviderRegistry {
 /** Singleton registry — first registered = default */
 export const providerRegistry = new ProviderRegistry();
 providerRegistry.register(new ClaudeAgentSdkProvider()); // default — real streaming, multi-turn
-providerRegistry.register(new ClaudeCodeCliProvider());   // fallback — spawns claude CLI
 providerRegistry.register(new MockProvider());            // testing only

package/src/server/index.ts

@@ -3,6 +3,7 @@ import { cors } from "hono/cors";
 import { configService } from "../services/config.service.ts";
 import { authMiddleware } from "./middleware/auth.ts";
 import { projectRoutes } from "./routes/projects.ts";
+import { settingsRoutes } from "./routes/settings.ts";
 import { staticRoutes } from "./routes/static.ts";
 import { projectScopedRouter } from "./routes/project-scoped.ts";
 import { terminalWebSocket } from "./ws/terminal.ts";
@@ -22,6 +23,7 @@ app.use("/api/*", authMiddleware);
 app.get("/api/auth/check", (c) => c.json(ok(true)));
 
 // API routes
+app.route("/api/settings", settingsRoutes);
 app.route("/api/projects", projectRoutes);
 app.route("/api/project/:projectName", projectScopedRouter);
 
@@ -99,6 +101,8 @@ export async function startServer(options: {
       return app.fetch(req, server);
     },
     websocket: {
+      idleTimeout: 960, // 16 minutes — keepalive ping handles liveness
+      sendPong: true,
       open(ws: any) {
         if (ws.data?.type === "chat") chatWebSocket.open(ws);
         else terminalWebSocket.open(ws);
@@ -114,7 +118,7 @@ export async function startServer(options: {
     } as Parameters<typeof Bun.serve>[0] extends { websocket?: infer W } ? W : never,
   });
 
-  console.log(`\n  PPM v0.1.3 ready\n`);
+  console.log(`\n  PPM v0.1.6 ready\n`);
   console.log(`  ➜  Local:   http://localhost:${server.port}/`);
 
   // List all network interfaces
@@ -178,6 +182,8 @@ if (process.argv.includes("__serve__")) {
       return app.fetch(req, server);
     },
     websocket: {
+      idleTimeout: 960,
+      sendPong: true,
       open(ws: any) {
         if (ws.data?.type === "chat") chatWebSocket.open(ws);
         else terminalWebSocket.open(ws);

package/src/server/routes/settings.ts

@@ -0,0 +1,70 @@
+import { Hono } from "hono";
+import { configService } from "../../services/config.service.ts";
+import {
+  validateAIProviderConfig,
+  validateDefaultProvider,
+  type AIProviderConfig,
+} from "../../types/config.ts";
+import { ok, err } from "../../types/api.ts";
+
+export const settingsRoutes = new Hono();
+
+/** GET /settings/ai — return current AI config (strips api_key_env) */
+settingsRoutes.get("/ai", (c) => {
+  const ai = structuredClone(configService.get("ai"));
+  // Strip sensitive env var names from response
+  for (const provider of Object.values(ai.providers)) {
+    delete (provider as unknown as Record<string, unknown>).api_key_env;
+  }
+  return c.json(ok(ai));
+});
+
+/** PUT /settings/ai — update AI provider settings, writes to yaml */
+settingsRoutes.put("/ai", async (c) => {
+  try {
+    const body = await c.req.json<{
+      default_provider?: string;
+      providers?: Record<string, Partial<AIProviderConfig>>;
+    }>();
+
+    const currentAi = configService.get("ai");
+
+    // Validate each provider config
+    if (body.providers) {
+      for (const [name, providerConfig] of Object.entries(body.providers)) {
+        const errors = validateAIProviderConfig(providerConfig);
+        if (errors.length > 0) {
+          return c.json(err(`Provider "${name}": ${errors.join(", ")}`), 400);
+        }
+      }
+    }
+
+    // Merge: body overrides current values (shallow merge per provider)
+    const updated = {
+      ...currentAi,
+      ...(body.default_provider && { default_provider: body.default_provider }),
+    };
+    if (body.providers) {
+      updated.providers = { ...currentAi.providers };
+      for (const [name, config] of Object.entries(body.providers)) {
+        updated.providers[name] = {
+          ...currentAi.providers[name],
+          ...config,
+        } as AIProviderConfig;
+      }
+    }
+
+    // Validate default_provider references existing provider
+    if (body.default_provider) {
+      const dpErr = validateDefaultProvider(updated.default_provider, updated.providers);
+      if (dpErr) return c.json(err(dpErr), 400);
+    }
+
+    configService.set("ai", updated);
+    configService.save();
+
+    return c.json(ok(updated));
+  } catch (e) {
+    return c.json(err((e as Error).message), 400);
+  }
+});