@hienlh/ppm 0.9.31 → 0.9.32

package/src/services/db.service.ts

@@ -4,7 +4,7 @@ import { homedir } from "node:os";
 import { mkdirSync, existsSync } from "node:fs";
 
 const PPM_DIR = process.env.PPM_HOME || resolve(homedir(), ".ppm");
-const CURRENT_SCHEMA_VERSION = 12;
+const CURRENT_SCHEMA_VERSION = 13;
 
 let db: Database | null = null;
 let dbProfile: string | null = null;
@@ -313,6 +313,80 @@ function runMigrations(database: Database): void {
       PRAGMA user_version = 12;
     `);
   }
+
+  if (current < 13) {
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS clawbot_sessions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        telegram_chat_id TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        provider_id TEXT NOT NULL DEFAULT 'claude',
+        project_name TEXT NOT NULL,
+        project_path TEXT NOT NULL,
+        is_active INTEGER NOT NULL DEFAULT 1,
+        created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+        last_message_at INTEGER NOT NULL DEFAULT (unixepoch())
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_clawbot_sessions_chat
+        ON clawbot_sessions(telegram_chat_id, is_active);
+      CREATE INDEX IF NOT EXISTS idx_clawbot_sessions_session
+        ON clawbot_sessions(session_id);
+
+      CREATE TABLE IF NOT EXISTS clawbot_memories (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        project TEXT NOT NULL,
+        content TEXT NOT NULL,
+        category TEXT NOT NULL DEFAULT 'fact',
+        importance REAL NOT NULL DEFAULT 1.0,
+        created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+        updated_at INTEGER NOT NULL DEFAULT (unixepoch()),
+        session_id TEXT,
+        superseded_by INTEGER REFERENCES clawbot_memories(id)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_clawbot_memories_project
+        ON clawbot_memories(project, superseded_by);
+      CREATE INDEX IF NOT EXISTS idx_clawbot_memories_importance
+        ON clawbot_memories(importance DESC);
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS clawbot_memories_fts USING fts5(
+        content,
+        content='clawbot_memories',
+        content_rowid='id'
+      );
+
+      -- FTS5 sync triggers
+      CREATE TRIGGER IF NOT EXISTS clawbot_memories_ai AFTER INSERT ON clawbot_memories BEGIN
+        INSERT INTO clawbot_memories_fts(rowid, content) VALUES (new.id, new.content);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS clawbot_memories_ad AFTER DELETE ON clawbot_memories BEGIN
+        INSERT INTO clawbot_memories_fts(clawbot_memories_fts, rowid, content) VALUES('delete', old.id, old.content);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS clawbot_memories_au AFTER UPDATE ON clawbot_memories BEGIN
+        INSERT INTO clawbot_memories_fts(clawbot_memories_fts, rowid, content) VALUES('delete', old.id, old.content);
+        INSERT INTO clawbot_memories_fts(rowid, content) VALUES (new.id, new.content);
+      END;
+
+      CREATE TABLE IF NOT EXISTS clawbot_paired_chats (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        telegram_chat_id TEXT NOT NULL UNIQUE,
+        telegram_user_id TEXT,
+        display_name TEXT,
+        pairing_code TEXT,
+        status TEXT NOT NULL DEFAULT 'pending',
+        created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+        approved_at INTEGER
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_clawbot_paired_status
+        ON clawbot_paired_chats(status);
+
+      PRAGMA user_version = 13;
+    `);
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -894,5 +968,209 @@ export function deleteExtensionStorage(extId: string): void {
   getDb().query("DELETE FROM extension_storage WHERE ext_id = ?").run(extId);
 }
 
