@vellumai/assistant 0.6.5 → 0.6.6

package/src/daemon/__tests__/conversation-tool-setup.test.ts

@@ -8,16 +8,16 @@
  *   run with `hasNoClient: true` because chrome-extension is not in
  *   `INTERACTIVE_INTERFACES`).
  * - macos requires a connected SSE client for host tools that flow through
- *   the proxy (e.g. host_bash, host_file_*), so `hasNoClient: true` denies
- *   those on macos.
- * - host_browser is NOT in the macos capability set because the proxy path
- *   requires a Chrome extension that isn't guaranteed to be attached; macos
- *   browser tools fall back to local Playwright Chromium.
+ *   the proxy (e.g. host_bash, host_file_*, host_browser), so
+ *   `hasNoClient: true` denies those on macos.
+ * - host_browser IS in the macos capability set — the proxy routes
+ *   host_browser_request frames to the desktop client via SSE (or via the
+ *   Chrome extension registry when an extension connection is present).
  *
  * The per-capability check (`supportsHostProxy(transport, capability)`) runs
  * first and is authoritative for structural support, so host_bash and
  * host_file_* are filtered out for chrome-extension regardless of the
- * hasNoClient flag, and host_browser is filtered out for macos.
+ * hasNoClient flag.
  */
 
 import { describe, expect, test } from "bun:test";
@@ -74,23 +74,22 @@ describe("isToolActiveForContext — host tool capability gating", () => {
     ).toBe(false);
   });
 
