@cloudcli-ai/cloudcli 1.37.2 → 1.37.3

package/server/modules/user/user.service.ts

@@ -5,6 +5,14 @@ type GitConfig = {
   git_email: string | null;
 };
 
+/** One chat scope's unsent composer text and queued message. */
+type DraftRecord = {
+  scope: string;
+  text: string;
+  queuedMessage: unknown | null;
+  updatedAt: string;
+};
+
 type UserDependencies = {
   users: {
     getGitConfig(userId: number): GitConfig | undefined;
@@ -12,12 +20,65 @@ type UserDependencies = {
     completeOnboarding(userId: number): void;
     hasCompletedOnboarding(userId: number): boolean;
   };
+  preferences: {
+    getPreferences(userId: number): Record<string, unknown>;
+    savePreferences(userId: number, updates: Record<string, unknown>): void;
+  };
+  drafts: {
+    getDrafts(userId: number): DraftRecord[];
+    saveDraft(userId: number, scope: string, draft: { text: string; queuedMessage: unknown | null }): void;
+    deleteDraft(userId: number, scope: string): void;
+  };
   readSystemGitConfig(): Promise<GitConfig>;
   applyGlobalGitConfig(gitName: string, gitEmail: string): Promise<void>;
   logInfo(message: string): void;
   logError(message: string, error: unknown): void;
 };
 
+/**
+ * The longest a draft scope or preference key may be.
+ *
+ * Scopes are session UUIDs or `project:<id>`, and preference keys are fixed
+ * identifiers, so anything longer is a client bug or an attempt to use the
+ * table as general storage.
+ */
+const MAX_KEY_LENGTH = 200;
+
+/** Guards against a runaway composer filling the database with one row. */
+const MAX_DRAFT_TEXT_LENGTH = 100_000;
+
+const readDraftScope = (value: unknown): string => {
+  const scope = typeof value === 'string' ? value.trim() : '';
+  if (!scope || scope.length > MAX_KEY_LENGTH) {
+    throw new AppError('A draft scope of 1-200 characters is required', {
+      code: 'INVALID_DRAFT_SCOPE',
+      statusCode: 400,
+    });
+  }
+  return scope;
+};
+
+const readPreferenceUpdates = (body: unknown): Record<string, unknown> => {
+  if (!body || typeof body !== 'object' || Array.isArray(body)) {
+    throw new AppError('Preferences must be sent as an object', {
+      code: 'INVALID_PREFERENCES',
+      statusCode: 400,
+    });
+  }
+
+  const updates = body as Record<string, unknown>;
+  for (const key of Object.keys(updates)) {
+    if (!key || key.length > MAX_KEY_LENGTH) {
+      throw new AppError('Preference keys must be 1-200 characters', {
+        code: 'INVALID_PREFERENCE_KEY',
+        statusCode: 400,
+      });
+    }
+  }
+
+  return updates;
+};
+
 /** Creates user-profile workflows with explicit repository and Git adapters. */
 export function createUserService(dependencies: UserDependencies) {
   return {
@@ -81,5 +142,49 @@ export function createUserService(dependencies: UserDependencies) {
         hasCompletedOnboarding: dependencies.users.hasCompletedOnboarding(userId),
       };
     },
+
+    /** Every stored preference at once; the client fills gaps with its defaults. */
+    getPreferences(userId: number) {
+      return { success: true, preferences: dependencies.preferences.getPreferences(userId) };
+    },
+
+    /**
+     * Merge-patch: only the keys in the request body are touched, so two
+     * independent settings screens can save concurrently without one erasing
+     * the other's work.
+     */
+    savePreferences(userId: number, body: unknown) {
+      const updates = readPreferenceUpdates(body);
+      dependencies.preferences.savePreferences(userId, updates);
+      return { success: true, preferences: dependencies.preferences.getPreferences(userId) };
+    },
+
+    getDrafts(userId: number) {
+      return { success: true, drafts: dependencies.drafts.getDrafts(userId) };
+    },
+
+    saveDraft(userId: number, scopeInput: unknown, body: unknown) {
+      const scope = readDraftScope(scopeInput);
+      const payload = (body ?? {}) as { text?: unknown; queuedMessage?: unknown };
+      const text = typeof payload.text === 'string' ? payload.text : '';
+
+      if (text.length > MAX_DRAFT_TEXT_LENGTH) {
+        throw new AppError('Draft text is too long to store', {
+          code: 'DRAFT_TEXT_TOO_LONG',
+          statusCode: 413,
+        });
+      }
+
+      dependencies.drafts.saveDraft(userId, scope, {
+        text,
+        queuedMessage: payload.queuedMessage ?? null,
+      });
+      return { success: true };
+    },
+
+    deleteDraft(userId: number, scopeInput: unknown) {
+      dependencies.drafts.deleteDraft(userId, readDraftScope(scopeInput));
+      return { success: true };
+    },
   };
 }

