@hienlh/ppm 0.9.0-beta.3 → 0.9.0-beta.4

package/src/providers/registry.ts

@@ -19,11 +19,17 @@ class ProviderRegistry {
     return this.providers.get(id);
   }
 
+  /** List providers visible to users (excludes internal-only providers like mock) */
   list(): ProviderInfo[] {
-    return Array.from(this.providers.values()).map((p) => ({
-      id: p.id,
-      name: p.name,
-    }));
+    return Array.from(this.providers.values())
+      .filter((p) => p.id !== "mock")
+      .map((p) => ({ id: p.id, name: p.name }));
+  }
+
+  /** List all registered providers including internal ones (for ChatService aggregation) */
+  listAll(): ProviderInfo[] {
+    return Array.from(this.providers.values())
+      .map((p) => ({ id: p.id, name: p.name }));
   }
 
   /** Get the default provider based on config's default_provider */
@@ -40,5 +46,38 @@ class ProviderRegistry {
 
 /** Singleton registry */
 export const providerRegistry = new ProviderRegistry();
+
+// SDK providers registered synchronously (no binary check needed)
 providerRegistry.register(new ClaudeAgentSdkProvider());
 providerRegistry.register(new MockProvider()); // testing only
+
+/**
+ * Bootstrap CLI providers asynchronously.
+ * Checks isAvailable() before registering — call at server startup.
+ */
+export async function bootstrapProviders(): Promise<void> {
+  try {
+    const { CursorCliProvider } = await import("./cursor-cli/cursor-provider.ts");
+    const cursor = new CursorCliProvider();
+    if (await cursor.isAvailable()) {
+      providerRegistry.register(cursor);
+      // Ensure config has an entry for cursor so settings UI shows it
+      const ai = configService.get("ai");
+      if (!ai.providers["cursor"]) {
+        configService.set("ai", {
+          ...ai,
+          providers: {
+            ...ai.providers,
+            cursor: { type: "cli", cli_command: "cursor-agent", permission_mode: "bypassPermissions" },
+          },
+        });
+        configService.save();
+      }
+      console.log("[registry] Cursor provider registered (cursor-agent found)");
+    } else {
+      console.log("[registry] Cursor provider skipped (cursor-agent not found)");
+    }
+  } catch (e) {
+    console.warn("[registry] Failed to load Cursor provider:", (e as Error).message);
+  }
+}

package/src/server/index.ts

@@ -14,6 +14,7 @@ import { databaseRoutes } from "./routes/database.ts";
 import { fsBrowseRoutes } from "./routes/fs-browse.ts";
 import { accountsRoutes } from "./routes/accounts.ts";
 import { proxyRoutes } from "./routes/proxy.ts";
+import { browserPreviewRoutes } from "./routes/browser-preview.ts";
 import { initAdapters } from "../services/database/init-adapters.ts";
 import { terminalWebSocket } from "./ws/terminal.ts";
 import { chatWebSocket } from "./ws/chat.ts";
@@ -126,6 +127,9 @@ app.route("/proxy", proxyRoutes);
 app.use("/api/*", authMiddleware);
 app.get("/api/auth/check", (c) => c.json(ok(true)));
 
+// Browser preview reverse proxy — proxies to localhost:<port> for iframe embedding
+app.route("/api/preview", browserPreviewRoutes);
+
 // Filesystem operations (browse, list, read, write) — consolidated in fs-browse route
 app.route("/api/fs", fsBrowseRoutes);
 
@@ -166,6 +170,10 @@ export async function startServer(options: {
   // Setup log file (both foreground and daemon modes)
   await setupLogFile();
 
+  // Bootstrap CLI providers (checks binary availability)
+  const { bootstrapProviders } = await import("../providers/registry.ts");
+  await bootstrapProviders();
+
   // Check if port is already in use before starting.
   // Skip in hot-reload mode — Bun.serve() replaces the previous server on the same port,
   // but a net.createServer() probe would see it as "in use" and exit prematurely.

package/src/server/routes/browser-preview.ts

@@ -0,0 +1,89 @@
+import { Hono } from "hono";
+
+/**
+ * Browser preview reverse proxy — forwards requests to localhost:<port>.
+ * Mounted at /api/preview/:port/* so the frontend iframe can load
+ * any localhost dev server through PPM's own origin (avoiding CORS/framing issues).
+ */
+export const browserPreviewRoutes = new Hono();
+
+/** Only allow proxying to localhost ports (security: prevent SSRF) */
+function isValidPort(port: string): boolean {
+  const n = parseInt(port, 10);
+  return !isNaN(n) && n >= 1 && n <= 65535;
+}
+
+browserPreviewRoutes.all("/:port{[0-9]+}/*", async (c) => {
+  const port = c.req.param("port");
+  if (!isValidPort(port)) {
+    return c.text("Invalid port", 400);
+  }
+
+  // Build target URL — strip the /api/preview/:port prefix
+  const url = new URL(c.req.url);
+  const prefix = `/api/preview/${port}`;
+  const targetPath = url.pathname.slice(prefix.length) || "/";
+  const targetUrl = `http://localhost:${port}${targetPath}${url.search}`;
+
+  try {
+    // Forward the request with original method, headers, and body
+    const headers = new Headers(c.req.raw.headers);
+    // Remove host header so target server sees localhost
+    headers.delete("host");
+
+    const resp = await fetch(targetUrl, {
+      method: c.req.method,
+      headers,
+      body: ["GET", "HEAD"].includes(c.req.method) ? undefined : c.req.raw.body,
+      redirect: "manual",
+    });
+
+    // Clone response headers, remove framing restrictions so iframe works
+    const respHeaders = new Headers(resp.headers);
+    respHeaders.delete("x-frame-options");
+    respHeaders.delete("content-security-policy");
+
+    return new Response(resp.body, {
+      status: resp.status,
+      statusText: resp.statusText,
+      headers: respHeaders,
+    });
+  } catch {
+    return c.text(`Cannot connect to localhost:${port}`, 502);
+  }
+});
+
+// Handle root path (no trailing slash)
+browserPreviewRoutes.all("/:port{[0-9]+}", async (c) => {
+  const port = c.req.param("port");
+  if (!isValidPort(port)) {
+    return c.text("Invalid port", 400);
+  }
+
+  const url = new URL(c.req.url);
+  const targetUrl = `http://localhost:${port}/${url.search}`;
+
+  try {
+    const headers = new Headers(c.req.raw.headers);
+    headers.delete("host");
+
+    const resp = await fetch(targetUrl, {
+      method: c.req.method,
+      headers,
+      body: ["GET", "HEAD"].includes(c.req.method) ? undefined : c.req.raw.body,
+      redirect: "manual",
+    });
+
+    const respHeaders = new Headers(resp.headers);
+    respHeaders.delete("x-frame-options");
+    respHeaders.delete("content-security-policy");
+
+    return new Response(resp.body, {
+      status: resp.status,
+      statusText: resp.statusText,
+      headers: respHeaders,
+    });
+  } catch {
+    return c.text(`Cannot connect to localhost:${port}`, 502);
+  }
+});

package/src/server/routes/chat.ts

@@ -57,6 +57,19 @@ chatRoutes.get("/providers", (c) => {
   }
 });
 
+/** GET /chat/providers/:providerId/models — list available models for a provider */
+chatRoutes.get("/providers/:providerId/models", async (c) => {
+  try {
+    const providerId = c.req.param("providerId");
+    const provider = providerRegistry.get(providerId);
+    if (!provider) return c.json(err(`Provider "${providerId}" not found`), 404);
+    const models = await provider.listModels?.() ?? [];
+    return c.json(ok(models));
+  } catch (e) {
+    return c.json(err((e as Error).message), 500);
+  }
+});
+
 /** GET /chat/sessions — list chat sessions filtered by project from context */
 chatRoutes.get("/sessions", async (c) => {
   try {
@@ -146,9 +159,7 @@ chatRoutes.post("/sessions/:id/fork", async (c) => {
     });
     // Store fork source so WS handler knows to use forkSession on first message
     const provider = providerRegistry.get(providerId);
-    if (provider && "setForkSource" in provider) {
-      (provider as any).setForkSource(session.id, sourceId);
-    }
+    provider?.setForkSource?.(session.id, sourceId);
     return c.json(ok({ ...session, forkedFrom: sourceId }), 201);
   } catch (e) {
     return c.json(err((e as Error).message), 500);

package/src/server/routes/settings.ts

@@ -11,6 +11,7 @@ import {
 } from "../../types/config.ts";
 import { ok, err } from "../../types/api.ts";
 import { proxyService } from "../../services/proxy.service.ts";
+import { providerRegistry } from "../../providers/registry.ts";
 
 export const settingsRoutes = new Hono();
 
@@ -155,6 +156,19 @@ settingsRoutes.put("/ai", async (c) => {
   }
 });
 
+/** GET /settings/ai/providers/:id/models — list models for a provider (global, no project context needed) */
+settingsRoutes.get("/ai/providers/:id/models", async (c) => {
+  try {
+    const id = c.req.param("id");
+    const provider = providerRegistry.get(id);
+    if (!provider) return c.json(err(`Provider "${id}" not found`), 404);
+    const models = await provider.listModels?.() ?? [];
+    return c.json(ok(models));
+  } catch (e) {
+    return c.json(err((e as Error).message), 500);
+  }
+});
+
 // ── Keybindings ──────────────────────────────────────────────────────
 
 const KEYBINDINGS_KEY = "keybindings";

package/src/server/ws/chat.ts

@@ -22,6 +22,7 @@ type ChatWsSocket = {
 interface SessionEntry {
   providerId: string;
   clients: Set<ChatWsSocket>;
+  abort?: AbortController;
   projectPath?: string;
   projectName?: string;
   pingIntervals: Map<ChatWsSocket, ReturnType<typeof setInterval>>;
@@ -31,8 +32,6 @@ interface SessionEntry {
   turnEvents: unknown[];
   streamPromise?: Promise<void>;
   permissionMode?: string;
-  /** Whether the persistent event consumer loop is running */
-  isStreamingActive: boolean;
 }
 
 /** Tracks active sessions — persists even when FE disconnects */
@@ -126,11 +125,6 @@ function startCleanupTimer(sessionId: string): void {
   entry.cleanupTimer = setTimeout(() => {
     console.log(`[chat] session=${sessionId} cleanup: no FE reconnected within timeout`);
     logSessionEvent(sessionId, "INFO", "Session cleaned up (no FE reconnected)");
-    // Close streaming session in provider
-    const provider = providerRegistry.get(entry.providerId);
-    if (provider && "closeStreamingSession" in provider) {
-      (provider as any).closeStreamingSession(sessionId);
-    }
     for (const interval of entry.pingIntervals.values()) clearInterval(interval);
     entry.pingIntervals.clear();
     activeSessions.delete(sessionId);
@@ -138,25 +132,28 @@ function startCleanupTimer(sessionId: string): void {
 }
 
 /**
- * Persistent event consumer — runs for the entire session lifetime.
- * First message creates the query; follow-ups push into the provider's
- * message channel. Events from ALL turns flow through this single loop.
+ * Standalone streaming loop — decoupled from WS message handler.
+ * Runs independently so WS close does NOT kill the Claude query.
  */
-async function startSessionConsumer(sessionId: string, providerId: string, content: string, permissionMode?: string, images?: Array<{ data: string; mediaType: string }>): Promise<void> {
+async function runStreamLoop(initialSessionId: string, providerId: string, content: string, permissionMode?: string): Promise<void> {
+  let sessionId = initialSessionId;
   const entry = activeSessions.get(sessionId);
   if (!entry) {
-    console.error(`[chat] session=${sessionId} startSessionConsumer: no entry — aborting`);
+    console.error(`[chat] session=${sessionId} runStreamLoop: no entry — aborting`);
     return;
   }
-  console.log(`[chat] session=${sessionId} startSessionConsumer started (clients=${entry.clients.size})`);
+  const streamStartMs = Date.now();
+  console.log(`[chat] session=${sessionId} runStreamLoop started (clients=${entry.clients.size})`);
 
-  entry.isStreamingActive = true;
+  const abortController = new AbortController();
+  entry.abort = abortController;
   entry.pendingApprovalEvent = undefined;
   entry.turnEvents = [];
   setPhase(sessionId, "connecting");
 
   let heartbeat: ReturnType<typeof setInterval> | undefined;
   let lastContextWindowPct: number | undefined;
+  let doneEmitted = false;
 
   try {
     const userPreview = content.slice(0, 200);
@@ -165,12 +162,12 @@ async function startSessionConsumer(sessionId: string, providerId: string, conte
 
     let eventCount = 0;
     let firstEventReceived = false;
-    let startTime = Date.now();
+    const startTime = Date.now();
 
     // Heartbeat: while waiting for first response, send elapsed time every 5s
     const CONNECTION_TIMEOUT_S = 120;
     heartbeat = setInterval(() => {
-      if (firstEventReceived) {
+      if (firstEventReceived || abortController.signal.aborted) {
         clearInterval(heartbeat);
         return;
       }
@@ -189,23 +186,44 @@ async function startSessionConsumer(sessionId: string, providerId: string, conte
           type: "error",
           message: `Claude SDK timed out after ${elapsed}s for project "${projectPath || "(no project)"}".${wslHint}\n\nDebug steps:\n1. Run: \`${debugCmd}\` — if it also hangs, the issue is your Claude CLI environment\n2. Check env vars: \`echo $ANTHROPIC_API_KEY $ANTHROPIC_BASE_URL\` — stale/invalid keys cause silent hang\n3. Try with env cleared: \`ANTHROPIC_API_KEY="" ANTHROPIC_BASE_URL="" ${debugCmd}\`\n4. Check hooks/MCP: \`cat ${projectPath}/.claude/settings.local.json\`\n5. Refresh auth: \`claude login\``,
         });
+        abortController.abort();
         return;
       }
+      // Heartbeat uses broadcast() directly — NOT setPhase() (same-phase guard would skip elapsed updates)
       broadcast(sessionId, { type: "phase_changed", phase: "connecting", elapsed });
     }, 5_000);
 
-    for await (const event of chatService.sendMessage(providerId, sessionId, content, { permissionMode, images })) {
+    for await (const event of chatService.sendMessage(providerId, sessionId, content, { permissionMode })) {
+      if (abortController.signal.aborted) break;
       eventCount++;
       const ev = event as any;
       const evType = ev.type ?? "unknown";
 
-      // System events → transition connecting → thinking
+      // Session ID migrated: CLI provider assigned a different ID than PPM generated.
+      // Migrate activeSessions key so all subsequent events use the real ID.
+      if (evType === "session_migrated") {
+        const { oldSessionId, newSessionId } = ev;
+        const migrated = activeSessions.get(oldSessionId);
+        if (migrated) {
+          activeSessions.delete(oldSessionId);
+          activeSessions.set(newSessionId, migrated);
+          sessionId = newSessionId; // update local ref for subsequent setPhase/broadcast calls
+          // Notify frontend to update its sessionId state
+          broadcast(newSessionId, { type: "session_migrated", oldSessionId, newSessionId });
+          console.log(`[chat] session migrated: ${oldSessionId} → ${newSessionId}`);
+          logSessionEvent(newSessionId, "INFO", `Session ID migrated from ${oldSessionId}`);
+        }
+        continue;
+      }
+
+      // System events (hook_started, init, etc.) → transition connecting → thinking
+      // These indicate SDK has connected and is processing, but no content yet.
       if (evType === "system") {
         if (!firstEventReceived) {
           if (heartbeat) clearInterval(heartbeat);
           setPhase(sessionId, "thinking");
         }
-        continue;
+        continue; // Don't buffer or broadcast system events
       }
 
       // First content event — stop heartbeat, transition phase
@@ -238,11 +256,10 @@ async function startSessionConsumer(sessionId: string, providerId: string, conte
         console.error(`[chat] session=${sessionId} error: ${errorDetail}`);
         logSessionEvent(sessionId, "ERROR", errorDetail);
       } else if (evType === "done") {
-        // Turn complete — transition to idle, clear buffer for next turn
+        doneEmitted = true;
         logSessionEvent(sessionId, "DONE", `subtype=${ev.resultSubtype ?? "none"} turns=${ev.numTurns ?? "?"} ctx=${ev.contextWindowPct ?? "?"}%`);
         if (ev.contextWindowPct != null) lastContextWindowPct = ev.contextWindowPct;
-
-        // Fire-and-forget: title + notification
+        // Fire-and-forget: fetch updated session title from SDK summary
         sdkListSessions({ dir: entry.projectPath, limit: 50 }).then((sessions) => {
           const found = sessions.find((s) => s.sessionId === sessionId || s.sessionId === ev.sessionId);
           const title = found?.customTitle ?? found?.summary;
@@ -252,6 +269,7 @@ async function startSessionConsumer(sessionId: string, providerId: string, conte
             if (session) session.title = title;
           }
         }).catch(() => {});
+        // Fire-and-forget notification broadcast (push + telegram)
         import("../../services/notification.service.ts").then(({ notificationService }) => {
           const project = entry.projectName || "Project";
           const session = chatService.getSession(sessionId);
@@ -266,6 +284,7 @@ async function startSessionConsumer(sessionId: string, providerId: string, conte
         }).catch(() => {});
       } else if (evType === "approval_request") {
         entry.pendingApprovalEvent = ev;
+        // Fire-and-forget notification for approval/question
         import("../../services/notification.service.ts").then(({ notificationService }) => {
           const project = entry.projectName || "Project";
           const session = chatService.getSession(sessionId);
@@ -284,40 +303,32 @@ async function startSessionConsumer(sessionId: string, providerId: string, conte
 
       // Buffer + broadcast content events
       bufferAndBroadcast(sessionId, event);
-
-      // After "done", transition to idle + clear turn buffer for next turn
-      // Consumer loop continues — query waits for next message in generator
-      if (evType === "done") {
-        entry.turnEvents = [];
-        entry.pendingApprovalEvent = undefined;
-        setPhase(sessionId, "idle");
-        // Reset heartbeat tracking for next turn
-        firstEventReceived = false;
-        startTime = Date.now();
-      }
     }
 
-    logSessionEvent(sessionId, "INFO", `Session consumer completed (${eventCount} events total)`);
-    console.log(`[chat] session=${sessionId} session consumer completed (${eventCount} events)`);
+    logSessionEvent(sessionId, "INFO", `Stream completed (${eventCount} events)`);
+    console.log(`[chat] session=${sessionId} stream completed (${eventCount} events)`);
   } catch (e) {
     const errMsg = (e as Error).message;
     logSessionEvent(sessionId, "ERROR", `Exception: ${errMsg}`);
-    bufferAndBroadcast(sessionId, { type: "error", message: errMsg });
+    if (!abortController.signal.aborted) {
+      bufferAndBroadcast(sessionId, { type: "error", message: errMsg });
+    }
   } finally {
     if (heartbeat) clearInterval(heartbeat);
-    entry.isStreamingActive = false;
+    // 1. Buffer and broadcast done event (skip if SDK already yielded one)
+    if (!doneEmitted) {
+      bufferAndBroadcast(sessionId, { type: "done", sessionId, contextWindowPct: lastContextWindowPct });
+    }
+    // 2. Clear buffer BEFORE setting phase to idle
     entry.turnEvents = [];
+    // 3. Transition to idle
     setPhase(sessionId, "idle");
+    // 4. Cleanup
+    entry.abort = undefined;
     entry.pendingApprovalEvent = undefined;
-    // Close streaming session in provider
-    const provider = providerRegistry.get(entry.providerId);
-    if (provider && "closeStreamingSession" in provider) {
-      (provider as any).closeStreamingSession(sessionId);
-    }
     if (entry.clients.size === 0) {
       startCleanupTimer(sessionId);
     }
-    console.log(`[chat] session=${sessionId} consumer loop ended`);
   }
 }
 
@@ -393,7 +404,6 @@ export const chatWebSocket = {
       pingIntervals: new Map(),
       phase: "idle",
       turnEvents: [],
-      isStreamingActive: false,
     };
     activeSessions.set(sessionId, newEntry);
     setupClientPing(newEntry, ws);
@@ -443,7 +453,7 @@ export const chatWebSocket = {
       if (pn) { try { pp = resolveProjectPath(pn); } catch { /* ignore */ } }
       const newEntry: SessionEntry = {
         providerId: pid, clients: new Set([ws]), projectPath: pp, projectName: pn,
-        pingIntervals: new Map(), phase: "idle", turnEvents: [], isStreamingActive: false,
+        pingIntervals: new Map(), phase: "idle", turnEvents: [],
       };
       activeSessions.set(sessionId, newEntry);
       setupClientPing(newEntry, ws);
@@ -480,78 +490,53 @@ export const chatWebSocket = {
         ws.send(JSON.stringify({ type: "error", message: "Message content is required" }));
         return;
       }
-      // Validate image payload
-      if (parsed.images?.length) {
-        if (parsed.images.length > 5) {
-          ws.send(JSON.stringify({ type: "error", message: "Max 5 images per message" }));
-          return;
-        }
-        const MAX_BASE64_SIZE = 7_000_000; // ~5MB decoded
-        const SUPPORTED_TYPES = new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
-        for (const img of parsed.images) {
-          if (img.data.length > MAX_BASE64_SIZE) {
-            ws.send(JSON.stringify({ type: "error", message: "Image too large (max 5MB)" }));
-            return;
-          }
-          if (!SUPPORTED_TYPES.has(img.mediaType)) {
-            ws.send(JSON.stringify({ type: "error", message: `Unsupported image type: ${img.mediaType}` }));
-            return;
-          }
-        }
-      }
       // Store permission mode — sticky for this session
       if (parsed.permissionMode) {
         entry.permissionMode = parsed.permissionMode;
       }
 
+      // Resume session in provider (can be slow on first call — sdkListSessions)
       const provider = providerRegistry.get(providerId);
-
-      if (!entry.isStreamingActive) {
-        // First message or post-crash recovery: start persistent consumer
-        // Resume session in provider (can be slow on first call — sdkListSessions)
-        if (provider && "resumeSession" in provider) {
-          const t0 = Date.now();
-          await (provider as any).resumeSession(sessionId);
-          const elapsed = Date.now() - t0;
-          if (elapsed > 500) {
-            console.warn(`[chat] session=${sessionId} resumeSession took ${elapsed}ms`);
-            logSessionEvent(sessionId, "PERF", `resumeSession took ${elapsed}ms`);
-          }
-        }
-        if (entry.projectPath && provider && "ensureProjectPath" in provider) {
-          (provider as any).ensureProjectPath(sessionId, entry.projectPath);
+      if (provider) {
+        const t0 = Date.now();
+        await provider.resumeSession(sessionId);
+        const elapsed = Date.now() - t0;
+        if (elapsed > 500) {
+          console.warn(`[chat] session=${sessionId} resumeSession took ${elapsed}ms`);
+          logSessionEvent(sessionId, "PERF", `resumeSession took ${elapsed}ms`);
         }
+      }
+      if (entry.projectPath && provider?.ensureProjectPath) {
+        provider.ensureProjectPath(sessionId, entry.projectPath);
+      }
 
-        entry.turnEvents = [];
-        setPhase(sessionId, "initializing");
-
-        const permMode = entry.permissionMode;
-        const msgImages = parsed.type === "message" ? parsed.images : undefined;
-        entry.streamPromise = new Promise<void>((resolve) => {
-          setTimeout(() => {
-            startSessionConsumer(sessionId, providerId, parsed.content, permMode, msgImages).then(resolve, resolve);
-          }, 0);
-        });
-      } else {
-        // Follow-up: push into existing generator via provider
-        if (provider && "pushMessage" in provider && parsed.type === "message") {
-          (provider as any).pushMessage(sessionId, parsed.content, {
-            priority: parsed.priority ?? 'next',
-            images: parsed.images,
-          });
+      // Abort-and-replace: if already streaming, abort current query and wait for cleanup
+      if (entry.phase !== "idle" && entry.abort) {
+        console.log(`[chat] session=${sessionId} aborting current query for new message`);
+        entry.abort.abort();
+        if (entry.streamPromise) {
+          await entry.streamPromise;
         }
-        // Clear turn events for new turn display + transition phase
-        entry.turnEvents = [];
-        entry.pendingApprovalEvent = undefined;
-        setPhase(sessionId, "thinking");
-        console.log(`[chat] session=${sessionId} follow-up pushed to generator`);
+        // Re-fetch entry after await — may have been mutated during cleanup
+        entry = activeSessions.get(sessionId)!;
+        if (!entry) return;
       }
+
+      // Reset for new query
+      entry.turnEvents = [];
+      setPhase(sessionId, "initializing");
+
+      // Store promise reference on entry to prevent GC from collecting the async operation.
+      // Use setTimeout(0) to detach from WS handler's async scope.
+      const permMode = entry.permissionMode;
+      entry.streamPromise = new Promise<void>((resolve) => {
+        setTimeout(() => {
+          runStreamLoop(sessionId, providerId, parsed.content, permMode).then(resolve, resolve);
+        }, 0);
+      });
     } else if (parsed.type === "cancel") {
-      // Interrupt current turn — session stays alive for next message
       const provider = providerRegistry.get(providerId);
-      if (provider && "abortQuery" in provider && typeof (provider as any).abortQuery === "function") {
-        (provider as any).abortQuery(sessionId);
-      }
+      provider?.abortQuery?.(sessionId);
     } else if (parsed.type === "approval_response") {
       const provider = providerRegistry.get(providerId);
       if (provider && typeof provider.resolveApproval === "function") {
@@ -574,7 +559,7 @@ export const chatWebSocket = {
     evictClient(entry, ws);
     console.log(`[chat] session=${sessionId} FE disconnected (phase=${entry.phase}, clients=${entry.clients.size})`);
 
-    if (entry.clients.size === 0 && !entry.isStreamingActive) {
+    if (entry.clients.size === 0 && entry.phase === "idle") {
       startCleanupTimer(sessionId);
     }
   },

package/src/services/chat.service.ts

@@ -7,7 +7,6 @@ import type {
   ChatMessage,
   SendMessageOpts,
 } from "../providers/provider.interface.ts";
-import { MockProvider } from "../providers/mock-provider.ts";
 
 class ChatService {
   async createSession(
@@ -34,19 +33,18 @@ class ChatService {
     if (providerId) {
       const provider = providerRegistry.get(providerId);
       if (!provider) throw new Error(`Provider "${providerId}" not found`);
-      // Pass dir to providers that support it (SDK provider)
-      if (dir && "listSessionsByDir" in provider) {
-        return (provider as any).listSessionsByDir(dir);
+      if (dir && provider.listSessionsByDir) {
+        return provider.listSessionsByDir(dir);
       }
       return provider.listSessions();
     }
     // Aggregate from all providers
     const all: SessionInfo[] = [];
-    for (const info of providerRegistry.list()) {
+    for (const info of providerRegistry.listAll()) {
       const provider = providerRegistry.get(info.id);
       if (provider) {
-        if (dir && "listSessionsByDir" in provider) {
-          all.push(...await (provider as any).listSessionsByDir(dir));
+        if (dir && provider.listSessionsByDir) {
+          all.push(...await provider.listSessionsByDir(dir));
         } else {
           all.push(...await provider.listSessions());
         }
@@ -83,13 +81,13 @@ class ChatService {
 
   /** Look up a session across all providers (for WS handler) */
   getSession(sessionId: string): Session | null {
-    for (const info of providerRegistry.list()) {
+    for (const info of providerRegistry.listAll()) {
       const provider = providerRegistry.get(info.id);
       if (!provider) continue;
-      const sessions = (provider as any).sessions as Map<string, unknown> | undefined;
-      if (sessions?.has(sessionId)) {
+      // Use internal sessions Map — SDK stores {meta, sdk}, others store Session directly
+      const sessions = (provider as any).sessions ?? (provider as any).activeSessions;
+      if (sessions instanceof Map && sessions.has(sessionId)) {
         const entry = sessions.get(sessionId);
-        // SDK provider stores {meta, sdk}, others store Session directly
         if (entry && typeof entry === "object" && "meta" in entry) {
           return (entry as { meta: Session }).meta;
         }
@@ -102,10 +100,7 @@ class ChatService {
   async getMessages(providerId: string, sessionId: string): Promise<ChatMessage[]> {
     const provider = providerRegistry.get(providerId);
     if (!provider) return [];
-    if ("getMessages" in provider && typeof (provider as any).getMessages === "function") {
-      return await (provider as any).getMessages(sessionId);
-    }
-    return [];
+    return await provider.getMessages?.(sessionId) ?? [];
   }
 }
 

package/src/types/api.ts

@@ -23,7 +23,7 @@ export type TerminalWsMessage =
 
 /** WebSocket message types (chat) */
 export type ChatWsClientMessage =
-  | { type: "message"; content: string; permissionMode?: string; priority?: 'now' | 'next' | 'later'; images?: Array<{ data: string; mediaType: string }> }
+  | { type: "message"; content: string; permissionMode?: string }
   | { type: "cancel" }
   | { type: "approval_response"; requestId: string; approved: boolean; reason?: string; data?: unknown }
   | { type: "ready" };