@vellumai/assistant 0.6.0 → 0.6.1

package/src/runtime/routes/conversation-routes.ts

@@ -38,6 +38,10 @@ import { HostBashProxy } from "../../daemon/host-bash-proxy.js";
 import { HostCuProxy } from "../../daemon/host-cu-proxy.js";
 import { HostFileProxy } from "../../daemon/host-file-proxy.js";
 import type { ServerMessage } from "../../daemon/message-protocol.js";
+import type {
+  MacosTransportMetadata,
+  NonMacosTransportMetadata,
+} from "../../daemon/message-types/conversations.js";
 import type { HeartbeatService } from "../../heartbeat/heartbeat-service.js";
 import * as attachmentsStore from "../../memory/attachments-store.js";
 import {
@@ -410,8 +414,15 @@ export function handleListMessages(
     rawMessages = getMessages(resolvedConversationId);
   }
 
+  // During streaming, tool_use (assistant) and tool_result (user) events are
+  // assembled client-side into a single assistant ChatMessage. On reload, they
+  // are separate DB rows. Merge tool_result blocks from user messages into the
+  // preceding assistant message so renderHistoryContent can pair them via its
+  // pendingToolUses map — otherwise they render as "Unknown" tool calls.
+  const mergedMessages = mergeToolResultsIntoAssistantMessages(rawMessages);
+
   // Parse content blocks and extract text + tool calls
-  const parsed = rawMessages.map((msg) => {
+  const parsed = mergedMessages.map((msg) => {
     let content: unknown;
     try {
       content = JSON.parse(msg.content);
@@ -424,10 +435,33 @@ export function handleListMessages(
     // was queued or its persistence was delayed (long assistant generation),
     // sentAt captures the actual event time. Falls back to createdAt.
     let sentAt: number | undefined;
+    let subagentNotification:
+      | {
+          subagentId: string;
+          label: string;
+          status: string;
+          error?: string;
+          conversationId?: string;
+        }
+      | undefined;
     if (msg.metadata) {
       try {
         const meta = JSON.parse(msg.metadata);
         if (typeof meta.sentAt === "number") sentAt = meta.sentAt;
+        if (meta.subagentNotification) {
+          const n = meta.subagentNotification;
+          if (typeof n.subagentId === "string" && typeof n.label === "string") {
+            subagentNotification = {
+              subagentId: n.subagentId,
+              label: n.label,
+              status: typeof n.status === "string" ? n.status : "completed",
+              ...(typeof n.error === "string" ? { error: n.error } : {}),
+              ...(typeof n.conversationId === "string"
+                ? { conversationId: n.conversationId }
+                : {}),
+            };
+          }
+        }
       } catch {
         // Ignore malformed metadata
       }
@@ -475,6 +509,7 @@ export function handleListMessages(
           ? { thinkingSegments: rendered.thinkingSegments }
           : {}),
         id: msg.id,
+        subagentNotification,
       };
     }
 
@@ -492,6 +527,7 @@ export function handleListMessages(
         ? { thinkingSegments: rendered.thinkingSegments }
         : {}),
       id: msg.id,
+      subagentNotification,
     };
   });
 
@@ -580,6 +616,9 @@ export function handleListMessages(
         ? { thinkingSegments: m.thinkingSegments }
         : {}),
       ...(m.contentOrder.length > 0 ? { contentOrder: m.contentOrder } : {}),
+      ...(m.subagentNotification
+        ? { subagentNotification: m.subagentNotification }
+        : {}),
     };
   });
 
@@ -599,6 +638,157 @@ export function handleListMessages(
   return Response.json({ messages });
 }
 
