@vellumai/assistant 0.7.1 → 0.7.3

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

package/src/__tests__/prechat-onboarding-contract.test.ts

@@ -47,7 +47,6 @@ mock.module("../config/loader.js", () => ({
   }),
   loadConfig: () => mockLoadedConfig,
   loadRawConfig: () => ({}),
-  saveConfig: () => {},
   saveRawConfig: () => {},
   invalidateConfigCache: () => {},
   getNestedValue: () => undefined,
@@ -154,22 +153,18 @@ describe("pre-chat onboarding contract", () => {
       const result = buildSystemPrompt({ onboardingContext: context });
       const dynamic = dynamicBlock(result);
 
-      expect(dynamic).toContain("## Pre-chat Onboarding Context");
+      expect(dynamic).toContain("## First-Run User Context");
       expect(dynamic).toContain(
-        "The user completed the native pre-chat onboarding.",
-      );
-      expect(dynamic).toContain('"tools"');
-      expect(dynamic).toContain('"slack"');
-      expect(dynamic).toContain('"linear"');
-      expect(dynamic).toContain('"tasks"');
-      expect(dynamic).toContain('"code-building"');
-      expect(dynamic).toContain('"tone": "warm"');
-      expect(dynamic).toContain('"userName": "Alex"');
-      expect(dynamic).toContain('"assistantName": "Nova"');
-      expect(dynamic).toContain("```json");
-      expect(dynamic).toContain(
-        "Use this to personalize your opener and skip redundant discovery.",
+        "The user completed setup before this conversation.",
       );
+      expect(dynamic).toContain("- Daily tools: Slack, Linear");
+      expect(dynamic).toContain("- Common work: builds code, apps, or tools");
+      expect(dynamic).toContain("- Name: Alex");
+      expect(dynamic).toContain("- Chosen assistant name: Nova");
+      expect(dynamic).toContain("Apply this context quietly.");
+
+      // Raw JSON must NOT be present
+      expect(dynamic).not.toContain("```json");
     });
 
     test("does NOT inject onboarding context when BOOTSTRAP.md does not exist", () => {
@@ -184,9 +179,9 @@ describe("pre-chat onboarding contract", () => {
       const result = buildSystemPrompt({ onboardingContext: context });
       const dynamic = dynamicBlock(result);
 
-      expect(dynamic).not.toContain("## Pre-chat Onboarding Context");
-      expect(dynamic).not.toContain("pre-chat onboarding");
-      expect(dynamic).not.toContain('"tools"');
+      expect(dynamic).not.toContain("## First-Run User Context");
+      expect(dynamic).not.toContain("First-Run User Context");
+      expect(dynamic).not.toContain("- Daily tools:");
     });
 
     test("does NOT inject onboarding context when excludeBootstrap is true", () => {
@@ -207,7 +202,7 @@ describe("pre-chat onboarding contract", () => {
       });
       const dynamic = dynamicBlock(result);
 
-      expect(dynamic).not.toContain("## Pre-chat Onboarding Context");
+      expect(dynamic).not.toContain("## First-Run User Context");
       expect(dynamic).not.toContain("First-Run Ritual");
     });
 
@@ -223,7 +218,7 @@ describe("pre-chat onboarding contract", () => {
       // Bootstrap should still be present
       expect(dynamic).toContain("First-Run Ritual");
       // But no onboarding context section
-      expect(dynamic).not.toContain("## Pre-chat Onboarding Context");
+      expect(dynamic).not.toContain("## First-Run User Context");
     });
 
     test("accepts all four personality tones", () => {
@@ -245,12 +240,12 @@ describe("pre-chat onboarding contract", () => {
         const result = buildSystemPrompt({ onboardingContext: context });
         const dynamic = dynamicBlock(result);
 
-        expect(dynamic).toContain("## Pre-chat Onboarding Context");
-        expect(dynamic).toContain(`"tone": "${tone}"`);
+        expect(dynamic).toContain("## First-Run User Context");
+        expect(dynamic).toContain(`- Preferred initial voice: ${tone}`);
       }
     });
 
-    test("serializes onboarding context as pretty-printed JSON", () => {
+    test("renders compact markdown, not JSON", () => {
       writeFileSync(
         join(TEST_DIR, "BOOTSTRAP.md"),
         "# Bootstrap\n\nOnboarding.",
@@ -267,9 +262,65 @@ describe("pre-chat onboarding contract", () => {
       const result = buildSystemPrompt({ onboardingContext: context });
       const dynamic = dynamicBlock(result);
 
-      // Verify it contains the pretty-printed JSON (indented with 2 spaces)
+      // Should contain compact markdown lines
+      expect(dynamic).toContain("## First-Run User Context");
+      expect(dynamic).toContain("- Name: Jane");
+      expect(dynamic).toContain("- Common work: plans and coordinates work");
+      expect(dynamic).toContain("- Daily tools: Notion");
+      expect(dynamic).toContain("- Chosen assistant name: Kit");
+      expect(dynamic).toContain("- Preferred initial voice: warm");
+
+      // Must NOT contain JSON output
+      expect(dynamic).not.toContain("```json");
       const expectedJson = JSON.stringify(context, null, 2);
-      expect(dynamic).toContain(expectedJson);
+      expect(dynamic).not.toContain(expectedJson);
+    });
+
+    test("empty tools/tasks arrays result in no Daily tools / Common work lines", () => {
+      writeFileSync(
+        join(TEST_DIR, "BOOTSTRAP.md"),
+        "# Bootstrap\n\nOnboarding.",
+      );
+
+      const context: OnboardingContext = {
+        tools: [],
+        tasks: [],
+        tone: "warm",
+        userName: "Alex",
+      };
+
+      const result = buildSystemPrompt({ onboardingContext: context });
+      const dynamic = dynamicBlock(result);
+
+      expect(dynamic).toContain("## First-Run User Context");
+      expect(dynamic).toContain("- Name: Alex");
+      expect(dynamic).not.toContain("- Daily tools:");
+      expect(dynamic).not.toContain("- Common work:");
+    });
+
+    test("absent userName results in no Name line", () => {
+      writeFileSync(
+        join(TEST_DIR, "BOOTSTRAP.md"),
+        "# Bootstrap\n\nOnboarding.",
+      );
+
+      const context: OnboardingContext = {
+        tools: ["slack"],
+        tasks: ["writing"],
+        tone: "warm",
+      };
+
+      const result = buildSystemPrompt({ onboardingContext: context });
+      const dynamic = dynamicBlock(result);
+
+      expect(dynamic).toContain("## First-Run User Context");
+      expect(dynamic).not.toContain("- Name:");
+      // Other fields should still be present
+      expect(dynamic).toContain("- Daily tools: Slack");
+      expect(dynamic).toContain(
+        "- Common work: writes docs, emails, or content",
+      );
+      expect(dynamic).toContain("- Preferred initial voice: warm");
     });
   });
 
@@ -288,4 +339,142 @@ describe("pre-chat onboarding contract", () => {
       expect(true).toBe(true); // structural acknowledgment
     });
   });
+
+  describe("end-to-end onboarding integration", () => {
+    test("with BOOTSTRAP.md present, onboarding context produces compact markdown with normalized labels", () => {
+      writeFileSync(
+        join(TEST_DIR, "BOOTSTRAP.md"),
+        "# Bootstrap\n\nWelcome to your first conversation.",
+      );
+
+      const context: OnboardingContext = {
+        tools: ["slack", "notion", "linear"],
+        tasks: ["code-building", "writing", "project-management"],
+        tone: "grounded",
+        userName: "Alice",
+        assistantName: "Pax",
+      };
+
+      const result = buildSystemPrompt({ onboardingContext: context });
+      const dynamic = dynamicBlock(result);
+
+      // Heading is present
+      expect(dynamic).toContain("## First-Run User Context");
+
+      // Normalized labels appear (capitalised tool names, human-readable task descriptions)
+      expect(dynamic).toContain("- Daily tools: Slack, Notion, Linear");
+      expect(dynamic).toContain("- Name: Alice");
+      expect(dynamic).toContain("- Chosen assistant name: Pax");
+      expect(dynamic).toContain("- Preferred initial voice: grounded");
+      // Common work descriptions are normalised from task IDs
+      expect(dynamic).toContain("- Common work:");
+
+      // No raw JSON anywhere in the dynamic block
+      expect(dynamic).not.toContain("```json");
+      expect(dynamic).not.toContain('"tools"');
+      expect(dynamic).not.toContain('"tasks"');
+      expect(dynamic).not.toContain('"tone"');
+      expect(dynamic).not.toContain('"userName"');
+      expect(dynamic).not.toContain('"assistantName"');
+    });
+
+    test("without BOOTSTRAP.md, onboarding context does NOT appear in system prompt", () => {
+      // No BOOTSTRAP.md created — simulates a returning user session
+      const context: OnboardingContext = {
+        tools: ["slack", "figma"],
+        tasks: ["design", "writing"],
+        tone: "warm",
+        userName: "Bob",
+        assistantName: "Kit",
+      };
+
+      const result = buildSystemPrompt({ onboardingContext: context });
+      const dynamic = dynamicBlock(result);
+
+      // Onboarding section must be absent
+      expect(dynamic).not.toContain("## First-Run User Context");
+      expect(dynamic).not.toContain("First-Run Ritual");
+      expect(dynamic).not.toContain("- Daily tools:");
+      expect(dynamic).not.toContain("- Name: Bob");
+      expect(dynamic).not.toContain("- Chosen assistant name:");
+      expect(dynamic).not.toContain("Apply this context quietly.");
+    });
+
+    test("excludeBootstrap suppresses both bootstrap and onboarding sections", () => {
+      writeFileSync(
+        join(TEST_DIR, "BOOTSTRAP.md"),
+        "# Bootstrap\n\nFirst run instructions.",
+      );
+
+      const context: OnboardingContext = {
+        tools: ["linear"],
+        tasks: ["code-building"],
+        tone: "energetic",
+        userName: "Charlie",
+        assistantName: "Nova",
+      };
+
+      const result = buildSystemPrompt({
+        onboardingContext: context,
+        excludeBootstrap: true,
+      });
+      const dynamic = dynamicBlock(result);
+
+      // Both bootstrap and onboarding must be suppressed
+      expect(dynamic).not.toContain("First-Run Ritual");
+      expect(dynamic).not.toContain("## First-Run User Context");
+      expect(dynamic).not.toContain("- Daily tools:");
+      expect(dynamic).not.toContain("- Name: Charlie");
+      expect(dynamic).not.toContain("Apply this context quietly.");
+    });
+
+    test("userPersona is included independently of onboarding context", () => {
+      // No BOOTSTRAP.md — the durable persona path after bootstrap is deleted
+      const personaContent =
+        "# User Persona\n\nPrefers concise answers. Works in fintech.";
+
+      const result = buildSystemPrompt({
+        userPersona: personaContent,
+        // No onboardingContext — simulates post-onboarding conversation
+      });
+      const dynamic = dynamicBlock(result);
+
+      // Persona content appears in prompt even without bootstrap or onboarding
+      expect(dynamic).toContain("# User Persona");
+      expect(dynamic).toContain("Prefers concise answers. Works in fintech.");
+
+      // No onboarding section should be present
+      expect(dynamic).not.toContain("## First-Run User Context");
+      expect(dynamic).not.toContain("First-Run Ritual");
+    });
+
+    test("userPersona appears alongside onboarding context during first run", () => {
+      writeFileSync(
+        join(TEST_DIR, "BOOTSTRAP.md"),
+        "# Bootstrap\n\nOnboarding flow.",
+      );
+
+      const personaContent =
+        "# User Persona\n\nEarly-stage startup founder. Likes bullet points.";
+      const context: OnboardingContext = {
+        tools: ["slack"],
+        tasks: ["writing"],
+        tone: "warm",
+        userName: "Dana",
+      };
+
+      const result = buildSystemPrompt({
+        userPersona: personaContent,
+        onboardingContext: context,
+      });
+      const dynamic = dynamicBlock(result);
+
+      // Both persona and onboarding context appear
+      expect(dynamic).toContain("# User Persona");
+      expect(dynamic).toContain("Likes bullet points.");
+      expect(dynamic).toContain("## First-Run User Context");
+      expect(dynamic).toContain("- Name: Dana");
+      expect(dynamic).toContain("- Daily tools: Slack");
+    });
+  });
 });

package/src/__tests__/process-message-background-slack.test.ts

@@ -101,6 +101,7 @@ interface TestConversation {
   ensureActorScopedHistory: () => Promise<void>;
   setChannelCapabilities: () => void;
   setHostCuProxy: () => void;
+  setHostAppControlProxy: () => void;
   addPreactivatedSkillId: () => void;
   setCommandIntent: () => void;
   setTurnChannelContext: (ctx: TurnChannelContext) => void;
@@ -188,6 +189,7 @@ function makeConversation(): TestConversation {
     ensureActorScopedHistory: async () => {},
     setChannelCapabilities: () => {},
     setHostCuProxy: () => {},
+    setHostAppControlProxy: () => {},
     addPreactivatedSkillId: () => {},
     setCommandIntent: () => {},
     setTurnChannelContext: (ctx: TurnChannelContext) => {

package/src/__tests__/provider-commit-message-generator.test.ts

@@ -46,7 +46,6 @@ mock.module("../config/loader.js", () => ({
   getConfig: () => currentConfig,
   loadConfig: () => currentConfig,
   invalidateConfigCache: () => {},
-  saveConfig: () => {},
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},
   getNestedValue: () => undefined,

package/src/__tests__/provider-tool-name.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  isProviderSafeToolName,
+  toProviderSafeToolName,
+} from "../tools/provider-tool-name.js";
+
+describe("provider tool names", () => {
+  test("leaves already-safe names unchanged", () => {
+    expect(toProviderSafeToolName("deploy")).toBe("deploy");
+    expect(isProviderSafeToolName("deploy")).toBe(true);
+  });
+
+  test("preserves raw-name identity for names that differ by edge whitespace", () => {
+    const plain = toProviderSafeToolName("deploy");
+    const padded = toProviderSafeToolName(" deploy ");
+
+    expect(plain).toBe("deploy");
+    expect(padded).toMatch(/^deploy__[a-f0-9]{12}$/);
+    expect(padded).not.toBe(plain);
+    expect(isProviderSafeToolName(padded)).toBe(true);
+  });
+});

package/src/__tests__/public-ingress-urls.test.ts

@@ -26,16 +26,49 @@ mock.module("../util/logger.js", () => ({
 }));
 
 import { setIngressPublicBaseUrl } from "../config/env.js";
+import { IngressConfigSchema } from "../config/schemas/ingress.js";
 import {
   getOAuthCallbackUrl,
   getPublicBaseUrl,
   getTelegramWebhookUrl,
   getTwilioConnectActionUrl,
+  getTwilioMediaStreamUrl,
   getTwilioRelayUrl,
   getTwilioStatusCallbackUrl,
   getTwilioVoiceWebhookUrl,
 } from "../inbound/public-ingress-urls.js";
 
+// ---------------------------------------------------------------------------
+// IngressConfigSchema
+// ---------------------------------------------------------------------------
+
+describe("IngressConfigSchema", () => {
+  test("accepts an absolute HTTP(S) public base URL", () => {
+    const result = IngressConfigSchema.parse({
+      publicBaseUrl: "https://example.com",
+    });
+
+    expect(result.publicBaseUrl).toBe("https://example.com");
+  });
+
+  test("accepts an empty public base URL", () => {
+    const result = IngressConfigSchema.parse({
+      publicBaseUrl: "",
+    });
+
+    expect(result.publicBaseUrl).toBe("");
+  });
+
+  test("rejects a relative public base URL", () => {
+    expect(() =>
+      IngressConfigSchema.parse({
+        publicBaseUrl: "/webhooks/twilio",
+      }),
+    ).toThrow(/ingress\.publicBaseUrl must be an absolute URL/);
+  });
+
+});
+
 // ---------------------------------------------------------------------------
 // getPublicBaseUrl — fallback chain
 // ---------------------------------------------------------------------------
@@ -155,6 +188,70 @@ describe("getPublicBaseUrl", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// Twilio-specific public base URL selection
+// ---------------------------------------------------------------------------
+
+describe("Twilio URL builders use publicBaseUrl", () => {
+  beforeEach(() => {
+    setIngressPublicBaseUrl(undefined);
+  });
+
+  afterEach(() => {
+    setIngressPublicBaseUrl(undefined);
+  });
+
+  test("Twilio URL builders use ingress.publicBaseUrl", () => {
+    const config = {
+      ingress: {
+        publicBaseUrl: "  https://example.com///  ",
+      },
+    };
+
+    expect(getTwilioVoiceWebhookUrl(config, "session-123")).toBe(
+      "https://example.com/webhooks/twilio/voice?callSessionId=session-123",
+    );
+    expect(getTwilioStatusCallbackUrl(config)).toBe(
+      "https://example.com/webhooks/twilio/status",
+    );
+    expect(getTwilioConnectActionUrl(config)).toBe(
+      "https://example.com/webhooks/twilio/connect-action",
+    );
+    expect(getTwilioRelayUrl(config)).toBe(
+      "wss://example.com/webhooks/twilio/relay",
+    );
+    expect(getTwilioMediaStreamUrl(config)).toBe(
+      "wss://example.com/webhooks/twilio/media-stream",
+    );
+  });
+
+  test("Twilio URL builders fall back to module-level ingress state", () => {
+    setIngressPublicBaseUrl("https://ingress-env.example.com");
+
+    expect(
+      getTwilioStatusCallbackUrl({
+        ingress: { publicBaseUrl: "" },
+      }),
+    ).toBe("https://ingress-env.example.com/webhooks/twilio/status");
+  });
+
+  test("all URL builders share the same publicBaseUrl", () => {
+    const config = {
+      ingress: {
+        publicBaseUrl: "https://example.com",
+      },
+    };
+
+    expect(getPublicBaseUrl(config)).toBe("https://example.com");
+    expect(getOAuthCallbackUrl(config)).toBe(
+      "https://example.com/webhooks/oauth/callback",
+    );
+    expect(getTelegramWebhookUrl(config)).toBe(
+      "https://example.com/webhooks/telegram",
+    );
+  });
+});
+
 // ---------------------------------------------------------------------------
 // getTwilioVoiceWebhookUrl
 // ---------------------------------------------------------------------------

package/src/__tests__/relay-server.test.ts

@@ -362,11 +362,22 @@ function getLatestAssistantText(conversationId: string): string | null {
     if (Array.isArray(parsed)) {
       return parsed
         .filter(
-          (block): block is { type: string; text?: string } =>
-            typeof block === "object" && block != null,
+          (block): block is {
+            type: string;
+            text?: string;
+            surfaceType?: string;
+            data?: { summaryText?: string };
+          } => typeof block === "object" && block != null,
         )
-        .filter((block) => block.type === "text")
-        .map((block) => block.text ?? "")
+        .map((block) => {
+          if (block.type === "text") return block.text ?? "";
+          if (
+            block.type === "ui_surface" &&
+            block.surfaceType === "call_summary"
+          )
+            return block.data?.summaryText ?? "";
+          return "";
+        })
         .join("");
     }
     if (typeof parsed === "string") return parsed;

package/src/__tests__/require-fresh-approval.test.ts

@@ -72,7 +72,6 @@ mock.module("../config/loader.js", () => ({
   getConfig: () => mockConfig,
   loadConfig: () => mockConfig,
   invalidateConfigCache: () => {},
-  saveConfig: () => {},
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},
   getNestedValue: () => undefined,