@vellumai/assistant 0.4.55 → 0.4.57

package/src/providers/registry.ts

@@ -1,5 +1,5 @@
 import { wrapWithLogfire } from "../logfire.js";
-import { getSecureKeyAsync } from "../security/secure-keys.js";
+import { getProviderKeyAsync } from "../security/secure-keys.js";
 import { ConfigError, ProviderNotConfiguredError } from "../util/errors.js";
 import { AnthropicProvider } from "./anthropic/client.js";
 import { FailoverProvider, type ProviderHealthStatus } from "./failover.js";
@@ -136,23 +136,39 @@ export function getDefaultModel(providerName: string): string {
 }
 
 export interface ProvidersConfig {
-  provider: string;
-  model: string;
-  webSearchProvider?: string;
+  services: {
+    inference: {
+      mode: "managed" | "your-own";
+      provider: string;
+      model: string;
+    };
+    "image-generation": {
+      mode: "managed" | "your-own";
+      provider: string;
+      model: string;
+    };
+    "web-search": {
+      mode: "managed" | "your-own";
+      provider: string;
+    };
+  };
+  providerOrder?: string[];
   timeouts?: { providerStreamTimeoutSec?: number };
 }
 
 function resolveModel(config: ProvidersConfig, providerName: string): string {
-  if (config.provider === providerName) {
+  const inferenceProvider = config.services.inference.provider;
+  const inferenceModel = config.services.inference.model;
+  if (inferenceProvider === providerName) {
     // If a non-Anthropic provider is selected with the untouched global default
     // model, use a provider-appropriate fallback instead.
     if (
       providerName !== "anthropic" &&
-      config.model === getProviderDefaultModel("anthropic")
+      inferenceModel === getProviderDefaultModel("anthropic")
     ) {
       return getProviderDefaultModel(providerName);
     }
-    return config.model;
+    return inferenceModel;
   }
   return getProviderDefaultModel(providerName);
 }
@@ -164,6 +180,7 @@ export interface ProviderDebugStatus {
   registeredProviders: string[];
   failoverHealth: ProviderHealthStatus[] | null;
   overallHealth: "healthy" | "degraded" | "down";
+  routingSources: Record<string, "user-key" | "managed-proxy">;
 }
 
 export function getProviderDebugStatus(
@@ -199,9 +216,59 @@ export function getProviderDebugStatus(
     registeredProviders: registered,
     failoverHealth,
     overallHealth,
+    routingSources: Object.fromEntries(routingSources),
   };
 }
 
+/**
+ * Resolve provider credentials using mode-aware logic.
+ * In "managed" mode, routes through the platform proxy.
+ * In "your-own" mode, uses the user's API key.
+ */
+async function resolveProviderCredentials(
+  providerName: string,
+  mode: "managed" | "your-own",
+): Promise<{
+  apiKey: string;
+  baseURL?: string;
+  source: "user-key" | "managed-proxy";
+} | null> {
+  if (mode === "managed") {
+    // In managed mode, try managed proxy first, then fall back to user key
+    const managedBaseUrl = await buildManagedBaseUrl(providerName);
+    if (managedBaseUrl) {
+      const ctx = await resolveManagedProxyContext();
+      return {
+        apiKey: ctx.assistantApiKey,
+        baseURL: managedBaseUrl,
+        source: "managed-proxy",
+      };
+    }
+    // Managed proxy unavailable for this provider; fall back to user key
+    const userKey = await getProviderKeyAsync(providerName);
+    if (userKey) {
+      return { apiKey: userKey, source: "user-key" };
+    }
+    return null;
+  }
+  // "your-own" mode: check user key first, then try managed proxy fallback
+  const userKey = await getProviderKeyAsync(providerName);
+  if (userKey) {
+    return { apiKey: userKey, source: "user-key" };
+  }
+  // Fall back to managed proxy even in your-own mode (backwards compat)
+  const managedBaseUrl = await buildManagedBaseUrl(providerName);
+  if (managedBaseUrl) {
+    const ctx = await resolveManagedProxyContext();
+    return {
+      apiKey: ctx.assistantApiKey,
+      baseURL: managedBaseUrl,
+      source: "managed-proxy",
+    };
+  }
+  return null;
+}
+
 export async function initializeProviders(
   config: ProvidersConfig,
 ): Promise<void> {
@@ -212,109 +279,75 @@ export async function initializeProviders(
 
   const streamTimeoutMs =
     (config.timeouts?.providerStreamTimeoutSec ?? 300) * 1000;
+  const inferenceMode = config.services.inference.mode;
+  const useNativeWebSearch =
+    config.services["web-search"].provider === "inference-provider-native";
 
-  const anthropicKey = await getSecureKeyAsync("anthropic");
-  if (anthropicKey) {
+  // Anthropic
+  const anthropicCreds = await resolveProviderCredentials(
+    "anthropic",
+    inferenceMode,
+  );
+  if (anthropicCreds) {
     const model = resolveModel(config, "anthropic");
     registerProvider(
       "anthropic",
       new RetryProvider(
         wrapWithLogfire(
-          new AnthropicProvider(anthropicKey, model, {
-            useNativeWebSearch: config.webSearchProvider === "anthropic-native",
+          new AnthropicProvider(anthropicCreds.apiKey, model, {
+            useNativeWebSearch,
             streamTimeoutMs,
+            ...(anthropicCreds.baseURL
+              ? { baseURL: anthropicCreds.baseURL }
+              : {}),
           }),
         ),
       ),
     );
-    routingSources.set("anthropic", "user-key");
-  } else {
-    // No user Anthropic key — route through managed proxy
-    const managedBaseUrl = await buildManagedBaseUrl("anthropic");
-    if (managedBaseUrl) {
-      const ctx = await resolveManagedProxyContext();
-      const model = resolveModel(config, "anthropic");
-      registerProvider(
-        "anthropic",
-        new RetryProvider(
-          wrapWithLogfire(
-            new AnthropicProvider(ctx.assistantApiKey, model, {
-              useNativeWebSearch:
-                config.webSearchProvider === "anthropic-native",
-              streamTimeoutMs,
-              baseURL: managedBaseUrl,
-            }),
-          ),
-        ),
-      );
-      routingSources.set("anthropic", "managed-proxy");
-    }
+    routingSources.set("anthropic", anthropicCreds.source);
   }
-  const openaiKey = await getSecureKeyAsync("openai");
-  if (openaiKey) {
+
+  // OpenAI
+  const openaiCreds = await resolveProviderCredentials("openai", inferenceMode);
+  if (openaiCreds) {
     const model = resolveModel(config, "openai");
     registerProvider(
       "openai",
       new RetryProvider(
         wrapWithLogfire(
-          new OpenAIProvider(openaiKey, model, { streamTimeoutMs }),
+          new OpenAIProvider(openaiCreds.apiKey, model, {
+            streamTimeoutMs,
+            ...(openaiCreds.baseURL ? { baseURL: openaiCreds.baseURL } : {}),
+          }),
         ),
       ),
     );
-    routingSources.set("openai", "user-key");
-  } else {
-    const managedBaseUrl = await buildManagedBaseUrl("openai");
-    if (managedBaseUrl) {
-      const ctx = await resolveManagedProxyContext();
-      const model = resolveModel(config, "openai");
-      registerProvider(
-        "openai",
-        new RetryProvider(
-          wrapWithLogfire(
-            new OpenAIProvider(ctx.assistantApiKey, model, {
-              baseURL: managedBaseUrl,
-              streamTimeoutMs,
-            }),
-          ),
-        ),
-      );
-      routingSources.set("openai", "managed-proxy");
-    }
+    routingSources.set("openai", openaiCreds.source);
   }
-  const geminiKey = await getSecureKeyAsync("gemini");
-  if (geminiKey) {
+
+  // Gemini
+  const geminiCreds = await resolveProviderCredentials("gemini", inferenceMode);
+  if (geminiCreds) {
     const model = resolveModel(config, "gemini");
     registerProvider(
       "gemini",
       new RetryProvider(
         wrapWithLogfire(
-          new GeminiProvider(geminiKey, model, { streamTimeoutMs }),
+          new GeminiProvider(geminiCreds.apiKey, model, {
+            streamTimeoutMs,
+            ...(geminiCreds.baseURL
+              ? { managedBaseUrl: geminiCreds.baseURL }
+              : {}),
+          }),
         ),
       ),
     );
-    routingSources.set("gemini", "user-key");
-  } else {
-    // No user Gemini key — route through Vertex managed proxy
-    const managedBaseUrl = await buildManagedBaseUrl("vertex");
-    if (managedBaseUrl) {
-      const ctx = await resolveManagedProxyContext();
-      const model = resolveModel(config, "gemini");
-      registerProvider(
-        "gemini",
-        new RetryProvider(
-          wrapWithLogfire(
-            new GeminiProvider(ctx.assistantApiKey, model, {
-              streamTimeoutMs,
-              managedBaseUrl,
-            }),
-          ),
-        ),
-      );
-      routingSources.set("gemini", "managed-proxy");
-    }
+    routingSources.set("gemini", geminiCreds.source);
   }
-  const ollamaKey = await getSecureKeyAsync("ollama");
-  if (config.provider === "ollama" || ollamaKey) {
+
+  // Ollama (keyless provider — always init when configured or key present)
+  const ollamaKey = await getProviderKeyAsync("ollama");
+  if (config.services.inference.provider === "ollama" || ollamaKey) {
     const model = resolveModel(config, "ollama");
     registerProvider(
       "ollama",
@@ -329,7 +362,9 @@ export async function initializeProviders(
     );
     routingSources.set("ollama", "user-key");
   }
-  const fireworksKey = await getSecureKeyAsync("fireworks");
+
+  // Fireworks
+  const fireworksKey = await getProviderKeyAsync("fireworks");
   if (fireworksKey) {
     const model = resolveModel(config, "fireworks");
     registerProvider(
@@ -344,7 +379,9 @@ export async function initializeProviders(
     );
     routingSources.set("fireworks", "user-key");
   }
-  const openrouterKey = await getSecureKeyAsync("openrouter");
+
+  // OpenRouter
+  const openrouterKey = await getProviderKeyAsync("openrouter");
   if (openrouterKey) {
     const model = resolveModel(config, "openrouter");
     registerProvider(

package/src/providers/retry.ts

@@ -18,10 +18,25 @@ import type {
 
 const log = getLogger("retry");
 
+/** Patterns that indicate a transient streaming corruption from the SDK. */
+const RETRYABLE_STREAM_PATTERNS = [
+  "Unexpected event order",
+  "stream ended without producing",
+  "request ended without sending any chunks",
+  "stream has ended, this shouldn't happen",
+];
+
+function isRetryableStreamError(error: unknown): boolean {
+  if (!(error instanceof ProviderError)) return false;
+  if (error.statusCode !== undefined) return false; // has a real HTTP status — not a stream error
+  return RETRYABLE_STREAM_PATTERNS.some((p) => error.message.includes(p));
+}
+
 function isRetryableError(error: unknown): boolean {
   if (error instanceof ProviderError && error.statusCode !== undefined) {
     if (error.statusCode === 429 || error.statusCode >= 500) return true;
   }
+  if (isRetryableStreamError(error)) return true;
   return isRetryableNetworkError(error);
 }
 
@@ -127,7 +142,9 @@ export class RetryProvider implements Provider {
                   error.statusCode !== undefined &&
                   error.statusCode >= 500
                 ? `server_error_${error.statusCode}`
-                : "network_error";
+                : isRetryableStreamError(error)
+                  ? "stream_corruption"
+                  : "network_error";
           log.warn(
             {
               attempt: attempt + 1,

package/src/runtime/AGENTS.md

@@ -6,7 +6,7 @@
 
 The single HTTP send endpoint is `POST /v1/messages`. Key behaviors:
 
-- **Queue if busy**: When the session is processing, messages are queued and processed when the current agent turn completes. No 409 rejections.
+- **Queue if busy**: When the conversation is processing, messages are queued and processed when the current agent turn completes. No 409 rejections.
 - **Fire-and-forget**: Returns `202 { accepted: true }` immediately. The client observes progress via SSE (`GET /v1/events`).
 - **Hub publishing**: All agent events are published to `assistantEventHub`, making them observable via SSE.
 
@@ -18,10 +18,10 @@ Approvals are **orthogonal to message sending**. The assistant asks for approval
 
 - **Discovery**: Clients discover pending approvals via SSE events (`confirmation_request`, `secret_request`) which include a `requestId`.
 - **Resolution**: Clients respond via standalone endpoints keyed by `requestId`:
-  - `POST /v1/confirm` — `{ requestId, decision, selectedPattern?, selectedScope? }`. Valid decisions: `"allow"`, `"allow_10m"`, `"allow_thread"`, `"deny"`, `"always_allow"`, `"always_deny"`, `"always_allow_high_risk"`. For persistent decisions (`always_allow`, `always_deny`, `always_allow_high_risk`), `selectedPattern` and `selectedScope` are validated against the server-provided allowlist/scope options from the original confirmation request before trust rules are persisted.
+  - `POST /v1/confirm` — `{ requestId, decision, selectedPattern?, selectedScope? }`. Valid decisions: `"allow"`, `"allow_10m"`, `"allow_conversation"`, `"deny"`, `"always_allow"`, `"always_deny"`, `"always_allow_high_risk"`. For persistent decisions (`always_allow`, `always_deny`, `always_allow_high_risk`), `selectedPattern` and `selectedScope` are validated against the server-provided allowlist/scope options from the original confirmation request before trust rules are persisted.
   - `POST /v1/secret` — `{ requestId, value, delivery }`
   - `POST /v1/trust-rules` — `{ requestId, pattern, scope, decision, allowHighRisk? }`. Validates pattern/scope against server-provided options. Does not resolve the confirmation itself.
-- **Tracking**: The `pending-interactions` tracker (`assistant/src/runtime/pending-interactions.ts`) maps `requestId → session`. Use `register()` to track, `resolve()` to consume, `getByConversation()` to query.
+- **Tracking**: The `pending-interactions` tracker (`assistant/src/runtime/pending-interactions.ts`) maps `requestId → conversation`. Use `register()` to track, `resolve()` to consume, `getByConversation()` to query.
 
 Do NOT couple approval handling to message sending. Do NOT add run/status tracking to the send path.
 
@@ -58,7 +58,7 @@ Channel approval flows use `requestId` (not `runId`) as the primary identifier:
 
 - Telegram callback buttons encode `apr:<requestId>:<action>` in `callback_data`.
 - Guardian approval records in `channelGuardianApprovalRequests` link via `requestId`.
-- The conversational approval engine classifies user intent and resolves via `session.handleConfirmationResponse(requestId, decision)`.
+- The conversational approval engine classifies user intent and resolves via `conversation.handleConfirmationResponse(requestId, decision)`.
 
 ## Rate Limiting & Diagnostics
 
@@ -67,7 +67,7 @@ All `/v1/*` endpoints share a per-client-IP sliding-window rate limiter (`middle
 - **Authenticated**: 300 requests/minute
 - **Unauthenticated**: 20 requests/minute
 
-When the limit is exceeded, the limiter returns 429 and logs a structured warning (module: `rate-limiter`) with the denied endpoint and a breakdown of which endpoints consumed the budget in the current window. This makes it easy to identify whether the cause is rapid thread switching, polling, or unexpected request volume.
+When the limit is exceeded, the limiter returns 429 and logs a structured warning (module: `rate-limiter`) with the denied endpoint and a breakdown of which endpoints consumed the budget in the current window. This makes it easy to identify whether the cause is rapid conversation switching, polling, or unexpected request volume.
 
 Logs are written to `~/.vellum/workspace/data/logs/vellum.log` by default. If `logFile.dir` is configured, logs rotate daily as `assistant-YYYY-MM-DD.log` in that directory. To watch rate limit events in real time:
 

package/src/runtime/access-request-helper.ts

@@ -196,14 +196,14 @@ export function notifyGuardianOfAccessRequest(
     guardianPrincipalId: guardianPrincipalId ?? undefined,
     toolName: "ingress_access_request",
     questionText: `${senderIdentifier} is requesting access to the assistant`,
-    expiresAt: new Date(Date.now() + GUARDIAN_APPROVAL_TTL_MS).toISOString(),
+    expiresAt: Date.now() + GUARDIAN_APPROVAL_TTL_MS,
   });
 
   let vellumDeliveryId: string | null = null;
   void emitNotificationSignal({
     sourceEventName: "ingress.access_request",
     sourceChannel: sourceChannel as NotificationSourceChannel,
-    sourceSessionId: `access-req-${sourceChannel}-${actorExternalId}`,
+    sourceContextId: `access-req-${sourceChannel}-${actorExternalId}`,
     attentionHints: {
       requiresAction: true,
       urgency: "high",
@@ -223,7 +223,7 @@ export function notifyGuardianOfAccessRequest(
       previousMemberStatus: previousMemberStatus ?? null,
     },
     dedupeKey: `access-request:${canonicalRequest.id}`,
-    onThreadCreated: (info) => {
+    onConversationCreated: (info) => {
       if (info.sourceEventName !== "ingress.access_request" || vellumDeliveryId)
         return;
       const delivery = createCanonicalGuardianDelivery({

package/src/runtime/actor-trust-resolver.ts

@@ -17,13 +17,13 @@ import {
   findGuardianForChannel,
 } from "../contacts/contact-store.js";
 import type { ContactChannel, ContactWithChannels } from "../contacts/types.js";
-import type { TrustContext } from "../daemon/session-runtime-assembly.js";
+import type { TrustContext } from "../daemon/conversation-runtime-assembly.js";
 import { canonicalizeInboundIdentity } from "../util/canonicalize-identity.js";
 import { getLogger } from "../util/logger.js";
 
 const log = getLogger("actor-trust-resolver");
 
-export type { TrustContext } from "../daemon/session-runtime-assembly.js";
+export type { TrustContext } from "../daemon/conversation-runtime-assembly.js";
 
 // ---------------------------------------------------------------------------
 // Types

package/src/runtime/approval-conversation-turn.ts

@@ -23,7 +23,7 @@ const VALID_DISPOSITIONS: ReadonlySet<ApprovalConversationDisposition> =
     "keep_pending",
     "approve_once",
     "approve_10m",
-    "approve_thread",
+    "approve_conversation",
     "approve_always",
     "reject",
   ]);
@@ -33,7 +33,7 @@ const DECISION_BEARING_DISPOSITIONS: ReadonlySet<ApprovalConversationDisposition
   new Set([
     "approve_once",
     "approve_10m",
-    "approve_thread",
+    "approve_conversation",
     "approve_always",
     "reject",
   ]);

package/src/runtime/assistant-event-hub.ts

@@ -13,8 +13,8 @@ import type { AssistantEvent } from "./assistant-event.js";
 export type AssistantEventFilter = {
   /** Only deliver events for this assistant. */
   assistantId: string;
-  /** When set, further restrict to this session. */
-  sessionId?: string;
+  /** When set, further restrict to this conversation. */
+  conversationId?: string;
 };
 
 export type AssistantEventCallback = (
@@ -42,7 +42,7 @@ interface SubscriberEntry {
  * Lightweight pub/sub hub for `AssistantEvent` messages.
  *
  * Filtering is applied at subscription level — subscribers receive only
- * events that match their `assistantId` (and optionally `sessionId`).
+ * events that match their `assistantId` (and optionally `conversationId`).
  *
  * The hub is intentionally simple: synchronous fanout, no buffering, no
  * backpressure. Slow-consumer protection lives in the SSE route (PR 7).
@@ -116,7 +116,7 @@ export class AssistantEventHub {
    *
    * Matching rules:
    * - `event.assistantId` must equal `filter.assistantId`
-   * - if `filter.sessionId` is set, `event.sessionId` must equal it
+   * - if `filter.conversationId` is set, `event.conversationId` must equal it
    *
    * Fanout is isolated: a throwing or rejecting subscriber does not abort
    * delivery to remaining subscribers. All callbacks (sync and async) are
@@ -133,12 +133,12 @@ export class AssistantEventHub {
     for (const entry of snapshot) {
       if (!entry.active) continue;
       if (entry.filter.assistantId !== event.assistantId) continue;
-      // System events (no sessionId) match all subscribers; scoped events
-      // must match the subscriber's sessionId filter when present.
+      // System events (no conversationId) match all subscribers; scoped events
+      // must match the subscriber's conversationId filter when present.
       if (
-        event.sessionId != null &&
-        entry.filter.sessionId != null &&
-        entry.filter.sessionId !== event.sessionId
+        event.conversationId != null &&
+        entry.filter.conversationId != null &&
+        entry.filter.conversationId !== event.conversationId
       )
         continue;
       try {

package/src/runtime/assistant-event.ts

@@ -22,8 +22,8 @@ export interface AssistantEvent {
   id: string;
   /** The assistant this event belongs to. */
   assistantId: string;
-  /** Resolved conversation/session id when available. */
-  sessionId?: string;
+  /** Resolved conversation id when available. */
+  conversationId?: string;
   /** ISO-8601 timestamp of when the event was emitted. */
   emittedAt: string;
   /** Outbound server message payload. */
@@ -37,17 +37,17 @@ export interface AssistantEvent {
  *
  * @param assistantId  The logical assistant identifier (e.g. from the daemon or HTTP route).
  * @param message      The outbound server message payload.
- * @param sessionId    Optional conversation/session id — pass when known.
+ * @param conversationId    Optional conversation id — pass when known.
  */
 export function buildAssistantEvent(
   assistantId: string,
   message: ServerMessage,
-  sessionId?: string,
+  conversationId?: string,
 ): AssistantEvent {
   return {
     id: randomUUID(),
     assistantId,
-    sessionId,
+    conversationId,
     emittedAt: new Date().toISOString(),
     message,
   };

package/src/runtime/auth/__tests__/context.test.ts

@@ -27,7 +27,7 @@ describe("buildAuthContext", () => {
       expect(result.context.principalType).toBe("actor");
       expect(result.context.assistantId).toBe("self");
       expect(result.context.actorPrincipalId).toBe("principal-abc");
-      expect(result.context.sessionId).toBeUndefined();
+      expect(result.context.conversationId).toBeUndefined();
       expect(result.context.scopeProfile).toBe("actor_client_v1");
       expect(result.context.policyEpoch).toBe(1);
       expect(result.context.scopes.has("chat.read")).toBe(true);
@@ -61,7 +61,7 @@ describe("buildAuthContext", () => {
     if (result.ok) {
       expect(result.context.principalType).toBe("local");
       expect(result.context.assistantId).toBe("self");
-      expect(result.context.sessionId).toBe("session-123");
+      expect(result.context.conversationId).toBe("session-123");
       expect(result.context.scopes.has("local.all")).toBe(true);
     }
   });

package/src/runtime/auth/__tests__/external-assistant-id.test.ts

@@ -0,0 +1,88 @@
+/**
+ * Tests for getExternalAssistantId resolution order.
+ */
+import { afterEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// Controllable mock for readLockfile — defaults to null (no lockfile data)
+const mockReadLockfile = mock(() => null as Record<string, unknown> | null);
+
+mock.module("../../../util/platform.js", () => ({
+  readLockfile: mockReadLockfile,
+}));
+
+import {
+  getExternalAssistantId,
+  resetExternalAssistantIdCache,
+} from "../external-assistant-id.js";
+
+afterEach(() => {
+  resetExternalAssistantIdCache();
+  mockReadLockfile.mockReset();
+  mockReadLockfile.mockImplementation(() => null);
+  delete process.env.BASE_DATA_DIR;
+});
+
+describe("getExternalAssistantId", () => {
+  test("resolves from lockfile assistants array (most recently hatched)", () => {
+    mockReadLockfile.mockImplementation(() => ({
+      assistants: [
+        { assistantId: "vellum-old-fox", hatchedAt: "2025-01-01T00:00:00Z" },
+        { assistantId: "vellum-new-eel", hatchedAt: "2025-06-15T12:00:00Z" },
+      ],
+    }));
+    expect(getExternalAssistantId()).toBe("vellum-new-eel");
+  });
+
+  test("resolves from lockfile with single assistant entry", () => {
+    mockReadLockfile.mockImplementation(() => ({
+      assistants: [
+        { assistantId: "vellum-solo-cat", hatchedAt: "2025-03-01T00:00:00Z" },
+      ],
+    }));
+    expect(getExternalAssistantId()).toBe("vellum-solo-cat");
+  });
+
+  test("resolves from BASE_DATA_DIR when lockfile has no data", () => {
+    process.env.BASE_DATA_DIR = "/tmp/vellum/assistants/vellum-true-eel";
+    expect(getExternalAssistantId()).toBe("vellum-true-eel");
+  });
+
+  test("resolves from BASE_DATA_DIR with trailing slash", () => {
+    process.env.BASE_DATA_DIR = "/tmp/vellum/assistants/vellum-cool-heron/";
+    expect(getExternalAssistantId()).toBe("vellum-cool-heron");
+  });
+
+  test("resolves from BASE_DATA_DIR with Windows-style backslashes", () => {
+    process.env.BASE_DATA_DIR =
+      "C:\\Users\\user\\.local\\share\\vellum\\assistants\\vellum-nice-fox";
+    expect(getExternalAssistantId()).toBe("vellum-nice-fox");
+  });
+
+  test("resolves from BASE_DATA_DIR with /instances/<name> path", () => {
+    process.env.BASE_DATA_DIR = "/home/user/.vellum/instances/vellum-swift-owl";
+    expect(getExternalAssistantId()).toBe("vellum-swift-owl");
+  });
+
+  test("resolves from BASE_DATA_DIR with /instances/<name> trailing slash", () => {
+    process.env.BASE_DATA_DIR =
+      "/home/user/.vellum/instances/vellum-swift-owl/";
+    expect(getExternalAssistantId()).toBe("vellum-swift-owl");
+  });
+
+  test("falls back to undefined when BASE_DATA_DIR does not match known patterns", () => {
+    process.env.BASE_DATA_DIR = "/tmp/some-other-path";
+    expect(getExternalAssistantId()).toBe(undefined);
+  });
+
+  test("falls back to undefined when BASE_DATA_DIR is not set", () => {
+    delete process.env.BASE_DATA_DIR;
+    expect(getExternalAssistantId()).toBe(undefined);
+  });
+});

package/src/runtime/auth/__tests__/guard-tests.test.ts

@@ -352,10 +352,6 @@ describe("CURRENT_POLICY_EPOCH sync", () => {
       label: "gateway",
       path: resolve(PROJECT_ROOT, "gateway/src/auth/policy.ts"),
     },
-    {
-      label: "cli",
-      path: resolve(PROJECT_ROOT, "cli/src/lib/policy.ts"),
-    },
   ];
 
   function extractEpoch(filePath: string): number {
@@ -387,7 +383,7 @@ describe("CURRENT_POLICY_EPOCH sync", () => {
         "",
         summary,
         "",
-        "All three locations must have the same value.",
+        "All locations must have the same value.",
         "The canonical source is assistant/src/runtime/auth/policy.ts.",
       ].join("\n");
       expect(mismatches, message).toEqual([]);

package/src/runtime/auth/__tests__/local-auth-context.test.ts

@@ -22,9 +22,9 @@ describe("buildLocalAuthContext", () => {
     expect(ctx.assistantId).toBe("self");
   });
 
-  test("includes sessionId from argument", () => {
+  test("includes conversationId from argument", () => {
     const ctx = buildLocalAuthContext("my-session-123");
-    expect(ctx.sessionId).toBe("my-session-123");
+    expect(ctx.conversationId).toBe("my-session-123");
   });
 
   test("uses local_v1 scope profile", () => {
@@ -62,10 +62,10 @@ describe("buildLocalAuthContext", () => {
     expect(typeof ctx.scopes.has).toBe("function");
   });
 
-  test("different session IDs produce different subjects", () => {
+  test("different conversation IDs produce different subjects", () => {
     const ctx1 = buildLocalAuthContext("session-1");
     const ctx2 = buildLocalAuthContext("session-2");
     expect(ctx1.subject).not.toBe(ctx2.subject);
-    expect(ctx1.sessionId).not.toBe(ctx2.sessionId);
+    expect(ctx1.conversationId).not.toBe(ctx2.conversationId);
   });
 });