@vellumai/assistant 0.11.6 → 0.11.7-staging.2

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

@@ -10,12 +10,23 @@ import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 let injectedProcessMessageForRunner:
   | ((conversationId: string, message: string) => Promise<unknown>)
   | null = null;
+// Options of every mocked `runBackgroundJob` call, for asserting what the
+// scheduler asked of the runner (e.g. that per-attempt failure emissions are
+// suppressed in favor of the retries-exhausted alert).
+const runnerCalls: Array<Record<string, unknown>> = [];
+// When set, a failing mocked run reports this classification instead of the
+// default generic exception, letting a test drive the cause-keyed alert path.
+let runnerFailureClassification: {
+  errorKind: "timeout" | "model_provider" | "exception";
+  failureCode?: string;
+} | null = null;
 mock.module("../runtime/background-job-runner.js", () => ({
   runBackgroundJob: async (opts: {
     jobName: string;
     prompt: string;
     onConversationCreated?: (conversationId: string) => void;
   }) => {
+    runnerCalls.push(opts as unknown as Record<string, unknown>);
     const conversationId = `mock-conv-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     opts.onConversationCreated?.(conversationId);
     try {
@@ -25,11 +36,17 @@ mock.module("../runtime/background-job-runner.js", () => ({
       return { conversationId, ok: true };
     } catch (err) {
       const error = err instanceof Error ? err : new Error(String(err));
+      const classification = runnerFailureClassification ?? {
+        errorKind: "exception" as const,
+      };
       return {
         conversationId,
         ok: false,
         error,
-        errorKind: "exception" as const,
+        errorKind: classification.errorKind,
+        ...(classification.failureCode !== undefined
+          ? { turnFailure: { failureCode: classification.failureCode } }
+          : {}),
       };
     }
   },
@@ -466,6 +483,171 @@ describe("scheduler retry integration", () => {
   });
 });
 
+// ── Execute-mode failure notifications ────────────────────────────────
+
+describe("execute-mode failure notifications", () => {
+  let scheduler: SchedulerHandle;
+
+  beforeEach(() => {
+    emitNotificationSignalImpl = async () => {};
+    runnerCalls.length = 0;
+    runnerFailureClassification = null;
+    const db = getDb();
+    db.run("DELETE FROM cron_runs");
+    db.run("DELETE FROM cron_jobs");
+  });
+
+  afterEach(() => {
+    scheduler?.stop();
+    runnerFailureClassification = null;
+  });
+
+  test("a failing schedule alerts once, at exhaustion, keyed on the failure cause", async () => {
+    const emitted: Array<Record<string, unknown>> = [];
+    emitNotificationSignalImpl = async (payload) => {
+      emitted.push(payload as Record<string, unknown>);
+    };
+    runnerFailureClassification = {
+      errorKind: "model_provider",
+      failureCode: "PROVIDER_BILLING",
+    };
+
+    const schedule = await createSchedule({
+      name: "Billing victim",
+      cronExpression: "0 * * * *",
+      message: "do work",
+      syntax: "cron",
+      maxRetries: 1,
+      retryBackoffMs: 1000,
+    });
+    forceScheduleDue(schedule.id);
+
+    scheduler = startScheduler(async () => {
+      throw new Error("PROVIDER_BILLING: Agent turn failed.");
+    });
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    // First failure: a retry is pending, so nothing is user-visible yet, and
+    // the scheduler told the runner to keep its per-attempt emission quiet.
+    expect(emitted).toHaveLength(0);
+    expect(runnerCalls.length).toBeGreaterThanOrEqual(1);
+    for (const call of runnerCalls) {
+      expect(call.suppressFailureNotifications).toBe(true);
+    }
+
+    // Second failure exhausts retries (maxRetries: 1) and fires the single
+    // alert, deduped on the classified cause rather than the schedule.
+    forceScheduleDue(schedule.id);
+    await scheduler.runOnce();
+    scheduler.stop();
+
+    expect(emitted).toHaveLength(1);
+    const alert = emitted[0];
+    expect(alert.sourceEventName).toBe("activity.failed");
+    expect(alert.sourceContextId).toBe(schedule.id);
+    // Schedules snapshot a concrete inference profile at creation, and that
+    // profile is the alert's provider scope.
+    const scope = schedule.inferenceProfile;
+    expect(scope).toBeTruthy();
+    expect(alert.dedupeKey).toMatch(
+      new RegExp(
+        `^activity-failed:cause:PROVIDER_BILLING:${scope}:\\d{4}-\\d{2}-\\d{2}$`,
+      ),
+    );
+    expect(alert.contextPayload).toMatchObject({
+      jobName: "schedule:Billing victim",
+      errorKind: "model_provider",
+    });
+  });
+
+  test("schedules on different profiles alert separately for the same cause", async () => {
+    // Two provider connections can fail for the same class of reason with
+    // different remedies; schedule A's alert must not suppress schedule B's.
+    const emitted: Array<Record<string, unknown>> = [];
+    emitNotificationSignalImpl = async (payload) => {
+      emitted.push(payload as Record<string, unknown>);
+    };
+    runnerFailureClassification = {
+      errorKind: "model_provider",
+      failureCode: "PROVIDER_INVALID_KEY",
+    };
+
+    const scheduleA = await createSchedule({
+      name: "Profile A victim",
+      cronExpression: "0 * * * *",
+      message: "do work",
+      syntax: "cron",
+      maxRetries: 1,
+      retryBackoffMs: 1000,
+      inferenceProfile: "cost-optimized",
+    });
+    const scheduleB = await createSchedule({
+      name: "Profile B victim",
+      cronExpression: "0 * * * *",
+      message: "do work",
+      syntax: "cron",
+      maxRetries: 1,
+      retryBackoffMs: 1000,
+      inferenceProfile: "balanced",
+    });
+    forceScheduleDue(scheduleA.id);
+    forceScheduleDue(scheduleB.id);
+
+    scheduler = startScheduler(async () => {
+      throw new Error("provider rejected the key");
+    });
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    forceScheduleDue(scheduleA.id);
+    forceScheduleDue(scheduleB.id);
+    await scheduler.runOnce();
+    scheduler.stop();
+
+    expect(emitted).toHaveLength(2);
+    const keys = emitted.map((signal) => signal.dedupeKey as string).sort();
+    expect(keys[0]).toMatch(
+      /^activity-failed:cause:PROVIDER_INVALID_KEY:balanced:\d{4}-\d{2}-\d{2}$/,
+    );
+    expect(keys[1]).toMatch(
+      /^activity-failed:cause:PROVIDER_INVALID_KEY:cost-optimized:\d{4}-\d{2}-\d{2}$/,
+    );
+  });
+
+  test("a cause-less failure keys the exhaustion alert per schedule", async () => {
+    const emitted: Array<Record<string, unknown>> = [];
+    emitNotificationSignalImpl = async (payload) => {
+      emitted.push(payload as Record<string, unknown>);
+    };
+
+    const schedule = await createSchedule({
+      name: "Crashing job",
+      cronExpression: "0 * * * *",
+      message: "do work",
+      syntax: "cron",
+      maxRetries: 1,
+      retryBackoffMs: 1000,
+    });
+    forceScheduleDue(schedule.id);
+
+    scheduler = startScheduler(async () => {
+      throw new Error("boom");
+    });
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    forceScheduleDue(schedule.id);
+    await scheduler.runOnce();
+    scheduler.stop();
+
+    expect(emitted).toHaveLength(1);
+    expect(emitted[0].dedupeKey).toMatch(
+      new RegExp(
+        `^activity-failed:schedule:${schedule.id}:\\d{4}-\\d{2}-\\d{2}$`,
+      ),
+    );
+    expect(emitted[0].contextPayload).toMatchObject({
+      errorKind: "exception",
+    });
+  });
+});
+
 // ── Crash recovery ────────────────────────────────────────────────────
 
 describe("crash recovery", () => {
@@ -667,7 +849,6 @@ describe("scheduler-recovery equivalence", () => {
     await applyRetryDecision({
       job: jobB,
       isOneShot: false,
-      errorMsg: "fail",
       decision,
       scheduleRetry,
       failOneShotPermanently: () => {},
@@ -747,7 +928,6 @@ describe("scheduler-recovery equivalence", () => {
     await applyRetryDecision({
       job: jobB1,
       isOneShot: true,
-      errorMsg: "fail",
       decision: decision1,
       scheduleRetry,
       failOneShotPermanently: (id: string) => {
@@ -774,7 +954,6 @@ describe("scheduler-recovery equivalence", () => {
     await applyRetryDecision({
       job: jobB2,
       isOneShot: true,
-      errorMsg: "fail",
       decision: decision2,
       scheduleRetry,
       failOneShotPermanently: (id: string) => {

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

@@ -456,7 +456,7 @@ describe("scheduler talk-mode runner option propagation", () => {
     runBackgroundJobBootstrapFails = false;
   });
 
-  test("talk-mode propagates conversationType=scheduled, scheduleJobId, and quiet=>suppressFailureNotifications", async () => {
+  test("talk-mode propagates conversationType=scheduled and scheduleJobId", async () => {
     const rruleExpr = buildEveryMinuteRrule();
     const schedule = await createSchedule({
       name: "Quiet Talk Mode",
@@ -475,10 +475,12 @@ describe("scheduler talk-mode runner option propagation", () => {
     expect(opts.conversationType).toBe("scheduled");
     expect(opts.scheduleJobId).toBe(schedule.id);
     expect(opts.groupId).toBe("system:scheduled");
-    expect(opts.suppressFailureNotifications).toBe(true);
   });
 
-  test("talk-mode without quiet leaves suppressFailureNotifications=false", async () => {
+  test("talk-mode always suppresses the runner's per-attempt failure emission", async () => {
+    // The retry policy owns the single user-facing alert for a failing
+    // schedule (fired once, at exhaustion), so the runner must stay quiet
+    // per attempt whether or not the schedule itself is quiet.
     const rruleExpr = buildEveryMinuteRrule();
     const schedule = await createSchedule({
       name: "Loud Talk Mode",
@@ -493,9 +495,7 @@ describe("scheduler talk-mode runner option propagation", () => {
     await runDueSchedulesOnce();
 
     expect(runBackgroundJobOptions).toHaveLength(1);
-    expect(runBackgroundJobOptions[0]!.suppressFailureNotifications).toBe(
-      false,
-    );
+    expect(runBackgroundJobOptions[0]!.suppressFailureNotifications).toBe(true);
   });
 
   test("talk-mode bootstrap failure writes sentinel conversationId, not empty string", async () => {

package/src/__tests__/secret-routes-platform-proxy.test.ts

@@ -12,6 +12,9 @@ let secureKeyStore: Record<string, string | undefined> = {};
 const metadataUpserts: Array<{ service: string; field: string }> = [];
 const metadataDeletes: Array<{ service: string; field: string }> = [];
 let providerRefreshCalls = 0;
+let identitySyncCalls = 0;
+let avatarSyncCalls = 0;
+let failSecureKeyWrites = false;
 
 const PLATFORM_BASE_URL = "https://platform.example.com";
 const ASSISTANT_API_KEY_PATH = credentialKey("vellum", "assistant_api_key");
@@ -73,6 +76,9 @@ mock.module("../security/secure-keys.js", () => ({
     unreachable: false,
   }),
   setSecureKeyAsync: async (key: string, value: string) => {
+    if (failSecureKeyWrites) {
+      return false;
+    }
     secureKeyStore[key] = value;
     return true;
   },
@@ -99,6 +105,19 @@ mock.module("../plugins/defaults/memory/substrate/boot-maintenance.js", () => ({
   maybeReseedCapabilitiesAfterManagedCredential: async () => {},
 }));
 
+// Live platform registration (`vellum login` against a running assistant)
+// must re-enqueue the name and avatar syncs that no-op'd at startup.
+mock.module("../platform/sync-identity.js", () => ({
+  syncWorkspaceIdentityToPlatform: () => {
+    identitySyncCalls++;
+  },
+}));
+mock.module("../platform/sync-avatar.js", () => ({
+  syncAvatarToPlatform: () => {
+    avatarSyncCalls++;
+  },
+}));
+
 // secret-routes evicts conversations after a credential change so the next turn
 // rebuilds against the new providers; count the calls to assert that happens.
 mock.module("../daemon/conversation-store.js", () => ({
@@ -164,6 +183,9 @@ describe("secret routes managed proxy registry sync", () => {
     lastGeminiConstructorOpts = null;
     platformBaseUrlOverride = undefined;
     providerRefreshCalls = 0;
+    identitySyncCalls = 0;
+    avatarSyncCalls = 0;
+    failSecureKeyWrites = false;
     getDb()
       .delete(providerConnections)
       .where(eq(providerConnections.name, "openrouter-connection"))
@@ -301,6 +323,39 @@ describe("secret routes managed proxy registry sync", () => {
     expect(providerRefreshCalls).toBe(0);
   });
 
+  test("storing a platform registration credential enqueues name and avatar syncs", async () => {
+    for (const name of [
+      "vellum:assistant_api_key",
+      "vellum:platform_assistant_id",
+      "vellum:platform_base_url",
+    ]) {
+      identitySyncCalls = 0;
+      avatarSyncCalls = 0;
+      await addCredential(name, "value");
+      expect(identitySyncCalls).toBe(1);
+      expect(avatarSyncCalls).toBe(1);
+    }
+  });
+
+  test("unrelated credentials do not enqueue platform syncs", async () => {
+    await addCredential("openrouter:api_key", "openrouter-key");
+    await addCredential("vellum:platform_user_id", "user-1");
+
+    expect(identitySyncCalls).toBe(0);
+    expect(avatarSyncCalls).toBe(0);
+  });
+
+  test("a failed platform credential write does not enqueue platform syncs", async () => {
+    failSecureKeyWrites = true;
+
+    await expect(
+      addCredential("vellum:platform_assistant_id", "asst-1"),
+    ).rejects.toThrow("Failed to store credential");
+
+    expect(identitySyncCalls).toBe(0);
+    expect(avatarSyncCalls).toBe(0);
+  });
+
   test("storing vellum:platform_base_url sets override and triggers initializeProviders", async () => {
     await addCredential(
       "vellum:platform_base_url",

package/src/__tests__/skill-load-tool.test.ts

@@ -2,6 +2,8 @@ import { mkdirSync, symlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import type { ClientOs } from "../channels/types.js";
+
 const TEST_DIR = process.env.VELLUM_WORKSPACE_DIR!;
 
 // Build a mock that covers every export from platform.ts — any function not
@@ -66,6 +68,7 @@ function writeToolsJson(
     input_schema?: Record<string, unknown>;
     executor?: string;
     execution_target?: string;
+    supported_client_os?: ClientOs[];
   }>,
 ): void {
   const skillDir = join(TEST_DIR, "skills", skillId);
@@ -80,6 +83,7 @@ function writeToolsJson(
       input_schema: t.input_schema ?? { type: "object", properties: {} },
       executor: t.executor ?? "scripts/run.sh",
       execution_target: t.execution_target ?? "host",
+      supported_client_os: t.supported_client_os,
     })),
   };
   writeFileSync(join(skillDir, "TOOLS.json"), JSON.stringify(manifest));
@@ -87,6 +91,7 @@ function writeToolsJson(
 
 async function executeSkillLoad(
   input: Record<string, unknown>,
+  clientOs?: ClientOs,
 ): Promise<{ content: string; isError: boolean }> {
   const tool = skillLoadTool;
 
@@ -94,6 +99,7 @@ async function executeSkillLoad(
     workingDir: "/tmp",
     conversationId: "conversation-1",
     trustClass: "guardian",
+    clientOs,
   });
   return { content: result.content, isError: result.isError };
 }
@@ -769,6 +775,34 @@ describe("skill_load tool", () => {
     expect(result.content).not.toContain("skill_execute");
   });
 
+  test("omits tools unsupported by the current client operating system", async () => {
+    writeSkill(
+      "platform-tools",
+      "Platform Tools",
+      "Has platform-specific tools",
+      "Body.",
+    );
+    writeToolsJson("platform-tools", [
+      {
+        name: "mac_only_action",
+        description: "Runs only on macOS",
+        supported_client_os: ["macos"],
+      },
+      {
+        name: "desktop_action",
+        description: "Runs on every desktop",
+      },
+    ]);
+
+    const result = await executeSkillLoad(
+      { skill: "platform-tools" },
+      "windows",
+    );
+
+    expect(result.content).not.toContain("mac_only_action");
+    expect(result.content).toContain("desktop_action");
+  });
+
   test("included child skill with TOOLS.json has its tool schemas in output", async () => {
     writeSkillWithIncludes(
       "parent-tools",

package/src/__tests__/skill-tool-factory.test.ts

@@ -83,11 +83,16 @@ afterAll(async () => {
 
 describe("createSkillTool", () => {
   test("produces a tool with correct name, description, and category", () => {
-    const tool = createSkillTool(makeEntry(), "/skills/my-skill", "v1:test");
+    const tool = createSkillTool(
+      makeEntry({ supported_client_os: ["macos"] }),
+      "/skills/my-skill",
+      "v1:test",
+    );
 
     expect(tool.name).toBe("test_tool");
     expect(tool.description).toBe("A test tool");
     expect(tool.category).toBe("testing");
+    expect(tool.supportedClientOs).toEqual(["macos"]);
   });
 
   // Removed "sets origin to skill" test — the factory no longer stamps an

package/src/__tests__/skill-tool-manifest.test.ts

@@ -165,6 +165,26 @@ describe("parseToolManifest", () => {
     }
   });
 
+  test("accepts supported client operating systems", () => {
+    const result = parseToolManifest(
+      makeManifest({
+        tools: [makeToolEntry({ supported_client_os: ["macos", "windows"] })],
+      }),
+    );
+
+    expect(result.tools[0].supported_client_os).toEqual(["macos", "windows"]);
+  });
+
+  test("rejects unknown supported client operating systems", () => {
+    expect(() =>
+      parseToolManifest(
+        makeManifest({
+          tools: [makeToolEntry({ supported_client_os: ["beos"] })],
+        }),
+      ),
+    ).toThrow(/supported_client_os/);
+  });
+
   test("accepts an empty input_schema object", () => {
     const raw = makeManifest({
       tools: [makeToolEntry({ input_schema: {} })],

package/src/__tests__/skills.test.ts

@@ -78,6 +78,31 @@ describe("skills catalog loading", () => {
     expect(catalog.map((skill) => skill.id)).toEqual(["alpha", "zeta"]);
   });
 
+  test("parses supported host platforms from Vellum metadata", () => {
+    const skillDir = join(TEST_DIR, "skills", "platform-skill");
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(
+      join(skillDir, "SKILL.md"),
+      `---
+name: platform-skill
+description: Platform-specific skill
+metadata:
+  vellum:
+    platforms:
+      - macos
+      - linux
+---
+
+Skill body
+`,
+    );
+
+    const skill = loadUserSkillCatalog().find(
+      (entry) => entry.id === "platform-skill",
+    );
+    expect(skill?.platforms).toEqual(["macos", "linux"]);
+  });
+
   test("ignores stale SKILLS.md while discovering valid skill directories", () => {
     writeSkill("first", "First Skill", "First");
     writeSkill("second", "Second Skill", "Second");

package/src/__tests__/subagent-manager-notify.test.ts

@@ -533,6 +533,44 @@ describe("SubagentManager notifyParent (via runSubagent)", () => {
   });
 });
 
+describe("SubagentManager hasActiveChildren", () => {
+  test("is true for pending, running, and awaiting_input children", () => {
+    const manager = new SubagentManager();
+    injectFakeSubagent(
+      manager,
+      "sub-running",
+      makeState("sub-running", { status: "running" }),
+    );
+
+    expect(manager.hasActiveChildren("parent-sess-1")).toBe(true);
+
+    asInternals(manager).subagents.get("sub-running")!.state.status =
+      "awaiting_input";
+    expect(manager.hasActiveChildren("parent-sess-1")).toBe(true);
+
+    asInternals(manager).subagents.get("sub-running")!.state.status = "pending";
+    expect(manager.hasActiveChildren("parent-sess-1")).toBe(true);
+  });
+
+  test("is false when every child is terminal or the parent has none", () => {
+    const manager = new SubagentManager();
+    expect(manager.hasActiveChildren("parent-sess-1")).toBe(false);
+
+    injectFakeSubagent(
+      manager,
+      "sub-done",
+      makeState("sub-done", { status: "completed" }),
+    );
+    injectFakeSubagent(
+      manager,
+      "sub-aborted",
+      makeState("sub-aborted", { status: "aborted" }),
+    );
+
+    expect(manager.hasActiveChildren("parent-sess-1")).toBe(false);
+  });
+});
+
 describe("SubagentManager abortAllForParent", () => {
   test("aborts active children but keeps every child's state readable", () => {
     clearCaptured();

package/src/__tests__/terminal-tools.test.ts

@@ -47,6 +47,7 @@ import {
   KATA_INJECTED_ENV_VARS,
   KATA_SAFE_ENV_VARS,
   SAFE_ENV_VARS,
+  WINDOWS_SAFE_ENV_VARS,
 } from "../tools/terminal/safe-env.js";
 import { shellTool } from "../tools/terminal/shell.js";
 
@@ -194,6 +195,7 @@ describe("buildSanitizedEnv", () => {
       ...KATA_SAFE_ENV_VARS,
       ...KATA_INJECTED_ENV_VARS,
       ...ALWAYS_INJECTED_ENV_VARS,
+      ...WINDOWS_SAFE_ENV_VARS,
     ];
     for (const key of keys) {
       expect(safeKeys).toContain(key);