@vellumai/assistant 0.8.1 → 0.8.3

package/src/__tests__/schedule-store.test.ts

@@ -9,13 +9,19 @@ mock.module("../util/logger.js", () => ({
   truncateForLog: (value: string) => value,
 }));
 
+import { SYNC_TAGS } from "../daemon/message-types/sync.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
+import type { AssistantEvent } from "../runtime/assistant-event.js";
+import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import {
   cancelSchedule,
   claimDueSchedules,
   completeOneShot,
+  completeScheduleRun,
   createSchedule,
+  createScheduleRun,
+  deleteSchedule,
   describeCronExpression,
   failOneShot,
   getSchedule,
@@ -31,6 +37,94 @@ function getRawDb(): import("bun:sqlite").Database {
     .$client;
 }
 
+async function waitFor(predicate: () => boolean): Promise<void> {
+  const deadline = Date.now() + 500;
+  while (Date.now() < deadline) {
+    if (predicate()) return;
+    await new Promise((resolve) => setTimeout(resolve, 5));
+  }
+  throw new Error("Timed out waiting for schedule-store event");
+}
+
+async function expectScheduleSyncEvent(
+  received: AssistantEvent[],
+): Promise<void> {
+  await waitFor(() =>
+    received.some(
+      (event) =>
+        event.message.type === "sync_changed" &&
+        event.message.tags.includes(SYNC_TAGS.assistantSchedules),
+    ),
+  );
+  const syncEvent = received.find(
+    (event) =>
+      event.message.type === "sync_changed" &&
+      event.message.tags.includes(SYNC_TAGS.assistantSchedules),
+  );
+  expect(syncEvent?.message).toEqual({
+    type: "sync_changed",
+    tags: [SYNC_TAGS.assistantSchedules],
+  });
+  received.length = 0;
+}
+
+describe("schedule sync invalidation", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run("DELETE FROM cron_runs");
+    db.run("DELETE FROM cron_jobs");
+  });
+
+  test("store-level schedule mutations emit schedule sync invalidation", async () => {
+    const received: AssistantEvent[] = [];
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      callback: (event) => {
+        received.push(event);
+      },
+    });
+
+    try {
+      const job = createSchedule({
+        name: "Sync test",
+        cronExpression: "* * * * *",
+        message: "sync me",
+        syntax: "cron",
+      });
+      await expectScheduleSyncEvent(received);
+
+      updateSchedule(job.id, { name: "Updated sync test" });
+      await expectScheduleSyncEvent(received);
+
+      getRawDb().run("UPDATE cron_jobs SET next_run_at = ? WHERE id = ?", [
+        Date.now() - 1000,
+        job.id,
+      ]);
+      expect(claimDueSchedules(Date.now())).toHaveLength(1);
+      await expectScheduleSyncEvent(received);
+
+      const runId = createScheduleRun(job.id, "conv-123");
+      completeScheduleRun(runId, { status: "ok" });
+      await expectScheduleSyncEvent(received);
+
+      const oneShot = createSchedule({
+        name: "One-shot sync test",
+        message: "cancel me",
+        nextRunAt: Date.now() + 60_000,
+      });
+      await expectScheduleSyncEvent(received);
+
+      expect(cancelSchedule(oneShot.id)).toBe(true);
+      await expectScheduleSyncEvent(received);
+
+      expect(deleteSchedule(job.id)).toBe(true);
+      await expectScheduleSyncEvent(received);
+    } finally {
+      subscription.dispose();
+    }
+  });
+});
+
 // ── Cron schedules ──────────────────────────────────────────────────
 
 describe("createSchedule (cron)", () => {

package/src/__tests__/scheduler-reuse-conversation.test.ts

@@ -31,6 +31,7 @@ const runBackgroundJobOptions: Array<{
   onConversationCreated?: (id: string) => void;
 }> = [];
 let runBackgroundJobShouldFail = false;
+let runBackgroundJobBootstrapFails = false;
 mock.module("../runtime/background-job-runner.js", () => ({
   runBackgroundJob: async (opts: {
     prompt: string;
@@ -40,6 +41,25 @@ mock.module("../runtime/background-job-runner.js", () => ({
     suppressFailureNotifications?: boolean;
     onConversationCreated?: (id: string) => void;
   }) => {
+    runBackgroundJobOptions.push({
+      conversationType: opts.conversationType,
+      scheduleJobId: opts.scheduleJobId,
+      groupId: opts.groupId,
+      suppressFailureNotifications: opts.suppressFailureNotifications,
+      onConversationCreated: opts.onConversationCreated,
+    });
+    // Bootstrap-failure path: the real runner returns conversationId: ""
+    // when `bootstrapConversation` throws before assignment. Skip the
+    // callback (it was never reached) and surface the empty id to the
+    // scheduler so it can exercise the sentinel guard.
+    if (runBackgroundJobBootstrapFails) {
+      return {
+        conversationId: "",
+        ok: false,
+        error: new Error("Bootstrap failure"),
+        errorKind: "exception" as const,
+      };
+    }
     const { createConversation } =
       await import("../memory/conversation-crud.js");
     const conv = createConversation({
@@ -49,13 +69,6 @@ mock.module("../runtime/background-job-runner.js", () => ({
       ...(opts.groupId ? { groupId: opts.groupId } : {}),
       ...(opts.scheduleJobId ? { scheduleJobId: opts.scheduleJobId } : {}),
     });
-    runBackgroundJobOptions.push({
-      conversationType: opts.conversationType,
-      scheduleJobId: opts.scheduleJobId,
-      groupId: opts.groupId,
-      suppressFailureNotifications: opts.suppressFailureNotifications,
-      onConversationCreated: opts.onConversationCreated,
-    });
     // Mirror the real runner's contract: fire the SSE callback synchronously
     // BEFORE the job's processMessage finishes, with the bootstrap-returned
     // conversation id.
@@ -137,6 +150,7 @@ describe("scheduler conversation reuse", () => {
     processedMessages.length = 0;
     runBackgroundJobOptions.length = 0;
     runBackgroundJobShouldFail = false;
+    runBackgroundJobBootstrapFails = false;
   });
 
   test("recurring schedule with reuseConversation=true reuses conversation across runs", async () => {
@@ -393,6 +407,7 @@ describe("scheduler talk-mode runner option propagation", () => {
     processedMessages.length = 0;
     runBackgroundJobOptions.length = 0;
     runBackgroundJobShouldFail = false;
+    runBackgroundJobBootstrapFails = false;
   });
 
   test("talk-mode propagates conversationType=scheduled, scheduleJobId, and quiet=>suppressFailureNotifications", async () => {
@@ -443,6 +458,38 @@ describe("scheduler talk-mode runner option propagation", () => {
     );
   });
 
+  test("talk-mode bootstrap failure writes sentinel conversationId, not empty string", async () => {
+    /**
+     * Regression: `runBackgroundJob` returns `{ conversationId: "", ok: false }`
+     * when bootstrap throws before the conversation row is assigned. The
+     * scheduler previously stored that empty string in the cron_runs DB row.
+     * Guard ensures we substitute a recognizable sentinel.
+     */
+    const rruleExpr = buildEveryMinuteRrule();
+    const schedule = createSchedule({
+      name: "Bootstrap Failure",
+      cronExpression: rruleExpr,
+      message: "x",
+      syntax: "rrule",
+      expression: rruleExpr,
+    });
+    forceScheduleDue(schedule.id);
+    runBackgroundJobBootstrapFails = true;
+
+    const processMessage = async () => {};
+    const scheduler = startScheduler(processMessage, () => {});
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    scheduler.stop();
+
+    const runs = getScheduleRuns(schedule.id);
+    expect(runs.length).toBe(1);
+    expect(runs[0].status).toBe("error");
+    // Critical: must NOT be empty — the DB column should carry a marker that
+    // identifies this run as a bootstrap-failure case.
+    expect(runs[0].conversationId).not.toBe("");
+    expect(runs[0].conversationId).toBe(`bootstrap-error:${schedule.id}`);
+  });
+
   test("talk-mode fires onScheduleConversationCreated synchronously via runner callback (BEFORE the runner returns)", async () => {
     const rruleExpr = buildEveryMinuteRrule();
     const schedule = createSchedule({

package/src/__tests__/schema-transforms.test.ts

@@ -157,6 +157,26 @@ describe("injectActivityField", () => {
     expect(Object.is(result[0], defs[0])).toBe(true);
   });
 
+  test("passes through undefined/null input_schema unchanged (no crash)", () => {
+    // Repro for the crash where an MCP server returned a tool with missing
+    // inputSchema and `injectActivityField` threw on `schema.type` access.
+    const defs: ToolDefinition[] = [
+      {
+        name: "missing",
+        description: "x",
+        input_schema: undefined as unknown as object,
+      },
+      {
+        name: "nullish",
+        description: "x",
+        input_schema: null as unknown as object,
+      },
+    ];
+    const result = injectActivityField(defs);
+    expect(Object.is(result[0], defs[0])).toBe(true);
+    expect(Object.is(result[1], defs[1])).toBe(true);
+  });
+
   test("does NOT add activity to top-level required when only in oneOf branch", () => {
     const defs = [
       makeDef("my_tool", {

package/src/__tests__/search-skills-unified.test.ts

@@ -124,9 +124,6 @@ mock.module("../providers/provider-send-message.js", () => ({
   getConfiguredProvider: async () => null,
   userMessage: () => ({}),
 }));
-mock.module("../runtime/routes/workspace-utils.js", () => ({
-  isTextMimeType: () => true,
-}));
 mock.module("../skills/catalog-cache.js", () => ({
   getCatalog: async () => [],
 }));
@@ -136,7 +133,6 @@ mock.module("../skills/catalog-install.js", () => ({
 mock.module("../skills/managed-store.js", () => ({
   createManagedSkill: () => ({ created: true }),
   deleteManagedSkill: () => ({ deleted: true }),
-  removeSkillsIndexEntry: () => {},
   validateManagedSkillId: () => null,
 }));
 mock.module("../memory/graph/capability-seed.js", () => ({
@@ -165,7 +161,6 @@ import { searchSkills } from "../daemon/handlers/skills.js";
 // Helpers
 // ---------------------------------------------------------------------------
 
-
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------

package/src/__tests__/{secret-routes-managed-proxy.test.ts → secret-routes-platform-proxy.test.ts}

@@ -12,7 +12,7 @@ let providerRefreshCalls = 0;
 const PLATFORM_BASE_URL = "https://platform.example.com";
 const ASSISTANT_API_KEY_PATH = credentialKey("vellum", "assistant_api_key");
 const PLATFORM_BASE_URL_PATH = credentialKey("vellum", "platform_base_url");
-const MANAGED_PROVIDERS = ["anthropic", "openai", "gemini"] as const;
+const MANAGED_PROVIDERS = ["anthropic", "openai", "gemini", "fireworks"] as const;
 
 let platformBaseUrlOverride: string | undefined;
 

package/src/__tests__/server-history-render.test.ts

@@ -91,6 +91,49 @@ describe("renderHistoryContent", () => {
     expect(renderHistoryContent(42).text).toBe("42");
   });
 
+  test("unwraps complete legacy external_content envelopes for plain string content", () => {
+    const output = renderHistoryContent(
+      '<external_content source="slack">\nVisible Slack text\n</external_content>',
+    );
+
+    expect(output.text).toBe("Visible Slack text");
+    expect(output.textSegments).toEqual(["Visible Slack text"]);
+    expect(output.contentOrder).toEqual(["text:0"]);
+  });
+
+  test("unwraps complete legacy external_content envelopes in text blocks", () => {
+    const output = renderHistoryContent([
+      {
+        type: "text",
+        text: '<external_content source="slack">\nVisible block text\n</external_content>',
+      },
+      { type: "text", text: "Plain follow-up." },
+    ]);
+
+    expect(output.text).toBe("Visible block text Plain follow-up.");
+    expect(output.textSegments).toEqual([
+      "Visible block text Plain follow-up.",
+    ]);
+    expect(output.contentOrder).toEqual(["text:0"]);
+  });
+
+  test("leaves malformed or mixed external_content text unchanged", () => {
+    const malformed =
+      '<external_content source="slack">Visible text</external_content>';
+    const mixed =
+      'prefix <external_content source="slack">\nVisible text\n</external_content>';
+
+    const malformedOutput = renderHistoryContent([
+      { type: "text", text: malformed },
+    ]);
+    expect(malformedOutput.text).toBe(malformed);
+    expect(malformedOutput.textSegments).toEqual([malformed]);
+
+    const mixedOutput = renderHistoryContent(mixed);
+    expect(mixedOutput.text).toBe(mixed);
+    expect(mixedOutput.textSegments).toEqual([mixed]);
+  });
+
   test("preserves JSON object content as JSON string", () => {
     expect(renderHistoryContent({ foo: "bar" }).text).toBe('{"foo":"bar"}');
   });

package/src/__tests__/skill-load-feature-flag.test.ts

@@ -103,10 +103,6 @@ describe("skill_load feature flag enforcement", () => {
       "Toggle email channel behavior",
       "Use the feature.",
     );
-    writeFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      `- ${DECLARED_SKILL_ID}\n`,
-    );
 
     _setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
 
@@ -124,10 +120,6 @@ describe("skill_load feature flag enforcement", () => {
       "Toggle email channel behavior",
       "Use the feature.",
     );
-    writeFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      `- ${DECLARED_SKILL_ID}\n`,
-    );
 
     _setOverridesForTesting({ [DECLARED_FLAG_KEY]: true });
 
@@ -144,10 +136,6 @@ describe("skill_load feature flag enforcement", () => {
       "Toggle email channel behavior",
       "Use the feature.",
     );
-    writeFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      `- ${DECLARED_SKILL_ID}\n`,
-    );
 
     // No overrides — uses registry defaults