@vellumai/assistant 0.4.56 → 0.4.57

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

@@ -43,8 +43,8 @@ import {
 } from "../../tools/execution-target.js";
 import { getAllTools, getTool } from "../../tools/registry.js";
 import {
-  injectReasonField,
-  REASON_SKIP_SET,
+  ACTIVITY_SKIP_SET,
+  injectActivityField,
 } from "../../tools/schema-transforms.js";
 import { isSideEffectTool } from "../../tools/side-effects.js";
 import { generateAndSaveAvatar } from "../../tools/system/avatar-generator.js";
@@ -400,17 +400,17 @@ function handleToolNamesList(): Response {
     }
   }
 
-  // Apply reason injection so settings/debug schemas match runtime behavior.
-  const transformedDefs = injectReasonField(rawDefs, REASON_SKIP_SET);
+  // Apply activity injection so settings/debug schemas match runtime behavior.
+  const transformedDefs = injectActivityField(rawDefs, ACTIVITY_SKIP_SET);
   for (const def of transformedDefs) {
     schemas[def.name] = def.input_schema as SchemaShape;
   }
 
   // Skill manifest schemas are served raw (untransformed). Unlike runtime tool
-  // schemas which have `reason` injected via injectReasonField(), skill manifests
-  // reflect the original TOOLS.json content. This is intentional: skill tools are
-  // invoked through skill_execute (which has its own reason field), so their
-  // individual schemas are never sent to the LLM directly.
+  // schemas which have `activity` injected via injectActivityField(), skill
+  // manifests reflect the original TOOLS.json content. This is intentional:
+  // skill tools are invoked through skill_execute (which has its own activity
+  // field), so their individual schemas are never sent to the LLM directly.
   try {
     const catalog = loadSkillCatalog();
     for (const skill of catalog) {

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

@@ -0,0 +1,53 @@
+/**
+ * Route handlers for telemetry lifecycle events.
+ *
+ * POST /v1/telemetry/lifecycle — record a lifecycle event (app_open, hatch).
+ */
+
+import { recordLifecycleEvent } from "../../memory/lifecycle-events-store.js";
+import { getLogger } from "../../util/logger.js";
+import { httpError } from "../http-errors.js";
+import type { RouteDefinition } from "../http-router.js";
+
+const log = getLogger("telemetry-routes");
+
+const VALID_EVENT_NAMES = new Set(["app_open", "hatch"]);
+
+export async function handleRecordLifecycleEvent(
+  req: Request,
+): Promise<Response> {
+  let body: { event_name?: string };
+  try {
+    body = (await req.json()) as { event_name?: string };
+  } catch {
+    return httpError("BAD_REQUEST", "Invalid JSON body", 400);
+  }
+
+  const eventName = body.event_name;
+  if (!eventName || !VALID_EVENT_NAMES.has(eventName)) {
+    return httpError(
+      "BAD_REQUEST",
+      `event_name must be one of: ${[...VALID_EVENT_NAMES].join(", ")}`,
+      400,
+    );
+  }
+
+  const event = recordLifecycleEvent(eventName);
+  log.info({ eventName, eventId: event.id }, "Recorded lifecycle event");
+
+  return Response.json({ id: event.id, event_name: event.eventName });
+}
+
+// ---------------------------------------------------------------------------
+// Route definitions
+// ---------------------------------------------------------------------------
+
+export function telemetryRouteDefinitions(): RouteDefinition[] {
+  return [
+    {
+      endpoint: "telemetry/lifecycle",
+      method: "POST",
+      handler: async ({ req }) => handleRecordLifecycleEvent(req),
+    },
+  ];
+}

package/src/runtime/routes/trace-event-routes.ts

@@ -0,0 +1,62 @@
+/**
+ * HTTP route handlers for trace event retrieval.
+ *
+ * GET /v1/trace-events — Returns persisted trace events for a conversation.
+ */
+
+import { getTraceEvents } from "../../memory/trace-event-store.js";
+import { httpError } from "../http-errors.js";
+import type { RouteDefinition } from "../http-router.js";
+
+// ---------------------------------------------------------------------------
+// Route definitions
+// ---------------------------------------------------------------------------
+
+export function traceEventRouteDefinitions(): RouteDefinition[] {
+  return [
+    {
+      endpoint: "trace-events",
+      method: "GET",
+      handler: ({ url }) => {
+        const conversationId = url.searchParams.get("conversationId");
+        if (!conversationId) {
+          return httpError(
+            "BAD_REQUEST",
+            "conversationId query parameter is required",
+            400,
+          );
+        }
+
+        const limitParam = url.searchParams.get("limit");
+        const afterSequenceParam = url.searchParams.get("afterSequence");
+
+        const limit = limitParam ? parseInt(limitParam, 10) : undefined;
+        if (limitParam && (isNaN(limit!) || limit! <= 0)) {
+          return httpError(
+            "BAD_REQUEST",
+            "limit must be a positive integer",
+            400,
+          );
+        }
+
+        const afterSequence = afterSequenceParam
+          ? parseInt(afterSequenceParam, 10)
+          : undefined;
+        if (afterSequenceParam && (isNaN(afterSequence!) || afterSequence! < 0)) {
+          return httpError(
+            "BAD_REQUEST",
+            "afterSequence must be a non-negative integer",
+            400,
+          );
+        }
+
+        const events = getTraceEvents(conversationId, {
+          limit,
+          afterSequence,
+        });
+
+        return Response.json({ events });
+      },
+    },
+  ];
+}

package/src/runtime/tool-grant-request-helper.ts

@@ -146,7 +146,7 @@ export function createOrReuseToolGrantRequest(
   const signalPromise = emitNotificationSignal({
     sourceEventName: "guardian.question",
     sourceChannel: sourceChannel as NotificationSourceChannel,
-    sourceSessionId: conversationId,
+    sourceContextId: conversationId,
     attentionHints: {
       requiresAction: true,
       urgency: "high",

package/src/runtime/verification-outbound-actions.ts

@@ -116,6 +116,12 @@ export interface OutboundActionResult {
   pendingBootstrap?: boolean;
   /** Echoed back so consumers know which conversation to target for pointers. */
   originConversationId?: string;
+  /** Internal: Slack DM delivery payload for the caller to dispatch.
+   *  The shared startOutbound/resendOutbound functions no longer fire the
+   *  delivery themselves because CLI subprocesses are sandboxed and cannot
+   *  reach the gateway.  The daemon HTTP route handler calls
+   *  deliverVerificationSlack() after receiving this payload. */
+  _pendingSlackDm?: { userId: string; text: string; assistantId: string };
 }
 
 // ---------------------------------------------------------------------------
@@ -486,42 +492,52 @@ function startOutboundVoice(
 
 /**
  * Deliver a verification Slack DM via the gateway's /deliver/slack endpoint.
- * Fire-and-forget with error logging.
+ * Returns a promise that resolves when the delivery attempt completes.
  */
-export function deliverVerificationSlack(
+export async function deliverVerificationSlackAsync(
   userId: string,
   text: string,
   assistantId: string,
-): void {
-  (async () => {
-    try {
-      const gatewayUrl = getGatewayInternalBaseUrl();
-      const bearerToken = mintDaemonDeliveryToken();
-      const url = `${gatewayUrl}/deliver/slack`;
-      const resp = await fetch(url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${bearerToken}`,
-        },
-        body: JSON.stringify({ chatId: userId, text, assistantId }),
-      });
-      if (!resp.ok) {
-        const body = await resp.text().catch(() => "<unreadable>");
-        log.error(
-          { userId, assistantId, status: resp.status, body },
-          "Gateway /deliver/slack failed for verification",
-        );
-      } else {
-        log.info({ userId, assistantId }, "Verification Slack DM delivered");
-      }
-    } catch (err) {
+): Promise<void> {
+  try {
+    const gatewayUrl = getGatewayInternalBaseUrl();
+    const bearerToken = mintDaemonDeliveryToken();
+    const url = `${gatewayUrl}/deliver/slack`;
+    const resp = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${bearerToken}`,
+      },
+      body: JSON.stringify({ chatId: userId, text, assistantId }),
+    });
+    if (!resp.ok) {
+      const body = await resp.text().catch(() => "<unreadable>");
       log.error(
-        { err, userId, assistantId },
-        "Failed to deliver verification Slack DM",
+        { userId, assistantId, status: resp.status, body },
+        "Gateway /deliver/slack failed for verification",
       );
+    } else {
+      log.info({ userId, assistantId }, "Verification Slack DM delivered");
     }
-  })();
+  } catch (err) {
+    log.error(
+      { err, userId, assistantId },
+      "Failed to deliver verification Slack DM",
+    );
+  }
+}
+
+/**
+ * Deliver a verification Slack DM via the gateway's /deliver/slack endpoint.
+ * Fire-and-forget wrapper for use in the daemon process (HTTP route handlers).
+ */
+export function deliverVerificationSlack(
+  userId: string,
+  text: string,
+  assistantId: string,
+): void {
+  deliverVerificationSlackAsync(userId, text, assistantId);
 }
 
 function startOutboundSlack(
@@ -588,7 +604,6 @@ function startOutboundSlack(
   const sendCount = 1;
 
   updateSessionDelivery(sessionResult.sessionId, now, sendCount, nextResendAt);
-  deliverVerificationSlack(destination, slackBody, assistantId);
 
   return {
     success: true,
@@ -599,6 +614,7 @@ function startOutboundSlack(
     sendCount,
     channel,
     originConversationId,
+    _pendingSlackDm: { userId: destination, text: slackBody, assistantId },
   };
 }
 
@@ -788,7 +804,6 @@ export function resendOutbound(
       newSendCount,
       nextResendAt,
     );
-    deliverVerificationSlack(destination, slackBody, assistantId);
 
     return {
       success: true,
@@ -798,6 +813,7 @@ export function resendOutbound(
       sendCount: newSendCount,
       channel,
       originConversationId,
+      _pendingSlackDm: { userId: destination, text: slackBody, assistantId },
     };
   }