-  test("host_browser is NOT active for macOS (uses local Playwright)", () => {
-    // host_browser is not in the macos capability set because the proxy path
-    // requires a Chrome extension that isn't guaranteed to be attached; macos
-    // browser tools fall back to local Playwright Chromium instead. The
-    // per-capability check is authoritative, so host_browser is filtered out
-    // for macos regardless of client connection state.
+  test("host_browser is active for macOS with a connected client", () => {
+    // macOS supports host_browser — the proxy routes host_browser_request
+    // frames to the desktop client via SSE (or via the Chrome extension
+    // registry when an extension connection is present).
     expect(
       isToolActiveForContext(
         "host_browser",
         makeCtx({ hasNoClient: false, transportInterface: "macos" }),
       ),
-    ).toBe(false);
+    ).toBe(true);
   });
 
   test("host_browser is NOT active for macOS when hasNoClient is true", () => {
-    // Same capability gate as above: host_browser is unsupported on macos
-    // regardless of connection state.
+    // macOS supports host_browser structurally, but without a connected
+    // client the host_browser_request frames have no consumer, so the tool
+    // is denied.
     expect(
       isToolActiveForContext(
         "host_browser",

package/src/daemon/config-watcher.ts

@@ -24,7 +24,6 @@ import { handleCancelSignal } from "../signals/cancel.js";
 import { handleConversationUndoSignal } from "../signals/conversation-undo.js";
 import { handleEmitEventSignal } from "../signals/emit-event.js";
 import { handleMcpReloadSignal } from "../signals/mcp-reload.js";
-import { handleShotgunSignal } from "../signals/shotgun.js";
 import { handleUserMessageSignal } from "../signals/user-message.js";
 import { DebouncerMap } from "../util/debounce.js";
 import { getLogger } from "../util/logger.js";
@@ -396,7 +395,6 @@ export class ConfigWatcher {
       (filename: string) => void | Promise<void>
     > = {
       "bash.": handleBashSignal,
-      "shotgun.": handleShotgunSignal,
       "user-message.": handleUserMessageSignal,
     };
 

package/src/daemon/context-overflow-policy.ts

@@ -4,10 +4,7 @@ import type { ContextOverflowRecoveryConfig } from "../config/schemas/inference.
  * Actions the overflow recovery loop can take when the context window is
  * exceeded and standard compaction has already been applied.
  */
-export type OverflowAction =
-  | "auto_compress_latest_turn"
-  | "request_user_approval"
-  | "fail_gracefully";
+export type OverflowAction = "auto_compress_latest_turn" | "fail_gracefully";
 
 export interface OverflowPolicyInput {
   overflowRecovery: ContextOverflowRecoveryConfig;
@@ -19,8 +16,8 @@ export interface OverflowPolicyInput {
  * to a concrete overflow action.
  *
  * The recovery pipeline calls this after standard compaction is exhausted.
- * Interactive conversations default to asking the user before compressing the
- * latest turn; non-interactive conversations auto-compress.
+ * All conversations auto-compress the latest turn when standard compaction is
+ * exhausted, unless the policy is `drop` (opt-out) or recovery is disabled.
  */
 export function resolveOverflowAction(
   input: OverflowPolicyInput,
@@ -40,11 +37,5 @@ export function resolveOverflowAction(
     return "fail_gracefully";
   }
 
-  // For non-interactive conversations, compress without asking.
-  if (!isInteractive) {
-    return "auto_compress_latest_turn";
-  }
-
-  // Interactive conversations ask for approval before compressing.
-  return "request_user_approval";
+  return "auto_compress_latest_turn";
 }

package/src/daemon/conversation-agent-loop-handlers.ts

@@ -16,13 +16,11 @@ import type {
 import { recordEstimate } from "../context/estimator-calibration.js";
 import { getCalibrationProviderKey } from "../context/token-estimator.js";
 import {
-  addMessage,
   getConversation,
   getMessageById,
   provenanceFromTrustContext,
   updateMessageContent,
 } from "../memory/conversation-crud.js";
-import { syncMessageToDisk } from "../memory/conversation-disk-view.js";
 import {
   backfillMessageIdOnLogs,
   recordRequestLog,
@@ -33,6 +31,15 @@ import {
   type SlackMessageMetadata,
   writeSlackMetadata,
 } from "../messaging/providers/slack/message-metadata.js";
+import { defaultPersistenceTerminal } from "../plugins/defaults/persistence.js";
+import { DEFAULT_TIMEOUTS, runPipeline } from "../plugins/pipeline.js";
+import { getMiddlewaresFor } from "../plugins/registry.js";
+import type {
+  PersistAddResult,
+  PersistArgs,
+  PersistResult,
+  TurnContext,
+} from "../plugins/types.js";
 import type { ContentBlock, ImageContent } from "../providers/types.js";
 import { isContextOverflowError } from "../providers/types.js";
 import { ProviderError } from "../util/errors.js";
@@ -53,6 +60,34 @@ import type { ServerMessage } from "./message-protocol.js";
 
 const log = getLogger("agent-loop-handlers");
 
+/**
+ * Build a {@link TurnContext} from the handler's deps for pipeline logging
+ * and plugin attribution.
+ *
+ * Reads `turnIndex` from `deps.ctx.turnCount` — the orchestrator-owned
+ * per-turn counter that is stable for the entire duration of a single
+ * `runAgentLoopImpl` invocation. The handlers fire after the orchestrator
+ * has completed its in-turn pipeline work but before `ctx.turnCount++` runs
+ * in the outer `finally` block, so this value always reflects the turn the
+ * handler's event belongs to. Trust pulls from the per-turn snapshot first,
+ * then the conversation-level context, then the canonical `unknown`
+ * fallback so the required field stays populated for edge cases (fresh
+ * conversations before the trust resolver runs, heartbeat turns that never
+ * bind an actor).
+ */
+function buildHandlerTurnContext(deps: EventHandlerDeps): TurnContext {
+  return {
+    requestId: deps.reqId,
+    conversationId: deps.ctx.conversationId,
+    turnIndex: deps.ctx.turnCount,
+    trust: deps.ctx.currentTurnTrustContext ??
+      deps.ctx.trustContext ?? {
+        sourceChannel: "vellum",
+        trustClass: "unknown",
+      },
+  };
+}
+
 // ── Types ────────────────────────────────────────────────────────────
 
 export interface PendingToolResult {
@@ -538,6 +573,10 @@ export function handleToolResult(
     imageData: imageDataList?.[0],
     imageDataList,
     toolUseId: event.toolUseId,
+    riskLevel: event.riskLevel,
+    riskReason: event.riskReason,
+    isContainerized: event.isContainerized,
+    riskScopeOptions: event.riskScopeOptions,
   });
 }
 
@@ -715,21 +754,30 @@ export async function handleMessageComplete(
       assistantMessageInterface:
         deps.turnInterfaceContext.assistantMessageInterface,
     };
-    const toolResultMsg = await addMessage(
-      deps.ctx.conversationId,
-      "user",
-      JSON.stringify(toolResultBlocks),
-      toolResultMetadata,
-    );
-    // Sync tool-result user message to disk view
+    // Route the add + disk-view sync through the `persistence` pipeline so
+    // plugins can observe or override both operations together. The default
+    // plugin's terminal performs the add and, when `syncToDisk` is true,
+    // immediately calls `syncMessageToDisk` against the just-persisted row.
+    // `getConversation` returns `ConversationRow | null`, so `!= null`
+    // gates on a real row (skipping the sync when the conversation was
+    // not found rather than asking the disk-view to resolve a missing id).
     const convForToolResult = getConversation(deps.ctx.conversationId);
-    if (convForToolResult) {
-      syncMessageToDisk(
-        deps.ctx.conversationId,
-        toolResultMsg.id,
-        convForToolResult.createdAt,
-      );
-    }
+    await runPipeline<PersistArgs, PersistResult>(
+      "persistence",
+      getMiddlewaresFor("persistence"),
+      defaultPersistenceTerminal,
+      {
+        op: "add",
+        conversationId: deps.ctx.conversationId,
+        role: "user",
+        content: JSON.stringify(toolResultBlocks),
+        metadata: toolResultMetadata,
+        syncToDisk: convForToolResult != null,
+        createdAtMs: convForToolResult?.createdAt,
+      },
+      buildHandlerTurnContext(deps),
+      DEFAULT_TIMEOUTS.persistence,
+    );
     for (const id of state.pendingToolResults.keys()) {
       state.persistedToolUseIds.add(id);
     }
@@ -816,12 +864,25 @@ export async function handleMessageComplete(
       );
     }
   }
-  const assistantMsg = await addMessage(
-    deps.ctx.conversationId,
-    "assistant",
-    JSON.stringify(contentWithSurfaces),
-    assistantChannelMetadata,
-  );
+  // Route the assistant-message persistence through the `persistence`
+  // pipeline. No `syncToDisk` here — the orchestrator separately invokes
+  // `syncMessageToDisk` on `state.lastAssistantMessageId` after the loop
+  // completes (see `conversation-agent-loop.ts::syncLastAssistantMessageToDisk`).
+  const assistantPersistResult = (await runPipeline<PersistArgs, PersistResult>(
+    "persistence",
+    getMiddlewaresFor("persistence"),
+    defaultPersistenceTerminal,
+    {
+      op: "add",
+      conversationId: deps.ctx.conversationId,
+      role: "assistant",
+      content: JSON.stringify(contentWithSurfaces),
+      metadata: assistantChannelMetadata,
+    },
+    buildHandlerTurnContext(deps),
+    DEFAULT_TIMEOUTS.persistence,
+  )) as PersistAddResult;
+  const assistantMsg = assistantPersistResult.message;
   state.lastAssistantMessageId = assistantMsg.id;
 
   // Backfill message_id on all LLM request logs from this turn.