+// ---------------------------------------------------------------------------
+// ClawBot session helpers
+// ---------------------------------------------------------------------------
+
+import type { ClawBotSessionRow, ClawBotMemoryRow, ClawBotPairedChat } from "../types/clawbot.ts";
+
+export function getActiveClawBotSession(
+  telegramChatId: string,
+  projectName: string,
+): ClawBotSessionRow | null {
+  return getDb().query(
+    `SELECT * FROM clawbot_sessions
+     WHERE telegram_chat_id = ? AND project_name = ? AND is_active = 1
+     ORDER BY last_message_at DESC LIMIT 1`,
+  ).get(telegramChatId, projectName) as ClawBotSessionRow | null;
+}
+
+export function createClawBotSession(
+  telegramChatId: string,
+  sessionId: string,
+  providerId: string,
+  projectName: string,
+  projectPath: string,
+): void {
+  getDb().query(
+    `INSERT INTO clawbot_sessions
+     (telegram_chat_id, session_id, provider_id, project_name, project_path)
+     VALUES (?, ?, ?, ?, ?)`,
+  ).run(telegramChatId, sessionId, providerId, projectName, projectPath);
+}
+
+export function deactivateClawBotSession(sessionId: string): void {
+  getDb().query(
+    "UPDATE clawbot_sessions SET is_active = 0 WHERE session_id = ?",
+  ).run(sessionId);
+}
+
+export function touchClawBotSession(sessionId: string): void {
+  getDb().query(
+    "UPDATE clawbot_sessions SET last_message_at = unixepoch() WHERE session_id = ?",
+  ).run(sessionId);
+}
+
+export function getRecentClawBotSessions(
+  telegramChatId: string,
+  limit = 10,
+): ClawBotSessionRow[] {
+  return getDb().query(
+    `SELECT * FROM clawbot_sessions
+     WHERE telegram_chat_id = ?
+     ORDER BY last_message_at DESC LIMIT ?`,
+  ).all(telegramChatId, limit) as ClawBotSessionRow[];
+}
+
+// ---------------------------------------------------------------------------
+// ClawBot memory helpers
+// ---------------------------------------------------------------------------
+
+export function insertClawBotMemory(
+  project: string,
+  content: string,
+  category: string,
+  importance: number,
+  sessionId?: string,
+): number {
+  const result = getDb().query(
+    `INSERT INTO clawbot_memories (project, content, category, importance, session_id)
+     VALUES (?, ?, ?, ?, ?)`,
+  ).run(project, content, category, importance, sessionId ?? null);
+  return Number(result.lastInsertRowid);
+}
+
+export function searchClawBotMemories(
+  project: string,
+  query: string,
+  limit = 20,
+): Array<ClawBotMemoryRow & { rank: number }> {
+  return getDb().query(
+    `SELECT m.*, fts.rank
+     FROM clawbot_memories m
+     JOIN clawbot_memories_fts fts ON m.id = fts.rowid
+     WHERE clawbot_memories_fts MATCH ?
+       AND m.project IN (?, '_global')
+       AND m.superseded_by IS NULL
+     ORDER BY fts.rank
+     LIMIT ?`,
+  ).all(query, project, limit) as Array<ClawBotMemoryRow & { rank: number }>;
+}
+
+export function getClawBotMemories(
+  project: string,
+  limit = 20,
+): ClawBotMemoryRow[] {
+  return getDb().query(
+    `SELECT * FROM clawbot_memories
+     WHERE project IN (?, '_global')
+       AND superseded_by IS NULL
+     ORDER BY importance DESC, updated_at DESC
+     LIMIT ?`,
+  ).all(project, limit) as ClawBotMemoryRow[];
+}
+
+export function supersedeClawBotMemory(
+  oldId: number,
+  newId: number,
+): void {
+  getDb().query(
+    "UPDATE clawbot_memories SET superseded_by = ? WHERE id = ?",
+  ).run(newId, oldId);
+}
+
+export function deleteClawBotMemoriesByTopic(
+  project: string,
+  topic: string,
+): number {
+  const matches = getDb().query(
+    `SELECT m.id FROM clawbot_memories m
+     JOIN clawbot_memories_fts fts ON m.id = fts.rowid
+     WHERE clawbot_memories_fts MATCH ?
+       AND m.project IN (?, '_global')
+       AND m.superseded_by IS NULL`,
+  ).all(topic, project) as { id: number }[];
+
+  for (const row of matches) {
+    getDb().query("DELETE FROM clawbot_memories WHERE id = ?").run(row.id);
+  }
+  return matches.length;
+}
+
+export function decayClawBotMemories(): void {
+  getDb().query(
+    `UPDATE clawbot_memories
+     SET importance = importance * 0.95,
+         updated_at = unixepoch()
+     WHERE superseded_by IS NULL
+       AND category NOT IN ('preference', 'architecture')
+       AND updated_at < unixepoch() - 604800`,
+  ).run();
+  getDb().query(
+    `DELETE FROM clawbot_memories WHERE importance < 0.1 AND superseded_by IS NULL`,
+  ).run();
+}
+
+// ---------------------------------------------------------------------------
+// ClawBot pairing helpers
+// ---------------------------------------------------------------------------
+
+export function createPairingRequest(
+  chatId: string,
+  userId: string,
+  displayName: string,
+  code: string,
+): void {
+  getDb().query(
+    `INSERT INTO clawbot_paired_chats (telegram_chat_id, telegram_user_id, display_name, pairing_code, status)
+     VALUES (?, ?, ?, ?, 'pending')
+     ON CONFLICT(telegram_chat_id) DO UPDATE SET
+       telegram_user_id = excluded.telegram_user_id,
+       display_name = excluded.display_name,
+       pairing_code = excluded.pairing_code,
+       status = 'pending',
+       approved_at = NULL`,
+  ).run(chatId, userId, displayName, code);
+}
+
+export function approvePairing(chatId: string): void {
+  getDb().query(
+    `UPDATE clawbot_paired_chats
+     SET status = 'approved', pairing_code = NULL, approved_at = unixepoch()
+     WHERE telegram_chat_id = ? AND status = 'pending'`,
+  ).run(chatId);
+}
+
+export function revokePairing(chatId: string): void {
+  getDb().query(
+    "UPDATE clawbot_paired_chats SET status = 'revoked' WHERE telegram_chat_id = ?",
+  ).run(chatId);
+}
+
+export function getPairingByCode(code: string): ClawBotPairedChat | null {
+  return getDb().query(
+    "SELECT * FROM clawbot_paired_chats WHERE pairing_code = ? AND status = 'pending'",
+  ).get(code) as ClawBotPairedChat | null;
+}
+
+export function getPairingByChatId(chatId: string): ClawBotPairedChat | null {
+  return getDb().query(
+    "SELECT * FROM clawbot_paired_chats WHERE telegram_chat_id = ?",
+  ).get(chatId) as ClawBotPairedChat | null;
+}
+
+export function listPairedChats(): ClawBotPairedChat[] {
+  return getDb().query(
+    "SELECT * FROM clawbot_paired_chats WHERE status != 'revoked' ORDER BY created_at DESC",
+  ).all() as ClawBotPairedChat[];
+}
+
+export function isPairedChat(chatId: string): boolean {
+  const row = getDb().query(
+    "SELECT 1 FROM clawbot_paired_chats WHERE telegram_chat_id = ? AND status = 'approved'",
+  ).get(chatId);
+  return row != null;
+}
+
 // Auto-close on process exit
 process.on("beforeExit", closeDb);

