@vellumai/assistant 0.5.13 → 0.5.14

package/src/providers/retry.ts

@@ -18,6 +18,14 @@ import type {
 
 const log = getLogger("retry");
 
+/** Providers that support the `effort` config (extended thinking / reasoning). */
+const EFFORT_SUPPORTED_PROVIDERS = new Set([
+  "anthropic",
+  "openai",
+  "openrouter",
+  "fireworks",
+]);
+
 /** Patterns that indicate a transient streaming corruption from the SDK. */
 const RETRYABLE_STREAM_PATTERNS = [
   "Unexpected event order",
@@ -59,13 +67,16 @@ function normalizeSendMessageOptions(
   const needsThinkingStrip =
     providerName !== "anthropic" && config.thinking !== undefined;
   const needsEffortStrip =
-    providerName !== "anthropic" && config.effort !== undefined;
+    !EFFORT_SUPPORTED_PROVIDERS.has(providerName) && config.effort !== undefined;
+  const needsSpeedStrip =
+    providerName !== "anthropic" && config.speed !== undefined;
 
   if (
     !hasIntent &&
     explicitModel === config.model &&
     !needsThinkingStrip &&
-    !needsEffortStrip
+    !needsEffortStrip &&
+    !needsSpeedStrip
   ) {
     return options;
   }
@@ -78,11 +89,19 @@ function normalizeSendMessageOptions(
     delete nextConfig.thinking;
   }
 
-  // effort is Anthropic-specific; strip it for other providers
-  if (providerName !== "anthropic" && nextConfig.effort !== undefined) {
+  // effort is supported by Anthropic, OpenAI, and OpenAI-compatible providers; strip for others
+  if (
+    !EFFORT_SUPPORTED_PROVIDERS.has(providerName) &&
+    nextConfig.effort !== undefined
+  ) {
     delete nextConfig.effort;
   }
 
+  // speed (fast mode) is Anthropic-specific; strip for other providers
+  if (providerName !== "anthropic" && nextConfig.speed !== undefined) {
+    delete nextConfig.speed;
+  }
+
   if (explicitModel) {
     nextConfig.model = explicitModel;
   } else if (intent) {

package/src/providers/types.ts

@@ -101,6 +101,7 @@ export interface ProviderResponse {
     outputTokens: number;
     cacheCreationInputTokens?: number;
     cacheReadInputTokens?: number;
+    reasoningTokens?: number;
   };
   stopReason: string;
   /** Raw JSON request body sent to the provider (for diagnostics logging). */
@@ -131,6 +132,7 @@ export interface SendMessageConfig {
   model?: string;
   modelIntent?: ModelIntent;
   effort?: "low" | "medium" | "high" | "max";
+  speed?: "standard" | "fast";
   [key: string]: unknown;
 }
 

package/src/runtime/assistant-scope.ts

@@ -8,7 +8,7 @@
  * IDs — use this constant instead.
  *
  * Multi-instance invariant: each daemon process is single-tenant within
- * its own BASE_DATA_DIR. The fixed "self" value works across multiple
+ * its own workspace. The fixed "self" value works across multiple
  * local instances because each instance has isolated storage — there is
  * no cross-instance data sharing that would require disambiguating IDs.
  */

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

@@ -50,6 +50,7 @@ const TEST_KEY = Buffer.from("test-signing-key-32-bytes-long!!");
 initializeDb();
 
 beforeEach(() => {
+  process.env.VELLUM_ASSISTANT_NAME = "vellum-test-eel";
   initAuthSigningKey(TEST_KEY);
   resetExternalAssistantIdCache();
   resetDb();

package/src/runtime/auth/route-policy.ts

@@ -463,6 +463,7 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   { endpoint: "oauth/apps/connections", scopes: ["settings.read"] },
   { endpoint: "oauth/apps/connect", scopes: ["settings.write"] },
   { endpoint: "oauth/connections", scopes: ["settings.write"] },
+  { endpoint: "oauth/providers", scopes: ["settings.read"] },
 
   // Ingress config
   { endpoint: "integrations/ingress/config:GET", scopes: ["settings.read"] },

package/src/runtime/auth/token-service.ts

@@ -19,10 +19,11 @@ import {
   renameSync,
   writeFileSync,
 } from "node:fs";
+import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 
 import { getLogger } from "../../util/logger.js";
-import { getRootDir } from "../../util/platform.js";
+import { getDeprecatedDir } from "../../util/platform.js";
 import { CURRENT_POLICY_EPOCH, isStaleEpoch } from "./policy.js";
 import type { ScopeProfile, TokenAudience, TokenClaims } from "./types.js";
 
@@ -35,51 +36,71 @@ const log = getLogger("token-service");
 let _authSigningKey: Buffer | undefined;
 
 /**
- * Path to the persisted signing key file.
- * Stored in the protected directory alongside other sensitive material.
+ * Hardcoded legacy path to the signing key under ~/.vellum/protected/.
+ * Used as a read-only fallback so existing assistants keep working after
+ * the code update — avoids generating a new key that would break auth
+ * with an already-running daemon.
+ *
+ * This constant can be deleted once we stop calling the gateway directly.
+ */
+const LEGACY_SIGNING_KEY_PATH = join(
+  homedir(),
+  ".vellum",
+  "protected",
+  "actor-token-signing-key",
+);
+
+/**
+ * Returns the canonical path to the signing key file under workspace/deprecated/.
+ *
+ * This file can be fully deleted once the assistant stops making direct
+ * calls to the gateway (i.e. all auth flows go through the env var).
  */
 function getSigningKeyPath(): string {
-  return join(getRootDir(), "protected", "actor-token-signing-key");
+  return join(getDeprecatedDir(), "actor-token-signing-key");
 }
 
 /**
- * Load a signing key from disk. Returns the key buffer if found and valid,
- * or undefined if the file does not exist or is invalid.
- *
- * Used in the Docker 403-fallback path where generating a new key would
- * create a mismatch with the gateway's already-bootstrapped key.
+ * Load a signing key from a file on disk. Returns the key buffer if found
+ * and valid, or undefined if the file does not exist or is invalid.
  */
 export function loadSigningKey(): Buffer | undefined {
-  const keyPath = getSigningKeyPath();
-  if (!existsSync(keyPath)) {
-    return undefined;
-  }
-  try {
-    const raw = readFileSync(keyPath);
-    if (raw.length === 32) {
-      log.info("Auth signing key loaded from disk");
-      return raw;
+  // Try the canonical workspace/deprecated/ path first, then fall back to
+  // the legacy protected/ path so existing assistants keep working.
+  for (const keyPath of [getSigningKeyPath(), LEGACY_SIGNING_KEY_PATH]) {
+    if (!existsSync(keyPath)) {
+      continue;
+    }
+    try {
+      const raw = readFileSync(keyPath);
+      if (raw.length === 32) {
+        log.info({ keyPath }, "Auth signing key loaded from disk");
+        return raw;
+      }
+      log.warn({ keyPath }, "Signing key file has unexpected length");
+    } catch (err) {
+      log.warn({ err, keyPath }, "Failed to read signing key file");
     }
-    log.warn("Signing key file has unexpected length");
-    return undefined;
-  } catch (err) {
-    log.warn({ err }, "Failed to read signing key file");
-    return undefined;
   }
+  return undefined;
 }
 
 /**
  * Load a signing key from disk or generate and persist a new one.
  * Uses atomic-write + chmod 0o600 for safe persistence.
+ *
+ * The key is stored at workspace/deprecated/actor-token-signing-key.
+ * This file can be fully deleted once the assistant stops making direct
+ * calls to the gateway (i.e. all auth flows go through the env var).
  */
 export function loadOrCreateSigningKey(): Buffer {
+  const keyPath = getSigningKeyPath();
   const existing = loadSigningKey();
   if (existing) {
     return existing;
   }
 
   // Generate and persist a new key
-  const keyPath = getSigningKeyPath();
   const newKey = randomBytes(32);
   const dir = dirname(keyPath);
   if (!existsSync(dir)) {
@@ -95,11 +116,9 @@ export function loadOrCreateSigningKey(): Buffer {
 }
 
 /**
- * Resolve the signing key for the current environment.
- *
- * Resolution order:
- *   1. ACTOR_TOKEN_SIGNING_KEY env var (hex-encoded, set by CLI for Docker)
- *   2. File-based load/create (~/.vellum/protected/actor-token-signing-key)
+ * Resolve the signing key for the daemon from the `ACTOR_TOKEN_SIGNING_KEY`
+ * env var (hex-encoded, 64 chars). The CLI launcher sets this before
+ * spawning the daemon; in Docker the gateway injects it.
  */
 export function resolveSigningKey(): Buffer {
   const envKey = process.env.ACTOR_TOKEN_SIGNING_KEY;
@@ -113,6 +132,9 @@ export function resolveSigningKey(): Buffer {
     return Buffer.from(envKey, "hex");
   }
 
+  // Fallback: env var not set (e.g. daemon spawned by cli/src/lib/local.ts
+  // which does not yet inject the env var). Load or create from disk.
+  log.warn("ACTOR_TOKEN_SIGNING_KEY env var not set — falling back to disk");
   return loadOrCreateSigningKey();
 }
 

package/src/runtime/confirmation-request-guardian-bridge.ts

@@ -140,7 +140,9 @@ export function bridgeConfirmationRequestToGuardian(
     trustContext.requesterExternalUserId ||
     "unknown";
 
-  const questionText = `Tool approval request: ${toolName}`;
+  const questionText = canonicalRequest.activityText
+    ? `Approve tool: ${toolName} — ${canonicalRequest.activityText}`
+    : `Approve tool: ${toolName}`;
 
   // Emit guardian.question notification so the guardian is alerted.
   const signalPromise = emitNotificationSignal({

package/src/runtime/guardian-decision-types.ts

@@ -31,6 +31,14 @@ export interface GuardianDecisionPrompt {
    * store. Absent for legacy-only prompts.
    */
   kind?: string;
+  /** Human-readable preview of the command being approved (e.g. shell command). */
+  commandPreview?: string;
+  /** Risk level label for the request (e.g. 'low', 'medium', 'high'). */
+  riskLevel?: string;
+  /** Short activity description for richer prompt display. */
+  activityText?: string;
+  /** Where the tool will execute — sandbox or host. */
+  executionTarget?: "sandbox" | "host";
 }
 
 export interface GuardianDecisionAction {
@@ -55,12 +63,12 @@ export const GUARDIAN_DECISION_ACTIONS = {
   },
   approve_10m: {
     action: "approve_10m",
-    label: "Allow 10 min",
+    label: "Allow all, 10 min",
     description: "All tools for 10 minutes",
   },
   approve_conversation: {
     action: "approve_conversation",
-    label: "Allow conversation",
+    label: "Allow all, convo",
     description: "All tools for this conversation",
   },
   approve_always: {
@@ -76,12 +84,11 @@ export const GUARDIAN_DECISION_ACTIONS = {
  * respecting whether persistent decisions (approve_always) are allowed.
  *
  * When `persistentDecisionsAllowed` is `false`, the `approve_always` action
- * is excluded. When `forGuardianOnBehalf` is `true` (guardian acting on behalf
- * of a requester), both `approve_always` and the temporary modes are excluded
- * since guardians cannot grant broad delegated allow modes on behalf of others.
- *
- * Temporary modes (`approve_10m`, `approve_conversation`) are included for
- * requester-side standard approval flows when persistent decisions are allowed.
+ * and temporary modes are excluded. When `forGuardianOnBehalf` is `true`
+ * (guardian acting on behalf of a requester), only `approve_always` is excluded
+ * — temporary modes (`approve_10m`, `approve_conversation`) are permitted
+ * because grants are scoped to the tool+input signature via scopeMode:
+ * "tool_signature".
  */
 export function buildDecisionActions(opts?: {
   persistentDecisionsAllowed?: boolean;
@@ -89,8 +96,7 @@ export function buildDecisionActions(opts?: {
 }): GuardianDecisionAction[] {
   const showAlways =
     opts?.persistentDecisionsAllowed !== false && !opts?.forGuardianOnBehalf;
-  const showTemporary =
-    opts?.persistentDecisionsAllowed !== false && !opts?.forGuardianOnBehalf;
+  const showTemporary = opts?.persistentDecisionsAllowed !== false;
   return [
     GUARDIAN_DECISION_ACTIONS.approve_once,
     ...(showTemporary

package/src/runtime/http-server.ts

@@ -6,7 +6,7 @@
  */
 
 import { existsSync, readFileSync } from "node:fs";
-import { join, resolve } from "node:path";
+import { resolve } from "node:path";
 
 import type { ServerWebSocket } from "bun";
 
@@ -61,7 +61,6 @@ import {
 } from "../security/oauth-callback-registry.js";
 import { UserError } from "../util/errors.js";
 import { getLogger } from "../util/logger.js";
-import { getRootDir } from "../util/platform.js";
 import { buildAssistantEvent } from "./assistant-event.js";
 import { assistantEventHub } from "./assistant-event-hub.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "./assistant-scope.js";
@@ -163,6 +162,7 @@ import { migrationRollbackRouteDefinitions } from "./routes/migration-rollback-r
 import { migrationRouteDefinitions } from "./routes/migration-routes.js";
 import { notificationRouteDefinitions } from "./routes/notification-routes.js";
 import { oauthAppsRouteDefinitions } from "./routes/oauth-apps.js";
+import { oauthProvidersRouteDefinitions } from "./routes/oauth-providers.js";
 import type { PairingHandlerContext } from "./routes/pairing-routes.js";
 import {
   handlePairingRequest,
@@ -293,23 +293,11 @@ export class RuntimeHttpServer {
     this.pairingBroadcast = fn;
   }
 
-  /** Read the feature-flag client token from disk so it can be included in pairing approval responses. */
-  private readFeatureFlagToken(): string | undefined {
-    try {
-      const tokenPath = join(getRootDir(), "feature-flag-token");
-      const token = readFileSync(tokenPath, "utf-8").trim();
-      return token || undefined;
-    } catch {
-      return undefined;
-    }
-  }
-
   private get pairingContext(): PairingHandlerContext {
     const broadcast = this.pairingBroadcast;
     return {
       pairingStore: this.pairingStore,
       bearerToken: this.bearerToken,
-      featureFlagToken: this.readFeatureFlagToken(),
       pairingBroadcast: broadcast
         ? (msg) => {
             // Broadcast to all clients via the event hub so HTTP/SSE clients
@@ -1204,6 +1192,7 @@ export class RuntimeHttpServer {
       ...twilioRouteDefinitions(),
       ...vercelRouteDefinitions(),
       ...channelReadinessRouteDefinitions(),
+      ...oauthProvidersRouteDefinitions(),
       ...oauthAppsRouteDefinitions(),
       ...attachmentRouteDefinitions(),
 

package/src/runtime/http-types.ts

@@ -272,5 +272,6 @@ export interface RuntimeMessagePayload {
     display?: string;
   }>;
   textSegments?: string[];
+  thinkingSegments?: string[];
   contentOrder?: string[];
 }

package/src/runtime/migrations/vbundle-builder.ts

@@ -395,9 +395,12 @@ export interface BuildExportVBundleOptions {
   /** Absolute path to trust.json. If provided and the file exists, it is included in the archive. */
   trustPath?: string;
   /**
-   * Absolute path to the hooks directory (~/.vellum/hooks/).
-   * Hooks live outside the workspace, so they must be included explicitly.
-   * Included in the archive under the "hooks/" prefix for backward compat.
+   * Absolute path to the hooks directory. Previously hooks lived outside the
+   * workspace at ~/.vellum/hooks/ and needed explicit inclusion. Now hooks
+   * live under workspace (~/.vellum/workspace/hooks/) and are included in
+   * the workspace walk. Only pass this for backward-compat scenarios where
+   * hooks are still outside the workspace; otherwise omit to avoid double
+   * export. Included in the archive under the "hooks/" prefix.
    */
   hooksDir?: string;
   /**
@@ -455,7 +458,7 @@ export function buildExportVBundle(
     files.push(
       ...walkDirectory(workspaceDir, "workspace", {
         includeBinary: true,
-        skipDirs: ["embedding-models", "data/qdrant"],
+        skipDirs: ["embedding-models", "data/qdrant", "signals", "deprecated"],
       }),
     );
   }

package/src/runtime/migrations/vbundle-import-analyzer.ts

@@ -88,7 +88,6 @@ export interface PathResolver {
 
 export class DefaultPathResolver implements PathResolver {
   constructor(
-    private protectedDir?: string,
     private workspaceDir?: string,
     private hooksDir?: string,
   ) {}
@@ -114,9 +113,6 @@ export class DefaultPathResolver implements PathResolver {
     if (archivePath === "config/settings.json" && this.workspaceDir) {
       return join(this.workspaceDir, "config.json");
     }
-    if (archivePath === "trust/trust.json" && this.protectedDir) {
-      return join(this.protectedDir, "trust.json");
-    }
     if (archivePath.startsWith("skills/") && this.workspaceDir) {
       const resolved = resolve(
         this.workspaceDir,

package/src/runtime/migrations/vbundle-importer.ts

@@ -164,7 +164,7 @@ export function commitImport(options: ImportCommitOptions): ImportCommitResult {
   }
 
   // Directories to preserve when clearing the workspace (large/regenerable).
-  const WORKSPACE_SKIP_DIRS = new Set(["embedding-models"]);
+  const WORKSPACE_SKIP_DIRS = new Set(["embedding-models", "deprecated"]);
   // data/qdrant is nested — we skip "qdrant" inside "data/"
   const DATA_SKIP_DIRS = new Set(["qdrant"]);
 

package/src/runtime/routes/conversation-query-routes.ts

@@ -48,9 +48,13 @@ import { deleteQueuedMessage } from "../../daemon/handlers/conversations.js";
 import { getAssistantMessageIdsInTurn } from "../../memory/conversation-crud.js";
 import { getRequestLogsByMessageId } from "../../memory/llm-request-log-store.js";
 import { getMemoryRecallLogByMessageIds } from "../../memory/memory-recall-log-store.js";
+import { resolvePricingForUsage } from "../../util/pricing.js";
 import { httpError } from "../http-errors.js";
 import type { RouteDefinition } from "../http-router.js";
-import { normalizeLlmContextPayloads } from "./llm-context-normalization.js";
+import {
+  type LlmContextSummary,
+  normalizeLlmContextPayloads,
+} from "./llm-context-normalization.js";
 
 const validProviderSet = new Set<string>(VALID_INFERENCE_PROVIDERS);
 const validEmbeddingProviderSet = new Set<string>(
@@ -71,20 +75,48 @@ type LlmContextRouteResult = Omit<LlmContextNormalizationResult, "summary"> & {
   summary?: LlmContextSummaryResponse;
 };
 
+function attachEstimatedCost(summary: LlmContextSummary): LlmContextSummary {
+  const { provider, model, inputTokens, outputTokens } = summary;
+  if (!model || inputTokens == null || outputTokens == null) {
+    return summary;
+  }
+
+  const cacheCreation = summary.cacheCreationInputTokens ?? 0;
+  const cacheRead = summary.cacheReadInputTokens ?? 0;
+  const directInputTokens = Math.max(
+    inputTokens - cacheCreation - cacheRead,
+    0,
+  );
+
+  const result = resolvePricingForUsage(provider, model, {
+    directInputTokens,
+    outputTokens,
+    cacheCreationInputTokens: cacheCreation,
+    cacheReadInputTokens: cacheRead,
+    anthropicCacheCreation: null,
+  });
+
+  return { ...summary, estimatedCostUsd: result.estimatedCostUsd };
+}
+
 function applyStoredProviderToLlmContextResult(
   normalized: LlmContextNormalizationResult,
   provider: string | null,
 ): LlmContextRouteResult {
   if (!provider) {
-    return normalized as LlmContextRouteResult;
+    const summary = normalized.summary
+      ? attachEstimatedCost(normalized.summary)
+      : undefined;
+    return { ...normalized, summary } as LlmContextRouteResult;
   }
 
-  return {
-    ...normalized,
-    summary: normalized.summary
-      ? { ...normalized.summary, provider }
-      : { provider },
-  };
+  const mergedSummary = normalized.summary
+    ? { ...normalized.summary, provider }
+    : { provider };
+  const summary = attachEstimatedCost(
+    mergedSummary as LlmContextSummary,
+  );
+  return { ...normalized, summary };
 }
 
 // ---------------------------------------------------------------------------