@vellumai/assistant 0.6.4 → 0.6.6

package/src/daemon/conversation.ts

@@ -5,7 +5,7 @@
  * - conversation-lifecycle.ts    — loadFromDb, abort, dispose
  * - conversation-messaging.ts    — enqueueMessage, persistUserMessage, redirectToSecurePrompt
  * - conversation-agent-loop.ts   — runAgentLoop, generateTitle
- * - conversation-notifiers.ts    — watch/call notifier registration
+ * - conversation-notifiers.ts    — call notifier registration
  * - conversation-tool-setup.ts   — tool definitions, executor, resolveTools callback
  * - conversation-media-retry.ts  — media trimming + raceWithTimeout
  * - conversation-process.ts      — drainQueue, processMessage
@@ -24,7 +24,7 @@ import type {
 } from "../channels/types.js";
 import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { getConfig } from "../config/loader.js";
-import type { Speed } from "../config/schemas/inference.js";
+import type { LLMCallSite, Speed } from "../config/schemas/llm.js";
 import {
   ContextWindowManager,
   type ContextWindowResult,
@@ -43,11 +43,9 @@ import {
   ToolProfiler,
 } from "../events/tool-profiling-listener.js";
 import { registerToolTraceListener } from "../events/tool-trace-listener.js";
-import { getHookManager } from "../hooks/manager.js";
-import { enqueueAutoAnalysisOnCompaction } from "../memory/auto-analysis-enqueue.js";
 import { resolveCanonicalGuardianRequest } from "../memory/canonical-guardian-store.js";
 import {
-  updateConversationContextWindow,
+  getConversationOriginChannel,
   updateConversationHostAccess,
 } from "../memory/conversation-crud.js";
 import { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
@@ -62,19 +60,23 @@ import {
 } from "../permissions/v2-consent-policy.js";
 import { resolvePersonaContext } from "../prompts/persona-resolver.js";
 import { buildSystemPrompt } from "../prompts/system-prompt.js";
-import { resolveModelIntent } from "../providers/model-intents.js";
-import type { Message, ModelIntent } from "../providers/types.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 type { AuthContext } from "../runtime/auth/types.js";
 import * as approvalOverrides from "../runtime/conversation-approval-overrides.js";
+import type { InteractiveUiResult } from "../runtime/interactive-ui.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { ToolExecutor } from "../tools/executor.js";
 import type { OnboardingContext } from "../types/onboarding-context.js";
 import type { AbortReason } from "../util/abort-reasons.js";
 import { getLogger } from "../util/logger.js";
 import type { AssistantAttachmentDraft } from "./assistant-attachments.js";
-import { runAgentLoopImpl } from "./conversation-agent-loop.js";
+import {
+  applyCompactionResult,
+  runAgentLoopImpl,
+  trackCompactionOutcome,
+} from "./conversation-agent-loop.js";
 import type { HistoryConversationContext } from "./conversation-history.js";
 import {
   regenerate as regenerateImpl,
@@ -190,6 +192,19 @@ export class Conversation {
   /** @internal */ contextWindowManager: ContextWindowManager;
   /** @internal */ contextCompactedMessageCount = 0;
   /** @internal */ contextCompactedAt: number | null = null;
+  /**
+   * Tracks consecutive compaction failures (summary LLM call threw). In-memory
+   * only — resets to 0 on process restart, which is the intended "one free
+   * retry after restart" behavior. Reset to 0 on any successful compaction.
+   */
+  /** @internal */ consecutiveCompactionFailures = 0;
+  /**
+   * When the circuit breaker is open, this timestamp (ms since epoch) marks
+   * when auto-compaction is allowed to resume. Set to `Date.now() + 1h` after
+   * 3 consecutive failures; cleared on a successful compaction. User-initiated
+   * compaction (`force: true`) bypasses the breaker regardless.
+   */
+  /** @internal */ compactionCircuitOpenUntil: number | null = null;
   /** @internal */ currentRequestId?: string;
   /** @internal */ hasNoClient = false;
   /** @internal */ isSubagent = false;
@@ -238,6 +253,7 @@ export class Conversation {
     languageCode?: string;
   };
   /** @internal */ surfaceActionRequestIds = new Set<string>();
+  /** @internal */ approvedViaPromptThisTurn = false;
   /** @internal */ pendingSurfaceActions = new Map<
     string,
     { surfaceType: SurfaceType }
@@ -265,6 +281,28 @@ export class Conversation {
     string,
     Record<string, unknown>
   >();
+  /**
+   * Pending standalone UI requests keyed by surfaceId.
+   * Daemon-driven surfaces that block the caller until user response or timeout.
+   * @internal
+   */
+  pendingStandaloneSurfaces = new Map<
+    string,
+    {
+      resolve: (result: InteractiveUiResult) => void;
+      timer: ReturnType<typeof setTimeout>;
+      surfaceType: SurfaceType;
+    }
+  >();
+  /**
+   * Short-lived tombstone set of recently-completed standalone surface IDs.
+   * Prevents late client actions from falling through to the LLM path.
+   * @internal
+   */
+  recentlyCompletedStandaloneSurfaces = new Map<
+    string,
+    ReturnType<typeof setTimeout>
+  >();
   /** @internal */ broadcastToAllClients?: (msg: ServerMessage) => void;
   /** @internal */ withSurface = createSurfaceMutex();
   /** @internal */ currentTurnSurfaces: Array<{
@@ -325,6 +363,7 @@ export class Conversation {
     toolName?: string,
     toolUseId?: string,
   ) => void;
+  private cacheWarmAbort?: AbortController;
 
   constructor(
     conversationId: string,
@@ -338,7 +377,6 @@ export class Conversation {
     sharedCesClient?: CesClient,
     speedOverride?: Speed,
     cacheTtl?: "5m" | "1h",
-    modelIntent?: ModelIntent,
     modelOverride?: string,
   ) {
     this.conversationId = conversationId;
@@ -386,9 +424,12 @@ export class Conversation {
         );
       }
     });
-    this.secretPrompter = new SecretPrompter(sendToClient);
+    this.secretPrompter = new SecretPrompter(
+      sendToClient,
+      broadcastToAllClients,
+    );
 
-    // Register watch/call notifiers (reads ctx properties lazily)
+    // Register call notifiers (reads ctx properties lazily)
     registerConversationNotifiers(conversationId, this);
 
     // Tool infrastructure
@@ -424,7 +465,7 @@ export class Conversation {
     );
 
     const config = getConfig();
-    this.streamThinking = config.thinking.streamThinking ?? false;
+    this.streamThinking = config.llm.default.thinking.streamThinking ?? false;
 
     // CES (Credential Execution Service) — use the shared server-level client.
     // The CES sidecar accepts exactly one bootstrap connection, so the
@@ -441,13 +482,10 @@ export class Conversation {
     const hasSystemPromptOverride = systemPrompt !== buildSystemPrompt();
     this.hasSystemPromptOverride = hasSystemPromptOverride;
 
-    // If an explicit modelOverride is supplied, use it verbatim. Otherwise,
-    // if modelIntent is set, resolve it against the active provider's
-    // intent → model mapping. The AgentLoop passes the resulting string
-    // through to `providerConfig.model` on every turn.
-    const resolvedModel: string | undefined =
-      modelOverride ??
-      (modelIntent ? resolveModelIntent(provider.name, modelIntent) : undefined);
+    // If an explicit modelOverride is supplied, use it verbatim. Otherwise
+    // leave the model unset and let `RetryProvider`'s call-site resolver pick
+    // it up from `llm.default` / `llm.callSites.<id>` on every turn.
+    const resolvedModel: string | undefined = modelOverride;
 
     const resolveSystemPromptCallback = (
       _history: import("../providers/types.js").Message[],
@@ -477,16 +515,17 @@ export class Conversation {
     };
 
     const fastModeEnabled = isAssistantFeatureFlagEnabled("fast-mode", config);
-    const resolvedSpeed = speedOverride ?? config.speed;
+    const resolvedSpeed = speedOverride ?? config.llm.default.speed;
+    const llmDefault = config.llm.default;
 
     this.agentLoop = new AgentLoop(
       provider,
       systemPrompt,
       {
         maxTokens,
-        maxInputTokens: config.contextWindow.maxInputTokens,
-        thinking: config.thinking,
-        effort: config.effort,
+        maxInputTokens: llmDefault.contextWindow.maxInputTokens,
+        thinking: llmDefault.thinking,
+        effort: llmDefault.effort,
         ...(fastModeEnabled && resolvedSpeed === "fast"
           ? { speed: resolvedSpeed }
           : {}),
@@ -500,14 +539,9 @@ export class Conversation {
     this.contextWindowManager = new ContextWindowManager({
       provider,
       systemPrompt: () => resolveSystemPromptCallback([]).systemPrompt,
-      config: config.contextWindow,
+      config: llmDefault.contextWindow,
       toolTokenBudget: this.agentLoop.getToolTokenBudget(),
     });
-
-    void getHookManager().trigger("conversation-start", {
-      conversationId: this.conversationId,
-      workingDir: this.workingDir,
-    });
   }
 
   // ── Onboarding context ───────────────────────────────────────────
@@ -520,6 +554,61 @@ export class Conversation {
     return this.onboardingContext;
   }
 
+  // ── Prompt Cache Warming ─────────────────────────────────────────
+
+  /**
+   * Fire-and-forget LLM call with max_tokens=1 to populate the provider's
+   * prompt cache (system prompt + tools). Called after the canned first
+   * greeting so the user's next real message gets a cache hit.
+   */
+  warmPromptCache(): void {
+    this.cacheWarmAbort?.abort();
+    const abort = new AbortController();
+    this.cacheWarmAbort = abort;
+
+    const systemPrompt = this.hasSystemPromptOverride
+      ? this.systemPrompt
+      : (() => {
+          const persona = resolvePersonaContext(
+            this.currentTurnTrustContext,
+            this.currentTurnChannelCapabilities,
+          );
+          return buildSystemPrompt({
+            hasNoClient: this.hasNoClient,
+            userPersona: persona.userPersona,
+            channelPersona: persona.channelPersona,
+            userSlug: persona.userSlug,
+            onboardingContext: this.getOnboardingContext(),
+          });
+        })();
+    const tools = buildToolDefinitions();
+    const provider = this.provider;
+
+    const warmMessage: Message = {
+      role: "user",
+      content: [{ type: "text", text: "hi" }],
+    };
+
+    provider
+      .sendMessage([warmMessage], tools, systemPrompt, {
+        config: { max_tokens: 1, callSite: "mainAgent" },
+        signal: abort.signal,
+      })
+      .then(() => {
+        log.info("Prompt cache warmed successfully");
+      })
+      .catch((err) => {
+        if (!abort.signal.aborted) {
+          log.warn({ err }, "Prompt cache warming failed (non-fatal)");
+        }
+      })
+      .finally(() => {
+        if (this.cacheWarmAbort === abort) {
+          this.cacheWarmAbort = undefined;
+        }
+      });
+  }
+
   // ── Lifecycle ────────────────────────────────────────────────────
 
   async loadFromDb(): Promise<void> {
@@ -631,13 +720,16 @@ export class Conversation {
   }
 
   /**
-   * Restore host browser proxy availability only. Used for interfaces that
-   * support host_browser but not the full desktop proxy set, so calling
-   * restoreProxyAvailability() would incorrectly re-enable bash/file/CU
-   * proxies that should stay disabled. Applicable to chrome-extension turns
-   * (which only support host_browser) and macOS turns with an active
-   * extension connection (which route browser tools through the extension
-   * registry instead of cdp-inspect/local).
+   * 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
@@ -653,7 +745,9 @@ export class Conversation {
    * 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.
+   * 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")`)
@@ -724,6 +818,35 @@ export class Conversation {
 
   dispose(): void {
     approvalOverrides.clearMode(this.conversationId);
+    // Cancel all pending standalone surfaces so callers get a clean
+    // 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({
+          type: "ui_surface_dismiss",
+          conversationId: this.conversationId,
+          surfaceId,
+        });
+      } catch {
+        // Best-effort: the client may already be disconnected during dispose.
+      }
+      entry.resolve({
+        status: "cancelled",
+        surfaceId,
+        cancellationReason: "resolver_unavailable",
+      });
+    }
+    this.pendingStandaloneSurfaces.clear();
+    // Clear tombstone timers to prevent dangling references after dispose.
+    for (const timer of this.recentlyCompletedStandaloneSurfaces.values()) {
+      clearTimeout(timer);
+    }
+    this.recentlyCompletedStandaloneSurfaces.clear();
     this.hostBashProxy?.dispose();
     this.hostBrowserProxy?.dispose();
     this.hostCuProxy?.dispose();
@@ -762,6 +885,7 @@ export class Conversation {
     options?: { isInteractive?: boolean },
     displayContent?: string,
     transport?: ConversationTransportMetadata,
+    clientMessageId?: string,
   ): { queued: boolean; requestId: string; rejected?: boolean } {
     return enqueueMessageImpl(
       this,
@@ -775,6 +899,7 @@ export class Conversation {
       options,
       displayContent,
       transport,
+      clientMessageId,
     );
   }
 
@@ -927,7 +1052,7 @@ export class Conversation {
    * confirmations in the same conversation that match the decision.
    *
    * - allow_10m / allow_conversation → approve ALL pending in conversation
-   * - always_allow / always_allow_high_risk → approve pattern-matching pending
+   * - always_allow → approve pattern-matching pending
    * - always_deny → deny pattern-matching pending
    * - allow / deny (one-time) → no cascading
    */
@@ -1021,14 +1146,9 @@ export class Conversation {
     }
 
     // Persistent allow: cascade if the pattern matches any allowlist candidate.
-    // "always_allow" must NOT cascade to high-risk pending confirmations —
-    // only "always_allow_high_risk" has consent for those.
-    if (
-      (decision === "always_allow" || decision === "always_allow_high_risk") &&
-      selectedPattern &&
-      details
-    ) {
-      if (decision === "always_allow" && details.riskLevel === "high") {
+    // "always_allow" must NOT cascade to high-risk pending confirmations.
+    if (decision === "always_allow" && selectedPattern && details) {
+      if (details.riskLevel === "high") {
         return null;
       }
       for (const option of details.allowlistOptions) {
@@ -1170,30 +1290,41 @@ export class Conversation {
     const result = await this.contextWindowManager.maybeCompact(
       this.messages,
       this.abortController?.signal ?? undefined,
-      { force: true, lastCompactedAt: this.contextCompactedAt ?? undefined },
+      {
+        force: true,
+        lastCompactedAt: this.contextCompactedAt ?? undefined,
+        conversationOriginChannel:
+          getConversationOriginChannel(this.conversationId) ?? undefined,
+      },
     );
-    if (result.compacted) {
-      this.messages = result.messages;
-      this.contextCompactedMessageCount += result.compactedPersistedMessages;
-      this.contextCompactedAt = Date.now();
-      updateConversationContextWindow(
-        this.conversationId,
-        result.summaryText,
-        this.contextCompactedMessageCount,
-      );
-      // Fire auto-analysis on compaction so the reflective agent can
-      // crystallize anything worth remembering before the context window
-      // narrows further.
-      enqueueAutoAnalysisOnCompaction(
-        this.conversationId,
-        this.trustContext?.trustClass,
+    // Track circuit-breaker state for user-initiated `/compact` and other
+    // forced paths so a successful forced compaction clears a stuck counter
+    // and a run of forced failures still trips the breaker. `summaryFailed`
+    // is `undefined` on early-return paths (no eligible messages, disabled,
+    // etc.) — skip those so they don't silently reset the counter.
+    if (result.summaryFailed !== undefined) {
+      await trackCompactionOutcome(
+        this,
+        result.summaryFailed,
+        this.sendToClient,
       );
     }
+    if (result.compacted) {
+      applyCompactionResult(this, result, this.sendToClient, null);
+    }
     return result;
   }
 
   setChannelCapabilities(caps: ChannelCapabilities | null): void {
     this.channelCapabilities = caps ?? undefined;
+    this.secretPrompter.setChannelContext(
+      caps
+        ? {
+            channel: caps.channel,
+            supportsDynamicUi: caps.supportsDynamicUi,
+          }
+        : undefined,
+    );
   }
 
   setTrustContext(ctx: TrustContext | null): void {
@@ -1329,10 +1460,10 @@ export class Conversation {
     userMessageId: string,
     onEvent: (msg: ServerMessage) => void,
     options?: {
-      skipPreMessageRollback?: boolean;
       isInteractive?: boolean;
       isUserMessage?: boolean;
       titleText?: string;
+      callSite?: LLMCallSite;
     },
   ): Promise<void> {
     return runAgentLoopImpl(this, content, userMessageId, onEvent, options);
@@ -1349,9 +1480,11 @@ export class Conversation {
     requestId?: string,
     activeSurfaceId?: string,
     currentPage?: string,
-    options?: { isInteractive?: boolean },
+    options?: { isInteractive?: boolean; callSite?: LLMCallSite },
     displayContent?: string,
   ): Promise<string> {
+    this.cacheWarmAbort?.abort();
+    this.cacheWarmAbort = undefined;
     return processMessageImpl(
       this as ProcessConversationContext,
       content,