@vellumai/assistant 0.7.0 → 0.7.2

package/src/daemon/conversation.ts

@@ -9,13 +9,13 @@
  * - conversation-tool-setup.ts   — tool definitions, executor, resolveTools callback
  * - conversation-media-retry.ts  — media trimming + raceWithTimeout
  * - conversation-process.ts      — drainQueue, processMessage
- * - conversation-history.ts      — undo, regenerate, consolidateAssistantMessages
+ * - conversation-history.ts      — undo, consolidateAssistantMessages
  * - conversation-surfaces.ts     — handleSurfaceAction, handleSurfaceUndo
  * - conversation-workspace.ts    — refreshWorkspaceTopLevelContext
  * - conversation-usage.ts        — recordUsage
  */
 
-import type { ResolvedSystemPrompt } from "../agent/loop.js";
+import type { AgentLoopConfig, ResolvedSystemPrompt } from "../agent/loop.js";
 import { AgentLoop } from "../agent/loop.js";
 import type {
   InterfaceId,
@@ -23,8 +23,13 @@ import type {
   TurnInterfaceContext,
 } from "../channels/types.js";
 import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
+import {
+  contextWindowConfigFromEffective,
+  resolveEffectiveContextWindow,
+} from "../config/llm-context-resolution.js";
 import { getConfig } from "../config/loader.js";
 import type { LLMCallSite, Speed } from "../config/schemas/llm.js";
+import type { ContextWindowConfig } from "../config/types.js";
 import {
   ContextWindowManager,
   type ContextWindowResult,
@@ -36,7 +41,6 @@ import type { AssistantDomainEvents } from "../events/domain-events.js";
 import { createToolAuditListener } from "../events/tool-audit-listener.js";
 import { createToolDomainEventPublisher } from "../events/tool-domain-event-publisher.js";
 import { registerToolMetricsLoggingListener } from "../events/tool-metrics-listener.js";
-import { registerToolNotificationListener } from "../events/tool-notification-listener.js";
 import { registerToolPermissionTelemetryListener } from "../events/tool-permission-telemetry-listener.js";
 import {
   registerToolProfilingListener,
@@ -44,7 +48,11 @@ import {
 } from "../events/tool-profiling-listener.js";
 import { registerToolTraceListener } from "../events/tool-trace-listener.js";
 import { resolveCanonicalGuardianRequest } from "../memory/canonical-guardian-store.js";
-import { getConversationOriginChannel } from "../memory/conversation-crud.js";
+import {
+  getConversation,
+  getConversationOriginChannel,
+  getConversationOverrideProfileFromRow,
+} from "../memory/conversation-crud.js";
 import { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
 import { PermissionPrompter } from "../permissions/prompter.js";
 import { SecretPrompter } from "../permissions/secret-prompter.js";
@@ -54,6 +62,7 @@ import { buildSystemPrompt } from "../prompts/system-prompt.js";
 import type { Message } from "../providers/types.js";
 import type { Provider } from "../providers/types.js";
 import type { TrustClass } from "../runtime/actor-trust-resolver.js";
+import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import type { AuthContext } from "../runtime/auth/types.js";
 import type { InteractiveUiResult } from "../runtime/interactive-ui.js";
 import { ToolExecutor } from "../tools/executor.js";
@@ -68,10 +77,7 @@ import {
   trackCompactionOutcome,
 } from "./conversation-agent-loop.js";
 import type { HistoryConversationContext } from "./conversation-history.js";
-import {
-  regenerate as regenerateImpl,
-  undo as undoImpl,
-} from "./conversation-history.js";
+import { undo as undoImpl } from "./conversation-history.js";
 import {
   abortConversation,
   disposeConversation,
@@ -92,7 +98,11 @@ import {
 } from "./conversation-process.js";
 import type { QueueDrainReason } from "./conversation-queue-manager.js";
 import { MessageQueue } from "./conversation-queue-manager.js";
-import type { ChannelCapabilities } from "./conversation-runtime-assembly.js";
+import {
+  type ChannelCapabilities,
+  getSlackCompactionWatermarkForPrefix,
+  loadSlackChronologicalContext,
+} from "./conversation-runtime-assembly.js";
 import type { SkillProjectionCache } from "./conversation-skill-tools.js";
 import {
   createSurfaceMutex,
@@ -107,12 +117,8 @@ import {
   createToolExecutor,
 } from "./conversation-tool-setup.js";
 import { refreshWorkspaceTopLevelContextIfNeeded as refreshWorkspaceImpl } from "./conversation-workspace.js";
-import { HostBashProxy } from "./host-bash-proxy.js";
-import { HostBrowserProxy } from "./host-browser-proxy.js";
-import type { CuObservationResult } from "./host-cu-proxy.js";
+import type { HostAppControlProxy } from "./host-app-control-proxy.js";
 import { HostCuProxy } from "./host-cu-proxy.js";
-import { HostFileProxy } from "./host-file-proxy.js";
-import { HostTransferProxy } from "./host-transfer-proxy.js";
 import type {
   ServerMessage,
   SurfaceData,
@@ -198,24 +204,15 @@ export class Conversation {
   /** @internal */ headlessLock = false;
   /** @internal */ taskRunId?: string;
   /** @internal */ callSessionId?: string;
-  /** @internal */ hostBashProxy?: HostBashProxy;
-  /** @internal */ hostBrowserProxy?: HostBrowserProxy;
   /** @internal */ hostCuProxy?: HostCuProxy;
-  /** @internal */ hostFileProxy?: HostFileProxy;
-  /** @internal */ hostTransferProxy?: HostTransferProxy;
   /**
-   * Optional override sender used by `restoreBrowserProxyAvailability` so
-   * registry-routed transports can preserve their sender across drain queue
-   * restores. When set, `restoreBrowserProxyAvailability()` uses this
-   * function instead of `sendToClient` so the drain-queue path doesn't
-   * clobber the registry-routed sender with the SSE hub emitter.
-   *
-   * Populated by the POST /messages handler when the guardian has an active
-   * extension connection in the `ChromeExtensionRegistry`, regardless of
-   * interface (chrome-extension, macOS, etc.). Cleared when a turn without
-   * an active extension connection takes over.
+   * Per-conversation host app-control proxy. Set via
+   * `setHostAppControlProxy` and disposed in `dispose()`. The
+   * `/v1/host-app-control-result` route forwards result payloads to the
+   * awaiting promise via this reference.
+   * @internal
    */
-  /** @internal */ hostBrowserSenderOverride?: (msg: ServerMessage) => void;
+  hostAppControlProxy?: HostAppControlProxy;
   /** @internal */ cesClient?: CesClient;
   /** @internal */ readonly queue = new MessageQueue();
   /** @internal */ currentActiveSurfaceId?: string;
@@ -235,6 +232,7 @@ export class Conversation {
   /** @internal */ loadedHistoryTrustClass?: TrustClass;
   /** @internal */ voiceCallControlPrompt?: string;
   /** @internal */ transportHints?: string[];
+  /** @internal */ slackRuntimeContextNotice?: string;
   /** @internal */ assistantId?: string;
   /** @internal */ commandIntent?: {
     type: string;
@@ -292,7 +290,6 @@ export class Conversation {
     string,
     ReturnType<typeof setTimeout>
   >();
-  /** @internal */ broadcastToAllClients?: (msg: ServerMessage) => void;
   /** @internal */ withSurface = createSurfaceMutex();
   /** @internal */ currentTurnSurfaces: Array<{
     surfaceId: string;
@@ -358,10 +355,9 @@ export class Conversation {
     conversationId: string,
     provider: Provider,
     systemPrompt: string,
-    maxTokens: number,
+    maxTokens: number | undefined,
     sendToClient: (msg: ServerMessage) => void,
     workingDir: string,
-    broadcastToAllClients?: (msg: ServerMessage) => void,
     memoryPolicy?: ConversationMemoryPolicy,
     sharedCesClient?: CesClient,
     speedOverride?: Speed,
@@ -373,7 +369,6 @@ export class Conversation {
     this.provider = provider;
     this.workingDir = workingDir;
     this.sendToClient = sendToClient;
-    this.broadcastToAllClients = broadcastToAllClients;
     this.memoryPolicy = memoryPolicy
       ? { ...memoryPolicy }
       : { ...DEFAULT_MEMORY_POLICY };
@@ -413,10 +408,7 @@ export class Conversation {
         );
       }
     });
-    this.secretPrompter = new SecretPrompter(
-      sendToClient,
-      broadcastToAllClients,
-    );
+    this.secretPrompter = new SecretPrompter();
 
     // Register call notifiers (reads ctx properties lazily)
     registerConversationNotifiers(conversationId, this);
@@ -425,9 +417,6 @@ export class Conversation {
     this.executor = new ToolExecutor(this.prompter);
     this.profiler = new ToolProfiler();
     registerToolMetricsLoggingListener(this.eventBus);
-    registerToolNotificationListener(this.eventBus, (msg) =>
-      this.sendToClient(msg),
-    );
     registerToolTraceListener(this.eventBus, this.traceEmitter);
     registerToolProfilingListener(this.eventBus, this.profiler);
     registerToolPermissionTelemetryListener(this.eventBus);
@@ -448,7 +437,6 @@ export class Conversation {
       this.secretPrompter,
       this as ToolSetupContext,
       handleToolLifecycleEvent,
-      broadcastToAllClients,
     );
 
     const config = getConfig();
@@ -493,8 +481,10 @@ export class Conversation {
                 onboardingContext: this.getOnboardingContext(),
               });
             })(),
-        maxTokens: configuredMaxTokens,
       };
+      if (configuredMaxTokens !== undefined) {
+        resolved.maxTokens = configuredMaxTokens;
+      }
       if (resolvedModel !== undefined) {
         resolved.model = resolvedModel;
       }
@@ -504,20 +494,31 @@ export class Conversation {
     const fastModeEnabled = isAssistantFeatureFlagEnabled("fast-mode", config);
     const resolvedSpeed = speedOverride ?? config.llm.default.speed;
     const llmDefault = config.llm.default;
+    const initialContextWindow = resolveEffectiveContextWindow({
+      llm: config.llm,
+      callSite: "mainAgent",
+    });
+    const initialContextWindowConfig = contextWindowConfigFromEffective(
+      llmDefault.contextWindow,
+      initialContextWindow,
+    );
+
+    const agentLoopConfig: Partial<AgentLoopConfig> = {
+      thinking: llmDefault.thinking,
+      effort: llmDefault.effort,
+      ...(fastModeEnabled && resolvedSpeed === "fast"
+        ? { speed: resolvedSpeed }
+        : {}),
+      ...(cacheTtl ? { cacheTtl } : {}),
+    };
+    if (configuredMaxTokens !== undefined) {
+      agentLoopConfig.maxTokens = configuredMaxTokens;
+    }
 
     this.agentLoop = new AgentLoop(
       provider,
       systemPrompt,
-      {
-        maxTokens,
-        maxInputTokens: llmDefault.contextWindow.maxInputTokens,
-        thinking: llmDefault.thinking,
-        effort: llmDefault.effort,
-        ...(fastModeEnabled && resolvedSpeed === "fast"
-          ? { speed: resolvedSpeed }
-          : {}),
-        ...(cacheTtl ? { cacheTtl } : {}),
-      },
+      agentLoopConfig,
       toolDefs.length > 0 ? toolDefs : undefined,
       toolDefs.length > 0 ? toolExecutor : undefined,
       resolveTools,
@@ -526,7 +527,7 @@ export class Conversation {
     this.contextWindowManager = new ContextWindowManager({
       provider,
       systemPrompt: () => resolveSystemPromptCallback([]).systemPrompt,
-      config: llmDefault.contextWindow,
+      config: initialContextWindowConfig,
       toolTokenBudget: this.agentLoop.getToolTokenBudget(),
     });
   }
@@ -578,7 +579,11 @@ export class Conversation {
 
     provider
       .sendMessage([warmMessage], tools, systemPrompt, {
-        config: { max_tokens: 1, callSite: "mainAgent" },
+        config: {
+          max_tokens: 1,
+          callSite: "mainAgent",
+          usageTracking: "manual",
+        },
         signal: abort.signal,
       })
       .then(() => {
@@ -648,20 +653,11 @@ export class Conversation {
   updateClient(
     sendToClient: (msg: ServerMessage) => void,
     hasNoClient = false,
-    opts?: { skipProxySenderUpdate?: boolean },
   ): void {
     this.sendToClient = sendToClient;
     this.hasNoClient = hasNoClient;
     this.prompter.updateSender(sendToClient);
-    this.secretPrompter.updateSender(sendToClient);
     this.traceEmitter.updateSender(sendToClient);
-    if (!opts?.skipProxySenderUpdate) {
-      this.hostBashProxy?.updateSender(sendToClient, !hasNoClient);
-      this.hostBrowserProxy?.updateSender(sendToClient, !hasNoClient);
-      this.hostCuProxy?.updateSender(sendToClient, !hasNoClient);
-      this.hostFileProxy?.updateSender(sendToClient, !hasNoClient);
-      this.hostTransferProxy?.updateSender(sendToClient, !hasNoClient);
-    }
 
     // Replay last activity state so a reconnecting client sees the current phase
     // instead of being stuck on the last state it received before disconnection.
@@ -682,72 +678,6 @@ export class Conversation {
     return this.sendToClient;
   }
 
-  /** Mark host proxies as unavailable so tool execution uses local fallback. */
-  clearProxyAvailability(): void {
-    this.hostBashProxy?.updateSender(this.sendToClient, false);
-    this.hostBrowserProxy?.updateSender(this.sendToClient, false);
-    this.hostCuProxy?.updateSender(this.sendToClient, false);
-    this.hostFileProxy?.updateSender(this.sendToClient, false);
-    this.hostTransferProxy?.updateSender(this.sendToClient, false);
-  }
-
-  /**
-   * Restore host proxy availability based on whether a real client is connected.
-   * When `skipBrowser` is true, the browser proxy is left untouched — use this
-   * when `restoreBrowserProxyAvailability()` will handle the browser proxy
-   * separately with the correct registry-routed sender.
-   */
-  restoreProxyAvailability(options?: { skipBrowser?: boolean }): void {
-    if (!this.hasNoClient) {
-      this.hostBashProxy?.updateSender(this.sendToClient, true);
-      if (!options?.skipBrowser) {
-        this.hostBrowserProxy?.updateSender(this.sendToClient, true);
-      }
-      this.hostCuProxy?.updateSender(this.sendToClient, true);
-      this.hostFileProxy?.updateSender(this.sendToClient, true);
-      this.hostTransferProxy?.updateSender(this.sendToClient, true);
-    }
-  }
-
-  /**
-   * Restore host browser proxy availability only. Used in two scenarios:
-   *
-   * 1. **Chrome-extension turns** — only support host_browser (not the full
-   *    desktop proxy set), so calling restoreProxyAvailability() would
-   *    incorrectly re-enable bash/file/CU proxies.
-   * 2. **macOS turns** — when called from queue-drain, the browser proxy
-   *    sender needs to be either the registry-routed sender (when an
-   *    extension connection is present) or the SSE hub sender (when no
-   *    extension is connected). This helper resolves the correct sender
-   *    via `hostBrowserSenderOverride ?? sendToClient`.
-   *
-   * Unlike `restoreProxyAvailability()`, this helper does NOT gate on
-   * `hasNoClient`. The chrome-extension interface is non-interactive (so
-   * `hasNoClient === true`), but it DOES have a connected client that can
-   * service `host_browser_request` events. Gating on `hasNoClient` would
-   * leave the just-constructed proxy unavailable and the only way to make
-   * it available would be to flip `hasNoClient` false, which would
-   * incorrectly enable host_bash/host_file/host_cu tool gating downstream.
-   *
-   * When `hostBrowserSenderOverride` is set, that function is used as the
-   * sender instead of `sendToClient`. This is required for any interface
-   * whose host_browser frames route through the ChromeExtensionRegistry
-   * WebSocket rather than the SSE hub: if the queue-drain path called this
-   * helper with `sendToClient`, the registry-routed sender established at
-   * turn-start would be clobbered by the SSE hub emitter and
-   * host_browser_request frames would stop reaching the extension. When
-   * no override is set (macOS without extension), `sendToClient` is used
-   * so frames reach the desktop client via SSE.
-   *
-   * Callers must only invoke this when they know the current interface
-   * supports host_browser (see `supportsHostProxy(id, "host_browser")`)
-   * or has an active extension connection with a registry-routed sender.
-   */
-  restoreBrowserProxyAvailability(): void {
-    const sender = this.hostBrowserSenderOverride ?? this.sendToClient;
-    this.hostBrowserProxy?.updateSender(sender, true);
-  }
-
   setSubagentAllowedTools(tools: Set<string> | undefined): void {
     this.subagentAllowedTools = tools;
   }
@@ -811,12 +741,10 @@ export class Conversation {
     // cancellation instead of hanging forever. Emit dismiss notifications
     // to the client so surfaces don't remain visually active if the client
     // reconnects after dispose.
-    const emitDispose =
-      this.broadcastToAllClients ?? this.sendToClient.bind(this);
     for (const [surfaceId, entry] of this.pendingStandaloneSurfaces) {
       clearTimeout(entry.timer);
       try {
-        emitDispose({
+        broadcastMessage({
           type: "ui_surface_dismiss",
           conversationId: this.conversationId,
           surfaceId,
@@ -836,11 +764,12 @@ export class Conversation {
       clearTimeout(timer);
     }
     this.recentlyCompletedStandaloneSurfaces.clear();
-    this.hostBashProxy?.dispose();
-    this.hostBrowserProxy?.dispose();
+    // Only dispose the per-conversation CU and app-control proxies.
+    // Bash/File/Transfer are singletons — their lifecycle is managed by
+    // static disposeInstance().
     this.hostCuProxy?.dispose();
-    this.hostFileProxy?.dispose();
-    this.hostTransferProxy?.dispose();
+    this.hostAppControlProxy?.dispose();
+    this.hostAppControlProxy = undefined;
     // CES client is owned by DaemonServer — just drop the reference.
     // Do NOT close it here; the server manages the CES lifecycle.
     this.cesClient = undefined;
@@ -867,8 +796,8 @@ export class Conversation {
   enqueueMessage(
     content: string,
     attachments: UserMessageAttachment[],
-    onEvent: (msg: ServerMessage) => void,
-    requestId: string,
+    onEvent?: (msg: ServerMessage) => void,
+    requestId?: string,
     activeSurfaceId?: string,
     currentPage?: string,
     metadata?: Record<string, unknown>,
@@ -881,8 +810,8 @@ export class Conversation {
       this,
       content,
       attachments,
-      onEvent,
-      requestId,
+      onEvent ?? this.sendToClient,
+      requestId ?? crypto.randomUUID(),
       activeSurfaceId,
       currentPage,
       metadata,
@@ -1002,7 +931,6 @@ export class Conversation {
     } catch {
       // Canonical request tracking should not break the primary approval flow.
     }
-
   }
 
   handleSecretResponse(
@@ -1013,79 +941,6 @@ export class Conversation {
     this.secretPrompter.resolveSecret(requestId, value, delivery);
   }
 
-  resolveHostBash(
-    requestId: string,
-    response: {
-      stdout: string;
-      stderr: string;
-      exitCode: number | null;
-      timedOut: boolean;
-    },
-  ): void {
-    this.hostBashProxy?.resolve(requestId, response);
-  }
-
-  setHostBashProxy(proxy: HostBashProxy | undefined): void {
-    if (this.hostBashProxy && this.hostBashProxy !== proxy) {
-      this.hostBashProxy.dispose();
-    }
-    this.hostBashProxy = proxy;
-  }
-
-  resolveHostBrowser(
-    requestId: string,
-    response: { content: string; isError: boolean },
-  ): void {
-    this.hostBrowserProxy?.resolve(requestId, response);
-  }
-
-  setHostBrowserProxy(proxy: HostBrowserProxy | undefined): void {
-    if (this.hostBrowserProxy && this.hostBrowserProxy !== proxy) {
-      this.hostBrowserProxy.dispose();
-    }
-    this.hostBrowserProxy = proxy;
-  }
-
-  resolveHostFile(
-    requestId: string,
-    response: { content: string; isError: boolean; imageData?: string },
-  ): void {
-    this.hostFileProxy?.resolve(requestId, response);
-  }
-
-  setHostFileProxy(proxy: HostFileProxy | undefined): void {
-    if (this.hostFileProxy && this.hostFileProxy !== proxy) {
-      this.hostFileProxy.dispose();
-    }
-    this.hostFileProxy = proxy;
-  }
-
-  resolveHostTransfer(
-    requestId: string,
-    result: {
-      isError: boolean;
-      bytesWritten?: number;
-      errorMessage?: string;
-    },
-  ): void {
-    this.hostTransferProxy?.resolveTransferResult(requestId, result);
-  }
-
-  setHostTransferProxy(proxy: HostTransferProxy | undefined): void {
-    if (this.hostTransferProxy && this.hostTransferProxy !== proxy) {
-      this.hostTransferProxy.dispose();
-    }
-    this.hostTransferProxy = proxy;
-  }
-
-  getHostTransferProxy(): HostTransferProxy | undefined {
-    return this.hostTransferProxy;
-  }
-
-  resolveHostCu(requestId: string, observation: CuObservationResult): void {
-    this.hostCuProxy?.resolve(requestId, observation);
-  }
-
   setHostCuProxy(proxy: HostCuProxy | undefined): void {
     if (this.hostCuProxy && this.hostCuProxy !== proxy) {
       this.hostCuProxy.dispose();
@@ -1093,6 +948,13 @@ export class Conversation {
     this.hostCuProxy = proxy;
   }
 
+  setHostAppControlProxy(proxy: HostAppControlProxy | undefined): void {
+    if (this.hostAppControlProxy && this.hostAppControlProxy !== proxy) {
+      this.hostAppControlProxy.dispose();
+    }
+    this.hostAppControlProxy = proxy;
+  }
+
   // ── Server-authoritative state signals ─────────────────────────────
 
   emitConfirmationStateChanged(
@@ -1142,14 +1004,51 @@ export class Conversation {
   }
 
   async forceCompact(): Promise<ContextWindowResult> {
+    const conversationRow = getConversation(this.conversationId);
+    const overrideProfile =
+      getConversationOverrideProfileFromRow(conversationRow) ?? null;
+    const config = getConfig();
+    const effectiveContextWindow = resolveEffectiveContextWindow({
+      llm: config.llm,
+      callSite: "mainAgent",
+      overrideProfile: overrideProfile ?? undefined,
+    });
+    (
+      this.contextWindowManager as ContextWindowManager & {
+        updateConfig?: (config: ContextWindowConfig) => void;
+      }
+    ).updateConfig?.(
+      contextWindowConfigFromEffective(
+        config.llm.default.contextWindow,
+        effectiveContextWindow,
+      ),
+    );
+    const slackChronologicalContext =
+      this.channelCapabilities?.channel === "slack"
+        ? loadSlackChronologicalContext(
+            this.conversationId,
+            this.channelCapabilities,
+            {
+              trustClass: this.trustContext?.trustClass,
+              contextSummary: conversationRow?.contextSummary,
+              contextCompactedMessageCount:
+                conversationRow?.contextCompactedMessageCount,
+              slackContextCompactionWatermarkTs:
+                conversationRow?.slackContextCompactionWatermarkTs,
+            },
+          )
+        : null;
+    const messagesToCompact =
+      slackChronologicalContext?.messages ?? this.messages;
     const result = await this.contextWindowManager.maybeCompact(
-      this.messages,
+      messagesToCompact,
       this.abortController?.signal ?? undefined,
       {
         force: true,
         lastCompactedAt: this.contextCompactedAt ?? undefined,
         conversationOriginChannel:
           getConversationOriginChannel(this.conversationId) ?? undefined,
+        overrideProfile,
       },
     );
     // Track circuit-breaker state for user-initiated `/compact` and other
@@ -1165,7 +1064,12 @@ export class Conversation {
       );
     }
     if (result.compacted) {
-      applyCompactionResult(this, result, this.sendToClient, null);
+      applyCompactionResult(this, result, this.sendToClient, null, {
+        slackContextCompactionWatermarkTs: getSlackCompactionWatermarkForPrefix(
+          slackChronologicalContext,
+          result.compactedMessages,
+        ),
+      });
     }
     return result;
   }
@@ -1202,6 +1106,10 @@ export class Conversation {
     this.transportHints = hints;
   }
 
+  setSlackRuntimeContextNotice(notice: string | undefined): void {
+    this.slackRuntimeContextNotice = notice;
+  }
+
   /**
    * Apply client-reported host environment (home dir, username) from
    * transport metadata onto the conversation. Only interfaces whose
@@ -1313,7 +1221,7 @@ export class Conversation {
   async runAgentLoop(
     content: string,
     userMessageId: string,
-    onEvent: (msg: ServerMessage) => void,
+    onEvent?: (msg: ServerMessage) => void,
     options?: {
       isInteractive?: boolean;
       isUserMessage?: boolean;
@@ -1330,7 +1238,13 @@ export class Conversation {
       overrideProfile?: string;
     },
   ): Promise<void> {
-    return runAgentLoopImpl(this, content, userMessageId, onEvent, options);
+    return runAgentLoopImpl(
+      this,
+      content,
+      userMessageId,
+      onEvent ?? this.sendToClient,
+      options,
+    );
   }
 
   drainQueue(reason: QueueDrainReason = "loop_complete"): Promise<void> {
@@ -1340,7 +1254,7 @@ export class Conversation {
   async processMessage(
     content: string,
     attachments: UserMessageAttachment[],
-    onEvent: (msg: ServerMessage) => void,
+    onEvent?: (msg: ServerMessage) => void,
     requestId?: string,
     activeSurfaceId?: string,
     currentPage?: string,
@@ -1353,7 +1267,7 @@ export class Conversation {
       this as ProcessConversationContext,
       content,
       attachments,
-      onEvent,
+      onEvent ?? this.sendToClient,
       requestId,
       activeSurfaceId,
       currentPage,
@@ -1372,17 +1286,6 @@ export class Conversation {
     return undoImpl(this as HistoryConversationContext);
   }
 
-  async regenerate(
-    onEvent: (msg: ServerMessage) => void,
-    requestId?: string,
-  ): Promise<void> {
-    return regenerateImpl(
-      this as HistoryConversationContext,
-      onEvent,
-      requestId,
-    );
-  }
-
   // ── Surfaces ─────────────────────────────────────────────────────
 
   handleSurfaceAction(