package/src/services/proxy-openai-bridge.ts

@@ -0,0 +1,241 @@
+/**
+ * OpenAI-compatible proxy bridge — converts OpenAI Chat Completions
+ * requests into SDK query() calls and returns OpenAI-format responses.
+ *
+ * Endpoint: POST /proxy/v1/chat/completions
+ * Reference: https://github.com/fuergaosi233/claude-code-proxy
+ */
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { accountSelector } from "./account-selector.service.ts";
+
+// ── Helpers ──────────────────────────────────────────────────────────
+
+function mapModelToSdkModel(model: string): "sonnet" | "opus" | "haiku" {
+  if (model.includes("opus")) return "opus";
+  if (model.includes("haiku")) return "haiku";
+  return "sonnet";
+}
+
+function buildSdkEnv(accessToken: string): Record<string, string | undefined> {
+  const isOAuth = accessToken.startsWith("sk-ant-oat");
+  return {
+    ...process.env,
+    ANTHROPIC_API_KEY: isOAuth ? "" : accessToken,
+    CLAUDE_CODE_OAUTH_TOKEN: isOAuth ? accessToken : "",
+    ANTHROPIC_BASE_URL: "",
+  };
+}
+
+/** Extract system prompt and build text prompt from OpenAI messages format */
+function buildPromptFromOpenAiMessages(body: any): { prompt: string; systemPrompt?: string } {
+  const messages: any[] = body.messages ?? [];
+  let systemPrompt: string | undefined;
+  const conversationParts: string[] = [];
+
+  for (const m of messages) {
+    const text = typeof m.content === "string"
+      ? m.content
+      : Array.isArray(m.content)
+        ? m.content.filter((b: any) => b.type === "text").map((b: any) => b.text).join("\n")
+        : String(m.content ?? "");
+
+    if (m.role === "system") {
+      systemPrompt = systemPrompt ? `${systemPrompt}\n${text}` : text;
+    } else {
+      const role = m.role === "assistant" ? "Assistant" : "Human";
+      conversationParts.push(`${role}: ${text}`);
+    }
+  }
+
+  return { prompt: conversationParts.join("\n\n"), systemPrompt };
+}
+
+function openAiError(status: number, message: string): Response {
+  return new Response(JSON.stringify({
+    error: { message, type: "server_error", code: String(status) },
+  }), { status, headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" } });
+}
+
+// ── Public API ───────────────────────────────────────────────────────
+
+interface SdkAccount {
+  id: string;
+  email?: string | null;
+  accessToken: string;
+}
+
+/** Forward an OpenAI-format chat completions request via SDK query() */
+export async function forwardOpenAiViaSdk(body: any, account: SdkAccount): Promise<Response> {
+  const model = mapModelToSdkModel(body.model || "sonnet");
+  const stream = body.stream ?? false;
+  const { prompt, systemPrompt } = buildPromptFromOpenAiMessages(body);
+  const env = buildSdkEnv(account.accessToken);
+
+  console.log(`[proxy-openai] ${stream ? "stream" : "non-stream"} → ${model} via ${account.email ?? account.id}`);
+
+  if (!stream) return handleNonStreaming(prompt, systemPrompt, model, env, body, account);
+  return handleStreaming(prompt, systemPrompt, model, env, body, account);
+}
+
+// ── Non-streaming ────────────────────────────────────────────────────
+
+async function handleNonStreaming(
+  prompt: string, systemPrompt: string | undefined,
+  model: "sonnet" | "opus" | "haiku",
+  env: Record<string, string | undefined>,
+  body: any, account: SdkAccount,
+): Promise<Response> {
+  try {
+    let fullContent = "";
+    const response = query({
+      prompt,
+      options: { maxTurns: 1, model, env, ...(systemPrompt && { systemPrompt }) },
+    });
+
+    for await (const message of response) {
+      if (message.type === "assistant") {
+        for (const block of (message as any).message?.content ?? []) {
+          if (block.type === "text") fullContent += block.text;
+        }
+      }
+    }
+
+    accountSelector.onSuccess(account.id);
+
+    return new Response(JSON.stringify({
+      id: `chatcmpl-${Date.now()}`,
+      object: "chat.completion",
+      created: Math.floor(Date.now() / 1000),
+      model: body.model || "claude-sonnet-4-6",
+      choices: [{
+        index: 0,
+        message: { role: "assistant", content: fullContent },
+        finish_reason: "stop",
+      }],
+      usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+    }), {
+      status: 200,
+      headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" },
+    });
+  } catch (error) {
+    console.error(`[proxy-openai] Non-stream error:`, (error as Error).message);
+    accountSelector.onRateLimit(account.id);
+    return openAiError(502, (error as Error).message);
+  }
+}
+
+// ── Streaming ────────────────────────────────────────────────────────
+
+async function handleStreaming(
+  prompt: string, systemPrompt: string | undefined,
+  model: "sonnet" | "opus" | "haiku",
+  env: Record<string, string | undefined>,
+  body: any, account: SdkAccount,
+): Promise<Response> {
+  const encoder = new TextEncoder();
+  const chatId = `chatcmpl-${Date.now()}`;
+  const created = Math.floor(Date.now() / 1000);
+  const modelName = body.model || "claude-sonnet-4-6";
+
+  const chunk = (delta: any, finishReason: string | null) => ({
+    id: chatId, object: "chat.completion.chunk", created, model: modelName,
+    choices: [{ index: 0, delta, finish_reason: finishReason }],
+  });
+
+  const readable = new ReadableStream({
+    async start(controller) {
+      const send = (data: any) => {
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}\n\n`));
+      };
+
+      try {
+        const response = query({
+          prompt,
+          options: {
+            maxTurns: 1, model, env,
+            ...(systemPrompt && { systemPrompt }),
+            includePartialMessages: true,
+          },
+        });
+
+        // Initial chunk with role
+        send(chunk({ role: "assistant", content: "" }, null));
+
+        const skipBlockIndices = new Set<number>();
+        let streamed = false;
+        let lastContentLen = 0;
+
+        for await (const message of response) {
+          const msgType = (message as any).type;
+
+          // ── stream_event: raw Anthropic SSE events (best quality) ──
+          if (msgType === "stream_event") {
+            const event = (message as any).event;
+            const eventType = event.type as string;
+            const eventIndex = event.index as number | undefined;
+
+            if (eventType === "content_block_start" && event.content_block?.type === "tool_use") {
+              if (eventIndex !== undefined) skipBlockIndices.add(eventIndex);
+              continue;
+            }
+            if (eventIndex !== undefined && skipBlockIndices.has(eventIndex)) continue;
+
+            if (eventType === "content_block_delta" && event.delta?.type === "text_delta") {
+              const text = event.delta.text ?? "";
+              if (text) send(chunk({ content: text }, null));
+            }
+            if (eventType === "message_stop") send(chunk({}, "stop"));
+            streamed = true;
+            continue;
+          }
+
+          // ── partial: incremental content (fallback if no stream_event) ──
+          if (msgType === "partial" && !streamed) {
+            const content = (message as any).message?.content ?? [];
+            let fullText = "";
+            for (const block of content) {
+              if (block.type === "text") fullText += block.text ?? "";
+            }
+            const delta = fullText.slice(lastContentLen);
+            if (delta) {
+              send(chunk({ content: delta }, null));
+              lastContentLen = fullText.length;
+            }
+            continue;
+          }
+
+          // ── assistant: final message (fallback if nothing streamed) ──
+          if (msgType === "assistant" && !streamed && lastContentLen === 0) {
+            const content = (message as any).message?.content ?? [];
+            let fullText = "";
+            for (const block of content) {
+              if (block.type === "text") fullText += block.text ?? "";
+            }
+            if (fullText) send(chunk({ content: fullText }, null));
+          }
+        }
+
+        // Always send finish + DONE
+        if (!streamed) send(chunk({}, "stop"));
+        accountSelector.onSuccess(account.id);
+        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+        controller.close();
+      } catch (error) {
+        console.error(`[proxy-openai] Stream error:`, (error as Error).message);
+        accountSelector.onRateLimit(account.id);
+        send(chunk({ content: `\n\nError: ${(error as Error).message}` }, "stop"));
+        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+        controller.close();
+      }
+    },
+  });
+
+  return new Response(readable, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "Connection": "keep-alive",
+      "Access-Control-Allow-Origin": "*",
+    },
+  });
+}

package/src/services/proxy-sdk-bridge.ts

@@ -172,40 +172,82 @@ async function handleStreaming(
 
         // Track tool_use block indices to filter them out
         const skipBlockIndices = new Set<number>();
+        let streamed = false; // track if we sent any SSE events
+        let lastContentLen = 0; // for partial message diff
 
         try {
           for await (const message of response) {
-            if (message.type !== "stream_event") continue;
+            const msgType = (message as any).type;
 
-            const event = (message as any).event;
-            const eventType = event.type as string;
-            const eventIndex = event.index as number | undefined;
+            // ── stream_event: raw Anthropic SSE events (best quality) ──
+            if (msgType === "stream_event") {
+              const event = (message as any).event;
+              const eventType = event.type as string;
+              const eventIndex = event.index as number | undefined;
 
-            // Filter tool_use content blocks — external tools expect text only
-            if (eventType === "content_block_start") {
-              const block = event.content_block;
-              if (block?.type === "tool_use") {
+              if (eventType === "content_block_start" && event.content_block?.type === "tool_use") {
                 if (eventIndex !== undefined) skipBlockIndices.add(eventIndex);
                 continue;
               }
+              if (eventIndex !== undefined && skipBlockIndices.has(eventIndex)) continue;
+
+              if (eventType === "message_delta") {
+                const patched = {
+                  ...event,
+                  delta: { ...(event.delta || {}), stop_reason: "end_turn" },
+                  usage: event.usage || { output_tokens: 0 },
+                };
+                controller.enqueue(encoder.encode(`event: ${eventType}\ndata: ${JSON.stringify(patched)}\n\n`));
+              } else {
+                controller.enqueue(encoder.encode(`event: ${eventType}\ndata: ${JSON.stringify(event)}\n\n`));
+              }
+              streamed = true;
+              continue;
             }
 
-            // Skip deltas and stops for tool_use blocks
-            if (eventIndex !== undefined && skipBlockIndices.has(eventIndex)) continue;
-
-            // Override message_delta to always show end_turn
-            if (eventType === "message_delta") {
-              const patched = {
-                ...event,
-                delta: { ...(event.delta || {}), stop_reason: "end_turn" },
-                usage: event.usage || { output_tokens: 0 },
-              };
-              controller.enqueue(encoder.encode(`event: ${eventType}\ndata: ${JSON.stringify(patched)}\n\n`));
+            // ── partial: incremental content (fallback if no stream_event) ──
+            if (msgType === "partial" && !streamed) {
+              const content = (message as any).message?.content ?? [];
+              let fullText = "";
+              for (const block of content) {
+                if (block.type === "text") fullText += block.text ?? "";
+              }
+              const delta = fullText.slice(lastContentLen);
+              if (delta) {
+                // Emit Anthropic SSE envelope on first partial
+                if (lastContentLen === 0) {
+                  const msgStart = { type: "message_start", message: { id: `msg_${Date.now()}`, type: "message", role: "assistant", model: body.model, content: [], stop_reason: null, usage: { input_tokens: 0, output_tokens: 0 } } };
+                  controller.enqueue(encoder.encode(`event: message_start\ndata: ${JSON.stringify(msgStart)}\n\n`));
+                  controller.enqueue(encoder.encode(`event: content_block_start\ndata: ${JSON.stringify({ type: "content_block_start", index: 0, content_block: { type: "text", text: "" } })}\n\n`));
+                }
+                controller.enqueue(encoder.encode(`event: content_block_delta\ndata: ${JSON.stringify({ type: "content_block_delta", index: 0, delta: { type: "text_delta", text: delta } })}\n\n`));
+                lastContentLen = fullText.length;
+              }
               continue;
             }
 
-            // Forward all other events (message_start, text deltas, content_block_start/stop, message_stop)
-            controller.enqueue(encoder.encode(`event: ${eventType}\ndata: ${JSON.stringify(event)}\n\n`));
+            // ── assistant: final complete message (fallback if nothing streamed) ──
+            if (msgType === "assistant" && !streamed && lastContentLen === 0) {
+              const content = (message as any).message?.content ?? [];
+              let fullText = "";
+              for (const block of content) {
+                if (block.type === "text") fullText += block.text ?? "";
+              }
+              if (fullText) {
+                const msgStart = { type: "message_start", message: { id: `msg_${Date.now()}`, type: "message", role: "assistant", model: body.model, content: [], stop_reason: null, usage: { input_tokens: 0, output_tokens: 0 } } };
+                controller.enqueue(encoder.encode(`event: message_start\ndata: ${JSON.stringify(msgStart)}\n\n`));
+                controller.enqueue(encoder.encode(`event: content_block_start\ndata: ${JSON.stringify({ type: "content_block_start", index: 0, content_block: { type: "text", text: "" } })}\n\n`));
+                controller.enqueue(encoder.encode(`event: content_block_delta\ndata: ${JSON.stringify({ type: "content_block_delta", index: 0, delta: { type: "text_delta", text: fullText } })}\n\n`));
+                lastContentLen = fullText.length;
+              }
+            }
+          }
+
+          // Close SSE envelope if we used partial/assistant fallback
+          if (!streamed && lastContentLen > 0) {
+            controller.enqueue(encoder.encode(`event: content_block_stop\ndata: ${JSON.stringify({ type: "content_block_stop", index: 0 })}\n\n`));
+            controller.enqueue(encoder.encode(`event: message_delta\ndata: ${JSON.stringify({ type: "message_delta", delta: { stop_reason: "end_turn" }, usage: { output_tokens: 0 } })}\n\n`));
+            controller.enqueue(encoder.encode(`event: message_stop\ndata: ${JSON.stringify({ type: "message_stop" })}\n\n`));
           }
 
           accountSelector.onSuccess(account.id);