@vellumai/assistant 0.7.2 → 0.7.3

package/src/__tests__/openai-provider.test.ts

@@ -50,6 +50,10 @@ let lastCreateOptions: Record<string, unknown> | null = null;
 let lastConstructorOptions: Record<string, unknown> | null = null;
 let shouldThrow: Error | null = null;
 
+function userMsg(text: string): Message {
+  return { role: "user", content: [{ type: "text", text }] };
+}
+
 // Simulate OpenAI.APIError
 class FakeAPIError extends Error {
   status: number;
@@ -1294,10 +1298,6 @@ describe("effort config passthrough", () => {
 // ---------------------------------------------------------------------------
 
 describe("OpenRouterProvider reasoning", () => {
-  function userMsg(text: string): Message {
-    return { role: "user", content: [{ type: "text", text }] };
-  }
-
   beforeEach(() => {
     fakeChunks = [textChunk("OK"), usageChunk(10, 2)];
     lastCreateParams = null;
@@ -1367,6 +1367,47 @@ describe("OpenRouterProvider reasoning", () => {
   });
 });
 
+describe("OpenRouterProvider Anthropic-compatible errors", () => {
+  test("retags Anthropic ProviderError instances as OpenRouter errors", async () => {
+    const provider = new OpenRouterProvider("or-key", "anthropic/claude-4.5");
+    const abortReason = createAbortReason(
+      "user_cancel",
+      "openrouter-provider-test",
+    );
+    const cause = new Error("upstream cause");
+    const innerError = new ProviderError(
+      "Anthropic API error (402): Payment Required",
+      "anthropic",
+      402,
+      { cause, retryAfterMs: 1250, abortReason },
+    );
+
+    (
+      provider as unknown as {
+        anthropicInner: {
+          sendMessage: OpenRouterProvider["sendMessage"];
+        };
+      }
+    ).anthropicInner = {
+      sendMessage: async () => {
+        throw innerError;
+      },
+    };
+
+    try {
+      await provider.sendMessage([userMsg("hi")]);
+      throw new Error("expected sendMessage to throw");
+    } catch (error) {
+      expect(error).toBeInstanceOf(ProviderError);
+      expect((error as ProviderError).provider).toBe("openrouter");
+      expect((error as ProviderError).statusCode).toBe(402);
+      expect((error as ProviderError).retryAfterMs).toBe(1250);
+      expect((error as ProviderError).abortReason).toBe(abortReason);
+      expect((error as Error).cause).toBe(cause);
+    }
+  });
+});
+
 // ---------------------------------------------------------------------------
 // Reasoning effort → OpenAI reasoning_effort mapping
 // ---------------------------------------------------------------------------
@@ -1374,10 +1415,6 @@ describe("OpenRouterProvider reasoning", () => {
 describe("OpenAIProvider reasoning_effort", () => {
   let provider: OpenAIProvider;
 
-  function userMsg(text: string): Message {
-    return { role: "user", content: [{ type: "text", text }] };
-  }
-
   beforeEach(() => {
     fakeChunks = [textChunk("OK"), usageChunk(10, 2)];
     lastCreateParams = null;

package/src/__tests__/persist-onboarding-artifacts.test.ts

@@ -27,6 +27,31 @@ mock.module("../util/logger.js", () => ({
 
 let writeRelationshipStateCalled = false;
 let sidecarPayload: unknown = null;
+let writeOnboardingSectionPayload: unknown = null;
+
+mock.module("../prompts/normalize-onboarding.js", () => ({
+  normalizeOnboardingContext: (ctx: unknown) => ctx,
+}));
+
+mock.module("../prompts/persona-resolver.js", () => ({
+  writeOnboardingSection: (payload: unknown) => {
+    writeOnboardingSectionPayload = payload;
+  },
+  resolveGuardianPersonaPath: () => join(TEST_DIR, "users", "guardian.md"),
+  resolveGuardianPersona: () => null,
+  resolveGuardianPersonaStrict: () => null,
+  resolveUserPersona: () => null,
+  resolveChannelPersona: () => null,
+  resolvePersonaContext: () => ({
+    userPersona: null,
+    userSlug: null,
+    channelPersona: null,
+  }),
+  resolveUserSlug: () => null,
+  ensureGuardianPersonaFile: () => {},
+  isGuardianPersonaCustomized: () => false,
+  GUARDIAN_PERSONA_TEMPLATE: "",
+}));
 
 mock.module("../home/relationship-state-writer.js", () => ({
   RELATIONSHIP_STATE_FILENAME: "relationship-state.json",
@@ -59,13 +84,12 @@ describe("persistOnboardingArtifacts", () => {
     mkdirSync(TEST_DIR, { recursive: true });
     writeRelationshipStateCalled = false;
     sidecarPayload = null;
+    writeOnboardingSectionPayload = null;
   });
 
   afterEach(() => {
-    for (const name of ["IDENTITY.md", "USER.md"]) {
-      const p = workspacePath(name);
-      if (existsSync(p)) rmSync(p, { force: true });
-    }
+    const p = workspacePath("IDENTITY.md");
+    if (existsSync(p)) rmSync(p, { force: true });
   });
 
   test("seeds IDENTITY.md with assistant name when file does not exist", () => {
@@ -80,19 +104,7 @@ describe("persistOnboardingArtifacts", () => {
     expect(content).toBe("# Identity\n\n- **Name:** Nova\n");
   });
 
-  test("seeds USER.md with user name when file does not exist", () => {
-    persistOnboardingArtifacts({
-      tools: ["slack"],
-      tasks: ["email"],
-      tone: "balanced",
-      userName: "Alex",
-    });
-
-    const content = readFileSync(workspacePath("USER.md"), "utf-8");
-    expect(content).toBe("# User\n\n- **Name:** Alex\n");
-  });
-
-  test("seeds both IDENTITY.md and USER.md when both names are provided", () => {
+  test("seeds IDENTITY.md when both names are provided", () => {
     persistOnboardingArtifacts({
       tools: [],
       tasks: [],
@@ -104,9 +116,6 @@ describe("persistOnboardingArtifacts", () => {
     expect(readFileSync(workspacePath("IDENTITY.md"), "utf-8")).toBe(
       "# Identity\n\n- **Name:** Pax\n",
     );
-    expect(readFileSync(workspacePath("USER.md"), "utf-8")).toBe(
-      "# User\n\n- **Name:** Alex\n",
-    );
   });
 
   test("updates Name field in existing IDENTITY.md template", () => {
@@ -128,23 +137,6 @@ describe("persistOnboardingArtifacts", () => {
     );
   });
 
-  test("updates Name field in existing USER.md template", () => {
-    writeFileSync(
-      workspacePath("USER.md"),
-      "# User\n\n- **Name:** _(not yet chosen)_\n",
-    );
-
-    persistOnboardingArtifacts({
-      tools: [],
-      tasks: [],
-      tone: "casual",
-      userName: "NewUser",
-    });
-
-    const content = readFileSync(workspacePath("USER.md"), "utf-8");
-    expect(content).toBe("# User\n\n- **Name:** NewUser\n");
-  });
-
   test("updates old-format Name field in existing IDENTITY.md", () => {
     writeFileSync(
       workspacePath("IDENTITY.md"),
@@ -190,17 +182,6 @@ describe("persistOnboardingArtifacts", () => {
     expect(existsSync(workspacePath("IDENTITY.md"))).toBe(false);
   });
 
-  test("skips USER.md when userName is missing", () => {
-    persistOnboardingArtifacts({
-      tools: ["notion"],
-      tasks: ["project-management"],
-      tone: "balanced",
-      assistantName: "Nova",
-    });
-
-    expect(existsSync(workspacePath("USER.md"))).toBe(false);
-  });
-
   test("skips IDENTITY.md when assistantName is whitespace-only", () => {
     persistOnboardingArtifacts({
       tools: [],
@@ -212,32 +193,17 @@ describe("persistOnboardingArtifacts", () => {
     expect(existsSync(workspacePath("IDENTITY.md"))).toBe(false);
   });
 
-  test("skips USER.md when userName is whitespace-only", () => {
-    persistOnboardingArtifacts({
-      tools: [],
-      tasks: [],
-      tone: "balanced",
-      userName: "  ",
-    });
-
-    expect(existsSync(workspacePath("USER.md"))).toBe(false);
-  });
-
-  test("trims whitespace from names before writing", () => {
+  test("trims whitespace from assistantName before writing", () => {
     persistOnboardingArtifacts({
       tools: [],
       tasks: [],
       tone: "balanced",
-      userName: "  Alex  ",
       assistantName: "  Nova  ",
     });
 
     expect(readFileSync(workspacePath("IDENTITY.md"), "utf-8")).toBe(
       "# Identity\n\n- **Name:** Nova\n",
     );
-    expect(readFileSync(workspacePath("USER.md"), "utf-8")).toBe(
-      "# User\n\n- **Name:** Alex\n",
-    );
   });
 
   test("passes onboarding payload to writeOnboardingSidecar", () => {
@@ -263,4 +229,18 @@ describe("persistOnboardingArtifacts", () => {
 
     expect(writeRelationshipStateCalled).toBe(true);
   });
+
+  test("calls writeOnboardingSection with normalized data", () => {
+    const payload = {
+      tools: ["slack", "linear"],
+      tasks: ["code-building", "writing"],
+      tone: "professional",
+      userName: "Alex",
+      assistantName: "Nova",
+    };
+
+    persistOnboardingArtifacts(payload);
+
+    expect(writeOnboardingSectionPayload).toEqual(payload);
+  });
 });

package/src/__tests__/platform-callback-registration.test.ts

@@ -5,7 +5,6 @@ import { credentialKey } from "../security/credential-key.js";
 let mockIsPlatform = true;
 let mockPlatformBaseUrl = "";
 let mockPlatformAssistantId = "";
-let mockPlatformInternalApiKey = "";
 let mockSecureKeys: Record<string, string> = {};
 
 mock.module("../config/env-registry.js", () => ({
@@ -15,7 +14,6 @@ mock.module("../config/env-registry.js", () => ({
 mock.module("../config/env.js", () => ({
   getPlatformBaseUrl: () => mockPlatformBaseUrl,
   getPlatformAssistantId: () => mockPlatformAssistantId,
-  getPlatformInternalApiKey: () => mockPlatformInternalApiKey,
 }));
 
 mock.module("../security/secure-keys.js", () => ({
@@ -32,6 +30,7 @@ mock.module("../util/logger.js", () => ({
 }));
 
 const originalFetch = globalThis.fetch;
+const originalEnvCredential = process.env.ASSISTANT_API_KEY;
 
 const { registerCallbackRoute, resolvePlatformCallbackRegistrationContext } =
   await import("../inbound/platform-callback-registration.js");
@@ -41,13 +40,18 @@ describe("platform callback registration", () => {
     mockIsPlatform = true;
     mockPlatformBaseUrl = "";
     mockPlatformAssistantId = "";
-    mockPlatformInternalApiKey = "";
     mockSecureKeys = {};
+    delete process.env.ASSISTANT_API_KEY;
     globalThis.fetch = originalFetch;
   });
 
   afterEach(() => {
     globalThis.fetch = originalFetch;
+    if (originalEnvCredential === undefined) {
+      delete process.env.ASSISTANT_API_KEY;
+    } else {
+      process.env.ASSISTANT_API_KEY = originalEnvCredential;
+    }
   });
 
   test("resolves managed callback context from stored credentials", async () => {
@@ -64,7 +68,6 @@ describe("platform callback registration", () => {
     expect(context.isPlatform).toBe(true);
     expect(context.platformBaseUrl).toBe("https://platform.example.com");
     expect(context.assistantId).toBe("11111111-2222-4333-8444-555555555555");
-    expect(context.hasInternalApiKey).toBe(false);
     expect(context.hasAssistantApiKey).toBe(true);
     expect(context.authHeader).toBe("Api-Key ast-managed-key");
   });
@@ -88,6 +91,20 @@ describe("platform callback registration", () => {
     expect(context.authHeader).toBe("Api-Key ast-self-hosted-key");
   });
 
+  test("uses ASSISTANT_API_KEY env fallback when stored credential is missing", async () => {
+    process.env.ASSISTANT_API_KEY = "env-key";
+    mockPlatformBaseUrl = "https://platform.example.com";
+    mockPlatformAssistantId = "33333333-4444-4555-8666-777777777777";
+
+    const context = await resolvePlatformCallbackRegistrationContext();
+
+    expect(context.enabled).toBe(true);
+    expect(context.platformBaseUrl).toBe("https://platform.example.com");
+    expect(context.assistantId).toBe("33333333-4444-4555-8666-777777777777");
+    expect(context.hasAssistantApiKey).toBe(true);
+    expect(context.authHeader).toBe("Api-Key env-key");
+  });
+
   test("registerCallbackRoute falls back to assistant API key auth", async () => {
     mockSecureKeys[credentialKey("vellum", "platform_base_url")] =
       "https://platform.example.com";

package/src/__tests__/platform.test.ts

@@ -19,6 +19,7 @@ import {
   getWorkspacePromptPath,
   getWorkspaceSkillsDir,
   getXdgVellumConfigDirName,
+  vellumRoot,
 } from "../util/platform.js";
 
 const originalWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
@@ -99,7 +100,7 @@ describe("path characterization", () => {
     ensureDataDir();
 
     // Root-level dirs (ensureDataDir always creates these)
-    const root = join(homedir(), ".vellum");
+    const root = vellumRoot();
     expect(existsSync(root)).toBe(true);
 
     // Workspace dirs (in our temp location)

package/src/__tests__/playbook-execution.test.ts

@@ -411,28 +411,6 @@ describe("compilePlaybooks", () => {
 describe("playbook tool edge cases", () => {
   beforeEach(clearPlaybooks);
 
-  test("create uses memoryScopeId from context when present", async () => {
-    const scopedCtx: ToolContext = { ...ctx, memoryScopeId: "custom-scope" };
-    const result = await executePlaybookCreate(
-      {
-        trigger: "scoped trigger",
-        action: "scoped action",
-      },
-      scopedCtx,
-    );
-
-    expect(result.isError).toBe(false);
-    expect(result.content).toContain("Playbook created successfully");
-
-    // Verify it's invisible to default scope
-    const defaultList = await executePlaybookList({}, ctx);
-    expect(defaultList.content).toContain("No playbooks found");
-
-    // Visible to custom scope
-    const scopedList = await executePlaybookList({}, scopedCtx);
-    expect(scopedList.content).toContain("scoped trigger");
-  });
-
   test("update detects collision with another playbook", async () => {
     const _r1 = await executePlaybookCreate(
       { trigger: "trigger A", action: "action A" },
@@ -587,25 +565,4 @@ describe("playbook tool edge cases", () => {
     expect(result.content).toContain("Found 1 playbook");
     expect(result.content).toContain("**a**");
   });
-
-  test("delete is scoped and does not affect other scopes", async () => {
-    const scopedCtx: ToolContext = { ...ctx, memoryScopeId: "scope-A" };
-    const createResult = await executePlaybookCreate(
-      { trigger: "x", action: "y" },
-      scopedCtx,
-    );
-    const id = createResult.content.match(/ID: (\S+)/)![1];
-
-    // Try to delete from default scope
-    const deleteResult = await executePlaybookDelete({ playbook_id: id }, ctx);
-    expect(deleteResult.isError).toBe(true);
-    expect(deleteResult.content).toContain("not found");
-
-    // Delete from correct scope succeeds
-    const correctDelete = await executePlaybookDelete(
-      { playbook_id: id },
-      scopedCtx,
-    );
-    expect(correctDelete.isError).toBe(false);
-  });
 });

package/src/__tests__/plugin-tool-contribution.test.ts

@@ -236,6 +236,53 @@ describe("registerPluginTools / unregisterPluginTools helpers", () => {
     expect(retrieved?.ownerPluginId).toBe("my-plugin");
   });
 
+  test("registerPluginTools exposes provider-safe aliases for unsafe plugin tool names", async () => {
+    const execute = mock(
+      async (
+        _input: Record<string, unknown>,
+        _context: ToolContext,
+      ): Promise<ToolExecutionResult> => ({ content: "ok", isError: false }),
+    );
+    const accepted = registerPluginTools("stripe-plugin", [
+      makeFakeTool("Stripe Link CLI", { execute }),
+    ]);
+
+    expect(accepted).toHaveLength(1);
+    const alias = accepted[0]!.name;
+    expect(alias).toMatch(/^[a-zA-Z0-9_-]{1,64}$/);
+    expect(alias.startsWith("Stripe_Link_CLI__")).toBe(true);
+    expect(getTool(alias)).toBeDefined();
+    expect(accepted[0]!.getDefinition().name).toBe(alias);
+
+    await accepted[0]!.execute(
+      {},
+      {
+        workingDir: "/tmp",
+        conversationId: "conv-1",
+        trustClass: "guardian",
+      },
+    );
+
+    expect(execute).toHaveBeenCalledTimes(1);
+  });
+
+  test("registerPluginTools keeps edge-whitespace tool names distinct", () => {
+    const accepted = registerPluginTools("deploy-plugin", [
+      makeFakeTool("deploy"),
+      makeFakeTool(" deploy "),
+    ]);
+
+    expect(accepted).toHaveLength(2);
+    const aliases = accepted.map((tool) => tool.name);
+    expect(new Set(aliases).size).toBe(2);
+    expect(aliases).toContain("deploy");
+
+    const paddedAlias = aliases.find((name) => name !== "deploy");
+    expect(paddedAlias).toMatch(/^deploy__[a-f0-9]{12}$/);
+    expect(getTool("deploy")).toBeDefined();
+    expect(getTool(paddedAlias!)).toBeDefined();
+  });
+
   test("registerPluginTools overwrites any pre-existing ownership metadata", () => {
     // A plugin author could (maliciously or mistakenly) hand in a tool
     // pre-tagged with another skill's or plugin's ID. The helper must