@vellumai/assistant 0.4.56 → 0.5.0

package/src/providers/managed-proxy/constants.ts

@@ -38,7 +38,7 @@ export const MANAGED_PROVIDER_META: Record<string, ManagedProviderMeta> = {
   gemini: {
     name: "gemini",
     managed: true,
-    proxyPath: "/v1/runtime-proxy/vertex",
+    proxyPath: "/v1/runtime-proxy/gemini",
   },
   fireworks: {
     name: "fireworks",
@@ -48,11 +48,5 @@ export const MANAGED_PROVIDER_META: Record<string, ManagedProviderMeta> = {
     name: "openrouter",
     managed: false,
   },
-  vertex: {
-    name: "vertex",
-    managed: true,
-    proxyPath: "/v1/runtime-proxy/vertex",
-  },
   ollama: { name: "ollama", managed: false },
 };
-

package/src/providers/managed-proxy/context.ts

@@ -47,7 +47,6 @@ export async function resolveManagedProxyContext(): Promise<ManagedProxyContext>
   const platformBaseUrl = getPlatformBaseUrl().replace(/\/+$/, "");
   const assistantApiKey =
     (await getSecureKeyAsync(ASSISTANT_API_KEY_STORAGE_KEY)) ?? "";
-
   const enabled = !!platformBaseUrl && !!assistantApiKey;
   _managedProxyEnabled = enabled;
 

package/src/providers/model-intents.ts

@@ -18,12 +18,12 @@ const PROVIDER_MODEL_INTENTS: Record<
   anthropic: {
     "latency-optimized": "claude-haiku-4-5-20251001",
     "quality-optimized": "claude-opus-4-6",
-    "vision-optimized": "claude-sonnet-4-6",
+    "vision-optimized": "claude-opus-4-6",
   },
   openai: {
-    "latency-optimized": "gpt-4o-mini",
-    "quality-optimized": "gpt-5.2",
-    "vision-optimized": "gpt-4o",
+    "latency-optimized": "gpt-5.4-nano",
+    "quality-optimized": "gpt-5.4",
+    "vision-optimized": "gpt-5.4",
   },
   gemini: {
     "latency-optimized": "gemini-3-flash",
@@ -42,7 +42,7 @@ const PROVIDER_MODEL_INTENTS: Record<
   },
   openrouter: {
     "latency-optimized": "x-ai/grok-4",
-    "quality-optimized": "x-ai/grok-4",
+    "quality-optimized": "x-ai/grok-4.20-beta",
     "vision-optimized": "x-ai/grok-4",
   },
 };

package/src/providers/openai/client.ts

@@ -1,5 +1,6 @@
 import OpenAI from "openai";
 
+import { SYSTEM_PROMPT_CACHE_BOUNDARY } from "../../prompts/cache-boundary.js";
 import { ProviderError } from "../../util/errors.js";
 import { extractRetryAfterMs } from "../../util/retry.js";
 import { escapeXmlAttr } from "../../util/xml.js";
