@vellumai/assistant 0.7.0 → 0.7.1

package/src/tasks/task-store.ts

@@ -1,4 +1,4 @@
-import { asc, desc, eq, inArray, or } from "drizzle-orm";
+import { desc, eq, inArray } from "drizzle-orm";
 
 import { getDb } from "../memory/db-connection.js";
 import { taskRuns, tasks, workItems } from "../memory/schema.js";
@@ -154,30 +154,3 @@ export interface ActionableWorkItem {
   priorityTier: number;
   updatedAt: number;
 }
-
-/**
- * Return actionable work items — those that are queued, running, or
- * awaiting review. Ordered by priority (high first) then most-recently-updated.
- */
-export function getActionableWorkItems(): ActionableWorkItem[] {
-  const db = getDb();
-  return db
-    .select({
-      id: workItems.id,
-      taskId: workItems.taskId,
-      title: workItems.title,
-      status: workItems.status,
-      priorityTier: workItems.priorityTier,
-      updatedAt: workItems.updatedAt,
-    })
-    .from(workItems)
-    .where(
-      or(
-        eq(workItems.status, "queued"),
-        eq(workItems.status, "running"),
-        eq(workItems.status, "awaiting_review"),
-      ),
-    )
-    .orderBy(asc(workItems.priorityTier), desc(workItems.updatedAt))
-    .all();
-}

package/src/telemetry/types.ts

