@vellumai/assistant 0.4.54 → 0.4.56

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

@@ -136,17 +136,17 @@ describe("SSE HTTP parity — streaming/delta message types", () => {
     const msg = {
       type: "assistant_text_delta" as const,
       text: "Hello, world!",
-      sessionId: "conv-text-delta",
+      conversationId: "conv-text-delta",
     };
     const event = await publishAndReadFrame("parity-text-delta", msg);
 
     expect(event.message.type).toBe("assistant_text_delta");
     const m = event.message as typeof msg;
     expect(m.text).toBe("Hello, world!");
-    expect(m.sessionId).toBe("conv-text-delta");
+    expect(m.conversationId).toBe("conv-text-delta");
   });
 
-  test("preserves assistant_text_delta without optional sessionId", async () => {
+  test("preserves assistant_text_delta without optional conversationId", async () => {
     const msg = {
       type: "assistant_text_delta" as const,
       text: "No session here",
@@ -156,7 +156,7 @@ describe("SSE HTTP parity — streaming/delta message types", () => {
     const m = event.message as typeof msg;
     expect(m.type).toBe("assistant_text_delta");
     expect(m.text).toBe("No session here");
-    expect((m as Record<string, unknown>).sessionId).toBeUndefined();
+    expect((m as Record<string, unknown>).conversationId).toBeUndefined();
   });
 
   // ── assistant_thinking_delta ─────────────────────────────────────────────
@@ -180,7 +180,7 @@ describe("SSE HTTP parity — streaming/delta message types", () => {
       type: "tool_input_delta" as const,
       toolName: "bash",
       content: '{"command": "ls -la"}',
-      sessionId: "conv-tool-input",
+      conversationId: "conv-tool-input",
     };
     const event = await publishAndReadFrame("parity-tool-input-delta", msg);
 
@@ -188,7 +188,7 @@ describe("SSE HTTP parity — streaming/delta message types", () => {
     const m = event.message as typeof msg;
     expect(m.toolName).toBe("bash");
     expect(m.content).toBe('{"command": "ls -la"}');
-    expect(m.sessionId).toBe("conv-tool-input");
+    expect(m.conversationId).toBe("conv-tool-input");
   });
 
   // ── tool_output_chunk ────────────────────────────────────────────────────
@@ -197,7 +197,7 @@ describe("SSE HTTP parity — streaming/delta message types", () => {
     const msg = {
       type: "tool_output_chunk" as const,
       chunk: "total 42\n-rw-r--r-- 1 user group 1234 Jan 1 00:00 file.ts",
-      sessionId: "conv-tool-output",
+      conversationId: "conv-tool-output",
       subType: "tool_complete" as const,
       subToolName: "bash",
       subToolInput: "ls -la",
@@ -209,7 +209,7 @@ describe("SSE HTTP parity — streaming/delta message types", () => {
     expect(event.message.type).toBe("tool_output_chunk");
     const m = event.message as typeof msg;
     expect(m.chunk).toBe(msg.chunk);
-    expect(m.sessionId).toBe("conv-tool-output");
+    expect(m.conversationId).toBe("conv-tool-output");
     expect(m.subType).toBe("tool_complete");
     expect(m.subToolName).toBe("bash");
     expect(m.subToolInput).toBe("ls -la");
@@ -240,7 +240,7 @@ describe("SSE HTTP parity — streaming/delta message types", () => {
       toolName: "read_file",
       result: "File contents here",
       isError: false,
-      sessionId: "conv-tool-result",
+      conversationId: "conv-tool-result",
       status: "success",
     };
     const event = await publishAndReadFrame("parity-tool-result", msg);
@@ -250,7 +250,7 @@ describe("SSE HTTP parity — streaming/delta message types", () => {
     expect(m.toolName).toBe("read_file");
     expect(m.result).toBe("File contents here");
     expect(m.isError).toBe(false);
-    expect(m.sessionId).toBe("conv-tool-result");
+    expect(m.conversationId).toBe("conv-tool-result");
     expect(m.status).toBe("success");
   });
 
@@ -274,16 +274,16 @@ describe("SSE HTTP parity — streaming/delta message types", () => {
   test("preserves message_complete payload", async () => {
     const msg = {
       type: "message_complete" as const,
-      sessionId: "conv-msg-complete",
+      conversationId: "conv-msg-complete",
     };
     const event = await publishAndReadFrame("parity-message-complete", msg);
 
     expect(event.message.type).toBe("message_complete");
     const m = event.message as typeof msg;
-    expect(m.sessionId).toBe("conv-msg-complete");
+    expect(m.conversationId).toBe("conv-msg-complete");
   });
 
-  test("preserves message_complete without sessionId", async () => {
+  test("preserves message_complete without conversationId", async () => {
     const msg = { type: "message_complete" as const };
     const event = await publishAndReadFrame(
       "parity-message-complete-nosession",
@@ -298,7 +298,7 @@ describe("SSE HTTP parity — streaming/delta message types", () => {
   test("preserves message_request_complete payload", async () => {
     const msg = {
       type: "message_request_complete" as const,
-      sessionId: "conv-msg-request-complete",
+      conversationId: "conv-msg-request-complete",
       requestId: "req-123",
       runStillActive: true,
     };
@@ -309,7 +309,7 @@ describe("SSE HTTP parity — streaming/delta message types", () => {
 
     expect(event.message.type).toBe("message_request_complete");
     const m = event.message as typeof msg;
-    expect(m.sessionId).toBe("conv-msg-request-complete");
+    expect(m.conversationId).toBe("conv-msg-request-complete");
     expect(m.requestId).toBe("req-123");
     expect(m.runStillActive).toBe(true);
   });
@@ -319,7 +319,7 @@ describe("SSE HTTP parity — streaming/delta message types", () => {
   test("preserves generation_handoff payload", async () => {
     const msg = {
       type: "generation_handoff" as const,
-      sessionId: "conv-handoff",
+      conversationId: "conv-handoff",
       requestId: "req-xyz-789",
       queuedCount: 2,
     };
@@ -327,7 +327,7 @@ describe("SSE HTTP parity — streaming/delta message types", () => {
 
     expect(event.message.type).toBe("generation_handoff");
     const m = event.message as typeof msg;
-    expect(m.sessionId).toBe("conv-handoff");
+    expect(m.conversationId).toBe("conv-handoff");
     expect(m.requestId).toBe("req-xyz-789");
     expect(m.queuedCount).toBe(2);
   });
@@ -337,18 +337,18 @@ describe("SSE HTTP parity — streaming/delta message types", () => {
   test("preserves generation_cancelled payload", async () => {
     const msg = {
       type: "generation_cancelled" as const,
-      sessionId: "conv-cancelled",
+      conversationId: "conv-cancelled",
     };
     const event = await publishAndReadFrame("parity-generation-cancelled", msg);
 
     expect(event.message.type).toBe("generation_cancelled");
     const m = event.message as typeof msg;
-    expect(m.sessionId).toBe("conv-cancelled");
+    expect(m.conversationId).toBe("conv-cancelled");
   });
 
   // ── Envelope integrity ───────────────────────────────────────────────────
 
-  test("SSE envelope preserves assistantId and sessionId across all event types", async () => {
+  test("SSE envelope preserves assistantId and conversationId across all event types", async () => {
     const conversationKey = "parity-envelope-check";
     const { conversationId } = getOrCreateConversation(conversationKey);
 
@@ -386,7 +386,7 @@ describe("SSE HTTP parity — streaming/delta message types", () => {
     // Envelope fields
     expect(received.id).toBe(published.id);
     expect(received.assistantId).toBe("self");
-    expect(received.sessionId).toBe(conversationId);
+    expect(received.conversationId).toBe(conversationId);
     expect(received.emittedAt).toBe(published.emittedAt);
     // SSE frame fields
     expect(frame).toContain("event: assistant_event");

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

@@ -179,14 +179,14 @@ describe("SSE assistant-events endpoint", () => {
     const frame = new TextDecoder().decode(value);
     expect(frame).toContain("event: assistant_event");
     expect(frame).toContain(`"assistantId":"self"`);
-    expect(frame).toContain(`"sessionId":"${conversationId}"`);
+    expect(frame).toContain(`"conversationId":"${conversationId}"`);
     expect(frame).toContain('"type":"pong"');
   });
 
   // ── Unfiltered subscription ──────────────────────────────────────────────
 
   test("streams all events when conversationKey is omitted", async () => {
-    // Subscribe without a conversationKey — should receive events from any session.
+    // Subscribe without a conversationKey — should receive events from any conversation.
     const ac = new AbortController();
     const req = new Request("http://localhost/v1/events", {
       signal: ac.signal,
@@ -212,9 +212,17 @@ describe("SSE assistant-events endpoint", () => {
     expect(heartbeat.done).toBe(false);
     expect(new TextDecoder().decode(heartbeat.value)).toBe(": heartbeat\n\n");
 
-    // Publish events with two different sessionIds.
-    const eventA = buildAssistantEvent("self", { type: "pong" }, "session-aaa");
-    const eventB = buildAssistantEvent("self", { type: "pong" }, "session-bbb");
+    // Publish events with two different conversationIds.
+    const eventA = buildAssistantEvent(
+      "self",
+      { type: "pong" },
+      "conversation-aaa",
+    );
+    const eventB = buildAssistantEvent(
+      "self",
+      { type: "pong" },
+      "conversation-bbb",
+    );
     await testHub.publish(eventA);
     await testHub.publish(eventB);
 
@@ -222,12 +230,12 @@ describe("SSE assistant-events endpoint", () => {
     const frameA = await reader.read();
     expect(frameA.done).toBe(false);
     const textA = new TextDecoder().decode(frameA.value);
-    expect(textA).toContain("session-aaa");
+    expect(textA).toContain("conversation-aaa");
 
     const frameB = await reader.read();
     expect(frameB.done).toBe(false);
     const textB = new TextDecoder().decode(frameB.value);
-    expect(textB).toContain("session-bbb");
+    expect(textB).toContain("conversation-bbb");
 
     ac.abort();
   });

package/src/__tests__/scaffold-managed-skill-tool.test.ts

@@ -24,7 +24,6 @@ import type { ToolContext } from "../tools/types.js";
 function makeContext(): ToolContext {
   return {
     workingDir: "/tmp",
-    sessionId: "test-session",
     conversationId: "test-conversation",
     trustClass: "guardian",
   };
@@ -143,9 +142,7 @@ describe("scaffold_managed_skill tool", () => {
       .filter((l) => l.trim() && !l.match(/^\s/));
     // Each top-level frontmatter line must start with a known key -- no injected keys
     for (const line of fmLines) {
-      expect(line).toMatch(
-        /^(name|description|emoji|user-invocable|disable-model-invocation|metadata)(:\s|:$)/,
-      );
+      expect(line).toMatch(/^(name|description|emoji|metadata)(:\s|:$)/);
     }
   });
 

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

@@ -56,7 +56,6 @@ function getRawDb(): Database {
 
 const ctx: ToolContext = {
   workingDir: "/tmp",
-  sessionId: "test-session",
   conversationId: "test-conversation",
   trustClass: "guardian",
 };

package/src/__tests__/scoped-approval-grants.test.ts

@@ -66,7 +66,7 @@ afterAll(() => {
 function grantParams(
   overrides: Partial<CreateScopedApprovalGrantParams> = {},
 ): CreateScopedApprovalGrantParams {
-  const futureExpiry = new Date(Date.now() + 60_000).toISOString();
+  const futureExpiry = Date.now() + 60_000;
   return {
     scopeMode: "request_id",
     requestChannel: "telegram",
@@ -119,7 +119,7 @@ describe("scoped-approval-grants / request_id scope", () => {
   });
 
   test("expired grant cannot be consumed", () => {
-    const pastExpiry = new Date(Date.now() - 1_000).toISOString();
+    const pastExpiry = Date.now() - 1_000;
     createScopedApprovalGrant(
       grantParams({
         scopeMode: "request_id",
@@ -307,7 +307,7 @@ describe("scoped-approval-grants / tool_signature scope", () => {
   });
 
   test("expired tool_signature grant cannot be consumed", () => {
-    const pastExpiry = new Date(Date.now() - 1_000).toISOString();
+    const pastExpiry = Date.now() - 1_000;
     const digest = computeToolApprovalDigest("bash", { cmd: "ls" });
     createScopedApprovalGrant(
       grantParams({
@@ -378,7 +378,7 @@ describe("scoped-approval-grants / expiry", () => {
   beforeEach(() => clearTables());
 
   test("expireScopedApprovalGrants transitions active past-TTL grants to expired", () => {
-    const pastExpiry = new Date(Date.now() - 1_000).toISOString();
+    const pastExpiry = Date.now() - 1_000;
     createScopedApprovalGrant(
       grantParams({
         scopeMode: "request_id",
@@ -407,12 +407,12 @@ describe("scoped-approval-grants / expiry", () => {
   });
 
   test("already-consumed grants are not affected by expiry sweep", () => {
-    const _pastExpiry = new Date(Date.now() - 1_000).toISOString();
+    const _pastExpiry = Date.now() - 1_000;
     createScopedApprovalGrant(
       grantParams({
         scopeMode: "request_id",
         requestId: "req-consumed",
-        expiresAt: new Date(Date.now() + 60_000).toISOString(),
+        expiresAt: Date.now() + 60_000,
       }),
     );
     consumeScopedApprovalGrantByRequestId("req-consumed", "c1");

package/src/__tests__/scoped-grant-security-matrix.test.ts

@@ -83,7 +83,7 @@ afterAll(() => {
 function grantParams(
   overrides: Partial<CreateScopedApprovalGrantParams> = {},
 ): CreateScopedApprovalGrantParams {
-  const futureExpiry = new Date(Date.now() + 60_000).toISOString();
+  const futureExpiry = Date.now() + 60_000;
   return {
     scopeMode: "tool_signature",
     toolName: "bash",

package/src/__tests__/{script-proxy-session-manager.test.ts → script-proxy-conversation-manager.test.ts}

@@ -19,10 +19,13 @@ mock.module("../tools/credentials/metadata-store.js", () => ({
 }));
 
 // Stub ensureLocalCA so tests never run openssl
-mock.module("../tools/network/script-proxy/certs.js", () => ({
+mock.module("../outbound-proxy/certs.js", () => ({
   ensureLocalCA: async () => {},
+  ensureCombinedCABundle: async () => null,
   issueLeafCert: async () => ({ cert: "", key: "" }),
   getCAPath: (dataDir: string) => `${dataDir}/proxy-ca/ca.pem`,
+  getCombinedCAPath: (dataDir: string) =>
+    `${dataDir}/proxy-ca/combined-ca-bundle.pem`,
 }));
 
 import {

package/src/__tests__/secret-onetime-send.test.ts

@@ -78,7 +78,6 @@ describe("one-time send override", () => {
   test("transient_send is rejected when allowOneTimeSend is disabled", async () => {
     const context = {
       workingDir: "/tmp",
-      sessionId: "s1",
       conversationId: "c1",
       trustClass: "guardian" as const,
       requestSecret: async () => ({
@@ -101,7 +100,6 @@ describe("one-time send override", () => {
     mockConfig.secretDetection.allowOneTimeSend = true;
     const context = {
       workingDir: "/tmp",
-      sessionId: "s1",
       conversationId: "c1",
       trustClass: "guardian" as const,
       requestSecret: async () => ({
@@ -124,7 +122,6 @@ describe("one-time send override", () => {
     mockConfig.secretDetection.allowOneTimeSend = true;
     const context = {
       workingDir: "/tmp",
-      sessionId: "s1",
       conversationId: "c1",
       trustClass: "guardian" as const,
       requestSecret: async () => ({ value: "v1", delivery: "store" as const }),
@@ -144,7 +141,6 @@ describe("one-time send override", () => {
     const secretVal = ["nv", "sh", "1"].join("");
     const context = {
       workingDir: "/tmp",
-      sessionId: "s1",
       conversationId: "c1",
       trustClass: "guardian" as const,
       requestSecret: async () => ({

package/src/__tests__/secret-response-routing.test.ts

@@ -82,7 +82,7 @@ describe("secret response routing", () => {
     expect(msg.label).toBe("GitHub Token");
     expect(msg.description).toBe("desc");
     expect(msg.placeholder).toBe("placeholder");
-    expect(msg.sessionId).toBe("session-1");
+    expect(msg.conversationId).toBe("session-1");
     // Clean up
     prompter.resolveSecret(msg.requestId, undefined);
     await promise;

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

@@ -9,11 +9,25 @@ const metadataDeletes: Array<{ service: string; field: string }> = [];
 
 const PLATFORM_BASE_URL = "https://platform.example.com";
 const ASSISTANT_API_KEY_PATH = credentialKey("vellum", "assistant_api_key");
+const PLATFORM_BASE_URL_PATH = credentialKey("vellum", "platform_base_url");
 const MANAGED_PROVIDERS = ["anthropic", "gemini"] as const;
 
+let platformBaseUrlOverride: string | undefined;
+
 const mockConfig = {
-  provider: "anthropic",
-  model: "test-model",
+  services: {
+    inference: {
+      mode: "your-own" as const,
+      provider: "anthropic",
+      model: "test-model",
+    },
+    "image-generation": {
+      mode: "your-own" as const,
+      provider: "gemini",
+      model: "gemini-2.5-flash-image",
+    },
+    "web-search": { mode: "your-own" as const, provider: "anthropic-native" },
+  },
 };
 
 mock.module("@google/genai", () => ({
@@ -41,6 +55,9 @@ mock.module("@google/genai", () => ({
 
 mock.module("../config/env.js", () => ({
   getPlatformBaseUrl: () => PLATFORM_BASE_URL,
+  setPlatformBaseUrl: (value: string | undefined) => {
+    platformBaseUrlOverride = value;
+  },
 }));
 
 mock.module("../config/loader.js", () => ({
@@ -127,6 +144,7 @@ describe("secret routes managed proxy registry sync", () => {
     metadataUpserts.length = 0;
     metadataDeletes.length = 0;
     lastGeminiConstructorOpts = null;
+    platformBaseUrlOverride = undefined;
     await initializeProviders(mockConfig);
   });
 
@@ -172,4 +190,63 @@ describe("secret routes managed proxy registry sync", () => {
     ]);
     expect(listProviders()).toEqual([]);
   });
+
+  test("storing vellum:platform_base_url sets override and triggers initializeProviders", async () => {
+    const res = await handleAddSecret(
+      makeAddCredentialRequest(
+        "vellum:platform_base_url",
+        "https://managed.example.com",
+      ),
+    );
+
+    expect(res.status).toBe(201);
+    expect(secureKeyStore[PLATFORM_BASE_URL_PATH]).toBe(
+      "https://managed.example.com",
+    );
+    expect(platformBaseUrlOverride).toBe("https://managed.example.com");
+    expect(metadataUpserts).toEqual([
+      { service: "vellum", field: "platform_base_url" },
+    ]);
+  });
+
+  test("storing both vellum:platform_base_url and vellum:assistant_api_key enables managed proxy", async () => {
+    expect(listProviders()).toEqual([]);
+
+    await handleAddSecret(
+      makeAddCredentialRequest(
+        "vellum:platform_base_url",
+        "https://managed.example.com",
+      ),
+    );
+    expect(platformBaseUrlOverride).toBe("https://managed.example.com");
+
+    const res = await handleAddSecret(
+      makeAddCredentialRequest("vellum:assistant_api_key", "ast-managed-key"),
+    );
+
+    expect(res.status).toBe(201);
+    const providers = listProviders();
+    expect(providers).toHaveLength(MANAGED_PROVIDERS.length);
+    for (const provider of MANAGED_PROVIDERS) {
+      expect(providers).toContain(provider);
+      expect(getProviderRoutingSource(provider)).toBe("managed-proxy");
+    }
+  });
+
+  test("deleting vellum:platform_base_url clears override and re-initializes providers", async () => {
+    // Set up: store the platform URL credential first
+    secureKeyStore[PLATFORM_BASE_URL_PATH] = "https://managed.example.com";
+    platformBaseUrlOverride = "https://managed.example.com";
+
+    const res = await handleDeleteSecret(
+      makeDeleteCredentialRequest("vellum:platform_base_url"),
+    );
+
+    expect(res.status).toBe(200);
+    expect(secureKeyStore[PLATFORM_BASE_URL_PATH]).toBeUndefined();
+    expect(platformBaseUrlOverride).toBeUndefined();
+    expect(metadataDeletes).toEqual([
+      { service: "vellum", field: "platform_base_url" },
+    ]);
+  });
 });

package/src/__tests__/secret-scanner-executor.test.ts

@@ -109,7 +109,6 @@ function makeContext(
   const auditListener = createToolAuditListener();
   return {
     workingDir: "/tmp",
-    sessionId: "test-session",
     conversationId: "test-conversation",
     trustClass: "guardian" as const,
     onToolLifecycleEvent: (event: ToolLifecycleEvent) => {
@@ -345,7 +344,6 @@ describe("Secret scanner executor integration", () => {
 
     const ctx = {
       workingDir: "/tmp",
-      sessionId: "test-session",
       conversationId: "test-conversation",
       trustClass: "guardian" as const,
     };