@vellumai/assistant 0.8.6 → 0.8.7-dev.202606052118.34cd356

package/src/runtime/services/__tests__/analyze-conversation.test.ts

@@ -61,6 +61,12 @@ function makeConversation() {
     setSubagentAllowedTools: mock(() => {}),
     updateClient: mock(() => {}),
     processing: false,
+    isProcessing(this: { processing: boolean }) {
+      return this.processing;
+    },
+    setProcessing(this: { processing: boolean }, value: boolean) {
+      this.processing = value;
+    },
     abortController: null as AbortController | null,
     currentRequestId: null as string | null,
     loadedHistoryTrustClass: undefined as string | undefined,
@@ -167,7 +173,7 @@ describe("analyzeConversation", () => {
       "analysis-new",
       "user",
       expect.any(String),
-      { provenanceTrustClass: "unknown" },
+      { metadata: { provenanceTrustClass: "unknown" } },
     );
 
     // Sets trust context to unknown.
@@ -192,7 +198,6 @@ describe("analyzeConversation", () => {
     expect(currentConversation.runAgentLoop).toHaveBeenCalledWith(
       expect.any(String),
       "msg-1",
-      undefined,
       expect.objectContaining({
         isInteractive: false,
         isUserMessage: true,
@@ -287,7 +292,7 @@ describe("analyzeConversation", () => {
       "analysis-existing",
       "user",
       expect.any(String),
-      { provenanceTrustClass: "guardian" },
+      { metadata: { provenanceTrustClass: "guardian" } },
     );
   });
 
@@ -366,7 +371,6 @@ describe("analyzeConversation", () => {
     expect(currentConversation.runAgentLoop).toHaveBeenCalledWith(
       expect.any(String),
       "msg-1",
-      undefined,
       expect.objectContaining({ callSite: "analyzeConversation" }),
     );
   });

package/src/runtime/services/analyze-conversation.ts

@@ -35,10 +35,7 @@ import {
 } from "../../memory/conversation-crud.js";
 import { resolveConversationId } from "../../memory/conversation-key-store.js";
 import { getLogger } from "../../util/logger.js";
-import {
-  assistantEventHub,
-  broadcastMessage,
-} from "../assistant-event-hub.js";
+import { assistantEventHub, broadcastMessage } from "../assistant-event-hub.js";
 import {
   buildAutoAnalysisPrompt,
   neutralizeTranscriptSentinel,
@@ -201,7 +198,7 @@ export async function analyzeConversation(
   // `currentRequestId` and let two loops mutate the same Conversation
   // state. Skip this run instead — the next upstream trigger will
   // re-enqueue once the in-flight loop finishes.
-  if (opts.trigger === "auto" && analysisConversation.processing) {
+  if (opts.trigger === "auto" && analysisConversation.isProcessing()) {
     log.info(
       {
         sourceConversationId: resolvedId,
@@ -218,7 +215,7 @@ export async function analyzeConversation(
     analysisConversationId,
     "user",
     JSON.stringify([{ type: "text", text: prompt }]),
-    { provenanceTrustClass: trustClass },
+    { metadata: { provenanceTrustClass: trustClass } },
   );
   const messageId = message.id;
 
@@ -250,7 +247,7 @@ export async function analyzeConversation(
   analysisConversation.updateClient(broadcastMessage, !hasLiveSubscriber);
 
   // k. Set up processing state (required by runAgentLoop guard)
-  analysisConversation.processing = true;
+  analysisConversation.setProcessing(true);
   analysisConversation.abortController = new AbortController();
   analysisConversation.currentRequestId = crypto.randomUUID();
 
@@ -258,7 +255,7 @@ export async function analyzeConversation(
   // routes the per-call provider config through `resolveCallSiteConfig`
   // against `llm.callSites.analyzeConversation`.
   analysisConversation
-    .runAgentLoop(prompt, messageId, undefined, {
+    .runAgentLoop(prompt, messageId, {
       isInteractive: false,
       isUserMessage: true,
       callSite: "analyzeConversation",

package/src/runtime/services/conversation-serializer.ts

@@ -9,6 +9,7 @@
 
 import { parseChannelId } from "../../channels/types.js";
 import { getConfig } from "../../config/loader.js";
+import { findConversation } from "../../daemon/conversation-registry.js";
 import { normalizeConversationType } from "../../daemon/message-types/shared.js";
 import {
   type AttentionState,
@@ -162,9 +163,24 @@ export function serializeConversationSummary(params: {
     groupId: string | null;
   };
   parentCache: Map<string, ConversationRow | null>;
+  /**
+   * Whether the agent loop is currently mid-turn for this conversation.
+   * Sourced from the in-memory daemon `Conversation.isProcessing()` flag
+   * — callers resolve via `findConversation(id)?.isProcessing() ?? false`
+   * so cold (evicted / never-loaded) rows report `false`. Plumbed in
+   * rather than read here so the serializer stays a pure shape mapper
+   * with no daemon-store coupling.
+   */
+  isProcessing: boolean;
 }) {
-  const { conversation, binding, attentionState, displayMeta, parentCache } =
-    params;
+  const {
+    conversation,
+    binding,
+    attentionState,
+    displayMeta,
+    parentCache,
+    isProcessing,
+  } = params;
   const originChannel = parseChannelId(conversation.originChannel);
   const assistantAttention = buildAssistantAttention(attentionState);
   const forkParent = buildForkParent(conversation, parentCache);
@@ -205,6 +221,7 @@ export function serializeConversationSummary(params: {
     ...(conversation.inferenceProfile != null
       ? { inferenceProfile: conversation.inferenceProfile }
       : {}),
+    isProcessing,
   };
 }
 
@@ -232,6 +249,11 @@ export function buildConversationDetailResponse(
       attentionState: attentionStates.get(conversation.id),
       displayMeta: displayMeta.get(conversation.id),
       parentCache,
+      // Cold (evicted / never-loaded) rows aren't in the in-memory
+      // store, so `findConversation` returns `undefined` and they
+      // report `isProcessing: false` — by definition they aren't
+      // mid-turn since the agent loop only runs on resident convs.
+      isProcessing: findConversation(conversation.id)?.isProcessing() ?? false,
     }),
   };
 }

package/src/runtime/sync/resource-sync-events.ts

@@ -1,5 +1,5 @@
+import type { ConversationListInvalidatedReason } from "../../api/events/conversation-list-invalidated.js";
 import type { IdentityFields } from "../../daemon/handlers/identity.js";
-import type { ConversationListInvalidatedReason } from "../../daemon/message-types/conversations.js";
 import {
   conversationMessagesSyncTag,
   conversationMetadataSyncTag,
@@ -29,7 +29,17 @@ export function publishIdentityChanged(
     emoji: fields.emoji,
     home: fields.home,
   });
-  void publishSyncInvalidation([SYNC_TAGS.assistantIdentity], originClientId);
+  void publishSyncInvalidation(
+    [SYNC_TAGS.assistantIdentity, SYNC_TAGS.assistantIdentityIntro],
+    originClientId,
+  );
+}
+
+export function publishIdentityIntroChanged(originClientId?: string): void {
+  void publishSyncInvalidation(
+    [SYNC_TAGS.assistantIdentityIntro],
+    originClientId,
+  );
 }
 
 export function publishConfigChanged(originClientId?: string): void {
@@ -46,6 +56,10 @@ export function publishSchedulesChanged(originClientId?: string): void {
   void publishSyncInvalidation([SYNC_TAGS.assistantSchedules], originClientId);
 }
 
+export function publishAppsChanged(originClientId?: string): void {
+  void publishSyncInvalidation([SYNC_TAGS.appsList], originClientId);
+}
+
 /**
  * Reasons that change the *shape* of the conversation list — a row is
  * added, removed, or its position changes. These require web clients to

package/src/runtime/sync/sync-publisher.ts

@@ -1,6 +1,6 @@
-import type { SyncChangedMessage } from "../../daemon/message-types/sync.js";
 import {
   buildSyncChangedMessage,
+  type SyncChangedEvent,
   type SyncInvalidationTag,
 } from "../../daemon/message-types/sync.js";
 import { getLogger } from "../../util/logger.js";
@@ -11,7 +11,7 @@ const log = getLogger("sync-publisher");
 export async function publishSyncInvalidation(
   tags: SyncInvalidationTag[],
   originClientId?: string,
-): Promise<SyncChangedMessage> {
+): Promise<SyncChangedEvent> {
   const message = buildSyncChangedMessage(tags, originClientId);
   try {
     broadcastMessage(message);

package/src/schedule/run-script.ts

@@ -6,8 +6,16 @@ const log = getLogger("run-script");
 
 /** Maximum combined stdout + stderr captured (bytes). */
 const MAX_OUTPUT_BYTES = 10_000;
-/** Default timeout for script execution (ms). */
-const DEFAULT_TIMEOUT_MS = 60_000;
+/** Default timeout for script execution (ms) when a schedule sets no override. */
+export const DEFAULT_TIMEOUT_MS = 60_000;
+/** Smallest script timeout override a caller may set (ms). */
+export const MIN_SCRIPT_TIMEOUT_MS = 1_000;
+/**
+ * Largest script timeout override a caller may set (ms). Capped so a wedged
+ * script cannot block the scheduler tick indefinitely; mirrors the talk-mode
+ * budget in scheduler.ts.
+ */
+export const MAX_SCRIPT_TIMEOUT_MS = 30 * 60 * 1000;
 
 export interface ScriptResult {
   exitCode: number;
@@ -75,7 +83,9 @@ export async function runScript(
     ]);
     const stdout = truncate(stdoutStr);
     const timeoutMsg = `Script timed out after ${timeoutMs}ms`;
-    const stderr = truncate(stderrStr ? `${timeoutMsg}\n${stderrStr}` : timeoutMsg);
+    const stderr = truncate(
+      stderrStr ? `${timeoutMsg}\n${stderrStr}` : timeoutMsg,
+    );
     log.info(
       { command, timedOut: true, stdoutLen: stdout.length },
       "Script timed out",
@@ -98,3 +108,18 @@ function truncate(text: string): string {
   if (text.length <= MAX_OUTPUT_BYTES) return text;
   return text.slice(0, MAX_OUTPUT_BYTES) + "\n... (truncated)";
 }
+
+/**
+ * Validate a caller-supplied script timeout override (ms). Returns an error
+ * message when the value is not a positive integer within the allowed bounds,
+ * or `null` when it is acceptable.
+ */
+export function validateScriptTimeoutMs(value: number): string | null {
+  if (!Number.isInteger(value)) {
+    return "timeout_ms must be an integer number of milliseconds";
+  }
+  if (value < MIN_SCRIPT_TIMEOUT_MS || value > MAX_SCRIPT_TIMEOUT_MS) {
+    return `timeout_ms must be between ${MIN_SCRIPT_TIMEOUT_MS} and ${MAX_SCRIPT_TIMEOUT_MS} (ms)`;
+  }
+  return null;
+}

package/src/schedule/schedule-store.ts

@@ -47,6 +47,9 @@ export interface ScheduleJob {
   retryCount: number;
   maxRetries: number;
   retryBackoffMs: number;
+  /** Script-mode execution timeout override (ms); null = use the default. */
+  timeoutMs: number | null;
+  createdFromConversationId: string | null;
   createdBy: string;
   mode: ScheduleMode;
   routingIntent: RoutingIntent;
@@ -99,6 +102,8 @@ export function createSchedule(params: {
   reuseConversation?: boolean;
   maxRetries?: number;
   retryBackoffMs?: number;
+  timeoutMs?: number | null;
+  createdFromConversationId?: string | null;
 }): ScheduleJob {
   const expression = params.expression ?? params.cronExpression ?? null;
   const isOneShot = expression == null;
@@ -134,6 +139,8 @@ export function createSchedule(params: {
   const reuseConversation = params.reuseConversation ?? !isOneShot;
   const maxRetries = params.maxRetries ?? 3;
   const retryBackoffMs = params.retryBackoffMs ?? 60000;
+  const timeoutMs = params.timeoutMs ?? null;
+  const createdFromConversationId = params.createdFromConversationId ?? null;
 
   let nextRunAt: number;
   if (isOneShot) {
@@ -160,6 +167,8 @@ export function createSchedule(params: {
     retryCount: 0,
     maxRetries,
     retryBackoffMs,
+    timeoutMs,
+    createdFromConversationId,
     createdBy: params.createdBy ?? "agent",
     mode,
     routingIntent,
@@ -258,6 +267,8 @@ export function updateSchedule(
     wakeConversationId?: string | null;
     maxRetries?: number;
     retryBackoffMs?: number;
+    timeoutMs?: number | null;
+    createdFromConversationId?: string | null;
   },
 ): ScheduleJob | null {
   const db = getDb();
@@ -322,6 +333,9 @@ export function updateSchedule(
   if (updates.maxRetries !== undefined) set.maxRetries = updates.maxRetries;
   if (updates.retryBackoffMs !== undefined)
     set.retryBackoffMs = updates.retryBackoffMs;
+  if (updates.timeoutMs !== undefined) set.timeoutMs = updates.timeoutMs;
+  if (updates.createdFromConversationId !== undefined)
+    set.createdFromConversationId = updates.createdFromConversationId;
 
   // Recompute nextRunAt if schedule timing may have changed (only for recurring)
   if (
@@ -584,7 +598,7 @@ export function cancelSchedule(id: string): boolean {
 
 export function createScheduleRun(
   jobId: string,
-  conversationId: string,
+  conversationId: string | null,
 ): string {
   const db = getDb();
   const id = uuid();
@@ -606,6 +620,17 @@ export function createScheduleRun(
   return id;
 }
 
+export function setScheduleRunConversationId(
+  runId: string,
+  conversationId: string,
+): void {
+  const db = getDb();
+  db.update(scheduleRuns)
+    .set({ conversationId })
+    .where(eq(scheduleRuns.id, runId))
+    .run();
+}
+
 export function completeScheduleRun(
   runId: string,
   result: { status: "ok" | "error"; output?: string; error?: string },
@@ -969,6 +994,8 @@ function parseJobRow(row: typeof scheduleJobs.$inferSelect): ScheduleJob {
     retryCount: row.retryCount,
     maxRetries: row.maxRetries ?? 3,
     retryBackoffMs: row.retryBackoffMs ?? 60000,
+    timeoutMs: row.timeoutMs ?? null,
+    createdFromConversationId: row.createdFromConversationId ?? null,
     createdBy: row.createdBy,
     mode: (row.mode ?? "execute") as ScheduleMode,
     routingIntent: (row.routingIntent ?? "all_channels") as RoutingIntent,

package/src/schedule/schedule-usage-store.ts

@@ -0,0 +1,83 @@
+import { rawAll } from "../memory/raw-query.js";
+import { buildScheduleAttributionSubquery } from "../memory/schedule-attribution-sql.js";
+
+export interface ScheduleUsageSummary {
+  scheduleId: string;
+  runCount: number;
+  totalEstimatedCostUsd: number;
+  eventCount: number;
+}
+
+interface ScheduleUsageSummaryRow {
+  schedule_id: string;
+  run_count: number;
+  total_estimated_cost_usd: number | null;
+  event_count: number | null;
+}
+
+export function getScheduleUsageSummaries({
+  from,
+  to,
+}: {
+  from: number;
+  to: number;
+}): ScheduleUsageSummary[] {
+  const now = Date.now();
+  const scheduleAttribution = buildScheduleAttributionSubquery({
+    eventAlias: "e",
+    now,
+    selectExpression: "schedule_attr_runs.job_id",
+  });
+  const rows = rawAll<ScheduleUsageSummaryRow>(
+    /*sql*/ `
+    WITH run_counts AS (
+      SELECT
+        job_id AS schedule_id,
+        COUNT(*) AS run_count
+      FROM cron_runs
+      WHERE started_at >= ?
+        AND started_at <= ?
+      GROUP BY job_id
+    ),
+    attributed_usage AS (
+      SELECT
+        e.estimated_cost_usd,
+        COALESCE(e.llm_call_count, 1) AS event_count,
+        ${scheduleAttribution.sql} AS schedule_id
+      FROM llm_usage_events e
+      WHERE e.created_at >= ?
+        AND e.created_at <= ?
+    ),
+    usage_totals AS (
+      SELECT
+        schedule_id,
+        COALESCE(SUM(estimated_cost_usd), 0) AS total_estimated_cost_usd,
+        COALESCE(SUM(event_count), 0) AS event_count
+      FROM attributed_usage
+      WHERE schedule_id IS NOT NULL
+      GROUP BY schedule_id
+    )
+    SELECT
+      cron_jobs.id AS schedule_id,
+      COALESCE(run_counts.run_count, 0) AS run_count,
+      COALESCE(usage_totals.total_estimated_cost_usd, 0) AS total_estimated_cost_usd,
+      COALESCE(usage_totals.event_count, 0) AS event_count
+    FROM cron_jobs
+    LEFT JOIN run_counts ON run_counts.schedule_id = cron_jobs.id
+    LEFT JOIN usage_totals ON usage_totals.schedule_id = cron_jobs.id
+    ORDER BY cron_jobs.created_at ASC, cron_jobs.id ASC
+    `,
+    from,
+    to,
+    ...scheduleAttribution.params,
+    from,
+    to,
+  );
+
+  return rows.map((row) => ({
+    scheduleId: row.schedule_id,
+    runCount: row.run_count,
+    totalEstimatedCostUsd: row.total_estimated_cost_usd ?? 0,
+    eventCount: row.event_count ?? 0,
+  }));
+}

package/src/schedule/scheduler.ts

@@ -28,6 +28,7 @@ import {
   type RoutingIntent,
   type ScheduleJob,
   scheduleRetry,
+  setScheduleRunConversationId,
 } from "./schedule-store.js";
 
 const log = getLogger("scheduler");
@@ -303,7 +304,9 @@ export async function runScheduleDueWorkOnce(
           { jobId: job.id, name: job.name, isOneShot },
           "Executing script schedule",
         );
-        const result: ScriptResult = await runScript(job.script);
+        const result: ScriptResult = await runScript(job.script, {
+          timeoutMs: job.timeoutMs ?? undefined,
+        });
         completeScheduleRun(runId, {
           status: result.exitCode === 0 ? "ok" : "error",
           output: result.stdout || undefined,
@@ -440,6 +443,7 @@ export async function runScheduleDueWorkOnce(
         job.syntax === "rrule" &&
         job.expression != null &&
         hasSetConstructs(job.expression);
+      const runId = createScheduleRun(job.id, null);
       let failed = false;
       try {
         log.info(
@@ -470,14 +474,13 @@ export async function runScheduleDueWorkOnce(
           },
         );
 
+        setScheduleRunConversationId(runId, result.conversationId);
         onScheduleConversationCreated?.({
           conversationId: result.conversationId,
           scheduleJobId: job.id,
           title: result.status === "failed" ? `${job.name}: Error` : job.name,
         });
 
-        // Track the schedule run using the task's conversation
-        const runId = createScheduleRun(job.id, result.conversationId);
         if (result.status === "failed") {
           const errorMessage = result.error ?? "Task run failed";
           completeScheduleRun(runId, {
@@ -528,7 +531,7 @@ export async function runScheduleDueWorkOnce(
           scheduleJobId: job.id,
           title: `${job.name}: Error`,
         });
-        const runId = createScheduleRun(job.id, fallbackConversation.id);
+        setScheduleRunConversationId(runId, fallbackConversation.id);
         completeScheduleRun(runId, { status: "error", error: message });
         emitTaskActivityFailed({
           taskId,
@@ -582,6 +585,8 @@ export async function runScheduleDueWorkOnce(
     let ok: boolean;
     let errorMsg: string | undefined;
     const conversationReused = reusedConversationId != null;
+    let runConversationId = reusedConversationId;
+    const runId = createScheduleRun(job.id, reusedConversationId);
 
     if (reusedConversationId) {
       // Reuse path: keep using the injected `processMessage` callback so the
@@ -623,6 +628,8 @@ export async function runScheduleDueWorkOnce(
         scheduleJobId: job.id,
         suppressFailureNotifications: job.quiet === true,
         onConversationCreated: (newConversationId) => {
+          runConversationId = newConversationId;
+          setScheduleRunConversationId(runId, newConversationId);
           onScheduleConversationCreated?.({
             conversationId: newConversationId,
             scheduleJobId: job.id,
@@ -639,12 +646,14 @@ export async function runScheduleDueWorkOnce(
         !result.ok && result.conversationId === ""
           ? `bootstrap-error:${job.id}`
           : result.conversationId;
+      if (runConversationId !== conversationId) {
+        runConversationId = conversationId;
+        setScheduleRunConversationId(runId, conversationId);
+      }
       ok = result.ok;
       errorMsg = result.error?.message;
     }
 
-    const runId = createScheduleRun(job.id, conversationId);
-
     if (ok) {
       completeScheduleRun(runId, { status: "ok" });
       if (isOneShot) completeOneShot(job.id);

package/src/signals/cancel.ts

@@ -11,10 +11,8 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 
 import { getIsContainerized } from "../config/env-registry.js";
-import {
-  findConversation,
-  touchConversation,
-} from "../daemon/conversation-store.js";
+import { findConversation } from "../daemon/conversation-registry.js";
+import { touchConversation } from "../daemon/conversation-store.js";
 import { getSubagentManager } from "../subagent/index.js";
 import { createAbortReason } from "../util/abort-reasons.js";
 import { getLogger } from "../util/logger.js";

package/src/signals/user-message.ts

@@ -134,14 +134,11 @@ async function dispatchUserMessage(params: {
     return { accepted: !result.rejected };
   }
 
-  await processMessageInBackground(
-    conversationId,
-    params.content,
-    attachmentIds.length > 0 ? attachmentIds : undefined,
-    undefined,
-    params.sourceChannel,
-    params.sourceInterface,
-  );
+  await processMessageInBackground(conversationId, params.content, {
+    attachmentIds: attachmentIds.length > 0 ? attachmentIds : undefined,
+    sourceChannel: params.sourceChannel,
+    sourceInterface: params.sourceInterface,
+  });
   return { accepted: true };
 }
 

package/src/skills/catalog-files.ts

@@ -497,14 +497,17 @@ export async function readCatalogSkillFileContent(
  * otherwise be reachable via the handler module.
  */
 export function catalogSkillToSlim(cs: CatalogSkill): SlimSkillResponse {
+  const name = cs.metadata?.vellum?.["display-name"] ?? cs.name;
   return {
     id: cs.id,
-    name: cs.metadata?.vellum?.["display-name"] ?? cs.name,
+    name,
     description: cs.description,
+    icon: cs.icon ?? cs.metadata?.icon,
     emoji: cs.emoji ?? cs.metadata?.emoji,
     kind: "catalog",
     origin: "vellum",
     status: "available",
+    category: cs.metadata?.vellum?.category ?? "system",
   };
 }
 

package/src/skills/catalog-install.ts

@@ -29,17 +29,20 @@ export interface CatalogSkill {
   id: string;
   name: string;
   description: string;
+  icon?: string;
   emoji?: string;
   includes?: string[];
   version?: string;
   updatedAt?: string;
   metadata?: {
+    icon?: string;
     emoji?: string;
     vellum?: {
       "display-name"?: string;
       "activation-hints"?: string[];
       "avoid-when"?: string[];
       "feature-flag"?: string;
+      category?: string;
     };
   };
 }