@@ -1,3 +1,6 @@
+import type { LLMCallSite } from "../config/schemas/llm.js";
+import type { UsageAttributionProfileSource } from "../usage/types.js";
+
 /** Base fields present on every telemetry event. */
 export interface TelemetryEventBase {
   type: string;
@@ -15,6 +18,9 @@ export interface LlmUsageTelemetryEvent extends TelemetryEventBase {
   cache_creation_input_tokens: number | null;
   cache_read_input_tokens: number | null;
   actor: string;
+  llm_call_site: LLMCallSite | null;
+  inference_profile: string | null;
+  inference_profile_source: UsageAttributionProfileSource | null;
 }
 
 /** Turn event — one per user message. */

package/src/telemetry/usage-telemetry-reporter.test.ts

@@ -70,14 +70,6 @@ mock.module("../util/device-id.js", () => ({
   getDeviceId: mockGetDeviceId,
 }));
 
-const mockGetExternalAssistantId = mock<() => string | undefined>(
-  () => "test-assistant-id",
-);
-
-mock.module("../runtime/auth/external-assistant-id.js", () => ({
-  getExternalAssistantId: mockGetExternalAssistantId,
-}));
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -107,7 +99,6 @@ mock.module("../memory/lifecycle-events-store.js", () => ({
 // Production import (after mocks)
 // ---------------------------------------------------------------------------
 
-import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
 import type { UsageEvent } from "../usage/types.js";
 import { UsageTelemetryReporter } from "./usage-telemetry-reporter.js";
 
@@ -129,6 +120,9 @@ function makeUsageEvent(overrides: Partial<UsageEvent> = {}): UsageEvent {
     cacheCreationInputTokens: 10,
     cacheReadInputTokens: 5,
     actor: "main_agent",
+    callSite: null,
+    inferenceProfile: null,
+    inferenceProfileSource: null,
     conversationId: "conv-1",
     runId: null,
     requestId: null,
@@ -159,8 +153,6 @@ beforeEach(() => {
   mockGetPlatformBaseUrl.mockReset();
   mockGetDeviceId.mockReset();
   mockGetDeviceId.mockReturnValue("test-device-id");
-  mockGetExternalAssistantId.mockReset();
-  mockGetExternalAssistantId.mockReturnValue("test-assistant-id");
   mockGetPlatformOrganizationId.mockReset();
   mockGetPlatformOrganizationId.mockReturnValue("");
   mockGetPlatformUserId.mockReset();
@@ -359,6 +351,9 @@ describe("UsageTelemetryReporter", () => {
       cacheCreationInputTokens: 20,
       cacheReadInputTokens: 15,
       actor: "context_compactor",
+      callSite: "compactionAgent",
+      inferenceProfile: "quality-optimized",
+      inferenceProfileSource: "conversation",
       createdAt: 1700000099000,
     });
     mockQueryUnreportedUsageEvents.mockReturnValue([event]);
@@ -391,9 +386,39 @@ describe("UsageTelemetryReporter", () => {
     expect(e.cache_creation_input_tokens).toBe(20);
     expect(e.cache_read_input_tokens).toBe(15);
     expect(e.actor).toBe("context_compactor");
+    expect(e.llm_call_site).toBe("compactionAgent");
+    expect(e.inference_profile).toBe("quality-optimized");
+    expect(e.inference_profile_source).toBe("conversation");
     expect(e.recorded_at).toBe(1700000099000);
   });
 
+  test("payload preserves null attribution for historical usage rows", async () => {
+    const event = makeUsageEvent({
+      id: "evt-legacy-usage",
+      callSite: null,
+      inferenceProfile: null,
+      inferenceProfileSource: null,
+    });
+    mockQueryUnreportedUsageEvents.mockReturnValue([event]);
+    mockFetch.mockImplementation(() =>
+      Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
+    );
+
+    const reporter = new UsageTelemetryReporter();
+    await reporter.flush();
+
+    const body = JSON.parse(
+      (mockFetch.mock.calls[0] as [string, RequestInit])[1].body as string,
+    );
+    expect(body.events[0]).toMatchObject({
+      type: "llm_usage",
+      daemon_event_id: "evt-legacy-usage",
+      llm_call_site: null,
+      inference_profile: null,
+      inference_profile_source: null,
+    });
+  });
+
   test("organization_id and user_id included in payload when available", async () => {
     mockGetPlatformOrganizationId.mockReturnValue("org-123");
     mockGetPlatformUserId.mockReturnValue("user-456");
@@ -434,8 +459,7 @@ describe("UsageTelemetryReporter", () => {
     expect(body.user_id).toBeUndefined();
   });
 
-  test("assistant_id falls back to DAEMON_INTERNAL_ASSISTANT_ID when getExternalAssistantId returns undefined", async () => {
-    mockGetExternalAssistantId.mockReturnValue(undefined);
+  test("payload does not include assistant_id", async () => {
     const events = [makeUsageEvent()];
     mockQueryUnreportedUsageEvents.mockReturnValue(events);
     mockFetch.mockImplementation(() =>
@@ -449,8 +473,7 @@ describe("UsageTelemetryReporter", () => {
     const body = JSON.parse(
       (mockFetch.mock.calls[0] as [string, RequestInit])[1].body as string,
     );
-    expect(body.device_id).toBe("test-device-id");
-    expect(body.assistant_id).toBe(DAEMON_INTERNAL_ASSISTANT_ID);
+    expect(body.assistant_id).toBeUndefined();
   });
 
   test("turn events are included in the events array with type discriminator", async () => {

package/src/telemetry/usage-telemetry-reporter.ts

@@ -23,8 +23,6 @@ import { queryUnreportedLifecycleEvents } from "../memory/lifecycle-events-store
 import { queryUnreportedUsageEvents } from "../memory/llm-usage-store.js";
 import { queryUnreportedTurnEvents } from "../memory/turn-events-store.js";
 import { VellumPlatformClient } from "../platform/client.js";
-import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
-import { getExternalAssistantId } from "../runtime/auth/external-assistant-id.js";
 import { getDeviceId } from "../util/device-id.js";
 import { getLogger } from "../util/logger.js";
 import { APP_VERSION } from "../version.js";
@@ -193,6 +191,9 @@ export class UsageTelemetryReporter {
             cache_creation_input_tokens: e.cacheCreationInputTokens ?? null,
             cache_read_input_tokens: e.cacheReadInputTokens ?? null,
             actor: e.actor,
+            llm_call_site: e.callSite,
+            inference_profile: e.inferenceProfile,
+            inference_profile_source: e.inferenceProfileSource,
             recorded_at: e.createdAt,
           }),
         ),
@@ -213,13 +214,10 @@ export class UsageTelemetryReporter {
         ),
       ];
 
-      const assistantId =
-        getExternalAssistantId() ?? DAEMON_INTERNAL_ASSISTANT_ID;
       const organizationId = getPlatformOrganizationId() || undefined;
       const userId = getPlatformUserId() || undefined;
       const payload = {
         device_id: getDeviceId(),
-        assistant_id: assistantId,
         assistant_version: APP_VERSION,
         ...(organizationId ? { organization_id: organizationId } : {}),
         ...(userId ? { user_id: userId } : {}),

package/src/tools/acp/spawn.test.ts

@@ -98,8 +98,7 @@ const spawnMock = mock(
 );
 
 // Spread the real module's exports so transitive importers that pull other
-// names from `../../acp/index.js` (e.g. `broadcastToAllClients` from the
-// HTTP route layer) still resolve at parse time. Bun's `mock.module` is
+// names from `../../acp/index.js` still resolve at parse time. Bun's `mock.module` is
 // process-global and returns *exactly* the keys the factory returns —
 // without the spread, any module evaluated after this test file errors at
 // load with "Export named '<X>' not found".

package/src/tools/acp/steer.test.ts

@@ -16,8 +16,7 @@ let steerImpl: (acpSessionId: string, instruction: string) => Promise<void> =
   defaultSteer;
 
 // Spread the real module's exports so transitive importers that pull other
-// names from `../../acp/index.js` (e.g. `broadcastToAllClients` from the
-// HTTP route layer) still resolve at parse time. Bun's `mock.module` is
+// names from `../../acp/index.js` still resolve at parse time. Bun's `mock.module` is
 // process-global and returns *exactly* the keys the factory returns.
 const realAcpModule = await import("../../acp/index.js");
 mock.module("../../acp/index.js", () => ({

package/src/tools/browser/__tests__/browser-status.test.ts

@@ -82,6 +82,25 @@ mock.module("../browser-manager.js", () => ({
   },
 }));
 
+/** Mutable proxy returned by HostBrowserProxy.instance. */
+let mockSingletonProxy: {
+  isAvailable: () => boolean;
+  request: unknown;
+} | null = null;
+
+const unavailableFallback = {
+  isAvailable: () => false,
+  request: () => Promise.reject(new Error("no extension")),
+};
+
+mock.module("../../../daemon/host-browser-proxy.js", () => ({
+  HostBrowserProxy: {
+    get instance() {
+      return mockSingletonProxy ?? unavailableFallback;
+    },
+  },
+}));
+
 const { executeBrowserStatus } = await import("../browser-execution.js");
 
 function makeContext(overrides: Partial<ToolContext> = {}): ToolContext {
@@ -101,6 +120,7 @@ describe("executeBrowserStatus", () => {
     probeErrors[BROWSER_STATUS_MODE.EXTENSION] = null;
     probeErrors[BROWSER_STATUS_MODE.CDP_INSPECT] = null;
     probeErrors[BROWSER_STATUS_MODE.LOCAL] = null;
+    mockSingletonProxy = null;
   });
 
   test("reports extension preflight-unavailable when no host browser proxy is bound", async () => {
@@ -139,20 +159,14 @@ describe("executeBrowserStatus", () => {
   });
 
   test("reports extension as connected when probe fails on restricted chrome:// page", async () => {
+    mockSingletonProxy = { isAvailable: () => true, request: () => {} };
     probeOutcomes[BROWSER_STATUS_MODE.EXTENSION] = "fail";
     probeErrors[BROWSER_STATUS_MODE.EXTENSION] = new CdpError(
       "cdp_error",
       "Cannot access a chrome:// URL",
     );
 
-    const result = await executeBrowserStatus(
-      {},
-      makeContext({
-        hostBrowserProxy: {
-          isAvailable: () => true,
-        } as ToolContext["hostBrowserProxy"],
-      }),
-    );
+    const result = await executeBrowserStatus({}, makeContext());
     expect(result.isError).toBe(false);
     const payload = JSON.parse(result.content);
     const extension = payload.modes.find(
@@ -166,14 +180,12 @@ describe("executeBrowserStatus", () => {
 
   // ── macOS host-browser proxy mode tests ─────────────────────────────
 
-  test("macOS: reports host browser proxy as available when proxy is bound and connected", async () => {
+  test("reports extension as available when singleton proxy is connected", async () => {
+    mockSingletonProxy = { isAvailable: () => true, request: () => {} };
     const result = await executeBrowserStatus(
       {},
       makeContext({
         transportInterface: "macos",
-        hostBrowserProxy: {
-          isAvailable: () => true,
-        } as ToolContext["hostBrowserProxy"],
       }),
     );
     expect(result.isError).toBe(false);
@@ -184,64 +196,12 @@ describe("executeBrowserStatus", () => {
     expect(extension).toBeDefined();
     expect(extension.available).toBe(true);
     expect(extension.verified).toBe("active_probe");
-    expect(extension.summary).toContain("macOS host browser proxy");
-    expect(extension.details.transport).toBe("macos-sse");
-  });
-
-  test("macOS: reports transport as extension-ws when hostBrowserRegistryRouted is true", async () => {
-    const result = await executeBrowserStatus(
-      {},
-      makeContext({
-        transportInterface: "macos",
-        hostBrowserRegistryRouted: true,
-        hostBrowserProxy: {
-          isAvailable: () => true,
-        } as ToolContext["hostBrowserProxy"],
-      }),
-    );
-    expect(result.isError).toBe(false);
-    const payload = JSON.parse(result.content);
-    const extension = payload.modes.find(
-      (m: { mode: string }) => m.mode === BROWSER_STATUS_MODE.EXTENSION,
-    );
-    expect(extension).toBeDefined();
-    expect(extension.available).toBe(true);
     expect(extension.details.transport).toBe("extension-ws");
   });
 
-  test("macOS: reports proxy unbound with macOS-specific actions when no proxy is present", async () => {
-    const result = await executeBrowserStatus(
-      {},
-      makeContext({
-        transportInterface: "macos",
-      }),
-    );
-    expect(result.isError).toBe(false);
-    const payload = JSON.parse(result.content);
-    const extension = payload.modes.find(
-      (m: { mode: string }) => m.mode === BROWSER_STATUS_MODE.EXTENSION,
-    );
-    expect(extension).toBeDefined();
-    expect(extension.available).toBe(false);
-    expect(extension.summary).toContain("macOS host browser proxy");
-    expect(extension.summary).toContain("desktop client");
-    expect(extension.details.transport).toBe("macos-sse");
-    // macOS-specific user actions should mention the desktop app, not the extension
-    expect(
-      extension.userActions.some((a: string) => a.includes("desktop app")),
-    ).toBe(true);
-  });
-
-  test("macOS: reports proxy disconnected with reconnect actions when proxy is bound but not available", async () => {
-    const result = await executeBrowserStatus(
-      {},
-      makeContext({
-        transportInterface: "macos",
-        hostBrowserProxy: {
-          isAvailable: () => false,
-        } as ToolContext["hostBrowserProxy"],
-      }),
-    );
+  test("reports extension disconnected when singleton proxy is not available", async () => {
+    // mockSingletonProxy = null → falls back to unavailableFallback
+    const result = await executeBrowserStatus({}, makeContext());
     expect(result.isError).toBe(false);
     const payload = JSON.parse(result.content);
     const extension = payload.modes.find(
@@ -249,31 +209,19 @@ describe("executeBrowserStatus", () => {
     );
     expect(extension).toBeDefined();
     expect(extension.available).toBe(false);
-    expect(extension.summary).toContain("macOS host browser proxy");
-    expect(extension.summary).toContain("SSE transport");
-    expect(extension.details.transport).toBe("macos-sse");
-    // Should suggest reconnection, not extension install
-    expect(
-      extension.userActions.some((a: string) => a.includes("desktop app")),
-    ).toBe(true);
+    expect(extension.summary).toContain("disconnected");
+    expect(extension.details.transport).toBe("extension-ws");
   });
 
-  test("macOS: probe failure diagnostics include transport-specific remediation", async () => {
+  test("probe failure diagnostics include remediation actions", async () => {
+    mockSingletonProxy = { isAvailable: () => true, request: () => {} };
     probeOutcomes[BROWSER_STATUS_MODE.EXTENSION] = "fail";
     probeErrors[BROWSER_STATUS_MODE.EXTENSION] = new CdpError(
       "transport_error",
       "transport disconnected before response",
     );
 
-    const result = await executeBrowserStatus(
-      {},
-      makeContext({
-        transportInterface: "macos",
-        hostBrowserProxy: {
-          isAvailable: () => true,
-        } as ToolContext["hostBrowserProxy"],
-      }),
-    );
+    const result = await executeBrowserStatus({}, makeContext());
     expect(result.isError).toBe(false);
     const payload = JSON.parse(result.content);
     const extension = payload.modes.find(
@@ -281,23 +229,12 @@ describe("executeBrowserStatus", () => {
     );
     expect(extension).toBeDefined();
     expect(extension.available).toBe(false);
-    expect(extension.summary).toContain("macOS host browser proxy");
-    // Should have remediation actions mentioning SSE bridge
-    expect(
-      extension.userActions.some((a: string) => a.includes("SSE bridge")),
-    ).toBe(true);
+    expect(extension.summary).toContain("probe failed");
   });
 
-  test("recommendation order follows auto candidate precedence for macOS with available extension proxy", async () => {
-    const result = await executeBrowserStatus(
-      {},
-      makeContext({
-        transportInterface: "macos",
-        hostBrowserProxy: {
-          isAvailable: () => true,
-        } as ToolContext["hostBrowserProxy"],
-      }),
-    );
+  test("recommendation order follows auto candidate precedence with available extension", async () => {
+    mockSingletonProxy = { isAvailable: () => true, request: () => {} };
+    const result = await executeBrowserStatus({}, makeContext());
     expect(result.isError).toBe(false);
     const payload = JSON.parse(result.content);
     // Extension is the top auto candidate and is available, so it should be recommended
@@ -305,43 +242,24 @@ describe("executeBrowserStatus", () => {
     expect(payload.autoCandidateOrder[0]).toBe(BROWSER_STATUS_MODE.EXTENSION);
   });
 
-  test("recommendation falls to cdp-inspect when macOS proxy is unavailable", async () => {
-    // Extension probe fails
-    probeOutcomes[BROWSER_STATUS_MODE.EXTENSION] = "fail";
-    probeErrors[BROWSER_STATUS_MODE.EXTENSION] = new CdpError(
-      "transport_error",
-      "proxy not connected",
-    );
-
-    const result = await executeBrowserStatus(
-      {},
-      makeContext({
-        transportInterface: "macos",
-        // No proxy bound, so extension unavailable
-      }),
-    );
+  test("recommendation falls to cdp-inspect when extension is unavailable", async () => {
+    // No singleton proxy → extension unavailable
+    const result = await executeBrowserStatus({}, makeContext());
     expect(result.isError).toBe(false);
     const payload = JSON.parse(result.content);
-    // Extension is unavailable (no proxy), so recommendation should fall to next available
+    // Extension is unavailable, so recommendation should fall to next available
     expect(payload.recommendedMode).toBe(BROWSER_STATUS_MODE.CDP_INSPECT);
   });
 
-  test("macOS: restricted chrome:// page probe includes macOS transport details", async () => {
+  test("restricted chrome:// page probe includes transport details", async () => {
+    mockSingletonProxy = { isAvailable: () => true, request: () => {} };
     probeOutcomes[BROWSER_STATUS_MODE.EXTENSION] = "fail";
     probeErrors[BROWSER_STATUS_MODE.EXTENSION] = new CdpError(
       "cdp_error",
       "Cannot access a chrome:// URL",
     );
 
-    const result = await executeBrowserStatus(
-      {},
-      makeContext({
-        transportInterface: "macos",
-        hostBrowserProxy: {
-          isAvailable: () => true,
-        } as ToolContext["hostBrowserProxy"],
-      }),
-    );
+    const result = await executeBrowserStatus({}, makeContext());
     expect(result.isError).toBe(false);
     const payload = JSON.parse(result.content);
     const extension = payload.modes.find(
@@ -349,7 +267,6 @@ describe("executeBrowserStatus", () => {
     );
     expect(extension).toBeDefined();
     expect(extension.available).toBe(true);
-    expect(extension.summary).toContain("macOS host browser proxy");
-    expect(extension.details.transport).toBe("macos-sse");
+    expect(extension.details.transport).toBe("extension-ws");
   });
 });