+// ── Tool-result merging ─────────────────────────────────────────────
+
+function isToolResultType(type: string): boolean {
+  return type === "tool_result" || type === "web_search_tool_result";
+}
+
+function isSystemNoticeText(block: Record<string, unknown>): boolean {
+  if (block.type !== "text") return false;
+  const text = typeof block.text === "string" ? block.text : "";
+  return (
+    text.startsWith("<system_notice>") && text.endsWith("</system_notice>")
+  );
+}
+
+/**
+ * Merge tool_result blocks from user messages into the preceding assistant
+ * message's content array. This lets renderHistoryContent's pendingToolUses
+ * map pair tool_use and tool_result blocks, preventing "unknown" tool names.
+ *
+ * User messages that consist entirely of tool_result blocks (and optional
+ * system_notice text) are removed from the output. Mixed messages (tool_result
+ * + real user text) keep only the non-tool-result blocks.
+ */
+function mergeToolResultsIntoAssistantMessages(
+  messages: MessageRow[],
+): MessageRow[] {
+  // Index of the most recent assistant message in the output array.
+  let lastAssistantIdx = -1;
+  // Parsed content caches — lazily populated per assistant message.
+  const parsedAssistantContent = new Map<number, unknown[]>();
+
+  const result: MessageRow[] = [];
+
+  for (const msg of messages) {
+    if (msg.role === "assistant") {
+      lastAssistantIdx = result.length;
+      result.push(msg);
+      continue;
+    }
+
+    // Only process user messages — other roles pass through.
+    if (msg.role !== "user") {
+      result.push(msg);
+      continue;
+    }
+
+    let blocks: unknown[];
+    try {
+      const parsed = JSON.parse(msg.content);
+      if (!Array.isArray(parsed)) {
+        result.push(msg);
+        continue;
+      }
+      blocks = parsed;
+    } catch {
+      result.push(msg);
+      continue;
+    }
+
+    // Separate tool-result blocks from real user content.
+    const toolResultBlocks: unknown[] = [];
+    const otherBlocks: unknown[] = [];
+    for (const block of blocks) {
+      if (
+        typeof block === "object" &&
+        block !== null &&
+        typeof (block as Record<string, unknown>).type === "string"
+      ) {
+        const rec = block as Record<string, unknown>;
+        if (isToolResultType(rec.type as string)) {
+          toolResultBlocks.push(block);
+        } else if (isSystemNoticeText(rec)) {
+          // System notices don't count as user content — drop them when
+          // the message is otherwise tool-result-only.
+          otherBlocks.push(block);
+        } else {
+          otherBlocks.push(block);
+        }
+      } else {
+        otherBlocks.push(block);
+      }
+    }
+
+    // No tool results → pass through unchanged.
+    if (toolResultBlocks.length === 0) {
+      result.push(msg);
+      continue;
+    }
+
+    // Append tool_result blocks to the preceding assistant message's content.
+    if (lastAssistantIdx >= 0) {
+      const assistant = result[lastAssistantIdx];
+      let assistantContent = parsedAssistantContent.get(lastAssistantIdx);
+      if (!assistantContent) {
+        try {
+          const parsed = JSON.parse(assistant.content);
+          assistantContent = Array.isArray(parsed) ? parsed : [parsed];
+        } catch {
+          assistantContent = [];
+        }
+        parsedAssistantContent.set(lastAssistantIdx, assistantContent);
+      }
+      assistantContent.push(...toolResultBlocks);
+    } else {
+      // No preceding assistant message (pagination boundary) — keep the
+      // original message as-is to avoid permanent data loss. The preceding
+      // assistant tool_use lives in the previous page; dropping the result
+      // here would be unrecoverable.
+      // Still strip system notices so internal prompt text isn't exposed.
+      const filteredBlocks = blocks.filter(
+        (b) =>
+          !(
+            typeof b === "object" &&
+            b !== null &&
+            isSystemNoticeText(b as Record<string, unknown>)
+          ),
+      );
+      result.push({
+        ...msg,
+        content:
+          filteredBlocks.length === blocks.length
+            ? msg.content
+            : JSON.stringify(filteredBlocks),
+      });
+      continue;
+    }
+
+    // If the user message had only tool_result (+ system_notice) blocks,
+    // suppress it entirely. Otherwise keep the non-tool-result content.
+    const realUserContent = otherBlocks.filter(
+      (b) =>
+        !(
+          typeof b === "object" &&
+          b !== null &&
+          isSystemNoticeText(b as Record<string, unknown>)
+        ),
+    );
+    if (realUserContent.length > 0) {
+      result.push({ ...msg, content: JSON.stringify(otherBlocks) });
+    }
+    // else: tool-result-only → suppressed (results already merged above)
+  }
+
+  // Write back any modified assistant message content.
+  for (const [idx, content] of parsedAssistantContent) {
+    result[idx] = { ...result[idx], content: JSON.stringify(content) };
+  }
+
+  return result;
+}
+
 /**
  * Build an `onEvent` callback that publishes every outbound event to the
  * assistant event hub, maintaining ordered delivery through a serial chain.
@@ -658,13 +848,10 @@ function makeHubPublisher(
           guardianPrincipalId: trustContext?.guardianPrincipalId ?? undefined,
           toolName: msg.toolName,
           commandPreview:
-            redactSecrets(
-              summarizeToolInput(msg.toolName, inputRecord),
-            ) || undefined,
+            redactSecrets(summarizeToolInput(msg.toolName, inputRecord)) ||
+            undefined,
           riskLevel: msg.riskLevel,
-          activityText: activityRaw
-            ? redactSecrets(activityRaw)
-            : undefined,
+          activityText: activityRaw ? redactSecrets(activityRaw) : undefined,
           executionTarget: msg.executionTarget,
           status: "pending",
           requestCode: generateCanonicalRequestCode(),
@@ -759,6 +946,8 @@ export async function handleSendMessage(
     conversationType?: string;
     automated?: boolean;
     bypassSecretCheck?: boolean;
+    hostHomeDir?: string;
+    hostUsername?: string;
   };
 
   const { conversationKey, content, attachmentIds } = body;
@@ -791,9 +980,11 @@ export async function handleSendMessage(
     );
   }
 
-  if (!conversationKey) {
-    return httpError("BAD_REQUEST", "conversationKey is required", 400);
-  }
+  // When conversationKey is omitted, derive a stable default from
+  // sourceChannel + sourceInterface so that repeated calls from the same
+  // channel/interface pair share a single conversation thread.
+  const resolvedConversationKey =
+    conversationKey ?? `default:${sourceChannel}:${sourceInterface}`;
 
   // Reject non-string content values (numbers, objects, etc.)
   if (content != null && typeof content !== "string") {
@@ -856,12 +1047,29 @@ export async function handleSendMessage(
 
   const conversationType =
     body.conversationType === "private" ? ("private" as const) : undefined;
-  const mapping = getOrCreateConversation(conversationKey, {
+  const mapping = getOrCreateConversation(resolvedConversationKey, {
     conversationType,
   });
   const smDeps = deps.sendMessageDeps;
+
+  // Build transport metadata from the request so the daemon can inject
+  // host environment hints (home directory, username) into the LLM context.
+  const transport =
+    sourceInterface === "macos"
+      ? ({
+          channelId: sourceChannel,
+          interfaceId: "macos" as const,
+          hostHomeDir: body.hostHomeDir,
+          hostUsername: body.hostUsername,
+        } satisfies MacosTransportMetadata)
+      : ({
+          channelId: sourceChannel,
+          interfaceId: sourceInterface,
+        } satisfies NonMacosTransportMetadata);
+
   const conversation = await smDeps.getOrCreateConversation(
     mapping.conversationId,
+    { transport },
   );
 
   // Resolve guardian context from the AuthContext's actorPrincipalId.
@@ -932,7 +1140,7 @@ export async function handleSendMessage(
   // channels, headless) fall back to local execution.
   // Set the proxy BEFORE updateClient so updateClient's call to
   // hostBashProxy.updateSender targets the correct (new) proxy.
-  if (sourceInterface === "macos" || sourceInterface === "ios") {
+  if (sourceInterface === "macos") {
     // Reuse the existing proxy if the conversation is actively processing a
     // host bash request to avoid orphaning in-flight requests.
     if (!conversation.isProcessing() || !conversation.hostBashProxy) {
@@ -969,9 +1177,7 @@ export async function handleSendMessage(
   // When proxies are preserved during an active turn (non-desktop request while
   // processing), skip updating proxy senders to avoid degrading them.
   const preservingProxies =
-    conversation.isProcessing() &&
-    sourceInterface !== "macos" &&
-    sourceInterface !== "ios";
+    conversation.isProcessing() && sourceInterface !== "macos";
   conversation.updateClient(onEvent, !isInteractive, {
     skipProxySenderUpdate: preservingProxies,
   });
@@ -1143,36 +1349,47 @@ export async function handleSendMessage(
     // Auto-deny pending confirmations only after enqueue succeeds, so we
     // don't cancel approval-gated workflows when the replacement message
     // is itself rejected by the queue budget.
-    if (conversation.hasAnyPendingConfirmation()) {
-      // Emit authoritative denial state for each pending request.
-      // sendToClient (wired to the SSE hub) delivers these to the client.
-      for (const interaction of pendingInteractions.getByConversation(
-        mapping.conversationId,
-      )) {
-        if (
-          interaction.conversation === conversation &&
-          interaction.kind === "confirmation"
-        ) {
-          conversation.emitConfirmationStateChanged({
-            conversationId: mapping.conversationId,
-            requestId: interaction.requestId,
-            state: "denied" as const,
-            source: "auto_deny" as const,
-          });
-          // Sync canonical guardian request status so stale "pending" DB
-          // records don't get matched by later guardian reply routing.
-          resolveCanonicalGuardianRequest(interaction.requestId, "pending", {
-            status: "denied",
-          });
+    // Wrapped in try-catch: the message is already enqueued, so a failure
+    // here must not turn the 202 response into a 500 — that would leave
+    // the client showing "Failed to send" for a message the daemon will
+    // process from the queue.
+    try {
+      if (conversation.hasAnyPendingConfirmation()) {
+        // Emit authoritative denial state for each pending request.
+        // sendToClient (wired to the SSE hub) delivers these to the client.
+        for (const interaction of pendingInteractions.getByConversation(
+          mapping.conversationId,
+        )) {
+          if (
+            interaction.conversation === conversation &&
+            interaction.kind === "confirmation"
+          ) {
+            conversation.emitConfirmationStateChanged({
+              conversationId: mapping.conversationId,
+              requestId: interaction.requestId,
+              state: "denied" as const,
+              source: "auto_deny" as const,
+            });
+            // Sync canonical guardian request status so stale "pending" DB
+            // records don't get matched by later guardian reply routing.
+            resolveCanonicalGuardianRequest(interaction.requestId, "pending", {
+              status: "denied",
+            });
+          }
         }
+        conversation.denyAllPendingConfirmations();
+        pendingInteractions.removeByConversation(conversation);
       }
-      conversation.denyAllPendingConfirmations();
-      pendingInteractions.removeByConversation(conversation);
-    }
 
-    // Expire any orphaned canonical requests that survived without a
-    // matching in-memory pending interaction (e.g. prompter timeouts).
-    expireOrphanedCanonicalRequests(mapping.conversationId);
+      // Expire any orphaned canonical requests that survived without a
+      // matching in-memory pending interaction (e.g. prompter timeouts).
+      expireOrphanedCanonicalRequests(mapping.conversationId);
+    } catch (err) {
+      log.warn(
+        { err, conversationId: mapping.conversationId },
+        "Post-enqueue auto-deny failed — queued message unaffected",
+      );
+    }
 
     return Response.json(
       { accepted: true, queued: true, conversationId: mapping.conversationId },
@@ -1397,7 +1614,10 @@ export async function handleSendMessage(
           conversationId,
         });
         conversation.processing = false;
-        silentlyWithLog(conversation.drainQueue(), "compact-command queue drain");
+        silentlyWithLog(
+          conversation.drainQueue(),
+          "compact-command queue drain",
+        );
       }, 0);
 
       cleanupDeferred = true;
@@ -1713,7 +1933,7 @@ export function conversationRouteDefinitions(deps: {
         "Send a user message to a conversation and trigger the assistant response.",
       tags: ["messages"],
       requestBody: z.object({
-        conversationKey: z.string(),
+        conversationKey: z.string().optional(),
         content: z.string().describe("Message text content"),
         attachments: z
           .array(z.unknown())

package/src/runtime/routes/heartbeat-routes.ts

@@ -47,16 +47,10 @@ function handleUpdateConfig(
   if (typeof body.enabled === "boolean") heartbeat.enabled = body.enabled;
   if (typeof body.intervalMs === "number")
     heartbeat.intervalMs = body.intervalMs;
-  if ("activeHoursStart" in body) {
-    heartbeat.activeHoursStart =
-      typeof body.activeHoursStart === "number"
-        ? body.activeHoursStart
-        : undefined;
-  }
-  if ("activeHoursEnd" in body) {
-    heartbeat.activeHoursEnd =
-      typeof body.activeHoursEnd === "number" ? body.activeHoursEnd : undefined;
-  }
+  if (typeof body.activeHoursStart === "number")
+    heartbeat.activeHoursStart = body.activeHoursStart;
+  if (typeof body.activeHoursEnd === "number")
+    heartbeat.activeHoursEnd = body.activeHoursEnd;
 
   try {
     saveConfig({ ...config, heartbeat });

package/src/runtime/routes/identity-routes.ts

@@ -10,6 +10,7 @@ import { fileURLToPath } from "node:url";
 import { z } from "zod";
 
 import { parseIdentityFields } from "../../daemon/handlers/identity.js";
+import { getProfilerRuntimeStatus } from "../../daemon/profiler-run-store.js";
 import { getMaxMigrationVersion } from "../../memory/migrations/registry.js";
 import {
   getWorkspaceDir,
@@ -144,6 +145,13 @@ export function handleHealth(): Response {
 }
 
 export function handleDetailedHealth(): Response {
+  let profiler: ReturnType<typeof getProfilerRuntimeStatus> | undefined;
+  try {
+    profiler = getProfilerRuntimeStatus();
+  } catch {
+    // Profiler status is non-critical — omit on error
+  }
+
   return Response.json({
     status: "healthy",
     timestamp: new Date().toISOString(),
@@ -156,6 +164,7 @@ export function handleDetailedHealth(): Response {
       lastWorkspaceMigrationId:
         getLastWorkspaceMigrationId(WORKSPACE_MIGRATIONS),
     },
+    ...(profiler ? { profiler } : {}),
   });
 }
 
@@ -239,6 +248,48 @@ export function handleGetIdentityIntro(): Response {
   return Response.json({ text: cached.text });
 }
 
+// ---------------------------------------------------------------------------
+// Zod schemas for profiler health metadata
+// ---------------------------------------------------------------------------
+
+const profilerBudgetSchema = z.object({
+  maxBytes: z.number(),
+  remainingBytes: z.number(),
+  minFreeMb: z.number(),
+  freeMb: z.number(),
+  overBudget: z.boolean(),
+});
+
+const profilerLastCompletedRunSchema = z.object({
+  runId: z.string(),
+  totalBytes: z.number(),
+  artifactCount: z.number(),
+  hasSummaries: z.boolean(),
+  completedAt: z.string(),
+});
+
+const profilerStatusSchema = z.object({
+  enabled: z.boolean(),
+  mode: z.string().nullable(),
+  runId: z.string().nullable(),
+  runDir: z.string().nullable(),
+  totalBytes: z.number(),
+  artifactCount: z.number(),
+  budget: profilerBudgetSchema.nullable(),
+  lastCompletedRun: profilerLastCompletedRunSchema.nullable(),
+});
+
+const detailedHealthSchema = z.object({
+  status: z.string(),
+  timestamp: z.string(),
+  version: z.string(),
+  disk: z.object({}).passthrough(),
+  memory: z.object({}).passthrough(),
+  cpu: z.object({}).passthrough(),
+  migrations: z.object({}).passthrough(),
+  profiler: profilerStatusSchema.optional(),
+});
+
 // ---------------------------------------------------------------------------
 // Route definitions
 // ---------------------------------------------------------------------------
@@ -253,15 +304,7 @@ export function identityRouteDefinitions(): RouteDefinition[] {
       description:
         "Returns runtime health including version, disk, memory, CPU, and migration status.",
       tags: ["system"],
-      responseBody: z.object({
-        status: z.string(),
-        timestamp: z.string(),
-        version: z.string(),
-        disk: z.object({}).passthrough(),
-        memory: z.object({}).passthrough(),
-        cpu: z.object({}).passthrough(),
-        migrations: z.object({}).passthrough(),
-      }),
+      responseBody: detailedHealthSchema,
     },
     {
       endpoint: "healthz",
@@ -272,15 +315,7 @@ export function identityRouteDefinitions(): RouteDefinition[] {
       description:
         "Alias for /v1/health. Returns runtime health including version, disk, memory, CPU, and migration status.",
       tags: ["system"],
-      responseBody: z.object({
-        status: z.string(),
-        timestamp: z.string(),
-        version: z.string(),
-        disk: z.object({}).passthrough(),
-        memory: z.object({}).passthrough(),
-        cpu: z.object({}).passthrough(),
-        migrations: z.object({}).passthrough(),
-      }),
+      responseBody: detailedHealthSchema,
     },
     {
       endpoint: "identity",

package/src/runtime/routes/llm-context-normalization.ts

@@ -570,16 +570,8 @@ function anthropicMessageSections(
   const role = asString(message.role) ?? "unknown";
   const content = message.content;
   const sections: LlmContextSection[] = [];
-  const text = collectAnthropicMessageText(content);
-  if (text) {
-    sections.push({
-      kind: "message",
-      label,
-      role,
-      text,
-    });
-  }
 
+  // Collect reasoning sections first so they appear before the message text.
   for (const block of asRecordArray(content) ?? []) {
     const type = asString(block.type);
     if (type === "thinking" || type === "redacted_thinking") {
@@ -589,9 +581,21 @@ function anthropicMessageSections(
         role,
         text: collectAnthropicReasoningText(block),
       });
-      continue;
     }
+  }
 
+  const text = collectAnthropicMessageText(content);
+  if (text) {
+    sections.push({
+      kind: "message",
+      label,
+      role,
+      text,
+    });
+  }
+
+  for (const block of asRecordArray(content) ?? []) {
+    const type = asString(block.type);
     if (isAnthropicToolUseType(type)) {
       sections.push({
         kind: "tool_use",