@@ -18,6 +19,8 @@ export interface OpenAICompatibleProviderOptions {
   providerName?: string;
   providerLabel?: string;
   streamTimeoutMs?: number;
+  /** Extra params spread into every chat.completions.create call (e.g. reasoning). */
+  extraCreateParams?: Record<string, unknown>;
 }
 
 const OPENAI_SUPPORTED_IMAGE_TYPES = new Set([
@@ -33,6 +36,7 @@ export class OpenAIProvider implements Provider {
   private client: OpenAI;
   private model: string;
   private streamTimeoutMs: number;
+  private extraCreateParams: Record<string, unknown>;
 
   constructor(
     apiKey: string,
@@ -47,6 +51,7 @@ export class OpenAIProvider implements Provider {
     });
     this.model = model;
     this.streamTimeoutMs = options.streamTimeoutMs ?? 300_000;
+    this.extraCreateParams = options.extraCreateParams ?? {};
   }
 
   async sendMessage(
@@ -69,6 +74,7 @@ export class OpenAIProvider implements Provider {
           messages: openaiMessages,
           stream: true as const,
           stream_options: { include_usage: true },
+          ...this.extraCreateParams,
         };
 
       if (maxTokens) {
@@ -224,7 +230,10 @@ export class OpenAIProvider implements Provider {
     const result: OpenAI.Chat.Completions.ChatCompletionMessageParam[] = [];
 
     if (systemPrompt) {
-      result.push({ role: "system", content: systemPrompt });
+      result.push({
+        role: "system",
+        content: systemPrompt.replaceAll(SYSTEM_PROMPT_CACHE_BOUNDARY, "\n"),
+      });
     }
 
     for (const msg of messages) {

package/src/providers/openrouter/client.ts

@@ -19,6 +19,7 @@ export class OpenRouterProvider extends OpenAIProvider {
       providerName: "openrouter",
       providerLabel: "OpenRouter",
       streamTimeoutMs: options.streamTimeoutMs,
+      extraCreateParams: { reasoning: { enabled: true } },
     });
   }
 }

package/src/providers/ratelimit.ts

@@ -15,7 +15,6 @@ export class RateLimitProvider implements Provider {
   public readonly name: string;
 
   private requestTimestamps: number[];
-  private sessionTokens = 0;
 
   constructor(
     private readonly inner: Provider,
@@ -33,7 +32,6 @@ export class RateLimitProvider implements Provider {
     options?: SendMessageOptions,
   ): Promise<ProviderResponse> {
     this.enforceRequestRate();
-    this.enforceTokenBudget();
 
     // Record the request timestamp before the await to prevent concurrent
     // calls from bypassing the rate limit during the async gap.
@@ -46,8 +44,6 @@ export class RateLimitProvider implements Provider {
       options,
     );
 
-    this.recordTokens(response.usage.inputTokens + response.usage.outputTokens);
-
     return response;
   }
 
@@ -89,39 +85,8 @@ export class RateLimitProvider implements Provider {
     }
   }
 
-  private enforceTokenBudget(): void {
-    const limit = this.config.maxTokensPerSession;
-    if (limit <= 0) return;
-
-    if (this.sessionTokens >= limit) {
-      log.warn(
-        {
-          provider: this.name,
-          sessionTokens: this.sessionTokens,
-          limit,
-        },
-        `Session token budget exhausted for ${this.name}: ${this.sessionTokens.toLocaleString()}/${limit.toLocaleString()}`,
-      );
-      throw new RateLimitError(
-        `Session token budget exhausted: ${this.sessionTokens.toLocaleString()}/${limit.toLocaleString()} tokens used. Start a new session to continue.`,
-      );
-    }
-  }
-
   private recordRequest(): void {
     if (this.config.maxRequestsPerMinute <= 0) return;
     this.requestTimestamps.push(Date.now());
   }
-
-  private recordTokens(tokens: number): void {
-    if (this.config.maxTokensPerSession <= 0) return;
-    this.sessionTokens += tokens;
-    log.debug(
-      {
-        sessionTokens: this.sessionTokens,
-        limit: this.config.maxTokensPerSession,
-      },
-      "Token usage updated",
-    );
-  }
 }

package/src/providers/registry.ts

@@ -235,8 +235,7 @@ async function resolveProviderCredentials(
 } | null> {
   if (mode === "managed") {
     // In managed mode, try managed proxy first, then fall back to user key
-    const proxyName = providerName === "gemini" ? "vertex" : providerName;
-    const managedBaseUrl = await buildManagedBaseUrl(proxyName);
+    const managedBaseUrl = await buildManagedBaseUrl(providerName);
     if (managedBaseUrl) {
       const ctx = await resolveManagedProxyContext();
       return {
@@ -258,8 +257,7 @@ async function resolveProviderCredentials(
     return { apiKey: userKey, source: "user-key" };
   }
   // Fall back to managed proxy even in your-own mode (backwards compat)
-  const proxyName = providerName === "gemini" ? "vertex" : providerName;
-  const managedBaseUrl = await buildManagedBaseUrl(proxyName);
+  const managedBaseUrl = await buildManagedBaseUrl(providerName);
   if (managedBaseUrl) {
     const ctx = await resolveManagedProxyContext();
     return {
@@ -283,7 +281,7 @@ export async function initializeProviders(
     (config.timeouts?.providerStreamTimeoutSec ?? 300) * 1000;
   const inferenceMode = config.services.inference.mode;
   const useNativeWebSearch =
-    config.services["web-search"].provider === "anthropic-native";
+    config.services["web-search"].provider === "inference-provider-native";
 
   // Anthropic
   const anthropicCreds = await resolveProviderCredentials(

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/access-request-helper.ts

@@ -200,10 +200,24 @@ export function notifyGuardianOfAccessRequest(
   });
 
   let vellumDeliveryId: string | null = null;
+  // When the access request originates from a text channel with
+  // notification delivery support (Slack, Telegram), route the guardian
+  // notification to that same channel only. Delivering on the macOS
+  // client as well is noisy and approving from there doesn't work
+  // because the desktop path lacks the channel delivery context needed
+  // to deliver the verification code. Phone is excluded because it is
+  // not a deliverable notification channel.
+  const TEXT_CHANNELS_WITH_DELIVERY: ReadonlySet<string> = new Set([
+    "slack",
+    "telegram",
+  ]);
+  const sameChannelOnly = TEXT_CHANNELS_WITH_DELIVERY.has(sourceChannel);
+
   void emitNotificationSignal({
     sourceEventName: "ingress.access_request",
     sourceChannel: sourceChannel as NotificationSourceChannel,
-    sourceSessionId: `access-req-${sourceChannel}-${actorExternalId}`,
+    sourceContextId: `access-req-${sourceChannel}-${actorExternalId}`,
+    ...(sameChannelOnly ? { routingIntent: "single_channel" as const } : {}),
     attentionHints: {
       requiresAction: true,
       urgency: "high",
@@ -258,7 +272,7 @@ export function notifyGuardianOfAccessRequest(
         applyDeliveryStatus(delivery.id, result);
       }
 
-      if (!vellumDeliveryId) {
+      if (!vellumDeliveryId && !sameChannelOnly) {
         const fallback = createCanonicalGuardianDelivery({
           requestId: canonicalRequest.id,
           destinationChannel: "vellum",

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

@@ -157,6 +157,9 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   // Events (SSE)
   { endpoint: "events", scopes: ["chat.read"] },
 
+  // Trace events
+  { endpoint: "trace-events", scopes: ["chat.read"] },
+
   // Attachments
   { endpoint: "attachments:POST", scopes: ["attachments.write"] },
   { endpoint: "attachments:DELETE", scopes: ["attachments.write"] },
@@ -291,6 +294,9 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   { endpoint: "usage/daily", scopes: ["settings.read"] },
   { endpoint: "usage/breakdown", scopes: ["settings.read"] },
 
+  // Lifecycle telemetry
+  { endpoint: "telemetry/lifecycle", scopes: ["settings.write"] },
+
   // Debug
   { endpoint: "debug", scopes: ["settings.read"] },
 
@@ -337,6 +343,7 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   { endpoint: "model/image-gen", scopes: ["settings.write"] },
 
   // Conversation management
+  { endpoint: "conversations/wipe", scopes: ["chat.write"] },
   { endpoint: "conversations/reorder", scopes: ["chat.write"] },
 
   // Conversation search

package/src/runtime/channel-verification-service.ts

@@ -128,7 +128,7 @@ export function createInboundVerificationSession(
     channel,
     challengeHash,
     expiresAt,
-    createdByConversationId: conversationId,
+    sourceConversationId: conversationId,
   });
 
   const ttlSeconds = CHALLENGE_TTL_MS / 1000;

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

@@ -146,7 +146,7 @@ export function bridgeConfirmationRequestToGuardian(
   const signalPromise = emitNotificationSignal({
     sourceEventName: "guardian.question",
     sourceChannel: sourceChannel as NotificationSourceChannel,
-    sourceSessionId: conversationId,
+    sourceContextId: conversationId,
     attentionHints: {
       requiresAction: true,
       urgency: "high",

package/src/runtime/guardian-vellum-migration.ts

@@ -12,7 +12,10 @@
 
 import { v4 as uuid } from "uuid";
 
-import { findGuardianForChannel } from "../contacts/contact-store.js";
+import {
+  findGuardianForChannel,
+  updateContactPrincipalAndChannel,
+} from "../contacts/contact-store.js";
 import { createGuardianBinding } from "../contacts/contacts-write.js";
 import { getLogger } from "../util/logger.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "./assistant-scope.js";
@@ -70,3 +73,60 @@ export function ensureVellumGuardianBinding(
 
   return guardianPrincipalId;
 }
+
+/**
+ * Heal guardian binding drift for the vellum channel.
+ *
+ * After a DB reset, the daemon creates a new guardian binding with a fresh
+ * `vellum-principal-<uuid>`, but the client may still hold a valid JWT
+ * signed with the surviving signing key containing the old principal.
+ * The JWT passes signature validation but trust resolution returns
+ * `unknown` because the principals don't match.
+ *
+ * This function detects that scenario and updates the binding to match
+ * the JWT's principal. Only heals when both the stored and incoming
+ * principals have the `vellum-principal-` prefix (both auto-generated,
+ * no external identity meaning). The JWT's signature proves it was
+ * minted by this daemon's signing key.
+ *
+ * Returns true if healing occurred, false otherwise.
+ */
+export function healGuardianBindingDrift(incomingPrincipalId: string): boolean {
+  if (!incomingPrincipalId.startsWith("vellum-principal-")) {
+    return false;
+  }
+
+  const guardianResult = findGuardianForChannel("vellum");
+  if (!guardianResult) return false;
+
+  const currentPrincipalId = guardianResult.contact.principalId;
+  if (!currentPrincipalId?.startsWith("vellum-principal-")) return false;
+  if (currentPrincipalId === incomingPrincipalId) return false;
+
+  const updated = updateContactPrincipalAndChannel(
+    guardianResult.contact.id,
+    guardianResult.channel.id,
+    incomingPrincipalId,
+  );
+
+  if (!updated) {
+    log.warn(
+      {
+        oldPrincipalId: currentPrincipalId,
+        newPrincipalId: incomingPrincipalId,
+      },
+      "Skipped guardian binding drift heal — address collision on contact_channels",
+    );
+    return false;
+  }
+
+  log.info(
+    {
+      oldPrincipalId: currentPrincipalId,
+      newPrincipalId: incomingPrincipalId,
+    },
+    "Healed vellum guardian binding drift — updated principalId to match JWT actor",
+  );
+
+  return true;
+}

package/src/runtime/http-server.ts

@@ -125,6 +125,7 @@ import { conversationAttentionRouteDefinitions } from "./routes/conversation-att
 import { conversationManagementRouteDefinitions } from "./routes/conversation-management-routes.js";
 import { conversationQueryRouteDefinitions } from "./routes/conversation-query-routes.js";
 import { conversationRouteDefinitions } from "./routes/conversation-routes.js";
+import { conversationStarterRouteDefinitions } from "./routes/conversation-starter-routes.js";
 import { debugRouteDefinitions } from "./routes/debug-routes.js";
 import { diagnosticsRouteDefinitions } from "./routes/diagnostics-routes.js";
 import { documentRouteDefinitions } from "./routes/documents-routes.js";
@@ -160,7 +161,8 @@ import { skillRouteDefinitions } from "./routes/skills-routes.js";
 import { subagentRouteDefinitions } from "./routes/subagents-routes.js";
 import { surfaceActionRouteDefinitions } from "./routes/surface-action-routes.js";
 import { surfaceContentRouteDefinitions } from "./routes/surface-content-routes.js";
-import { threadStarterRouteDefinitions } from "./routes/thread-starter-routes.js";
+import { telemetryRouteDefinitions } from "./routes/telemetry-routes.js";
+import { traceEventRouteDefinitions } from "./routes/trace-event-routes.js";
 import { trustRulesRouteDefinitions } from "./routes/trust-rules-routes.js";
 import { usageRouteDefinitions } from "./routes/usage-routes.js";
 import { watchRouteDefinitions } from "./routes/watch-routes.js";
@@ -198,8 +200,8 @@ const log = getLogger("runtime-http");
 const DEFAULT_PORT = 7821;
 const DEFAULT_HOSTNAME = "127.0.0.1";
 
-/** Global hard cap on request body size (50 MB). */
-const MAX_REQUEST_BODY_BYTES = 50 * 1024 * 1024;
+/** Global hard cap on request body size (150 MB — accommodates base64-encoded 100 MB attachments). */
+const MAX_REQUEST_BODY_BYTES = 150 * 1024 * 1024;
 
 export class RuntimeHttpServer {
   private server: ReturnType<typeof Bun.serve> | null = null;
@@ -739,9 +741,10 @@ export class RuntimeHttpServer {
       ...identityRouteDefinitions(),
       ...debugRouteDefinitions(),
       ...usageRouteDefinitions(),
+      ...telemetryRouteDefinitions(),
       ...workspaceRouteDefinitions(),
       ...memoryItemRouteDefinitions(),
-      ...threadStarterRouteDefinitions(),
+      ...conversationStarterRouteDefinitions(),
       ...settingsRouteDefinitions(),
       ...avatarRouteDefinitions(),
       ...scheduleRouteDefinitions({
@@ -1194,6 +1197,7 @@ export class RuntimeHttpServer {
 
       ...brainGraphRouteDefinitions({ mintUiPageToken }),
       ...eventsRouteDefinitions(),
+      ...traceEventRouteDefinitions(),
       ...migrationRouteDefinitions(),
 
       // Internal OAuth callback (gateway -> runtime)