repoburg 1.3.186 → 1.3.195

package/agent-pane/backend/src/codex/codex-provider.ts

@@ -1,44 +1,156 @@
-import { Codex, type Thread, type ThreadEvent, type ThreadItem, type ThreadOptions } from '@openai/codex-sdk';
+import type { SessionRuntimeConfig, ModelInfo } from '@agentpane/shared';
 import { v4 as uuidv4 } from 'uuid';
+import type Database from 'better-sqlite3';
 import { getDb } from '../db/index.ts';
 import { broadcast } from '../ws/index.ts';
 import { mapItemData, getItemStatus } from './item-mapper.ts';
+import { AppServerClient } from './app-server-client.ts';
+import type {
+  ItemNotification,
+  TurnFailedNotification,
+  ThreadStartResult,
+  TurnStartResult,
+  AppServerItem,
+  AgentMessageDeltaNotification,
+  TokenUsageNotification,
+  ModelListResult,
+} from './app-server-types.ts';
+import { mapTokenUsage } from './app-server-types.ts';
+import { getSharedAppServer, closeSharedAppServer } from './shared-app-server.ts';
 import type { Session, Turn, Item, ItemStatus } from '../db/schema.ts';
+import type { RuntimeProvider } from '../providers/runtime-provider.ts';
 
