@vellumai/assistant 0.7.0 → 0.7.2

package/src/subagent/manager.ts

@@ -116,13 +116,6 @@ export interface SubagentNotificationInfo {
   conversationId?: string;
 }
 
-export type ParentNotifyCallback = (
-  parentConversationId: string,
-  message: string,
-  sendToClient: (msg: ServerMessage) => void,
-  notification: SubagentNotificationInfo,
-) => void;
-
 export class SubagentManager {
   /** subagentId → ManagedSubagent */
   private subagents = new Map<string, ManagedSubagent>();
@@ -131,26 +124,12 @@ export class SubagentManager {
   /** `${parentConversationId}:${normalizedLabel}` → subagentId */
   private labelIndex = new Map<string, string>();
 
-  /**
-   * Optional callback to inject a completion/failure message into the parent
-   * conversation so the LLM can automatically inform the user.
-   * Wired by DaemonServer at startup.
-   */
-  onSubagentFinished?: ParentNotifyCallback;
-
   /**
    * Shared rate-limit timestamps array from the daemon server.
    * Set by DaemonServer at startup so subagents share the global rate limit.
    */
   sharedRequestTimestamps: number[] = [];
 
-  /**
-   * Broadcast callback from the daemon server.
-   * Set by DaemonServer at startup so subagent conversations can broadcast
-   * to all connected clients (e.g. app_files_changed side-effects).
-   */
-  broadcastToAllClients?: (msg: ServerMessage) => void;
-
   // ── Spawn ───────────────────────────────────────────────────────────
 
   /**
@@ -310,7 +289,6 @@ export class SubagentManager {
       maxTokens,
       wrappedSendToClient,
       workingDir,
-      this.broadcastToAllClients, // forward parent's broadcast so tool side-effects (e.g. app_files_changed) reach all clients
       memoryPolicy,
       undefined, // sharedCesClient
       undefined, // speedOverride
@@ -427,8 +405,6 @@ export class SubagentManager {
     this.setStatus(subagentId, "running", getSender());
     managed.state.startedAt = Date.now();
 
-    const onEvent = conversation.sendToClient;
-
     try {
       // For forks, inject the parent's message history before the first message.
       // This prepends the inherited context so the fork has full conversational
@@ -462,7 +438,7 @@ export class SubagentManager {
           ].join("\n")
         : objective;
       const messageId = await conversation.persistUserMessage(message, []);
-      await conversation.runAgentLoop(message, messageId, onEvent, {
+      await conversation.runAgentLoop(message, messageId, undefined, {
         callSite: "subagentSpawn",
         ...(managed.state.config.overrideProfile
           ? { overrideProfile: managed.state.config.overrideProfile }
@@ -480,7 +456,7 @@ export class SubagentManager {
         log.info({ subagentId }, "Subagent completed");
 
         // Notify the parent conversation so the LLM can call subagent_read.
-        this.notifyParentTerminal(managed, "completed", getSender());
+        this.notifyParentTerminal(managed, "completed");
       }
     } catch (err) {
       const errorMsg = err instanceof Error ? err.message : String(err);
@@ -493,7 +469,7 @@ export class SubagentManager {
       // Only update status if not already terminal (e.g. aborted).
       if (!TERMINAL_STATUSES.has(managed.state.status)) {
         this.setStatus(subagentId, "failed", getSender(), errorMsg);
-        this.notifyParentTerminal(managed, "failed", getSender());
+        this.notifyParentTerminal(managed, "failed");
       }
 
       log.error({ subagentId, err }, "Subagent failed");
@@ -566,30 +542,24 @@ export class SubagentManager {
       this.setStatus(subagentId, "aborted", statusSender);
       // Notify parent that the subagent was explicitly aborted — tell it NOT to re-spawn.
       // Skip when the parent LLM itself called subagent_abort (it already has the tool result).
-      if (this.onSubagentFinished && !options?.suppressNotification) {
+      if (!options?.suppressNotification) {
         const label = managed.state.config.label;
         const prefix = managed.state.isFork ? "Fork" : "Subagent";
         const message =
           `[${prefix} "${label}" was explicitly aborted]\n\n` +
           `This ${prefix.toLowerCase()} was cancelled on purpose. Do NOT re-spawn or retry it.`;
-        try {
-          // Use the managed subagent's stored parentSendToClient so the
-          // notification routes to the parent conversation's socket, not the
-          // aborting socket (which may be a different conversation after switching).
-          this.onSubagentFinished(
-            managed.state.config.parentConversationId,
-            message,
-            managed.parentSendToClient,
-            {
+        this.injectMessageIntoParent(
+          managed.state.config.parentConversationId,
+          message,
+          {
+            subagentNotification: {
               subagentId,
               label,
-              status: "aborted",
+              status: "aborted" as const,
               conversationId: managed.state.conversationId,
             },
-          );
-        } catch (err) {
-          log.error({ subagentId, err }, "Failed to notify parent about abort");
-        }
+          },
+        );
       }
     } else {
       managed.state.status = "aborted";
@@ -640,18 +610,10 @@ export class SubagentManager {
     if (TERMINAL_STATUSES.has(managed.state.status) || !managed.conversation)
       return "terminal";
 
-    const onEvent = managed.conversation.sendToClient;
-    const requestId = uuid();
-
     // If the conversation is busy, queue the message; otherwise process immediately.
-    const result = managed.conversation.enqueueMessage(
-      trimmed,
-      [],
-      onEvent,
-      requestId,
-    );
+    const result = managed.conversation.enqueueMessage(trimmed, []);
     if (result.rejected) {
-      return "sent"; // error event already delivered via onEvent
+      return "sent"; // error event already delivered via sendToClient
     }
     if (result.queued) {
       managed.hadEnqueuedMessages = true;
@@ -662,7 +624,7 @@ export class SubagentManager {
       const conversation = managed.conversation;
       const messageId = await conversation.persistUserMessage(trimmed, []);
       conversation
-        .runAgentLoop(trimmed, messageId, onEvent, {
+        .runAgentLoop(trimmed, messageId, undefined, {
           callSite: "subagentSpawn",
           ...(managed.state.config.overrideProfile
             ? { overrideProfile: managed.state.config.overrideProfile }
@@ -928,7 +890,6 @@ export class SubagentManager {
 
     const managed = this.subagents.get(info.subagentId);
     if (!managed || TERMINAL_STATUSES.has(managed.state.status)) return false;
-    if (!this.onSubagentFinished) return false;
 
     const prefix = managed.state.isFork ? "Fork" : "Subagent";
     let notificationString = `[${prefix} "${info.label}" — ${urgency}] ${message}`;
@@ -936,25 +897,18 @@ export class SubagentManager {
       notificationString += `\nUse subagent_message to send guidance to this ${prefix.toLowerCase()}.`;
     }
 
-    try {
-      this.onSubagentFinished(
-        info.parentConversationId,
-        notificationString,
-        info.parentSendToClient,
-        {
+    this.injectMessageIntoParent(
+      info.parentConversationId,
+      notificationString,
+      {
+        subagentNotification: {
           subagentId: info.subagentId,
           label: info.label,
-          status: "running",
+          status: "running" as const,
         },
-      );
-      return true;
-    } catch (err) {
-      log.error(
-        { subagentId: info.subagentId, err },
-        "Failed to notify parent from subagent",
-      );
-      return false;
-    }
+      },
+    );
+    return true;
   }
 
   /**
@@ -964,10 +918,7 @@ export class SubagentManager {
   private notifyParentTerminal(
     managed: ManagedSubagent,
     outcome: "completed" | "failed",
-    parentSendToClient: (msg: ServerMessage) => void,
   ): void {
-    if (!this.onSubagentFinished) return;
-
     const { config } = managed.state;
     const isFork = managed.state.isFork;
     let message: string;
@@ -1009,18 +960,50 @@ export class SubagentManager {
         : {}),
     };
 
-    try {
-      this.onSubagentFinished(
-        config.parentConversationId,
-        message,
-        parentSendToClient,
-        notification,
-      );
-    } catch (err) {
-      log.error(
-        { subagentId: config.id, err },
-        "Failed to notify parent conversation",
+    this.injectMessageIntoParent(config.parentConversationId, message, {
+      subagentNotification: notification,
+    });
+  }
+
+  /**
+   * Inject a notification message into the parent conversation so the LLM
+   * sees subagent lifecycle events. Relies on the parent conversation's
+   * sendToClient (backed by broadcastMessage) for event delivery.
+   */
+  private injectMessageIntoParent(
+    parentConversationId: string,
+    message: string,
+    metadata?: Record<string, unknown>,
+  ): void {
+    const parentConversation = findConversation(parentConversationId);
+    if (!parentConversation) {
+      log.warn(
+        { parentConversationId },
+        "Subagent finished but parent conversation not found",
       );
+      return;
+    }
+    const enqueueResult = parentConversation.enqueueMessage(
+      message,
+      [],
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      metadata,
+    );
+    if (!enqueueResult.queued && !enqueueResult.rejected) {
+      parentConversation
+        .persistUserMessage(message, [], undefined, metadata)
+        .then((messageId) =>
+          parentConversation.runAgentLoop(message, messageId),
+        )
+        .catch((err) => {
+          log.error(
+            { parentConversationId, err },
+            "Failed to process subagent notification in parent",
+          );
+        });
     }
   }
 }

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,11 @@ 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;
+  /** Computed estimated cost in USD for this LLM call. Null when pricing data is unavailable. */
+  cost: number | 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,60 @@ 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.cost).toBe(0.001);
     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("cost is null when estimatedCostUsd is null (unpriced event)", async () => {
+    const event = makeUsageEvent({
+      id: "evt-unpriced",
+      estimatedCostUsd: null,
+      pricingStatus: "unpriced",
+    });
+    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].cost).toBeNull();
+  });
+
   test("organization_id and user_id included in payload when available", async () => {
     mockGetPlatformOrganizationId.mockReturnValue("org-123");
     mockGetPlatformUserId.mockReturnValue("user-456");
@@ -434,8 +480,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 +494,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,10 @@ 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,
+            cost: e.estimatedCostUsd ?? null,
             recorded_at: e.createdAt,
           }),
         ),
@@ -213,13 +215,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/app-control/skill-proxy-bridge.ts

@@ -0,0 +1,28 @@
+/**
+ * Shared helper for app-control skill wrapper scripts.
+ *
+ * Each wrapper calls forwardAppControlProxyTool() to delegate execution to
+ * the proxy resolver, which forwards the call to the connected client.
+ */
+
+import type { ToolContext, ToolExecutionResult } from "../types.js";
+
+/**
+ * Forward an app-control proxy tool call through the context's proxyToolResolver.
+ *
+ * Returns a clear error result if the resolver is missing (e.g. when the tool
+ * is invoked outside a session with a connected client).
+ */
+export function forwardAppControlProxyTool(
+  toolName: string,
+  input: Record<string, unknown>,
+  context: ToolContext,
+): Promise<ToolExecutionResult> {
+  if (!context.proxyToolResolver) {
+    return Promise.resolve({
+      content: `Cannot execute ${toolName}: no proxy resolver available. This tool requires a connected client.`,
+      isError: true,
+    });
+  }
+  return context.proxyToolResolver(toolName, input);
+}