@vellumai/assistant 0.9.0 → 0.9.1-staging.1

package/src/__tests__/registry.test.ts

@@ -21,11 +21,7 @@ import {
   unregisterWorkspaceTool,
 } from "../tools/registry.js";
 import { eagerModuleToolNames, explicitTools } from "../tools/tool-manifest.js";
-import type {
-  Tool,
-  ToolContext,
-  ToolExecutionResult,
-} from "../tools/types.js";
+import type { Tool, ToolContext, ToolExecutionResult } from "../tools/types.js";
 
 // Clean up global registry after this file completes to prevent
 // contamination of subsequent test files in combined runs.
@@ -115,12 +111,11 @@ describe("tool manifest", () => {
     expect(eagerModuleToolNames.length).toBe(11);
   });
 
-  test("explicit tools list includes memory and credential tools", () => {
+  test("explicit tools list includes memory tools", () => {
     const names = explicitTools.map((t) => t.name);
     expect(names).toContain("recall");
     expect(names.filter((name) => name === "recall")).toHaveLength(1);
     expect(names).toContain("remember");
-    expect(names).toContain("credential_store");
   });
 
   test("registered tool count is at least eager + host", async () => {

package/src/__tests__/schedule-routes-workflow-validation.test.ts

@@ -1,10 +1,6 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-// These tests exercise the PATCH-side `workflowName` validation, which only
-// runs once the `workflows` feature flag is ON (the flag gate short-circuits
-// first when it is off). Mock the flag resolver to ON so the validation path is
-// reachable; the sibling schedule-routes.test.ts keeps the flag OFF and asserts
-// the flag-gate behavior, so the two files do not conflict.
+// These tests exercise the PATCH-side `workflowName` validation.
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -12,11 +8,6 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-mock.module("../config/assistant-feature-flags.js", () => ({
-  isAssistantFeatureFlagEnabled: (key: string) => key === "workflows",
-  getAssistantFeatureFlagValue: (key: string) => key === "workflows",
-}));
-
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({}),
   invalidateConfigCache: () => {},

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

@@ -1243,36 +1243,6 @@ describe("POST /schedules — create", () => {
     ).toThrow("Only 'execute' and 'workflow' modes are supported");
   });
 
-  test("rejects workflow-mode creation when the workflows flag is off", () => {
-    // The mocked getConfig returns no feature flags, so `workflows` is off.
-    expect(() =>
-      postCreate({
-        name: "Triage",
-        description: "Triage the inbox every morning",
-        expression: "0 9 * * *",
-        message: "triage inbox",
-        mode: "workflow",
-        workflowName: "triage-inbox",
-      }),
-    ).toThrow("Workflows are not enabled");
-  });
-
-  test("rejects PATCH switching to workflow mode when the flag is off", () => {
-    const schedule = createSchedule({
-      name: "Plain execute",
-      cronExpression: "0 9 * * *",
-      message: "hi",
-      syntax: "cron",
-    });
-    const patch = findRoute("schedules/:id", "PATCH");
-    expect(() =>
-      patch.handler({
-        pathParams: { id: schedule.id },
-        body: { mode: "workflow", workflowName: "triage-inbox" },
-      }),
-    ).toThrow("Workflows are not enabled");
-  });
-
   test("rejects an unparseable expression", () => {
     expect(() =>
       postCreate({

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

@@ -421,7 +421,7 @@ describe("schedule tools — workflow mode", () => {
   beforeEach(() => {
     getRawDb().run("DELETE FROM cron_runs");
     getRawDb().run("DELETE FROM cron_jobs");
-    setOverridesForTesting({ workflows: true });
+    setOverridesForTesting({});
   });
   afterAll(() => {
     setOverridesForTesting({});
@@ -466,22 +466,6 @@ describe("schedule tools — workflow mode", () => {
     expect(result.content).toContain("workflow_name is required");
   });
 
-  test("rejects workflow mode when the workflows flag is off", async () => {
-    setOverridesForTesting({}); // flag off
-    const result = await executeScheduleCreate(
-      {
-        name: "Flag off",
-        expression: "0 8 * * *",
-        mode: "workflow",
-        workflow_name: "inbox-triage",
-      },
-      ctx,
-    );
-
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain("workflows are not enabled");
-  });
-
   test("update to workflow mode requires a workflow_name", async () => {
     await executeScheduleCreate(
       { name: "To workflow", expression: "0 9 * * *", message: "test" },
@@ -544,7 +528,7 @@ describe("schedule_create — workflow capability manifest", () => {
   beforeEach(() => {
     getRawDb().run("DELETE FROM cron_runs");
     getRawDb().run("DELETE FROM cron_jobs");
-    setOverridesForTesting({ workflows: true });
+    setOverridesForTesting({});
     // Deterministic registry so a declared side-effecting tool resolves.
     __clearRegistryForTesting();
     registerTool(makeFakeTool("file_write"));

package/src/__tests__/skill-execute-input.test.ts

@@ -1,6 +1,9 @@
 import { describe, expect, test } from "bun:test";
 
-import { resolveSkillExecuteInput } from "../tools/skills/execute.js";
+import {
+  augmentSkillExecuteError,
+  resolveSkillExecuteInput,
+} from "../tools/skills/execute.js";
 
 describe("resolveSkillExecuteInput", () => {
   test("returns a correctly nested object unchanged", () => {
@@ -83,3 +86,45 @@ describe("resolveSkillExecuteInput", () => {
     expect(result).toEqual({ foo: "bar" });
   });
 });
+
+describe("augmentSkillExecuteError", () => {
+  test("appends envelope guidance when an empty-input call errors", () => {
+    // The subagent_spawn failure: empty input, tool rejects with a field-level
+    // message that says nothing about the skill_execute envelope.
+    const result = augmentSkillExecuteError(
+      "subagent_spawn",
+      {},
+      { content: 'Both "label" and "objective" are required.', isError: true },
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain(
+      'Both "label" and "objective" are required.',
+    );
+    expect(result.content).toContain("carried no parameters");
+    expect(result.content).toContain('"tool": "subagent_spawn"');
+    expect(result.content).toContain("inside `input`");
+  });
+
+  test("leaves errors untouched when parameters were resolved", () => {
+    // A non-empty resolved input means the model structured the call; any error
+    // is a real tool-level failure, not an envelope-shape mistake.
+    const original = {
+      content: "Subagent quota exceeded.",
+      isError: true,
+    };
+    const result = augmentSkillExecuteError(
+      "subagent_spawn",
+      { label: "x", objective: "y" },
+      original,
+    );
+    expect(result).toBe(original);
+  });
+
+  test("leaves successful empty-input calls untouched", () => {
+    // Tools that legitimately accept no parameters (e.g. subagent_status) must
+    // not have guidance appended to their successful results.
+    const original = { content: "No subagents running.", isError: false };
+    const result = augmentSkillExecuteError("subagent_status", {}, original);
+    expect(result).toBe(original);
+  });
+});

package/src/__tests__/skill-runtime-path.test.ts

@@ -9,9 +9,8 @@
  * branches (macOS `.app` Resources, next-to-binary) key off
  * `import.meta.dir.startsWith("/$bunfs/")`, so at test time only the
  * source-mode early-return is exercised here; the compiled branch is
- * covered structurally via the signing + packaging step in
- * `clients/macos/build.sh` and will be exercised end-to-end by the
- * supervisor integration test added in PR 27.
+ * covered structurally via the Electron signing + packaging step in
+ * `clients/macos/scripts/pack.sh`.
  */
 
 import { mkdirSync, rmSync, writeFileSync } from "node:fs";

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

@@ -6,6 +6,27 @@ import { describe, expect, mock, test } from "bun:test";
 let mockGetMessages: (
   conversationId: string,
 ) => Array<{ role: string; content: string }> | null = () => null;
+const mockProfiles = {
+  balanced: {},
+  disabled: { status: "disabled" },
+  "quality-optimized": {},
+};
+mock.module("../config/loader.js", () => ({
+  getConfigReadOnly: () => ({
+    llm: { profiles: mockProfiles },
+  }),
+  getConfig: () => ({
+    llm: {
+      default: {
+        provider: "anthropic",
+        provider_connection: "anthropic-managed",
+        model: "claude-opus-4-7",
+      },
+      profiles: mockProfiles,
+    },
+    rateLimit: { maxRequestsPerMinute: 0 },
+  }),
+}));
 mock.module("../memory/conversation-crud.js", () => ({
   setConversationOriginChannelIfUnset: () => {},
   updateConversationContextWindow: () => {},
@@ -140,6 +161,7 @@ describe("Subagent tool definitions", () => {
     const def = findTool("subagent_spawn");
     expect(def).toBeDefined();
     expect(def.input_schema.required).toEqual(["label", "objective"]);
+    expect(def.input_schema.properties.inference_profile).toBeDefined();
   });
 
   test("abort tool has correct definition", () => {
@@ -422,6 +444,100 @@ describe("Subagent spawn success and failure", () => {
     }
   });
 
+  test("spawn passes explicit inference_profile to manager over inherited override", async () => {
+    const manager = getSubagentManager();
+    const originalSpawn = manager.spawn.bind(manager);
+    let capturedConfig: Record<string, unknown> | undefined;
+
+    manager.spawn = async (config: Record<string, unknown>) => {
+      capturedConfig = config;
+      return "profile-subagent-id";
+    };
+
+    try {
+      const result = await executeSubagentSpawn(
+        {
+          label: "Profile test",
+          objective: "Do it with a chosen model profile",
+          inference_profile: "quality-optimized",
+        },
+        makeContext("sess-spawn-profile", {
+          sendToClient: () => {},
+          overrideProfile: "balanced",
+        }),
+      );
+
+      expect(result.isError).toBe(false);
+      expect(capturedConfig).toBeDefined();
+      expect(capturedConfig!.overrideProfile).toBe("quality-optimized");
+      expect(capturedConfig!.forceOverrideProfile).toBe(true);
+    } finally {
+      manager.spawn = originalSpawn;
+    }
+  });
+
+  test("spawn returns error for unknown inference_profile", async () => {
+    const manager = getSubagentManager();
+    const originalSpawn = manager.spawn.bind(manager);
+    let spawnCalled = false;
+
+    manager.spawn = async () => {
+      spawnCalled = true;
+      return "profile-subagent-id";
+    };
+
+    try {
+      const result = await executeSubagentSpawn(
+        {
+          label: "Bad profile",
+          objective: "Do it",
+          inference_profile: "does-not-exist",
+        },
+        makeContext("sess-spawn-bad-profile", { sendToClient: () => {} }),
+      );
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain(
+        'Inference profile "does-not-exist" is not defined',
+      );
+      expect(spawnCalled).toBe(false);
+    } finally {
+      manager.spawn = originalSpawn;
+    }
+  });
+
+  test("spawn returns error for disabled inference_profile", async () => {
+    const manager = getSubagentManager();
+    const originalSpawn = manager.spawn.bind(manager);
+    let spawnCalled = false;
+
+    manager.spawn = async () => {
+      spawnCalled = true;
+      return "profile-subagent-id";
+    };
+
+    try {
+      const result = await executeSubagentSpawn(
+        {
+          label: "Disabled profile",
+          objective: "Do it",
+          inference_profile: "disabled",
+        },
+        makeContext("sess-spawn-disabled-profile", {
+          sendToClient: () => {},
+        }),
+      );
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain(
+        'Inference profile "disabled" is disabled',
+      );
+      expect(spawnCalled).toBe(false);
+    } finally {
+      manager.spawn = originalSpawn;
+    }
+  });
+
   test("spawn handles non-Error throws gracefully", async () => {
     const manager = getSubagentManager();
     const originalSpawn = manager.spawn.bind(manager);