-interface ThreadEntry {
-  codex: Codex;
-  thread: Thread;
-  abortController: AbortController | null;
+/** Per-session app-server client + thread state. */
+interface SessionEntry {
+  client: AppServerClient;
+  threadId: string;
+  turnId: string | null;
 }
 
-const threadMap = new Map<string, ThreadEntry>();
+const sessionMap = new Map<string, SessionEntry>();
+
+/** Update the running state and status of a session. */
+function setSessionStatus(
+  db: Database.Database,
+  sessionId: string,
+  isRunning: 0 | 1,
+  status: string,
+  now: string,
+  hasUnreviewed = false,
+): void {
+  if (hasUnreviewed) {
+    db.prepare('UPDATE sessions SET is_running = ?, status = ?, has_unreviewed = 1, updated_at = ? WHERE id = ?').run(
+      isRunning,
+      status,
+      now,
+      sessionId,
+    );
+  } else {
+    db.prepare('UPDATE sessions SET is_running = ?, status = ?, updated_at = ? WHERE id = ?').run(
+      isRunning,
+      status,
+      now,
+      sessionId,
+    );
+  }
+}
 
-function getThreadOptions(session: Session): ThreadOptions {
-  return {
-    model: session.model ?? undefined,
-    workingDirectory: session.cwd ?? undefined,
-    sandboxMode: 'workspace-write',
-    approvalPolicy: 'never',
-    skipGitRepoCheck: true,
-  };
+/** Parse runtime_config JSON from the session row. Returns null on parse failure. */
+function parseRuntimeConfig(session: Session): SessionRuntimeConfig | null {
+  if (!session.runtime_config) return null;
+  try {
+    return JSON.parse(session.runtime_config) as SessionRuntimeConfig;
+  } catch {
+    return null;
+  }
 }
 
-function getOrCreateThread(session: Session): { codex: Codex; thread: Thread } {
-  const existing = threadMap.get(session.id);
-  if (existing) {
-    return { codex: existing.codex, thread: existing.thread };
+/** Map runtime config sandbox mode to app-server sandbox type string (kebab-case). */
+function sandboxType(config: SessionRuntimeConfig | null): 'read-only' | 'workspace-write' | 'danger-full-access' {
+  switch (config?.sandboxMode) {
+    case 'read-only':
+      return 'read-only';
+    case 'danger-full-access':
+      return 'danger-full-access';
+    default:
+      return 'workspace-write';
   }
+}
+
+/** Convert app-server camelCase item type to DB snake_case item type. */
+function normalizeItemType(type: string): string {
+  const map: Record<string, string> = {
+    agentMessage: 'agent_message',
+    userMessage: 'user_message',
+    agentReasoning: 'reasoning',
+    commandExecution: 'command_execution',
+    fileChange: 'file_change',
+    mcpToolCall: 'mcp_tool_call',
+    webSearch: 'web_search',
+    todoList: 'todo_list',
+    error: 'error',
+  };
+  return map[type] ?? type;
+}
+
+/** Check if an item type should be skipped (not stored in DB). */
+function shouldSkipItem(type: string): boolean {
+  return type === 'userMessage' || type === 'user_message';
+}
+
+/** Check if a reasoning item has empty content (app-server sends summary: [], content: []). */
+function isEmptyReasoning(item: AppServerItem): boolean {
+  const summary = Array.isArray(item.summary) ? item.summary : [];
+  const content = Array.isArray(item.content) ? item.content : [];
+  const text = item.text ?? '';
+  return summary.length === 0 && content.length === 0 && text.length === 0;
+}
 
-  const codex = new Codex();
-  let thread: Thread;
+/** Create or resume a thread for the session via a per-session app-server client. */
+async function getOrCreateThread(session: Session): Promise<SessionEntry> {
+  const existing = sessionMap.get(session.id);
+  if (existing) return existing;
+
+  const cwd = session.cwd ?? process.cwd();
+  const client = new AppServerClient({ cwd });
+  await client.initialize();
+
+  const config = parseRuntimeConfig(session);
+  const sandbox = sandboxType(config);
+
+  let threadId: string;
 
   if (session.external_thread_id) {
-    thread = codex.resumeThread(session.external_thread_id, getThreadOptions(session));
+    const result = await client.request<ThreadStartResult>('thread/resume', {
+      threadId: session.external_thread_id,
+      cwd,
+      approvalPolicy: 'never',
+      sandbox,
+      model: session.model ?? undefined,
+    });
+    threadId = result.thread.id;
   } else {
-    thread = codex.startThread(getThreadOptions(session));
+    const result = await client.request<ThreadStartResult>('thread/start', {
+      cwd,
+      approvalPolicy: 'never',
+      sandbox,
+      model: session.model ?? undefined,
+    });
+    threadId = result.thread.id;
+
+    // Save the thread ID to the database
+    const db = getDb();
+    const now = new Date().toISOString();
+    db.prepare('UPDATE sessions SET external_thread_id = ?, updated_at = ? WHERE id = ?').run(
+      threadId,
+      now,
+      session.id,
+    );
   }
 
-  return { codex, thread };
+  const entry: SessionEntry = { client, threadId, turnId: null };
+  sessionMap.set(session.id, entry);
+  return entry;
 }
 
 /** Start a Codex turn. Fire-and-forget — streams events via WS. */
@@ -46,215 +158,462 @@ export async function startTurn(session: Session, turn: Turn): Promise<void> {
   const db = getDb();
 
   // Phase 1: create or resume thread
-  let codex: Codex;
-  let thread: Thread;
-
+  let entry: SessionEntry;
   try {
-    const result = getOrCreateThread(session);
-    codex = result.codex;
-    thread = result.thread;
+    entry = await getOrCreateThread(session);
   } catch (err) {
-    const errMsg = `Failed to create Codex thread: ${(err as Error).message}`;
+    const errMsg = `Failed to create app-server thread: ${(err as Error).message}`;
     const now = new Date().toISOString();
-    db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?')
-      .run('failed', errMsg, now, turn.id);
-    db.prepare('UPDATE sessions SET is_running = 0, status = ?, updated_at = ? WHERE id = ?')
-      .run('failed', now, session.id);
+    db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?').run(
+      'failed',
+      errMsg,
+      now,
+      turn.id,
+    );
+    setSessionStatus(db, session.id, 0, 'failed', now);
     broadcast('turn:failed', { sessionId: session.id, turnId: turn.id, error: errMsg });
     return;
   }
 
-  // Phase 2: set up abort controller and update status
-  const abortController = new AbortController();
-  threadMap.set(session.id, { codex, thread, abortController });
-
+  // Phase 2: update status
+  entry.turnId = turn.id;
   const now = new Date().toISOString();
-  db.prepare('UPDATE turns SET status = ?, updated_at = ? WHERE id = ?')
-    .run('running', now, turn.id);
-  db.prepare('UPDATE sessions SET is_running = 1, status = ?, updated_at = ? WHERE id = ?')
-    .run('running', now, session.id);
-
+  db.prepare('UPDATE turns SET status = ?, updated_at = ? WHERE id = ?').run('running', now, turn.id);
+  setSessionStatus(db, session.id, 1, 'running', now);
   broadcast('turn:started', { sessionId: session.id, turnId: turn.id });
 
-  // Phase 3: run the turn and handle events
-  try {
-    const { events } = await thread.runStreamed(turn.user_prompt, { signal: abortController.signal });
+  // Phase 3: register notification handlers and send turn/start
+  const { client, threadId } = entry;
+  const config = parseRuntimeConfig(session);
+  const sandbox = sandboxType(config);
+
+  // Flag to prevent duplicate handler execution after turn ends
+  let turnDone = false;
 
-    for await (const event of events) {
-      handleEvent(event, session.id, turn.id);
+  // Register handlers for this turn (scoped by threadId — one active turn per session)
+  const handleItemStarted = (params: unknown) => {
+    if (turnDone) return;
+    const p = params as ItemNotification;
+    if (p.threadId !== threadId) return;
+    handleItemEvent(p, session.id, turn.id, 'in_progress', 'item:started');
+  };
+  const handleItemUpdated = (params: unknown) => {
+    if (turnDone) return;
+    const p = params as ItemNotification;
+    if (p.threadId !== threadId) return;
+    handleItemEvent(p, session.id, turn.id, 'in_progress', 'item:updated');
+  };
+  const handleItemCompleted = (params: unknown) => {
+    if (turnDone) return;
+    const p = params as ItemNotification;
+    if (p.threadId !== threadId) return;
+    const status = getItemStatus(p.item);
+    handleItemEvent(p, session.id, turn.id, status, 'item:completed');
+  };
+  const handleTurnCompleted = (params: unknown) => {
+    if (turnDone) return;
+    const p = params as { threadId: string; turn?: { id: string; status: string }; usage?: unknown };
+    if (p.threadId !== threadId) return;
+    turnDone = true;
+    const db = getDb();
+    const now = new Date().toISOString();
+    // Token usage may be in params (mock) or already saved via thread/tokenUsage/updated (real app-server).
+    // When p.usage is undefined, preserve existing token_usage (set by thread/tokenUsage/updated handler).
+    if (p.usage !== undefined) {
+      db.prepare('UPDATE turns SET status = ?, token_usage = ?, updated_at = ? WHERE id = ?').run(
+        'completed',
+        JSON.stringify(p.usage),
+        now,
+        turn.id,
+      );
+      broadcast('turn:completed', { sessionId: session.id, turnId: turn.id, usage: p.usage, hasUnreviewed: true });
+    } else {
+      db.prepare('UPDATE turns SET status = ?, updated_at = ? WHERE id = ?').run('completed', now, turn.id);
+      broadcast('turn:completed', { sessionId: session.id, turnId: turn.id, hasUnreviewed: true });
     }
+    setSessionStatus(db, session.id, 0, 'active', now, true);
+    syncThreadTitle(session.id);
+  };
+  const handleTurnFailed = (params: unknown) => {
+    if (turnDone) return;
+    const p = params as TurnFailedNotification;
+    if (p.threadId !== threadId) return;
+    turnDone = true;
+    const db = getDb();
+    const now = new Date().toISOString();
+    db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?').run(
+      'failed',
+      p.error.message,
+      now,
+      turn.id,
+    );
+    setSessionStatus(db, session.id, 0, 'failed', now);
+    broadcast('turn:failed', { sessionId: session.id, turnId: turn.id, error: p.error.message });
+  };
+
+  // Stream incremental text deltas to frontend — no DB write per delta (performance).
+  // The final text is written by handleItemEvent on item/completed.
+  const handleAgentMessageDelta = (params: unknown) => {
+    if (turnDone) return;
+    const p = params as AgentMessageDeltaNotification;
+    if (p.threadId !== threadId) return;
+    broadcast('item:delta', {
+      sessionId: session.id,
+      turnId: turn.id,
+      itemId: p.itemId,
+      delta: p.delta,
+    });
+  };
+
+  // Save token usage from thread/tokenUsage/updated — no turnDone guard (may arrive before or after turn/completed).
+  const handleTokenUsageUpdated = (params: unknown) => {
+    const p = params as TokenUsageNotification;
+    if (p.threadId !== threadId) return;
+    const usage = mapTokenUsage(p.tokenUsage.total);
+    const db = getDb();
+    const now = new Date().toISOString();
+    db.prepare('UPDATE turns SET token_usage = ?, updated_at = ? WHERE id = ?').run(
+      JSON.stringify(usage),
+      now,
+      turn.id,
+    );
+    broadcast('turn:tokenUsage', { sessionId: session.id, turnId: turn.id, usage });
+  };
+
+  // Note: onNotification adds to a list, so we register before sending turn/start
+  client.onNotification('item/started', handleItemStarted);
+  client.onNotification('item/updated', handleItemUpdated);
+  client.onNotification('item/completed', handleItemCompleted);
+  client.onNotification('item/agentMessage/delta', handleAgentMessageDelta);
+  client.onNotification('turn/completed', handleTurnCompleted);
+  client.onNotification('turn/failed', handleTurnFailed);
+  client.onNotification('thread/tokenUsage/updated', handleTokenUsageUpdated);
+
+  // Phase 4: send turn/start
+  try {
+    await client.request<TurnStartResult>('turn/start', {
+      threadId,
+      input: [{ type: 'text', text: turn.user_prompt }],
+      approvalPolicy: 'never',
+      sandbox: { type: sandbox },
+      model: session.model ?? undefined,
+      effort: session.model_reasoning_effort ?? undefined,
+    });
+
+    // The turn runs asynchronously — events arrive via notifications
+    // If the process closes unexpectedly, handle cleanup
+    client.events.once('closed', () => {
+      const db = getDb();
+      const now = new Date().toISOString();
+      const currentTurn = db.prepare('SELECT status FROM turns WHERE id = ?').get(turn.id) as
+        | { status: string }
+        | undefined;
+      if (currentTurn && currentTurn.status === 'running') {
+        db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?').run(
+          'failed',
+          'App-server process closed unexpectedly',
+          now,
+          turn.id,
+        );
+        setSessionStatus(db, session.id, 0, 'failed', now);
+        broadcast('turn:failed', {
+          sessionId: session.id,
+          turnId: turn.id,
+          error: 'App-server process closed unexpectedly',
+        });
+      }
+    });
   } catch (err) {
-    const isAbort = abortController.signal.aborted || (err as Error).name === 'AbortError';
     const errMsg = (err as Error).message;
     const now2 = new Date().toISOString();
+    db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?').run(
+      'failed',
+      errMsg,
+      now2,
+      turn.id,
+    );
+    setSessionStatus(db, session.id, 0, 'failed', now2);
+    broadcast('turn:failed', { sessionId: session.id, turnId: turn.id, error: errMsg });
+    turnDone = true;
+  }
+}
 
-    if (isAbort) {
-      db.prepare('UPDATE turns SET status = ?, updated_at = ? WHERE id = ?')
-        .run('aborted', now2, turn.id);
-      db.prepare('UPDATE sessions SET is_running = 0, status = ?, updated_at = ? WHERE id = ?')
-        .run('active', now2, session.id);
-      broadcast('turn:failed', { sessionId: session.id, turnId: turn.id, error: 'Turn cancelled by user' });
-    } else {
-      db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?')
-        .run('failed', errMsg, now2, turn.id);
-      db.prepare('UPDATE sessions SET is_running = 0, status = ?, updated_at = ? WHERE id = ?')
-        .run('failed', now2, session.id);
-      broadcast('turn:failed', { sessionId: session.id, turnId: turn.id, error: errMsg });
+/** Handle an item notification — insert or update DB row and broadcast. */
+function handleItemEvent(
+  params: ItemNotification,
+  sessionId: string,
+  turnId: string,
+  status: ItemStatus,
+  broadcastEvent: string,
+): void {
+  const db = getDb();
+  const now = new Date().toISOString();
+  const item = params.item;
+
+  // Skip user messages — they are not agent output
+  if (shouldSkipItem(item.type)) return;
+
+  // Skip reasoning items with empty content — app-server sends summary: [], content: []
+  // These have no displayable text and would render as empty cards
+  if ((item.type === 'reasoning' || item.type === 'agentReasoning') && isEmptyReasoning(item)) return;
+
+  const data = mapItemData(item);
+  const normalizedType = normalizeItemType(item.type);
+
+  // Try to update existing row
+  const result = db
+    .prepare('UPDATE items SET data = ?, status = ?, updated_at = ? WHERE external_item_id = ? AND turn_id = ?')
+    .run(JSON.stringify(data), status, now, item.id, turnId);
+
+  let itemId: string;
+  let createdAt: string;
+
+  if (result.changes === 0) {
+    // Item not in DB yet — insert
+    itemId = uuidv4();
+    createdAt = now;
+    db.prepare(
+      'INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)',
+    ).run(itemId, turnId, item.id, normalizedType as Item['type'], JSON.stringify(data), status, now, now);
+  } else {
+    const row = db
+      .prepare('SELECT id, created_at FROM items WHERE external_item_id = ? AND turn_id = ?')
+      .get(item.id, turnId) as { id: string; created_at: string };
+    itemId = row.id;
+    createdAt = row.created_at;
+  }
+
+  // Update turn-level fields on item completion
+  if (status === 'completed' || status === 'in_progress') {
+    if (item.type === 'agentMessage' || item.type === 'agent_message') {
+      db.prepare('UPDATE turns SET agent_response = ?, updated_at = ? WHERE id = ?').run(item.text, now, turnId);
     }
-  } finally {
-    const entry = threadMap.get(session.id);
-    if (entry) {
-      threadMap.set(session.id, { ...entry, abortController: null });
+    if (item.type === 'reasoning' || item.type === 'agentReasoning') {
+      const summary = Array.isArray(item.summary) ? (item.summary as string[]).join('\n') : '';
+      const thoughts = summary || item.text || '';
+      if (thoughts) {
+        db.prepare('UPDATE turns SET thoughts = ?, updated_at = ? WHERE id = ?').run(thoughts, now, turnId);
+      }
     }
   }
+
+  const wsItem: Item = {
+    id: itemId,
+    turn_id: turnId,
+    external_item_id: item.id,
+    type: normalizedType as Item['type'],
+    data,
+    status,
+    created_at: createdAt,
+    updated_at: now,
+  };
+
+  broadcast(broadcastEvent, { sessionId, turnId, item: wsItem });
 }
 
 /** Cancel a running turn by session ID. Returns true if a turn was cancelled. */
-export function interruptTurn(sessionId: string): boolean {
-  const entry = threadMap.get(sessionId);
-  if (entry?.abortController) {
-    entry.abortController.abort();
-    return true;
-  }
-  return false;
-}
+export async function interruptTurn(sessionId: string): Promise<boolean> {
+  const entry = sessionMap.get(sessionId);
+  if (!entry || !entry.turnId) return false;
 
-function handleEvent(event: ThreadEvent, sessionId: string, turnId: string): void {
-  const db = getDb();
-  const now = new Date().toISOString();
+  try {
+    await entry.client.request('turn/interrupt', {
+      threadId: entry.threadId,
+      turnId: entry.turnId,
+    });
 
-  switch (event.type) {
-    case 'thread.started': {
-      db.prepare('UPDATE sessions SET external_thread_id = ?, updated_at = ? WHERE id = ?')
-        .run(event.thread_id, now, sessionId);
-      break;
-    }
+    // Update DB and broadcast — the app-server may not send a turn/failed notification
+    const db = getDb();
+    const now = new Date().toISOString();
+    db.prepare('UPDATE turns SET status = ?, updated_at = ? WHERE id = ?').run('aborted', now, entry.turnId);
+    setSessionStatus(db, sessionId, 0, 'active', now);
+    broadcast('turn:cancelled', { sessionId, turnId: entry.turnId });
 
-    case 'turn.started': {
-      // Already broadcasted turn:started before the stream started.
-      break;
-    }
+    // Clear turn ID so further notifications are ignored
+    entry.turnId = null;
 
-    case 'item.started': {
-      const item = event.item;
-      const itemId = uuidv4();
-      const data = mapItemData(item);
-      db.prepare(
-        'INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)',
-      ).run(itemId, turnId, item.id, item.type, JSON.stringify(data), 'in_progress', now, now);
+    return true;
+  } catch {
+    return false;
+  }
+}
 
-      broadcast('item:started', { sessionId, turnId, item: makeItem(itemId, turnId, item, 'in_progress', now, now) });
-      break;
-    }
+/** Remove a session's app-server client from the in-memory map. Used after rewind/branch. */
+export function clearThread(sessionId: string): void {
+  const entry = sessionMap.get(sessionId);
+  if (entry) {
+    entry.client.close().catch(() => {
+      // Ignore close errors
+    });
+    sessionMap.delete(sessionId);
+  }
+}
 
-    case 'item.updated': {
-      const item = event.item;
-      const data = mapItemData(item);
-      const result = db.prepare('UPDATE items SET data = ?, updated_at = ? WHERE external_item_id = ? AND turn_id = ?')
-        .run(JSON.stringify(data), now, item.id, turnId);
-
-      // SDK may skip item.started — insert if missing
-      if (result.changes === 0) {
-        const itemId = uuidv4();
-        db.prepare(
-          'INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)',
-        ).run(itemId, turnId, item.id, item.type, JSON.stringify(data), 'in_progress', now, now);
-        broadcast('item:updated', { sessionId, turnId, item: makeItem(itemId, turnId, item, 'in_progress', now, now) });
-      } else {
-        const row = db.prepare('SELECT id, status, created_at FROM items WHERE external_item_id = ? AND turn_id = ?')
-          .get(item.id, turnId) as { id: string; status: ItemStatus; created_at: string } | undefined;
-        if (row) {
-          broadcast('item:updated', { sessionId, turnId, item: makeItem(row.id, turnId, item, row.status, row.created_at, now) });
-        }
-      }
-      break;
-    }
+/** Clear all session entries. Used in test cleanup. */
+export function clearAllThreads(): void {
+  for (const [, entry] of sessionMap) {
+    entry.client.close().catch(() => {});
+  }
+  sessionMap.clear();
+  titleGenerating.clear();
+}
 
-    case 'item.completed': {
-      const item = event.item;
-      const status = getItemStatus(item);
-      const data = mapItemData(item);
-      const result = db.prepare('UPDATE items SET data = ?, status = ?, updated_at = ? WHERE external_item_id = ? AND turn_id = ?')
-        .run(JSON.stringify(data), status, now, item.id, turnId);
-
-      // SDK may skip item.started — insert if missing
-      let itemId: string;
-      let createdAt: string;
-      if (result.changes === 0) {
-        itemId = uuidv4();
-        createdAt = now;
-        db.prepare(
-          'INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)',
-        ).run(itemId, turnId, item.id, item.type, JSON.stringify(data), status, now, now);
-      } else {
-        const row = db.prepare('SELECT id, created_at FROM items WHERE external_item_id = ? AND turn_id = ?')
-          .get(item.id, turnId) as { id: string; created_at: string };
-        itemId = row.id;
-        createdAt = row.created_at;
-      }
+// --- Title generation ---
 
-      // Update turn-level fields
-      if (item.type === 'agent_message') {
-        db.prepare('UPDATE turns SET agent_response = ?, updated_at = ? WHERE id = ?')
-          .run(item.text, now, turnId);
-      }
-      if (item.type === 'reasoning') {
-        const existing = db.prepare('SELECT thoughts FROM turns WHERE id = ?').get(turnId) as { thoughts: string | null };
-        const thoughts = existing.thoughts ? existing.thoughts + '\n' + item.text : item.text;
-        db.prepare('UPDATE turns SET thoughts = ?, updated_at = ? WHERE id = ?')
-          .run(thoughts, now, turnId);
-      }
+/** Tracks sessions currently generating titles — prevents duplicate throwaway threads. */
+const titleGenerating = new Set<string>();
 
-      broadcast('item:completed', { sessionId, turnId, item: makeItem(itemId, turnId, item, status, createdAt, now) });
-      break;
-    }
+/** Generate a title for the session using a throwaway app-server thread. */
+function syncThreadTitle(sessionId: string): void {
+  const db = getDb();
+  const session = db.prepare('SELECT title FROM sessions WHERE id = ?').get(sessionId) as
+    | { title: string | null }
+    | undefined;
+  if (!session || session.title !== null) return;
+  if (titleGenerating.has(sessionId)) return;
+
+  const turn = db
+    .prepare('SELECT user_prompt, agent_response FROM turns WHERE session_id = ? ORDER BY created_at ASC LIMIT 1')
+    .get(sessionId) as { user_prompt: string; agent_response: string | null } | undefined;
+  if (!turn) return;
+
+  titleGenerating.add(sessionId);
+  generateTitleAsync(sessionId, turn.user_prompt, turn.agent_response).finally(() => {
+    titleGenerating.delete(sessionId);
+  });
+}
 
-    case 'turn.completed': {
-      const usage = event.usage;
-      db.prepare('UPDATE turns SET status = ?, token_usage = ?, updated_at = ? WHERE id = ?')
-        .run('completed', JSON.stringify(usage), now, turnId);
-      db.prepare('UPDATE sessions SET is_running = 0, status = ?, updated_at = ? WHERE id = ?')
-        .run('active', now, sessionId);
-      broadcast('turn:completed', { sessionId, turnId, usage });
-      break;
+/** Create a throwaway app-server thread, ask for a title, update the session. */
+async function generateTitleAsync(
+  sessionId: string,
+  userPrompt: string,
+  agentResponse: string | null,
+): Promise<void> {
+  let client: AppServerClient | null = null;
+  try {
+    client = new AppServerClient({ cwd: process.cwd() });
+    await client.initialize();
+
+    const initResult = await client.request<ThreadStartResult>('thread/start', {
+      cwd: process.cwd(),
+      approvalPolicy: 'never',
+      sandbox: 'read-only',
+    });
+    const threadId = initResult.thread.id;
+
+    const truncatedPrompt = userPrompt.slice(0, 500);
+    const truncatedResponse = (agentResponse || '').slice(0, 500);
+    const titlePrompt = `Generate a concise 3-5 word title for this conversation. Reply with only the title, nothing else.\n\nUser asked: "${truncatedPrompt}"\n\nAgent responded: "${truncatedResponse}"`;
+
+    // Set up promise to capture the title response
+    let titleResolve!: (value: string) => void;
+    let titleReject!: (error: Error) => void;
+    const titlePromise = new Promise<string>((resolve, reject) => {
+      titleResolve = resolve;
+      titleReject = reject;
+    });
+
+    // Capture agent_message text from item/completed
+    let titleResponse = '';
+    client.onNotification('item/completed', (params: unknown) => {
+      const p = params as ItemNotification;
+      if (p.threadId !== threadId) return;
+      if ((p.item.type === 'agentMessage' || p.item.type === 'agent_message') && p.item.text) {
+        titleResponse = p.item.text;
+      }
+    });
+
+    // Resolve on turn/completed
+    client.onNotification('turn/completed', (params: unknown) => {
+      const p = params as { threadId: string };
+      if (p.threadId !== threadId) return;
+      titleResolve(titleResponse);
+    });
+
+    // Reject on turn/failed
+    client.onNotification('turn/failed', (params: unknown) => {
+      const p = params as TurnFailedNotification;
+      if (p.threadId !== threadId) return;
+      titleReject(new Error(p.error.message));
+    });
+
+    // Set a timeout (30s)
+    const timeout = setTimeout(() => {
+      titleReject(new Error('Title generation timed out'));
+    }, 30_000);
+
+    // Send turn/start — events arrive via notifications
+    await client.request<TurnStartResult>('turn/start', {
+      threadId,
+      input: [{ type: 'text', text: titlePrompt }],
+      approvalPolicy: 'never',
+      sandbox: { type: 'read-only' },
+    });
+
+    const title = await titlePromise;
+    clearTimeout(timeout);
+
+    const cleanTitle = title.trim().replace(/^["']|["']$/g, '').slice(0, 100);
+
+    if (cleanTitle) {
+      const db = getDb();
+      const now = new Date().toISOString();
+      db.prepare('UPDATE sessions SET title = ?, updated_at = ? WHERE id = ?').run(cleanTitle, now, sessionId);
+      broadcast('session:title', { sessionId, title: cleanTitle });
     }
-
-    case 'turn.failed': {
-      db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?')
-        .run('failed', event.error.message, now, turnId);
-      db.prepare('UPDATE sessions SET is_running = 0, status = ?, updated_at = ? WHERE id = ?')
-        .run('failed', now, sessionId);
-      broadcast('turn:failed', { sessionId, turnId, error: event.error.message });
-      break;
+  } catch {
+    // Silently skip on error — session keeps null title
+  } finally {
+    if (client) {
+      await client.close().catch(() => {});
     }
+  }
+}
 
-    case 'error': {
-      db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?')
-        .run('failed', event.message, now, turnId);
-      db.prepare('UPDATE sessions SET is_running = 0, status = ?, updated_at = ? WHERE id = ?')
-        .run('failed', now, sessionId);
-      broadcast('turn:failed', { sessionId, turnId, error: event.message });
-      break;
-    }
+// --- Provider interface ---
+
+/** Map SDK effort values to UI labels. */
+const EFFORT_LABELS: Record<string, string> = {
+  minimal: 'Minimal',
+  low: 'Low',
+  medium: 'Medium',
+  high: 'High',
+  xhigh: 'Extra High',
+  max: 'Max',
+  ultra: 'Ultra',
+};
+
+/** Fetch available models from the shared app-server and map to ModelInfo[]. */
+async function getModels(): Promise<ModelInfo[]> {
+  try {
+    const result = await getSharedAppServer().request<ModelListResult>('model/list', {});
+    return (result.data ?? []).map((m) => ({
+      slug: m.id,
+      displayName: m.displayName,
+      description: m.description,
+      defaultReasoning: m.defaultReasoningEffort,
+      reasoningLevels: (m.supportedReasoningEfforts ?? []).map((r) => ({
+        effort: r.reasoningEffort,
+        label: EFFORT_LABELS[r.reasoningEffort] ?? r.reasoningEffort,
+      })),
+    }));
+  } catch {
+    return [];
   }
 }
 
-function makeItem(
-  id: string,
-  turnId: string,
-  sdkItem: ThreadItem,
-  status: ItemStatus,
-  createdAt: string,
-  updatedAt: string,
-): Item {
-  return {
-    id,
-    turn_id: turnId,
-    external_item_id: sdkItem.id,
-    type: sdkItem.type,
-    data: mapItemData(sdkItem),
-    status,
-    created_at: createdAt,
-    updated_at: updatedAt,
-  };
-}
+/** Graceful shutdown — close shared metadata process and all per-session clients. */
+async function shutdown(): Promise<void> {
+  await closeSharedAppServer();
+  clearAllThreads();
+}
+
+/** Codex provider — implements RuntimeProvider interface. */
+export const codexProvider: RuntimeProvider = {
+  startTurn,
+  interruptTurn,
+  clearThread,
+  clearAllThreads,
+  getModels,
+  shutdown,
+};