@vellumai/assistant 0.5.5 → 0.5.7

package/src/permissions/shell-identity.ts

@@ -105,8 +105,10 @@ export async function analyzeShellCommand(
  *   - action:gh pr
  *   - action:gh
  *
- * Only "simple action" commands (optional setup prefix + one action) get
- * action keys. Pipelines and complex chains are marked non-simple.
+ * Simple actions (optional setup prefix + one action) and pipelines get
+ * action keys. Both are marked non-simple when they involve pipes, but
+ * pipelines extract keys from the first segment before the first pipe.
+ * Complex chains (semicolons, ||, &, newlines) get no action keys.
  */
 export function deriveShellActionKeys(
   analysis: ShellIdentityAnalysis,
@@ -117,18 +119,22 @@ export function deriveShellActionKeys(
     return { keys: [], isSimpleAction: false };
   }
 
-  // For multi-segment commands, only allow simple-action classification if
-  // ALL inter-segment operators are explicitly &&. Any other operator (|, ||,
-  // ;, &, empty/missing) means the separator is unknown or unsafe.
-  // This safely handles cases where the parser doesn't capture certain
-  // separators (;, newline, &) and leaves them as empty operators.
+  // For multi-segment commands, check operators to determine the command shape.
+  // Pipes (|) get special handling — we can extract action keys from the first
+  // segment before the pipe. Other complex operators (||, ;, &, empty/missing)
+  // are truly opaque and get no action keys.
   if (segments.length > 1) {
+    let hasPipe = false;
+
     for (const seg of segments) {
       const op = seg.operator;
-      // Non-empty operator that isn't && → definitely complex
-      if (op && op !== "&&") {
+      // Non-empty operator that isn't && or | → definitely complex, no keys
+      if (op && op !== "&&" && op !== "|") {
         return { keys: [], isSimpleAction: false };
       }
+      if (op === "|") {
+        hasPipe = true;
+      }
     }
     // Also check: if there are multiple segments but no operators at all
     // between them (e.g. newline-separated), that's suspicious.
@@ -140,6 +146,42 @@ export function deriveShellActionKeys(
         return { keys: [], isSimpleAction: false };
       }
     }
+
+    // For pipelines, extract action keys from the first non-setup-prefix segment
+    // before the first pipe. This enables broader "Any pdftotext command" rules
+    // that match pipelines like "pdftotext file | head -100".
+    if (hasPipe) {
+      const firstPipeIndex = segments.findIndex((s) => s.operator === "|");
+      if (firstPipeIndex > 0) {
+        const preSegments = segments.slice(0, firstPipeIndex);
+        const actionSegs = preSegments.filter(
+          (s) => !SETUP_PREFIX_PROGRAMS.has(s.program),
+        );
+        if (actionSegs.length === 1) {
+          const seg = actionSegs[0];
+          const tokens: string[] = [seg.program];
+          for (const arg of seg.args) {
+            if (tokens.length >= MAX_ACTION_KEY_DEPTH) break;
+            if (arg.startsWith("-")) continue;
+            if (arg.includes("/") || arg.startsWith(".")) continue;
+            if (/^\d+$/.test(arg)) continue;
+            if (arg.includes("$") || arg.includes('"') || arg.includes("'"))
+              continue;
+            tokens.push(arg);
+          }
+          const keys: ShellActionKey[] = [];
+          for (let depth = tokens.length; depth >= 1; depth--) {
+            keys.push({
+              key: `action:${tokens.slice(0, depth).join(" ")}`,
+              depth,
+            });
+          }
+          return { keys, isSimpleAction: false, primarySegment: seg };
+        }
+      }
+      // Pipeline but couldn't extract a single primary action — no keys
+      return { keys: [], isSimpleAction: false };
+    }
   }
 
   // Separate setup-prefix segments from action segments
@@ -190,9 +232,10 @@ export function deriveShellActionKeys(
  * Candidate ordering:
  *   1. Raw command (most specific match — the full command as written)
  *   2. Canonical primary command (if simple action) — the full primary segment text
- *   3. Action keys from narrowest to broadest (if simple action)
+ *   3. Action keys from narrowest to broadest (if simple action or pipeline)
  *
- * Complex commands (pipelines, multi-action chains) only return the raw candidate.
+ * Complex non-pipeline commands (multi-action chains, semicolons, etc.) only
+ * return the raw candidate.
  */
 export async function buildShellCommandCandidates(
   command: string,
@@ -206,14 +249,15 @@ export async function buildShellCommandCandidates(
 
   const candidates: string[] = [trimmed];
 
-  if (actionResult.isSimpleAction && actionResult.primarySegment) {
-    // Add canonical primary command text (the actual segment, not the full command with setup prefixes)
-    const canonical = actionResult.primarySegment.command;
-    if (canonical !== trimmed) {
-      candidates.push(canonical);
+  // Add action keys as candidates if available (simple actions AND pipelines)
+  if (actionResult.keys.length > 0) {
+    // For simple actions, also add the canonical primary command text
+    if (actionResult.isSimpleAction && actionResult.primarySegment) {
+      const canonical = actionResult.primarySegment.command;
+      if (canonical !== trimmed) {
+        candidates.push(canonical);
+      }
     }
-
-    // Add action keys
     for (const actionKey of actionResult.keys) {
       candidates.push(actionKey.key);
     }
@@ -231,8 +275,9 @@ export async function buildShellCommandCandidates(
  *   2. Deepest action key (e.g. "action:gh pr view")
  *   3. Broader action keys (e.g. "action:gh pr", "action:gh")
  *
- * For complex commands (pipelines, multi-action chains), only the exact
- * command is offered (no broad options).
+ * For pipelines, the exact command plus action-key-based broader options
+ * are offered. For other complex commands (multi-action chains, semicolons,
+ * etc.), only the exact command is offered.
  */
 export async function buildShellAllowlistOptions(
   command: string,
@@ -244,14 +289,23 @@ export async function buildShellAllowlistOptions(
   const actionResult = deriveShellActionKeys(analysis);
 
   if (!actionResult.isSimpleAction || !actionResult.primarySegment) {
-    // Complex command — exact only
-    return [
+    const options: AllowlistOption[] = [
       {
         label: trimmed,
         description: "This exact compound command",
         pattern: trimmed,
       },
     ];
+    // If pipeline action keys were extracted, offer them as broader options
+    for (const actionKey of actionResult.keys) {
+      const keyTokens = actionKey.key.replace(/^action:/, "");
+      options.push({
+        label: `${keyTokens} *`,
+        description: `Any "${keyTokens}" command`,
+        pattern: actionKey.key,
+      });
+    }
+    return options;
   }
 
   const options: AllowlistOption[] = [];

package/src/permissions/trust-client.ts

@@ -33,17 +33,6 @@ export interface AcceptStarterBundleResult {
 // Helpers
 // ---------------------------------------------------------------------------
 
-/**
- * Resolve the gateway base URL for trust rule requests.
- *
- * Prefers the `GATEWAY_INTERNAL_URL` env var (set in Docker environments
- * where the gateway runs in a separate container), falling back to the
- * existing `getGatewayInternalBaseUrl()` helper for local deployments.
- */
-function getBaseUrl(): string {
-  return process.env.GATEWAY_INTERNAL_URL ?? getGatewayInternalBaseUrl();
-}
-
 function authHeaders(): Record<string, string> {
   return {
     Authorization: `Bearer ${mintDaemonDeliveryToken()}`,
@@ -60,7 +49,7 @@ async function request<T>(
   path: string,
   body?: unknown,
 ): Promise<T> {
-  const url = `${getBaseUrl()}${path}`;
+  const url = `${getGatewayInternalBaseUrl()}${path}`;
   const options: RequestInit = {
     method,
     headers: authHeaders(),
@@ -102,7 +91,7 @@ async function request<T>(
  * Write operations are user-initiated and infrequent, so blocking is acceptable.
  */
 function requestSync<T>(method: string, path: string, body?: unknown): T {
-  const url = `${getBaseUrl()}${path}`;
+  const url = `${getGatewayInternalBaseUrl()}${path}`;
   const headers = authHeaders();
   const args: string[] = [
     "curl",

package/src/permissions/trust-store.ts

@@ -185,9 +185,10 @@ function backfillDefaults(rules: TrustRule[]): boolean {
     }
   }
 
-  // Migrate existing default rules whose priority, pattern, decision, or
-  // allowHighRisk has changed in the template (e.g. host_bash pattern changed
-  // from '*' to '**', host tool priorities changed from 1000 to 50).
+  // Migrate existing default rules whose priority, pattern, scope, decision,
+  // or allowHighRisk has changed in the template (e.g. host_bash pattern
+  // changed from '*' to '**', host tool priorities changed from 1000 to 50,
+  // workspace scope changed from getRootDir()+workspace to getWorkspaceDir()).
   for (const template of getDefaultRuleTemplates()) {
     if (existingIds.has(template.id)) {
       const rule = rules.find((r) => r.id === template.id);
@@ -195,6 +196,7 @@ function backfillDefaults(rules: TrustRule[]): boolean {
         rule &&
         (rule.priority !== template.priority ||
           rule.pattern !== template.pattern ||
+          rule.scope !== template.scope ||
           rule.decision !== template.decision ||
           rule.allowHighRisk !== template.allowHighRisk)
       ) {
@@ -205,11 +207,14 @@ function backfillDefaults(rules: TrustRule[]): boolean {
             newPriority: template.priority,
             oldPattern: rule.pattern,
             newPattern: template.pattern,
+            oldScope: rule.scope,
+            newScope: template.scope,
           },
           "Migrated default rule to updated template values",
         );
         rule.priority = template.priority;
         rule.pattern = template.pattern;
+        rule.scope = template.scope;
         rule.decision = template.decision;
         if (template.allowHighRisk != null) {
           rule.allowHighRisk = template.allowHighRisk;

package/src/permissions/types.ts

@@ -24,7 +24,8 @@ export type UserDecision =
   | "always_allow_high_risk"
   | "deny"
   | "always_deny"
-  | "temporary_override";
+  | "temporary_override"
+  | "dangerously_skip_permissions";
 
 /** Returns true for any allow-variant decision. Centralizes the check to prevent omissions when new allow variants are added. */
 export function isAllowDecision(decision: UserDecision): boolean {
@@ -34,7 +35,8 @@ export function isAllowDecision(decision: UserDecision): boolean {
     decision === "allow_conversation" ||
     decision === "always_allow" ||
     decision === "always_allow_high_risk" ||
-    decision === "temporary_override"
+    decision === "temporary_override" ||
+    decision === "dangerously_skip_permissions"
   );
 }
 

package/src/platform/client.ts

@@ -7,6 +7,8 @@
 
 import { getPlatformAssistantId } from "../config/env.js";
 import { resolveManagedProxyContext } from "../providers/managed-proxy/context.js";
+import { credentialKey } from "../security/credential-key.js";
+import { getSecureKeyAsync } from "../security/secure-keys.js";
 
 export class VellumPlatformClient {
   private readonly platformBaseUrl: string;
@@ -26,21 +28,47 @@ export class VellumPlatformClient {
   /**
    * Create a platform client by resolving managed proxy context.
    *
+   * First tries the in-memory managed proxy context (available when the daemon
+   * has rehydrated env overrides). Falls back to reading platform credentials
+   * directly from the secure keychain so that standalone CLI invocations work
+   * without the daemon having run its rehydration step.
+   *
    * Returns `null` when auth prerequisites are missing (not logged in, no API
    * key). The assistant ID is resolved but not required — callers that need it
    * should check `platformAssistantId` themselves.
    */
   static async create(): Promise<VellumPlatformClient | null> {
     const ctx = await resolveManagedProxyContext();
-    if (!ctx.enabled) return null;
 
-    const assistantId = getPlatformAssistantId();
+    let baseUrl = ctx.enabled ? ctx.platformBaseUrl : "";
+    let apiKey = ctx.enabled ? ctx.assistantApiKey : "";
+    let assistantId = getPlatformAssistantId();
+
+    // Fall back to keychain for values not yet rehydrated (standalone CLI).
+    if (!baseUrl) {
+      baseUrl =
+        (await getSecureKeyAsync(
+          credentialKey("vellum", "platform_base_url"),
+        )) ?? "";
+    }
+    if (!apiKey) {
+      apiKey =
+        (await getSecureKeyAsync(
+          credentialKey("vellum", "assistant_api_key"),
+        )) ?? "";
+    }
+    if (!assistantId) {
+      assistantId =
+        (
+          await getSecureKeyAsync(
+            credentialKey("vellum", "platform_assistant_id"),
+          )
+        )?.trim() ?? "";
+    }
+
+    if (!baseUrl || !apiKey) return null;
 
-    return new VellumPlatformClient(
-      ctx.platformBaseUrl,
-      ctx.assistantApiKey,
-      assistantId,
-    );
+    return new VellumPlatformClient(baseUrl, apiKey, assistantId);
   }
 
   /**

package/src/prompts/persona-resolver.ts

@@ -0,0 +1,138 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import {
+  findContactByChannelExternalId,
+  listGuardianChannels,
+} from "../contacts/contact-store.js";
+import type {
+  ChannelCapabilities,
+  TrustContext,
+} from "../daemon/conversation-runtime-assembly.js";
+import { getLogger } from "../util/logger.js";
+import { getWorkspaceDir } from "../util/platform.js";
+import { stripCommentLines } from "./system-prompt.js";
+
+const log = getLogger("persona-resolver");
+
+// ── Types ──────────────────────────────────────────────────────────
+
+export interface PersonaContext {
+  userPersona: string | null;
+  channelPersona: string | null;
+}
+
+// ── Helpers ────────────────────────────────────────────────────────
+
+/**
+ * Read a persona file from disk, apply comment stripping, and return
+ * the content. Returns null if the file does not exist or is empty
+ * after stripping.
+ */
+function readPersonaFile(filePath: string): string | null {
+  if (!existsSync(filePath)) return null;
+  const raw = readFileSync(filePath, "utf-8");
+  const content = stripCommentLines(raw).trim();
+  return content.length > 0 ? content : null;
+}
+
+// ── User persona ───────────────────────────────────────────────────
+
+/**
+ * Resolve the per-user persona file for the current actor.
+ *
+ * - If `trustContext` is undefined (desktop/native), looks up the guardian
+ *   contact and reads their user file.
+ * - If `trustContext` is defined and carries a `requesterExternalUserId`,
+ *   looks up the contact by channel + external user ID.
+ * - Falls back to `users/default.md` when no contact is found or the
+ *   contact has no `userFile` set.
+ * - Logs a debug warning when a contact's `userFile` is set but the
+ *   corresponding file is missing on disk.
+ */
+export function resolveUserPersona(
+  trustContext: TrustContext | undefined,
+): string | null {
+  const usersDir = join(getWorkspaceDir(), "users");
+  const defaultPath = join(usersDir, "default.md");
+
+  let filename: string | null = null;
+
+  if (trustContext === undefined) {
+    // Desktop / native — resolve via guardian contact
+    const guardian = listGuardianChannels();
+    if (guardian) {
+      filename = guardian.contact.userFile ?? null;
+    }
+  } else if (trustContext.requesterExternalUserId) {
+    // Channel-routed request — look up contact by channel identity
+    const contactWithChannels = findContactByChannelExternalId(
+      trustContext.sourceChannel,
+      trustContext.requesterExternalUserId,
+    );
+    if (contactWithChannels) {
+      filename = contactWithChannels.userFile ?? null;
+    }
+  }
+
+  // Resolve file path
+  if (filename) {
+    const filePath = join(usersDir, filename);
+    if (existsSync(filePath)) {
+      return readPersonaFile(filePath);
+    }
+    // userFile is set but the file doesn't exist on disk
+    log.debug(
+      { userFile: filename },
+      "Contact has userFile set but file is missing on disk; falling back to default.md",
+    );
+  }
+
+  // Fall back to default.md
+  return readPersonaFile(defaultPath);
+}
+
+// ── Channel persona ────────────────────────────────────────────────
+
+/**
+ * Resolve the per-channel persona file based on channel capabilities.
+ *
+ * Reads from `channels/<channel>.md` in the workspace directory.
+ * Defaults to `"vellum"` when no channel capabilities are provided.
+ * Returns null if the channel file does not exist.
+ */
+export function resolveChannelPersona(
+  channelCapabilities: ChannelCapabilities | undefined,
+): string | null {
+  const channel = channelCapabilities?.channel ?? "vellum";
+  const filePath = join(getWorkspaceDir(), "channels", channel + ".md");
+  return readPersonaFile(filePath);
+}
+
+// ── Combined resolver ──────────────────────────────────────────────
+
+/**
+ * Resolve both user and channel persona context in a single call.
+ */
+export function resolvePersonaContext(
+  trustContext: TrustContext | undefined,
+  channelCapabilities: ChannelCapabilities | undefined,
+): PersonaContext {
+  return {
+    userPersona: resolveUserPersona(trustContext),
+    channelPersona: resolveChannelPersona(channelCapabilities),
+  };
+}
+
+// ── Guardian convenience ───────────────────────────────────────────
+
+/**
+ * Resolve the guardian's user persona.
+ *
+ * This is a convenience wrapper for background subsystems that need
+ * the guardian's persona without a full trust context. Passing
+ * `undefined` triggers the guardian lookup path in `resolveUserPersona`.
+ */
+export function resolveGuardianPersona(): string | null {
+  return resolveUserPersona(undefined);
+}

package/src/prompts/system-prompt.ts

@@ -1,4 +1,4 @@
-import { copyFileSync, existsSync, readFileSync } from "node:fs";
+import { copyFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 
 import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
@@ -9,7 +9,11 @@ import { loadSkillCatalog, type SkillSummary } from "../config/skills.js";
 import { listConnections } from "../oauth/oauth-store.js";
 import { resolveBundledDir } from "../util/bundled-asset.js";
 import { getLogger } from "../util/logger.js";
-import { getWorkspacePromptPath, isMacOS } from "../util/platform.js";
+import {
+  getWorkspaceDir,
+  getWorkspacePromptPath,
+  isMacOS,
+} from "../util/platform.js";
 import { SYSTEM_PROMPT_CACHE_BOUNDARY } from "./cache-boundary.js";
 
 export { SYSTEM_PROMPT_CACHE_BOUNDARY };
@@ -78,6 +82,26 @@ export function ensurePromptFiles(): void {
       }
     }
   }
+
+  // Seed users/default.md persona template
+  try {
+    const usersDir = join(getWorkspaceDir(), "users");
+    mkdirSync(usersDir, { recursive: true });
+    const defaultPersonaSrc = join(templatesDir, "users", "default.md");
+    const defaultPersonaDest = join(usersDir, "default.md");
+    if (!existsSync(defaultPersonaDest) && existsSync(defaultPersonaSrc)) {
+      copyFileSync(defaultPersonaSrc, defaultPersonaDest);
+      log.info(
+        { file: "users/default.md", dest: defaultPersonaDest },
+        "Created default persona file from template",
+      );
+    }
+  } catch (err) {
+    log.warn(
+      { err, file: "users/default.md" },
+      "Failed to create default persona file from template",
+    );
+  }
 }
 
 /**
@@ -93,6 +117,8 @@ export function ensurePromptFiles(): void {
 export interface BuildSystemPromptOptions {
   hasNoClient?: boolean;
   excludeBootstrap?: boolean;
+  userPersona?: string | null;
+  channelPersona?: string | null;
 }
 
 /**
@@ -159,7 +185,9 @@ export function buildSystemPrompt(options?: BuildSystemPromptOptions): string {
     dynamicParts.push(identity);
   }
   if (soul) dynamicParts.push(soul);
-  if (user && !userIsTemplate) dynamicParts.push(user);
+  if (options?.userPersona) dynamicParts.push(options.userPersona);
+  if (options?.channelPersona) dynamicParts.push(options.channelPersona);
+  if (user && !userIsTemplate && !options?.userPersona) dynamicParts.push(user);
   if (includeBootstrap) {
     dynamicParts.push(
       "# First-Run Ritual\n\n" +
@@ -377,7 +405,9 @@ function readPromptFile(path: string): string | null {
  * This is useful for injecting identity context into subsystems (e.g. memory
  * extraction) that run outside the main system prompt pipeline.
  */
-export function buildCoreIdentityContext(): string | null {
+export function buildCoreIdentityContext(
+  opts?: { userPersona?: string | null },
+): string | null {
   const parts: string[] = [];
   for (const file of PROMPT_FILES) {
     const content = readPromptFile(getWorkspacePromptPath(file));
@@ -386,8 +416,10 @@ export function buildCoreIdentityContext(): string | null {
     // before onboarding completes.  Only skip IDENTITY.md and USER.md when
     // they are still unmodified templates (matching buildSystemPrompt).
     if (file !== "SOUL.md" && isTemplateContent(content, file)) continue;
+    if (file === "USER.md" && opts?.userPersona) continue;
     parts.push(content);
   }
+  if (opts?.userPersona) parts.push(opts.userPersona);
   return parts.length > 0 ? parts.join("\n\n") : null;
 }
 

package/src/prompts/templates/users/default.md

@@ -0,0 +1 @@
+

package/src/providers/registry.ts

@@ -1,4 +1,3 @@
-import { wrapWithLogfire } from "../logfire.js";
 import { getProviderKeyAsync } from "../security/secure-keys.js";
 import { ConfigError, ProviderNotConfiguredError } from "../util/errors.js";
 import { AnthropicProvider } from "./anthropic/client.js";
@@ -293,15 +292,13 @@ export async function initializeProviders(
     registerProvider(
       "anthropic",
       new RetryProvider(
-        wrapWithLogfire(
-          new AnthropicProvider(anthropicCreds.apiKey, model, {
-            useNativeWebSearch,
-            streamTimeoutMs,
-            ...(anthropicCreds.baseURL
-              ? { baseURL: anthropicCreds.baseURL }
-              : {}),
-          }),
-        ),
+        new AnthropicProvider(anthropicCreds.apiKey, model, {
+          useNativeWebSearch,
+          streamTimeoutMs,
+          ...(anthropicCreds.baseURL
+            ? { baseURL: anthropicCreds.baseURL }
+            : {}),
+        }),
       ),
     );
     routingSources.set("anthropic", anthropicCreds.source);
@@ -314,12 +311,10 @@ export async function initializeProviders(
     registerProvider(
       "openai",
       new RetryProvider(
-        wrapWithLogfire(
-          new OpenAIProvider(openaiCreds.apiKey, model, {
-            streamTimeoutMs,
-            ...(openaiCreds.baseURL ? { baseURL: openaiCreds.baseURL } : {}),
-          }),
-        ),
+        new OpenAIProvider(openaiCreds.apiKey, model, {
+          streamTimeoutMs,
+          ...(openaiCreds.baseURL ? { baseURL: openaiCreds.baseURL } : {}),
+        }),
       ),
     );
     routingSources.set("openai", openaiCreds.source);
@@ -332,14 +327,12 @@ export async function initializeProviders(
     registerProvider(
       "gemini",
       new RetryProvider(
-        wrapWithLogfire(
-          new GeminiProvider(geminiCreds.apiKey, model, {
-            streamTimeoutMs,
-            ...(geminiCreds.baseURL
-              ? { managedBaseUrl: geminiCreds.baseURL }
-              : {}),
-          }),
-        ),
+        new GeminiProvider(geminiCreds.apiKey, model, {
+          streamTimeoutMs,
+          ...(geminiCreds.baseURL
+            ? { managedBaseUrl: geminiCreds.baseURL }
+            : {}),
+        }),
       ),
     );
     routingSources.set("gemini", geminiCreds.source);
@@ -352,12 +345,10 @@ export async function initializeProviders(
     registerProvider(
       "ollama",
       new RetryProvider(
-        wrapWithLogfire(
-          new OllamaProvider(model, {
-            apiKey: ollamaKey ?? undefined,
-            streamTimeoutMs,
-          }),
-        ),
+        new OllamaProvider(model, {
+          apiKey: ollamaKey ?? undefined,
+          streamTimeoutMs,
+        }),
       ),
     );
     routingSources.set("ollama", "user-key");
@@ -370,11 +361,9 @@ export async function initializeProviders(
     registerProvider(
       "fireworks",
       new RetryProvider(
-        wrapWithLogfire(
-          new FireworksProvider(fireworksKey, model, {
-            streamTimeoutMs,
-          }),
-        ),
+        new FireworksProvider(fireworksKey, model, {
+          streamTimeoutMs,
+        }),
       ),
     );
     routingSources.set("fireworks", "user-key");
@@ -387,11 +376,9 @@ export async function initializeProviders(
     registerProvider(
       "openrouter",
       new RetryProvider(
-        wrapWithLogfire(
-          new OpenRouterProvider(openrouterKey, model, {
-            streamTimeoutMs,
-          }),
-        ),
+        new OpenRouterProvider(openrouterKey, model, {
+          streamTimeoutMs,
+        }),
       ),
     );
     routingSources.set("openrouter", "user-key");

package/src/runtime/auth/__tests__/credential-service.test.ts

@@ -17,7 +17,6 @@ mock.module("../../../util/platform.js", () => ({
   getDataDir: () => testDir,
   getDbPath: () => join(testDir, "test.db"),
   normalizeAssistantId: (id: string) => (id === "self" ? "self" : id),
-  readLockfile: () => ({ assistants: [{ assistantId: "vellum-test-eel" }] }),
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",