package/server/modules/voice/tests/voice.service.test.ts

@@ -47,8 +47,9 @@ test('transcribes with injected fetch and request-level credential/model overrid
 
   assert.deepEqual(result, { ok: true, value: { text: 'hello' } });
   assert.equal(requestedUrl, 'https://voice.example/v1/audio/transcriptions');
-  assert.equal((requestedOptions?.headers as Record<string, string>).Authorization, 'Bearer request-key');
-  assert.equal((requestedOptions?.body as FormData).get('model'), 'custom-whisper');
+  assert.ok(requestedOptions, 'fetchBackend should receive request options');
+  assert.equal((requestedOptions.headers as Record<string, string>).Authorization, 'Bearer request-key');
+  assert.equal((requestedOptions.body as FormData).get('model'), 'custom-whisper');
 });
 
 test('forwards the explicit TTS format and maps backend authentication failures', async () => {

package/server/modules/websocket/index.ts

@@ -1,3 +1,11 @@
 export { WS_OPEN_STATE, connectedClients } from './services/websocket-state.service.js';
 export { createWebSocketServer } from './services/websocket-server.service.js';
 export { chatRunRegistry } from './services/chat-run-registry.service.js';
+// Consumed by the providers module's sessions watcher, which announces the
+// sessions it (re)indexed from disk through the same builder the chat gateway
+// uses, so both paths put the identical delta on the wire.
+export { broadcastSessionUpserted, broadcastSessionUpsertedBatch } from './services/session-upsert-broadcast.service.js';
+// runDetachedChatTurn: used by the scheduled-messages module to run a turn
+// from a timer, with no socket to stream to or report errors on.
+export { runDetachedChatTurn } from './services/chat-websocket.service.js';
+export type { ProviderRuntimeGateway } from './services/chat-websocket.service.js';

package/server/modules/websocket/services/chat-run-registry.service.ts

@@ -1,9 +1,6 @@
-import path from 'node:path';
-
-import { projectsDb, sessionsDb } from '@/modules/database/index.js';
-import { generateDisplayName } from '@/modules/projects/index.js';
+import { sessionsDb } from '@/modules/database/index.js';
 import { ChatSessionWriter } from '@/modules/websocket/services/chat-session-writer.service.js';
-import { connectedClients, WS_OPEN_STATE } from '@/modules/websocket/services/websocket-state.service.js';
+import { broadcastSessionUpserted } from '@/modules/websocket/services/session-upsert-broadcast.service.js';
 import type {
   LLMProvider,
   NormalizedMessage,
@@ -62,48 +59,6 @@ const MAX_BUFFERED_EVENTS_PER_RUN = 5000;
  */
 const runs = new Map<string, ChatRun>();
 
-async function broadcastCanonicalSessionUpsert(appSessionId: string): Promise<void> {
-  const row = sessionsDb.getSessionById(appSessionId);
-  if (!row || row.isArchived) {
-    return;
-  }
-
-  const projectPath = row.project_path;
-  const project = projectPath ? projectsDb.getProjectPath(projectPath) : null;
-  const displayName = project?.custom_project_name?.trim()
-    ? project.custom_project_name
-    : await generateDisplayName(path.basename(projectPath ?? '') || (projectPath ?? ''), projectPath);
-
-  const payload = JSON.stringify({
-    kind: 'session_upserted',
-    sessionId: row.session_id,
-    providerSessionId: row.provider_session_id,
-    provider: row.provider,
-    session: {
-      id: row.session_id,
-      summary: row.custom_name || '',
-      messageCount: 0,
-      lastActivity: row.updated_at ?? row.created_at ?? new Date().toISOString(),
-    },
-    project: project
-      ? {
-        projectId: project.project_id,
-        path: project.project_path,
-        fullPath: project.project_path,
-        displayName,
-        isStarred: Boolean(project.isStarred),
-      }
-      : null,
-    timestamp: new Date().toISOString(),
-  });
-
-  connectedClients.forEach((client) => {
-    if (client.readyState === WS_OPEN_STATE) {
-      client.send(payload);
-    }
-  });
-}
-
 function evictRunLater(appSessionId: string): void {
   const timer = setTimeout(() => {
     const run = runs.get(appSessionId);
@@ -178,7 +133,7 @@ function recordProviderSessionId(run: ChatRun, providerSessionId: string): void
 
   try {
     sessionsDb.assignProviderSessionId(run.appSessionId, providerSessionId);
-    void broadcastCanonicalSessionUpsert(run.appSessionId).catch((error) => {
+    void broadcastSessionUpserted(run.appSessionId).catch((error) => {
       const message = error instanceof Error ? error.message : String(error);
       console.error('[ChatRunRegistry] Failed to broadcast canonical session mapping', {
         appSessionId: run.appSessionId,
@@ -213,7 +168,13 @@ export const chatRunRegistry = {
     appSessionId: string;
     provider: LLMProvider;
     providerSessionId: string | null;
-    connection: RealtimeClientConnection;
+    /**
+     * The socket that asked for this run, or `null` for one nobody is watching
+     * — a scheduled message fires with no browser attached. The writer's event
+     * buffer still records everything, so a client that subscribes later
+     * replays the run from its start.
+     */
+    connection: RealtimeClientConnection | null;
     userId: string | number | null;
   }): ChatRun | null {
     const existing = runs.get(input.appSessionId);
@@ -273,11 +234,17 @@ export const chatRunRegistry = {
   },
 
   /**
-   * Re-attaches a run's outbound stream to a (new) websocket connection.
+   * Adds a websocket connection to a run's live audience.
    *
    * This is the generic replacement for the Claude-only writer reconnect:
    * after a page refresh the new socket subscribes and immediately starts
    * receiving the still-running stream, for every provider.
+   *
+   * Subscribing does not take the stream away from sockets that were already
+   * watching — a session open in two places stays live in both, and the
+   * refreshed tab's abandoned socket is dropped when the next event finds it
+   * closed. Replay stays per-connection because each client sends its own
+   * `lastSeq` with `chat.subscribe`.
    */
   attachConnection(appSessionId: string, connection: RealtimeClientConnection): boolean {
     const run = runs.get(appSessionId);

package/server/modules/websocket/services/chat-session-writer.service.ts

@@ -7,7 +7,7 @@ import type {
 import { createCompleteMessage, readObjectRecord } from '@/shared/utils.js';
 
 type ChatSessionWriterOptions = {
-  connection: RealtimeClientConnection;
+  connection: RealtimeClientConnection | null;
   userId: string | number | null;
   provider: LLMProvider;
   /** Provider-native id when resuming an existing session, otherwise null. */
@@ -44,7 +44,6 @@ type ChatSessionWriterOptions = {
  *   intercepted and recorded as the provider-id mapping as well.
  */
 export class ChatSessionWriter {
-  ws: RealtimeClientConnection;
   userId: string | number | null;
   /**
    * Some runtimes feature-detect their writer with this flag; keep it so the
@@ -53,6 +52,17 @@ export class ChatSessionWriter {
   isWebSocketWriter = true;
 
   private readonly options: ChatSessionWriterOptions;
+  /**
+   * Every socket currently watching this run, not just the one that started
+   * it. A session can legitimately be open in more than one place — a second
+   * browser tab, a phone alongside a laptop, the desktop app beside the web
+   * app — and each of those subscribes through `attachConnection`.
+   *
+   * Holding a single connection here meant the newest subscriber took the
+   * stream away from everyone before it, so a second tab silently froze
+   * mid-run and only caught up on the next REST history refresh.
+   */
+  private readonly connections = new Set<RealtimeClientConnection>();
   /**
    * The provider-native session id as the runtime knows it. Kept locally
    * (besides the registry) because runtimes read it back via `getSessionId()`
@@ -63,7 +73,12 @@ export class ChatSessionWriter {
 
   constructor(options: ChatSessionWriterOptions) {
     this.options = options;
-    this.ws = options.connection;
+    // A run started by a timer has no audience yet. Everything still goes
+    // through `decorateOutboundEvent` into the run's replay buffer, so a
+    // client that subscribes mid-run catches up from the beginning.
+    if (options.connection) {
+      this.connections.add(options.connection);
+    }
     this.userId = options.userId;
     this.providerSessionId = options.providerSessionId;
   }
@@ -116,8 +131,13 @@ export class ChatSessionWriter {
     }
   }
 
+  /**
+   * Adds a socket to the run's live audience. Named for the `WebSocketWriter`
+   * method it stands in for, so runtime adapters keep working unchanged —
+   * but it adds rather than replaces.
+   */
   updateWebSocket(newConnection: RealtimeClientConnection): void {
-    this.ws = newConnection;
+    this.connections.add(newConnection);
   }
 
   setSessionId(sessionId: string): void {
@@ -138,8 +158,18 @@ export class ChatSessionWriter {
   }
 
   private forward(message: NormalizedMessage): void {
-    if (this.ws.readyState === WS_OPEN_STATE) {
-      this.ws.send(JSON.stringify(message));
+    const payload = JSON.stringify(message);
+
+    // Sending is also when dead sockets get collected: a refreshed tab leaves
+    // its old connection behind, and without dropping it here the set would
+    // grow for the whole life of the run. Deleting during iteration is safe
+    // for a Set — the removed entry is simply not revisited.
+    for (const connection of this.connections) {
+      if (connection.readyState === WS_OPEN_STATE) {
+        connection.send(payload);
+      } else {
+        this.connections.delete(connection);
+      }
     }
   }
 }

package/server/modules/websocket/services/chat-websocket.service.ts

@@ -3,7 +3,7 @@ import path from 'node:path';
 import type { WebSocket } from 'ws';
 
 import { sessionsDb } from '@/modules/database/index.js';
-import { providerModelsService } from '@/modules/providers/index.js';
+import { providerModelsService, sessionsService } from '@/modules/providers/index.js';
 import { chatRunRegistry } from '@/modules/websocket/services/chat-run-registry.service.js';
 import { connectedClients, WS_OPEN_STATE } from '@/modules/websocket/services/websocket-state.service.js';
 import {
@@ -64,7 +64,7 @@ export function filterImagesToUploadStore(
 }
 
 /** Application boundary for dispatching provider runs and approvals. */
-type ProviderRuntimeGateway = {
+export type ProviderRuntimeGateway = {
   hasRuntime(provider: string): boolean;
   run(
     provider: LLMProvider,
@@ -149,10 +149,34 @@ async function handleChatSend(
   data: AnyRecord,
   dependencies: ChatWebSocketDependencies
 ): Promise<void> {
+  const resolved = resolveSendTarget(ws, data, dependencies, 'chat.send');
+  if (!resolved) {
+    return;
+  }
+
+  await dispatchRun(ws, userId, resolved.sessionId, resolved.session, data, dependencies);
+}
+
+type ResolvedSendTarget = {
+  sessionId: string;
+  session: NonNullable<ReturnType<typeof sessionsDb.getSessionById>>;
+  provider: LLMProvider;
+};
+
+/**
+ * Shared front half of `chat.send` and `chat.edit-send`: the session row and
+ * provider come from the database, never from the client.
+ */
+function resolveSendTarget(
+  ws: WebSocket,
+  data: AnyRecord,
+  dependencies: ChatWebSocketDependencies,
+  frameName: string,
+): ResolvedSendTarget | null {
   const sessionId = readRequiredSessionId(data);
   if (!sessionId) {
-    sendProtocolError(ws, 'SESSION_ID_REQUIRED', 'chat.send requires a sessionId.');
-    return;
+    sendProtocolError(ws, 'SESSION_ID_REQUIRED', `${frameName} requires a sessionId.`);
+    return null;
   }
 
   const session = sessionsDb.getSessionById(sessionId);
@@ -163,15 +187,36 @@ async function handleChatSend(
       `Session "${sessionId}" was not found. Create it via POST /api/providers/sessions first.`,
       sessionId
     );
-    return;
+    return null;
   }
 
   const provider = session.provider as LLMProvider;
   if (!dependencies.runtime.hasRuntime(provider)) {
     sendProtocolError(ws, 'UNSUPPORTED_PROVIDER', `Provider "${provider}" is not available.`, sessionId);
-    return;
+    return null;
   }
 
+  return { sessionId, session, provider };
+}
+
+/**
+ * Registers the run and hands the turn to the provider runtime.
+ *
+ * `extraRuntimeOptions` is how an edited message asks the provider to resume
+ * partway instead of continuing from the tip; a normal send passes nothing.
+ */
+async function dispatchRun(
+  ws: WebSocket | null,
+  userId: string | number | null,
+  sessionId: string,
+  session: NonNullable<ReturnType<typeof sessionsDb.getSessionById>>,
+  data: AnyRecord,
+  dependencies: ChatWebSocketDependencies,
+  extraRuntimeOptions: AnyRecord = {},
+  beforeRun?: (run: NonNullable<ReturnType<typeof chatRunRegistry.startRun>>) => void | Promise<void>,
+): Promise<{ started: boolean; error: string | null }> {
+  const provider = session.provider as LLMProvider;
+
   const run = chatRunRegistry.startRun({
     appSessionId: sessionId,
     provider,
@@ -181,13 +226,15 @@ async function handleChatSend(
   });
 
   if (!run) {
-    sendProtocolError(
-      ws,
-      'RUN_IN_PROGRESS',
-      `Session "${sessionId}" already has a run in progress.`,
-      sessionId
-    );
-    return;
+    if (ws) {
+      sendProtocolError(
+        ws,
+        'RUN_IN_PROGRESS',
+        `Session "${sessionId}" already has a run in progress.`,
+        sessionId
+      );
+    }
+    return { started: false, error: 'A run is already in progress for this session.' };
   }
 
   const clientOptions = (data.options ?? {}) as AnyRecord;
@@ -221,6 +268,7 @@ async function handleChatSend(
   // app session id.
   const runtimeOptions: AnyRecord = {
     ...clientOptions,
+    ...extraRuntimeOptions,
     // Attachments are re-validated server-side: only direct children of the
     // global upload store may reach provider runtimes or their file tools.
     attachments: uniqueAttachments,
@@ -231,11 +279,17 @@ async function handleChatSend(
     projectPath: session.project_path ?? clientOptions.projectPath,
   };
 
+  let failure: string | null = null;
   try {
+    // Runs only now that the session is reserved, because an edit rewinds the
+    // conversation here and a rewind for a run that was never admitted cannot
+    // be taken back. Inside the try so a rewind that throws still releases the
+    // run instead of leaving the session processing forever.
+    await beforeRun?.(run);
     await dependencies.runtime.run(provider, command, runtimeOptions, run.writer);
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    console.error(`[Chat] Provider runtime "${provider}" failed`, { sessionId, error: message });
+    failure = error instanceof Error ? error.message : String(error);
+    console.error(`[Chat] Provider runtime "${provider}" failed`, { sessionId, error: failure });
   } finally {
     // Safety net: a runtime that crashed (or resolved) without emitting its
     // terminal `complete` would otherwise leave the session stuck in
@@ -244,6 +298,113 @@ async function handleChatSend(
     // settles, and the session-keyed completeRun would kill that new run.
     chatRunRegistry.completeRunIfCurrent(run, { exitCode: 1 });
   }
+
+  return { started: true, error: failure };
+}
+
+/**
+ * Handles `chat.edit-send`: replaces an already-sent message and everything
+ * after it with a new turn.
+ *
+ * Nothing is deleted. The provider resumes the conversation partway and
+ * appends the replacement, so the abandoned attempt stays in the transcript
+ * file and is simply no longer part of the live conversation — the same shape
+ * Claude Code's rewind and Codex's fork-with-cut-point produce.
+ */
+async function handleChatEditSend(
+  ws: WebSocket,
+  userId: string | number | null,
+  data: AnyRecord,
+  dependencies: ChatWebSocketDependencies
+): Promise<void> {
+  const resolved = resolveSendTarget(ws, data, dependencies, 'chat.edit-send');
+  if (!resolved) {
+    return;
+  }
+
+  const { sessionId, session, provider } = resolved;
+  const anchorId = typeof data.anchorId === 'string' ? data.anchorId.trim() : '';
+  if (!anchorId) {
+    sendProtocolError(ws, 'ANCHOR_REQUIRED', 'chat.edit-send requires the anchorId of the message being replaced.', sessionId);
+    return;
+  }
+
+  let resumeThroughId: string | null;
+  try {
+    const anchor = await sessionsService.resolveEditAnchor(sessionId, anchorId);
+    if (!anchor) {
+      sendProtocolError(
+        ws,
+        'EDIT_NOT_SUPPORTED',
+        `Provider "${provider}" cannot replace an already-sent message.`,
+        sessionId
+      );
+      return;
+    }
+    if (!anchor.found) {
+      sendProtocolError(ws, 'ANCHOR_NOT_FOUND', 'That message is no longer in the transcript.', sessionId);
+      return;
+    }
+    resumeThroughId = anchor.resumeThroughId;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    sendProtocolError(ws, 'ANCHOR_LOOKUP_FAILED', `Could not read the transcript: ${message}`, sessionId);
+    return;
+  }
+
+  // Providers split here on what their runtime can do. Claude resumes its
+  // transcript partway, so the anchor rides along as a run option. Codex
+  // cannot — a thread only grows — so the conversation is rewound on disk and
+  // the run that follows is an ordinary resume of whatever the session then
+  // points at. Which of the two applies is decided here; the rewind itself
+  // waits until the run has actually been admitted.
+  const rewinds = sessionsService.providerRewindsForEdit(sessionId);
+
+  await dispatchRun(
+    ws,
+    userId,
+    sessionId,
+    session,
+    data,
+    dependencies,
+    // `null` is meaningful: the edited turn was the first prompt, so the
+    // conversation starts over instead of resuming.
+    rewinds
+      ? {}
+      : { resumeAnchorId: resumeThroughId ?? undefined, resumeFromScratch: resumeThroughId === null },
+    async (run) => {
+      // Emitted through the run's writer so it is sequenced and replayed like
+      // any other event — a second tab watching this session has to truncate
+      // too.
+      //
+      // Before the rewind, not after it. A rewind that has to branch spawns a
+      // process and waits on a JSON-RPC round trip, and holding the frame
+      // until that came back left the message the user had just edited away
+      // sitting on screen for about a second — the very flicker this feature
+      // exists to avoid. Announcing first is safe because a rewind that fails
+      // still ends the run, and the terminal `complete` makes every client
+      // re-read the transcript, which puts back anything that turned out not
+      // to have been replaced after all.
+      run.writer.send({
+        kind: 'history_truncated',
+        provider,
+        sessionId,
+        anchorId,
+      });
+
+      if (rewinds) {
+        try {
+          await sessionsService.rewindSessionForEdit(sessionId, resumeThroughId);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          sendProtocolError(ws, 'EDIT_REWIND_FAILED', `Could not rewind the conversation: ${message}`, sessionId);
+          // Ends the run before the provider is asked to continue a
+          // conversation that was not rewound after all.
+          throw error;
+        }
+      }
+    },
+  );
 }
 
 /**
@@ -374,6 +535,71 @@ function handlePermissionResponse(data: AnyRecord, dependencies: ChatWebSocketDe
  * (`chat_subscribed`, `session_upserted`, `loading_progress`,
  * `protocol_error`).
  */
+/**
+ * Runs a turn for a session with no client attached.
+ *
+ * Used by scheduled messages, which fire from a timer: there is no socket to
+ * report errors to and no audience to stream to. The run is registered exactly
+ * like an interactive one, so anyone who opens the session while it is going
+ * subscribes and replays it from the start, and the session shows as busy
+ * everywhere in the meantime.
+ *
+ * Resolves when the provider run settles. Returns false when the session has
+ * gone away or is busy without `interruptActiveRun`, which the caller reports
+ * on the schedule.
+ */
+export async function runDetachedChatTurn(
+  input: {
+    sessionId: string;
+    userId: string | number | null;
+    content: string;
+    options?: AnyRecord;
+    /**
+     * Aborts a run already in progress instead of refusing to start. A
+     * scheduled message sets this: the user picked the time knowing it might
+     * land mid-run, so the timer outranks whatever is running.
+     */
+    interruptActiveRun?: boolean;
+  },
+  dependencies: ChatWebSocketDependencies,
+): Promise<{ started: boolean; error: string | null }> {
+  const session = sessionsDb.getSessionById(input.sessionId);
+  if (!session) {
+    return { started: false, error: 'The session no longer exists.' };
+  }
+
+  const provider = session.provider as LLMProvider;
+  if (!dependencies.runtime.hasRuntime(provider)) {
+    return { started: false, error: `Provider "${provider}" is not available.` };
+  }
+
+  const activeRun = chatRunRegistry.getRun(input.sessionId);
+  if (activeRun && activeRun.status === 'running') {
+    if (!input.interruptActiveRun) {
+      return { started: false, error: 'A run was already in progress for this session.' };
+    }
+    // Same shape as `chat.abort`: cancel the provider run and emit the
+    // terminal `complete` on its behalf, so every watching client sees the
+    // interrupted run end before this turn's stream begins. The interrupted
+    // run's own dispatch settles later through completeRunIfCurrent, which is
+    // scoped to that run and cannot touch the one started here.
+    const aborted = await dependencies.runtime.abort(activeRun.provider, input.sessionId);
+    chatRunRegistry.completeRun(input.sessionId, {
+      exitCode: aborted ? 0 : 1,
+      aborted: true,
+    });
+  }
+
+  return dispatchRun(
+    null,
+    input.userId,
+    input.sessionId,
+    session,
+    { sessionId: input.sessionId, content: input.content, options: input.options ?? {} },
+    dependencies,
+  );
+}
+
 export function handleChatConnection(
   ws: WebSocket,
   request: AuthenticatedWebSocketRequest,
@@ -395,6 +621,9 @@ export function handleChatConnection(
       const messageType = typeof data.type === 'string' ? data.type : '';
 
       switch (messageType) {
+        case 'chat.edit-send':
+          await handleChatEditSend(ws, userId, data, dependencies);
+          return;
         case 'chat.send':
           await handleChatSend(ws, userId, data, dependencies);
           return;