@vellumai/assistant 0.8.10 → 0.8.11-staging.1

package/src/__tests__/conversation-store.test.ts

@@ -17,6 +17,7 @@ import {
   addMessage,
   clearAll,
   createConversation,
+  deleteConversation,
   deleteLastExchange,
   getConversation,
   getMessages,
@@ -24,6 +25,7 @@ import {
 import { isLastUserMessageToolResult } from "../memory/conversation-queries.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
+import { skillLoadedEvents } from "../memory/schema.js";
 // Initialize db once before all tests
 initializeDb();
 
@@ -351,6 +353,78 @@ describe("attachment orphan cleanup", () => {
     expect(linkCount.c).toBe(0);
   });
 
+  test("clearAll removes skill_loaded_events", async () => {
+    // Privacy posture: Clear All wins over unflushed telemetry — the
+    // skill_loaded_events rows (conversation id, skill name, model
+    // attribution) must not survive the wipe and ship later.
+    getDb().delete(skillLoadedEvents).run();
+    const conv = createConversation("test");
+    getDb()
+      .insert(skillLoadedEvents)
+      .values([
+        {
+          id: "sle-clear-1",
+          createdAt: 1000,
+          conversationId: conv.id,
+          skillName: "web-research",
+        },
+        // Rows without a conversation are wiped too.
+        { id: "sle-clear-2", createdAt: 2000, skillName: "tasks" },
+      ])
+      .run();
+
+    await clearAll();
+
+    expect(getDb().select().from(skillLoadedEvents).all()).toHaveLength(0);
+  });
+
+  test("deleteConversation removes that conversation's skill_loaded_events", async () => {
+    getDb().delete(skillLoadedEvents).run();
+    const conv = createConversation("doomed");
+    await addMessage(conv.id, "user", "hello");
+    const other = createConversation("kept");
+    getDb()
+      .insert(skillLoadedEvents)
+      .values([
+        {
+          id: "sle-del-1",
+          createdAt: 1000,
+          conversationId: conv.id,
+          skillName: "web-research",
+        },
+        {
+          id: "sle-del-2",
+          createdAt: 2000,
+          conversationId: other.id,
+          skillName: "tasks",
+        },
+      ])
+      .run();
+
+    deleteConversation(conv.id);
+
+    const remaining = getDb().select().from(skillLoadedEvents).all();
+    expect(remaining.map((r) => r.id)).toEqual(["sle-del-2"]);
+  });
+
+  test("deleteConversation removes skill_loaded_events when the conversation has no messages", () => {
+    getDb().delete(skillLoadedEvents).run();
+    const conv = createConversation("empty");
+    getDb()
+      .insert(skillLoadedEvents)
+      .values({
+        id: "sle-del-empty",
+        createdAt: 1000,
+        conversationId: conv.id,
+        skillName: "web-research",
+      })
+      .run();
+
+    deleteConversation(conv.id);
+
+    expect(getDb().select().from(skillLoadedEvents).all()).toHaveLength(0);
+  });
+
   test("deleteLastExchange does not delete unlinked user uploads", async () => {
     const conv = createConversation("test");
     await addMessage(conv.id, "user", "hello");

package/src/__tests__/conversation-surfaces-app-control.test.ts

@@ -511,6 +511,7 @@ describe("surfaceProxyResolver — app-control tool routing", () => {
       _setActiveAppControlSession({
         conversationId: "conv-1",
         app: "com.example.editor",
+        targetClientId: "client-b",
       });
 
       const resultPromise = surfaceProxyResolver(ctx, "app_control_observe", {
@@ -595,6 +596,7 @@ describe("surfaceProxyResolver — app-control tool routing", () => {
       _setActiveAppControlSession({
         conversationId: "conv-1",
         app: "com.example.editor",
+        targetClientId: "client-mine",
       });
 
       const resultPromise = surfaceProxyResolver(ctx, "app_control_observe", {
@@ -617,7 +619,7 @@ describe("surfaceProxyResolver — app-control tool routing", () => {
       proxy.dispose();
     });
 
-    test("single same-user client with no target proceeds without forcing targetClientId", async () => {
+    test("single same-user client with no target resolves to that client", async () => {
       mockHubClients = [
         {
           clientId: "only-client",
@@ -630,6 +632,7 @@ describe("surfaceProxyResolver — app-control tool routing", () => {
       _setActiveAppControlSession({
         conversationId: "conv-1",
         app: "com.example.editor",
+        targetClientId: "only-client",
       });
 
       const resultPromise = surfaceProxyResolver(ctx, "app_control_observe", {

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

@@ -0,0 +1,323 @@
+/**
+ * Tests for conversation model attribution threading in
+ * conversation-tool-setup.ts: `resolveConversationAttribution` must mirror
+ * the agent-loop usage path (the current turn's call site — defaulting to
+ * mainAgent — plus the per-turn override profile), `createToolExecutor`
+ * must stamp the snapshot onto the ToolContext handed to the executor, and
+ * attribution resolution failures must never break tool execution.
+ */
+
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { ToolSetupContext } from "../daemon/conversation-tool-setup.js";
+import type { SurfaceData, SurfaceType } from "../daemon/message-protocol.js";
+import type { PermissionPrompter } from "../permissions/prompter.js";
+import type { SecretPrompter } from "../permissions/secret-prompter.js";
+import type { ToolExecutor } from "../tools/executor.js";
+import type { ToolContext, ToolExecutionResult } from "../tools/types.js";
+
+// ---------------------------------------------------------------------------
+// Module mocks (must precede the import of the module under test)
+// ---------------------------------------------------------------------------
+
+let mockLlmConfig: Record<string, unknown> = {};
+let configThrows = false;
+
+// Non-llm fields used by other conversation-tool-setup consumers (e.g.
+// createResolveToolsCallback reads `tools.exclude`), so test files sharing
+// this process keep working against the mocked loader.
+const baseConfig = {
+  tools: { exclude: [] as string[] },
+  timeouts: {
+    shellDefaultTimeoutSec: 120,
+    shellMaxTimeoutSec: 600,
+    permissionTimeoutSec: 300,
+    toolExecutionTimeoutSec: 600,
+  },
+  services: {},
+};
+
+function mockGetConfig() {
+  if (configThrows) throw new Error("config unavailable");
+  return { ...baseConfig, llm: mockLlmConfig };
+}
+
+mock.module("../config/loader.js", () => ({
+  getConfig: mockGetConfig,
+  loadConfig: mockGetConfig,
+  invalidateConfigCache: () => {},
+  loadRawConfig: () => ({}),
+  saveRawConfig: () => {},
+  getNestedValue: () => undefined,
+  setNestedValue: () => {},
+}));
+
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  broadcastMessage: mock(() => {}),
+}));
+
+mock.module("../daemon/conversation-surfaces.js", () => ({
+  refreshSurfacesForApp: mock(() => {}),
+  surfaceProxyResolver: mock(() =>
+    Promise.resolve({ content: "", isError: false }),
+  ),
+}));
+
+mock.module("../services/published-app-updater.js", () => ({
+  updatePublishedAppDeployment: mock(() => Promise.resolve()),
+}));
+
+mock.module("../tools/browser/browser-screencast.js", () => ({
+  registerConversationSender: mock(() => {}),
+}));
+
+mock.module("../memory/app-store.js", () => ({
+  getApp: mock(() => null),
+  getAppDirPath: mock(() => "/tmp/test-apps/dummy"),
+  isMultifileApp: mock(() => false),
+  getAppsDir: mock(() => "/tmp/test-apps"),
+  resolveAppIdByDirName: mock(() => null),
+  resolveAppIdFromPath: mock(() => null),
+}));
+
+// ---------------------------------------------------------------------------
+// Imports after mocks are in place
+// ---------------------------------------------------------------------------
+
+import { LLMSchema } from "../config/schemas/llm.js";
+import {
+  createToolExecutor,
+  resolveConversationAttribution,
+} from "../daemon/conversation-tool-setup.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function setLlmConfig(raw: unknown): void {
+  mockLlmConfig = LLMSchema.parse(raw) as Record<string, unknown>;
+}
+
+/** Build a minimal ToolSetupContext stub. */
+function makeCtx(overrides: Partial<ToolSetupContext> = {}): ToolSetupContext {
+  return {
+    conversationId: "conv-test",
+    currentRequestId: "req-1",
+    workingDir: "/tmp/test",
+    abortController: null,
+    traceEmitter: { emit: () => {} },
+    sendToClient: mock(() => {}),
+    pendingSurfaceActions: new Map(),
+    lastSurfaceAction: new Map(),
+    surfaceState: new Map<
+      string,
+      { surfaceType: SurfaceType; data: SurfaceData; title?: string }
+    >(),
+    surfaceUndoStacks: new Map(),
+    accumulatedSurfaceState: new Map(),
+    surfaceActionRequestIds: new Set<string>(),
+    currentTurnSurfaces: [],
+    isProcessing: () => false,
+    enqueueMessage: () => ({ queued: false, requestId: "r" }),
+    getQueueDepth: () => 0,
+    processMessage: async () => "",
+    withSurface: async <T>(_id: string, fn: () => T | Promise<T>) => fn(),
+    ...overrides,
+  };
+}
+
+/** Fake ToolExecutor that captures the context of each execute() call. */
+function makeCapturingExecutor() {
+  const calls: Array<{ name: string; context: ToolContext }> = [];
+  const executor = {
+    execute: async (
+      name: string,
+      _input: Record<string, unknown>,
+      context: ToolContext,
+    ): Promise<ToolExecutionResult> => {
+      calls.push({ name, context });
+      return { content: "ok", isError: false };
+    },
+  };
+  return { executor: executor as unknown as ToolExecutor, calls };
+}
+
+const noopPrompter = {
+  prompt: mock(async () => ({ decision: "allow" as const })),
+} as unknown as PermissionPrompter;
+const noopSecretPrompter = {
+  prompt: mock(async () => ({ cancelled: true })),
+} as unknown as SecretPrompter;
+
+function makeToolFn(executor: ToolExecutor, ctx: ToolSetupContext) {
+  return createToolExecutor(
+    executor,
+    noopPrompter,
+    noopSecretPrompter,
+    ctx,
+    () => {},
+  );
+}
+
+// The module mock outlives this file when multiple test files share a
+// process, so leave the config in a working (non-throwing) state.
+afterEach(() => {
+  configThrows = false;
+});
+
+beforeEach(() => {
+  configThrows = false;
+  setLlmConfig({
+    default: { provider: "anthropic", model: "model-default" },
+    profiles: {
+      active: { provider: "openai", model: "model-active" },
+      pinned: { provider: "gemini", model: "model-pinned" },
+    },
+    activeProfile: "active",
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+// Precedence semantics (override/active/call-site/default) are owned by
+// resolveUsageAttribution and covered in usage-attribution.test.ts; the
+// tests here only exercise what the wrapper adds on top.
+describe("resolveConversationAttribution", () => {
+  test("falls back to the workspace active profile when no override is set", () => {
+    const snapshot = resolveConversationAttribution({
+      conversationId: "conv-test",
+    });
+
+    expect(snapshot).toMatchObject({
+      callSite: "mainAgent",
+      overrideProfile: null,
+      appliedProfile: "active",
+      profileSource: "active",
+      resolvedProvider: "openai",
+      resolvedModel: "model-active",
+    });
+  });
+
+  test("attributes non-main turns to the turn call site like the usage path (voice callAgent)", () => {
+    setLlmConfig({
+      default: { provider: "anthropic", model: "model-default" },
+      profiles: {
+        active: { provider: "openai", model: "model-active" },
+        pinned: { provider: "gemini", model: "model-pinned" },
+      },
+      activeProfile: "active",
+      callSites: { callAgent: { profile: "pinned" } },
+    });
+
+    const snapshot = resolveConversationAttribution({
+      conversationId: "conv-test",
+      currentCallSite: "callAgent",
+    });
+
+    // Matches resolveUsageAttribution semantics for non-main call sites:
+    // the call-site profile wins (profileSource "call_site"), not the
+    // workspace active profile the mainAgent path would report.
+    expect(snapshot).toMatchObject({
+      callSite: "callAgent",
+      activeProfile: "active",
+      callSiteProfile: "pinned",
+      appliedProfile: "pinned",
+      profileSource: "call_site",
+      resolvedProvider: "gemini",
+      resolvedModel: "model-pinned",
+    });
+  });
+
+  test("returns null instead of throwing when resolution fails", () => {
+    configThrows = true;
+
+    expect(
+      resolveConversationAttribution({ conversationId: "conv-test" }),
+    ).toBeNull();
+  });
+});
+
+describe("createToolExecutor attribution threading", () => {
+  test("stamps the attribution snapshot onto the ToolContext for direct tool calls", async () => {
+    const { executor, calls } = makeCapturingExecutor();
+    const toolFn = makeToolFn(
+      executor,
+      makeCtx({ currentTurnOverrideProfile: "pinned" }),
+    );
+
+    const result = await toolFn("file_read", { path: "/tmp/a" });
+
+    expect(result).toMatchObject({ content: "ok", isError: false });
+    expect(calls).toHaveLength(1);
+    expect(calls[0].context.attribution).toMatchObject({
+      callSite: "mainAgent",
+      appliedProfile: "pinned",
+      profileSource: "conversation",
+      resolvedProvider: "gemini",
+      resolvedModel: "model-pinned",
+    });
+  });
+
+  test("threads a non-main turn call site (voice callAgent) into the snapshot", async () => {
+    setLlmConfig({
+      default: { provider: "anthropic", model: "model-default" },
+      profiles: {
+        active: { provider: "openai", model: "model-active" },
+        pinned: { provider: "gemini", model: "model-pinned" },
+      },
+      activeProfile: "active",
+      callSites: { callAgent: { profile: "pinned" } },
+    });
+
+    const { executor, calls } = makeCapturingExecutor();
+    const toolFn = makeToolFn(
+      executor,
+      makeCtx({ currentCallSite: "callAgent" }),
+    );
+
+    await toolFn("file_read", { path: "/tmp/a" });
+
+    expect(calls).toHaveLength(1);
+    expect(calls[0].context.attribution).toMatchObject({
+      callSite: "callAgent",
+      appliedProfile: "pinned",
+      profileSource: "call_site",
+      resolvedProvider: "gemini",
+      resolvedModel: "model-pinned",
+    });
+  });
+
+  test("stamps the attribution snapshot onto skill_execute dispatches", async () => {
+    const { executor, calls } = makeCapturingExecutor();
+    const toolFn = makeToolFn(executor, makeCtx());
+
+    await toolFn("skill_execute", {
+      tool: "file_read",
+      input: { path: "/tmp/a" },
+      activity: "testing",
+    });
+
+    expect(calls).toHaveLength(1);
+    expect(calls[0].name).toBe("file_read");
+    expect(calls[0].context.attribution).toMatchObject({
+      callSite: "mainAgent",
+      appliedProfile: "active",
+      profileSource: "active",
+    });
+  });
+
+  test("attribution resolution failure yields null and does not break tool execution", async () => {
+    configThrows = true;
+
+    const { executor, calls } = makeCapturingExecutor();
+    const toolFn = makeToolFn(executor, makeCtx());
+
+    const result = await toolFn("file_read", { path: "/tmp/a" });
+
+    expect(result).toMatchObject({ content: "ok", isError: false });
+    expect(calls).toHaveLength(1);
+    expect(calls[0].context.attribution).toBeNull();
+  });
+});

package/src/__tests__/conversation-tool-setup-tools-disabled.test.ts

@@ -154,4 +154,38 @@ describe("createResolveToolsCallback — toolsDisabledDepth", () => {
     resolve(EMPTY_HISTORY);
     expect(ctx.allowedToolNames).toEqual(new Set());
   });
+
+  test("records the resolved set on lastResolvedToolNames for inventory queries", () => {
+    // GIVEN a normal resolver call
+    const toolDefs = [makeToolDef("tool_a"), makeToolDef("tool_b")];
+    const ctx = makeCtx();
+    const resolve = createResolveToolsCallback(toolDefs, ctx)!;
+
+    // WHEN tools resolve normally
+    resolve(EMPTY_HISTORY);
+
+    // THEN the durable snapshot mirrors the per-turn gate
+    expect(ctx.lastResolvedToolNames).toEqual(ctx.allowedToolNames!);
+    expect(ctx.lastResolvedToolNames?.has("tool_a")).toBe(true);
+    expect(ctx.lastResolvedToolNames?.has("tool_b")).toBe(true);
+  });
+
+  test("preserves lastResolvedToolNames when a later call disables tools", () => {
+    // GIVEN a conversation that resolved tools on a normal turn
+    const toolDefs = [makeToolDef("tool_a"), makeToolDef("tool_b")];
+    const ctx = makeCtx();
+    const resolve = createResolveToolsCallback(toolDefs, ctx)!;
+    resolve(EMPTY_HISTORY);
+    const snapshot = ctx.lastResolvedToolNames;
+
+    // WHEN a subsequent call disables tools (e.g. pointer generation, or the
+    // turn-teardown that clears the per-turn gate)
+    ctx.toolsDisabledDepth = 1;
+    resolve(EMPTY_HISTORY);
+
+    // THEN the per-turn gate is empty but the inventory snapshot survives
+    expect(ctx.allowedToolNames).toEqual(new Set());
+    expect(ctx.lastResolvedToolNames).toBe(snapshot);
+    expect(ctx.lastResolvedToolNames?.has("tool_a")).toBe(true);
+  });
 });

package/src/__tests__/conversation-workspace-cache-state.test.ts

@@ -147,6 +147,7 @@ mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
     async maybeCompact() {
       return { compacted: false };
     }
+    resetOverflowRecovery() {}
   },
   createContextSummaryMessage: () => ({
     role: "user",

package/src/__tests__/conversation-workspace-injection.test.ts

@@ -190,6 +190,7 @@ mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
     async maybeCompact() {
       return { compacted: false };
     }
+    resetOverflowRecovery() {}
   },
   createContextSummaryMessage: () => ({
     role: "user",
@@ -270,7 +271,6 @@ mock.module("../agent/loop.js", () => ({
       return {
         history: [...messages, assistantMessage],
         exitReason: null,
-        appendedNewMessages: true,
         newMessages: [assistantMessage],
       };
     }

package/src/__tests__/conversation-workspace-tool-tracking.test.ts

@@ -187,6 +187,7 @@ mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
     async maybeCompact() {
       return { compacted: false };
     }
+    resetOverflowRecovery() {}
   },
   createContextSummaryMessage: () => ({
     role: "user",

package/src/__tests__/corrected-target.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, test } from "bun:test";
+
+import { computeCorrectedOverflowTarget } from "../plugins/defaults/compaction/corrected-target.js";
+
+describe("computeCorrectedOverflowTarget", () => {
+  test("lowers the target proportionally when the estimator under-counted", () => {
+    /**
+     * When the provider's actual token count exceeds the estimator's count,
+     * the target is scaled down by the estimation-error ratio so a re-estimate
+     * of the reduced history lands under the provider's real ceiling.
+     */
+    // GIVEN a preflight budget and an estimator that under-counted (185k vs 242k actual)
+    const preflightBudget = 162_000;
+    const actualTokens = 242_000;
+    const estimatedTokens = 185_000;
+
+    // WHEN computing the corrected target
+    const result = computeCorrectedOverflowTarget({
+      preflightBudget,
+      actualTokens,
+      estimatedTokens,
+    });
+
+    // THEN the target is the budget divided by the error ratio
+    const expectedRatio = actualTokens / estimatedTokens;
+    expect(result.targetTokens).toBe(
+      Math.floor(preflightBudget / expectedRatio),
+    );
+    // AND the ratio is surfaced for logging
+    expect(result.estimationErrorRatio).toBeCloseTo(expectedRatio, 10);
+    // AND the corrected target is below the nominal budget
+    expect(result.targetTokens).toBeLessThan(preflightBudget);
+  });
+
+  test("returns the preflight budget unchanged when the estimator did not under-count", () => {
+    /**
+     * If the estimator matched or over-counted the provider, no correction is
+     * applied and the nominal preflight budget is the target.
+     */
+    // GIVEN an actual count at or below the estimate
+    const preflightBudget = 162_000;
+
+    // WHEN computing the corrected target
+    const result = computeCorrectedOverflowTarget({
+      preflightBudget,
+      actualTokens: 180_000,
+      estimatedTokens: 185_000,
+    });
+
+    // THEN the target is the unchanged preflight budget and no ratio is reported
+    expect(result.targetTokens).toBe(preflightBudget);
+    expect(result.estimationErrorRatio).toBeNull();
+  });
+
+  test("falls back to the preflight budget when the actual count is unavailable", () => {
+    /**
+     * Proxy-rewrapped or unparseable rejections yield a null actual count; the
+     * correction is skipped rather than guessed.
+     */
+    // GIVEN a null actual token count
+    const preflightBudget = 162_000;
+
+    // WHEN computing the corrected target
+    const result = computeCorrectedOverflowTarget({
+      preflightBudget,
+      actualTokens: null,
+      estimatedTokens: 185_000,
+    });
+
+    // THEN the nominal budget is used with no ratio
+    expect(result.targetTokens).toBe(preflightBudget);
+    expect(result.estimationErrorRatio).toBeNull();
+  });
+
+  test("falls back to the preflight budget when the estimate is zero", () => {
+    /**
+     * A zero estimate would make the ratio undefined; guard against it.
+     */
+    // GIVEN a zero estimate
+    const preflightBudget = 162_000;
+
+    // WHEN computing the corrected target
+    const result = computeCorrectedOverflowTarget({
+      preflightBudget,
+      actualTokens: 242_000,
+      estimatedTokens: 0,
+    });
+
+    // THEN the nominal budget is used with no ratio
+    expect(result.targetTokens).toBe(preflightBudget);
+    expect(result.estimationErrorRatio).toBeNull();
+  });
+});

package/src/__tests__/credential-execution-feature-gates.test.ts

@@ -157,7 +157,7 @@ describe("CES flags respect explicit false overrides", () => {
 // ---------------------------------------------------------------------------
 
 describe("CES flags do not affect unrelated flags", () => {
-  test("enabling all CES flags does not change declared default-enabled flags", () => {
+  test("enabling all CES flags does not change other declared flags", () => {
     const overrides: Record<string, boolean> = {};
     for (const key of ALL_CES_FLAG_KEYS) {
       overrides[key] = true;
@@ -165,10 +165,8 @@ describe("CES flags do not affect unrelated flags", () => {
     setOverridesForTesting(overrides);
     const config = makeConfig();
 
-    // account-deletion defaults to true in the registry and should stay true.
-    expect(isAssistantFeatureFlagEnabled("account-deletion", config)).toBe(
-      true,
-    );
+    // auto-analyze defaults to false and should stay false.
+    expect(isAssistantFeatureFlagEnabled("auto-analyze", config)).toBe(false);
   });
 
   test("enabling all CES flags does not change unrelated fail-closed flags", () => {