@vellumai/assistant 0.7.1 → 0.7.2

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,
@@ -170,6 +169,9 @@ describe("pre-chat onboarding contract", () => {
       expect(dynamic).toContain(
         "Use this to personalize your opener and skip redundant discovery.",
       );
+      expect(dynamic).toContain(
+        "If `assistantName` is present, it is the name the user chose for you; preserve it in IDENTITY.md.",
+      );
     });
 
     test("does NOT inject onboarding context when BOOTSTRAP.md does not exist", () => {

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__/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__/require-fresh-approval.test.ts

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

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

@@ -0,0 +1,87 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  computeRetryDelay,
+  DEFAULT_MAX_BACKOFF_MS,
+} from "../schedule/retry-backoff.js";
+import { decideRetry } from "../schedule/retry-policy.js";
+
+describe("computeRetryDelay", () => {
+  const noJitter = () => 0.5;
+  const maxJitter = () => 1.0;
+  const minJitter = () => 0.0;
+
+  test("returns exact baseMs with no jitter for attempt 0", () => {
+    expect(computeRetryDelay(0, 60_000, undefined, noJitter)).toBe(60_000);
+  });
+
+  test("doubles for each subsequent attempt", () => {
+    expect(computeRetryDelay(0, 1000, undefined, noJitter)).toBe(1000);
+    expect(computeRetryDelay(1, 1000, undefined, noJitter)).toBe(2000);
+    expect(computeRetryDelay(2, 1000, undefined, noJitter)).toBe(4000);
+    expect(computeRetryDelay(3, 1000, undefined, noJitter)).toBe(8000);
+  });
+
+  test("applies +20% jitter at max", () => {
+    expect(computeRetryDelay(0, 10_000, undefined, maxJitter)).toBe(12_000);
+  });
+
+  test("applies -20% jitter at min", () => {
+    expect(computeRetryDelay(0, 10_000, undefined, minJitter)).toBe(8_000);
+  });
+
+  test("caps at maxMs AFTER jitter (never exceeds cap)", () => {
+    expect(computeRetryDelay(20, 60_000, 300_000, maxJitter)).toBe(300_000);
+    expect(computeRetryDelay(20, 60_000, 300_000, noJitter)).toBe(300_000);
+  });
+
+  test("caps at DEFAULT_MAX_BACKOFF_MS when maxMs not specified", () => {
+    const d = computeRetryDelay(100, 60_000, undefined, maxJitter);
+    expect(d).toBeLessThanOrEqual(DEFAULT_MAX_BACKOFF_MS);
+  });
+
+  test("never returns negative", () => {
+    expect(
+      computeRetryDelay(0, 1, undefined, minJitter),
+    ).toBeGreaterThanOrEqual(0);
+    expect(computeRetryDelay(0, 0, undefined, minJitter)).toBe(0);
+  });
+});
+
+describe("decideRetry", () => {
+  const baseJob = {
+    id: "job-1",
+    name: "Test",
+    maxRetries: 3,
+    retryBackoffMs: 60_000,
+  };
+  const now = 1_000_000;
+
+  test("retries when retryCount < maxRetries", () => {
+    const d = decideRetry({ ...baseJob, retryCount: 0 }, now);
+    expect(d.action).toBe("retry");
+    if (d.action === "retry") {
+      expect(d.nextRetryAt).toBeGreaterThan(now);
+    }
+  });
+
+  test("retries on last allowed attempt (retryCount = maxRetries - 1)", () => {
+    const d = decideRetry({ ...baseJob, retryCount: 2 }, now);
+    expect(d.action).toBe("retry");
+  });
+
+  test("exhausts when retryCount >= maxRetries", () => {
+    expect(decideRetry({ ...baseJob, retryCount: 3 }, now).action).toBe(
+      "exhaust",
+    );
+    expect(decideRetry({ ...baseJob, retryCount: 5 }, now).action).toBe(
+      "exhaust",
+    );
+  });
+
+  test("maxRetries=0 means no retries", () => {
+    expect(
+      decideRetry({ ...baseJob, maxRetries: 0, retryCount: 0 }, now).action,
+    ).toBe("exhaust");
+  });
+});

package/src/__tests__/runtime-events-sse.test.ts

@@ -58,9 +58,9 @@ describe("SSE assistant-events endpoint", () => {
   });
 
   async function startServer(): Promise<void> {
-    port = 19500 + Math.floor(Math.random() * 500);
-    server = new RuntimeHttpServer({ port });
+    server = new RuntimeHttpServer({ port: 0 });
     await server.start();
+    port = server.actualPort;
   }
 
   async function stopServer(): Promise<void> {
@@ -135,10 +135,12 @@ describe("SSE assistant-events endpoint", () => {
     // Read the first frame directly from the stream.
     const reader = stream.getReader();
 
-    // The first chunk is the immediate heartbeat comment enqueued in start().
+    // The first chunk is the immediate heartbeat (comment + data event) enqueued in start().
     const initial = await reader.read();
     expect(initial.done).toBe(false);
-    expect(new TextDecoder().decode(initial.value)).toBe(": heartbeat\n\n");
+    const initialText = new TextDecoder().decode(initial.value);
+    expect(initialText).toContain(": heartbeat");
+    expect(initialText).toContain('{"type":"heartbeat"}');
 
     // The second chunk is the actual assistant event.
     const { value, done } = await reader.read();
@@ -170,10 +172,12 @@ describe("SSE assistant-events endpoint", () => {
 
     const reader = stream.getReader();
 
-    // Consume the initial heartbeat.
+    // Consume the initial heartbeat (comment + data event).
     const heartbeat = await reader.read();
     expect(heartbeat.done).toBe(false);
-    expect(new TextDecoder().decode(heartbeat.value)).toBe(": heartbeat\n\n");
+    const heartbeatText = new TextDecoder().decode(heartbeat.value);
+    expect(heartbeatText).toContain(": heartbeat");
+    expect(heartbeatText).toContain('{"type":"heartbeat"}');
 
     // Publish events with two different conversationIds.
     const eventA = buildAssistantEvent({ type: "pong" }, "conversation-aaa");

package/src/__tests__/sanitize-config-for-transfer.test.ts

@@ -8,6 +8,7 @@ describe("sanitizeConfigForTransfer", () => {
       ingress: {
         publicBaseUrl: "https://example.com",
         enabled: true,
+        publicBaseUrlManagedBy: "velay",
         webhook: { path: "/hook" },
       },
       daemon: { port: 3000, logLevel: "debug" },
@@ -31,6 +32,7 @@ describe("sanitizeConfigForTransfer", () => {
 
     expect(result.ingress.publicBaseUrl).toBe("");
     expect(result.ingress.enabled).toBeUndefined();
+    expect(result.ingress.publicBaseUrlManagedBy).toBeUndefined();
     expect(result.daemon).toBeUndefined();
     expect(result.skills.load.extraDirs).toEqual([]);
     expect(result.hostBrowser).toEqual({
@@ -135,11 +137,30 @@ describe("sanitizeConfigForTransfer", () => {
     expect(result.skills.load.builtIn).toBe(true);
   });
 
-  test("preserves nested ingress fields other than publicBaseUrl and enabled", () => {
+  test("strips Velay-managed ingress state during transfer", () => {
     const input = {
       ingress: {
-        publicBaseUrl: "https://old.url",
+        publicBaseUrl: "https://velay-public.example.test",
+        enabled: true,
+        publicBaseUrlManagedBy: "velay",
+        webhook: { path: "/webhook" },
+      },
+    };
+
+    const result = JSON.parse(sanitizeConfigForTransfer(JSON.stringify(input)));
+
+    expect(result.ingress).toEqual({
+      publicBaseUrl: "",
+      webhook: { path: "/webhook" },
+    });
+  });
+
+  test("preserves nested ingress fields other than environment-specific URL state", () => {
+    const input = {
+      ingress: {
+        publicBaseUrl: "https://velay-public.example.test",
         enabled: false,
+        publicBaseUrlManagedBy: "velay",
         webhook: { path: "/webhook", secret: "abc" },
         rateLimit: { max: 50, window: 60 },
       },
@@ -151,6 +172,7 @@ describe("sanitizeConfigForTransfer", () => {
     expect(result.ingress.rateLimit).toEqual({ max: 50, window: 60 });
     expect(result.ingress.publicBaseUrl).toBe("");
     expect(result.ingress.enabled).toBeUndefined();
+    expect(result.ingress.publicBaseUrlManagedBy).toBeUndefined();
   });
 
   test("handles config missing some target fields", () => {