@vellumai/assistant 0.12.3 → 0.12.4-dev.202609231620.a15f321

package/src/providers/openai/chat-completions-provider.ts

@@ -12,6 +12,10 @@ import { partialTagSuffix as sharedPartialTagSuffix } from "../../util/think-tag
 import { clampProviderString } from "../content-block-size.js";
 import { fileBlockToProviderText } from "../file-block-text.js";
 import { requestSupportsInlineAudio } from "../inline-audio-support.js";
+import {
+  isMalformedToolCallFinishReason,
+  malformedToolCallError,
+} from "../malformed-tool-call.js";
 import {
   base64Source,
   mediaSourceByteLength,
@@ -1150,6 +1154,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
       >();
       const toolProgress = createToolProgressEmitter(onEvent);
       let finishReason = "unknown";
+      let upstreamFinishReason: string | undefined;
       let responseModel = modelOverride ?? this.model;
       let promptTokens = 0;
       let completionTokens = 0;
@@ -1318,6 +1323,14 @@ export class OpenAIChatCompletionsProvider implements Provider {
             if (choice.finish_reason) {
               finishReason = choice.finish_reason;
             }
+            // OpenRouter normalizes upstream finish reasons and carries the
+            // raw value in `native_finish_reason`.
+            const nativeFinishReason = (
+              choice as { native_finish_reason?: string | null }
+            ).native_finish_reason;
+            if (nativeFinishReason) {
+              upstreamFinishReason = nativeFinishReason;
+            }
           }
 
           if (chunk.usage) {
@@ -1353,6 +1366,23 @@ export class OpenAIChatCompletionsProvider implements Provider {
         cleanupTimeout();
       }
 
+      const malformedFinishReason = [upstreamFinishReason, finishReason].find(
+        isMalformedToolCallFinishReason,
+      );
+      if (malformedFinishReason) {
+        log.warn(
+          {
+            provider: this.name,
+            model: responseModel,
+            finishReason,
+            upstreamFinishReason,
+            streamedTextLength: contentText.length,
+          },
+          "Response ended on a malformed tool call",
+        );
+        throw malformedToolCallError(this.name, malformedFinishReason);
+      }
+
       if (this.parseThinkTags && pendingContent) {
         flushPendingContent(true);
       }

package/src/providers/openai/codex-models.ts

@@ -10,6 +10,8 @@
  */
 export const CODEX_SUBSCRIPTION_MODEL_IDS: ReadonlySet<string> = new Set([
   "gpt-6-astra",
+  "gpt-6-sol",
+  "gpt-6-luna",
   "gpt-5.6-sol",
   "gpt-5.6-terra",
   "gpt-5.6-luna",

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

@@ -56,6 +56,11 @@ export const PLATFORM_PROVIDER_META: Record<string, ManagedProviderMeta> = {
     managed: true,
     proxyPath: "/v1/runtime-proxy/vellum",
   },
+  typesafe: {
+    name: "typesafe",
+    managed: true,
+    proxyPath: "/v1/runtime-proxy/typesafe",
+  },
   poolside: {
     name: "poolside",
     managed: false,

package/src/providers/retry.ts

@@ -36,6 +36,7 @@ import {
   tryAcquireRecoveryProbe,
 } from "./fallback-breaker.js";
 import { resolveLogitBiasPreset } from "./inference/logit-bias.js";
+import { MALFORMED_TOOL_CALL_MESSAGE } from "./malformed-tool-call.js";
 import {
   isAdaptiveThinkingOnlyModel,
   isAdaptiveThinkingUnsupportedModel,
@@ -165,18 +166,22 @@ const RETRYABLE_STREAM_PATTERNS = [
   // Anthropic client salvages most of these into a `_raw`-wrapped tool call
   // before they surface (see anthropic/stream-content-shadow.ts); ones that
   // still reach here retry with a corrective note
-  // (`withUnparseableToolArgsHint`) because the malformation can be
-  // conditioned on the request context — a byte-identical resend can
-  // reproduce it indefinitely.
+  // (`correctiveRetryHint`) because the malformation can be conditioned on
+  // the request context: a byte-identical resend can reproduce it
+  // indefinitely.
   UNPARSEABLE_TOOL_ARGS_SDK_MESSAGE,
+  // The response ended on a tool call the model emitted but that did not
+  // parse (Gemini `MALFORMED_FUNCTION_CALL` / `UNEXPECTED_TOOL_CALL`). Its
+  // text is the broken call's tail, so it retries with a corrective note too.
+  MALFORMED_TOOL_CALL_MESSAGE,
 ];
 
 /**
- * One-shot note appended to the retried request after a tool-argument JSON
- * parse failure. Appended as a trailing text block on the latest user
- * message: the request tail sits after every prompt-cache anchor, so the
- * hint costs no cache reuse (a system-prompt edit would invalidate the whole
- * cached prefix).
+ * One-shot notes appended to a retried request after the model's output was
+ * malformed in a way a byte-identical resend can reproduce. Appended as a
+ * trailing text block on the latest user message: the request tail sits
+ * after every prompt-cache anchor, so the hint costs no cache reuse (a
+ * system-prompt edit would invalidate the whole cached prefix).
  */
 const UNPARSEABLE_TOOL_ARGS_RETRY_HINT =
   "[assistant runtime] The previous attempt at this response was discarded: " +
@@ -185,23 +190,51 @@ const UNPARSEABLE_TOOL_ARGS_RETRY_HINT =
   "every string value double-quoted, including values that begin with '[' " +
   "or '{'.";
 
-function isUnparseableToolArgsError(error: unknown): boolean {
+const MALFORMED_TOOL_CALL_RETRY_HINT =
+  "[assistant runtime] The previous attempt at this response was discarded: " +
+  "it ended on a tool call that did not parse. Respond again. To call a " +
+  "tool, emit one complete, well-formed tool call through the tool-calling " +
+  "interface, never as text.";
+
+const CORRECTIVE_RETRY_HINTS: ReadonlyArray<{
+  pattern: string;
+  hint: string;
+}> = [
+  {
+    pattern: UNPARSEABLE_TOOL_ARGS_SDK_MESSAGE,
+    hint: UNPARSEABLE_TOOL_ARGS_RETRY_HINT,
+  },
+  {
+    pattern: MALFORMED_TOOL_CALL_MESSAGE,
+    hint: MALFORMED_TOOL_CALL_RETRY_HINT,
+  },
+];
+
+/**
+ * The corrective note a retry of `error` carries, or `undefined` when the
+ * error is not a request-conditioned output malformation. Only status-less
+ * provider errors qualify: those come from content the upstream streamed
+ * after accepting the request.
+ */
+function correctiveRetryHint(error: unknown): string | undefined {
   if (!(error instanceof ProviderError)) {
-    return false;
+    return undefined;
   }
   if (error.statusCode !== undefined) {
-    return false;
+    return undefined;
   }
-  return error.message.includes(UNPARSEABLE_TOOL_ARGS_SDK_MESSAGE);
+  return CORRECTIVE_RETRY_HINTS.find(({ pattern }) =>
+    error.message.includes(pattern),
+  )?.hint;
 }
 
 /**
- * Copy of `messages` with the corrective note appended to the latest user
- * message. When the request doesn't end on a user message (assistant
- * prefill), returns `messages` unchanged — appending anything there would
- * change prefill semantics.
+ * Copy of `messages` with `hint` appended to the latest user message. When
+ * the request doesn't end on a user message (assistant prefill), returns
+ * `messages` unchanged, since appending anything there would change prefill
+ * semantics.
  */
-function withUnparseableToolArgsHint(messages: Message[]): Message[] {
+function withRetryHint(messages: Message[], hint: string): Message[] {
   const last = messages[messages.length - 1];
   if (last === undefined || last.role !== "user") {
     return messages;
@@ -210,10 +243,7 @@ function withUnparseableToolArgsHint(messages: Message[]): Message[] {
     ...messages.slice(0, -1),
     {
       ...last,
-      content: [
-        ...last.content,
-        { type: "text", text: UNPARSEABLE_TOOL_ARGS_RETRY_HINT },
-      ],
+      content: [...last.content, { type: "text", text: hint }],
     },
   ];
 }
@@ -1393,12 +1423,10 @@ export class RetryProvider implements Provider {
             // outage the route had nothing to do with. Skipped when the hint
             // has nowhere to go (an assistant prefill tail), since an
             // unchanged resend would only cost another round trip.
-            if (
-              !correctiveResendAttempted &&
-              isUnparseableToolArgsError(error)
-            ) {
+            const hint = correctiveRetryHint(error);
+            if (!correctiveResendAttempted && hint !== undefined) {
               correctiveResendAttempted = true;
-              const repaired = withUnparseableToolArgsHint(messages);
+              const repaired = withRetryHint(messages, hint);
               if (repaired !== messages) {
                 messagesForAttempt = repaired;
                 continue;
@@ -1522,12 +1550,13 @@ export class RetryProvider implements Provider {
         }
 
         if (retryAttempt < DEFAULT_MAX_RETRIES && isRetryableError(error)) {
-          // Malformed tool-argument JSON is conditioned on the request, so
-          // resend with the corrective note. Built from the original
-          // `messages` each time — the note appears exactly once no matter
-          // how many attempts fail this way.
-          if (isUnparseableToolArgsError(error)) {
-            messagesForAttempt = withUnparseableToolArgsHint(messages);
+          // A malformed tool call is conditioned on the request, so resend
+          // with the corrective note. Built from the original `messages`
+          // each time, so the note appears exactly once no matter how many
+          // attempts fail this way.
+          const hint = correctiveRetryHint(error);
+          if (hint !== undefined) {
+            messagesForAttempt = withRetryHint(messages, hint);
           }
           // Prefer server-provided Retry-After; fall back to exponential backoff.
           const { delay, retryAfterHeader } = retryPlan(error, retryAttempt);
@@ -1587,9 +1616,11 @@ export class RetryProvider implements Provider {
         ) {
           fallbackAttempted = true;
           // What the failure indicts: the whole upstream for an outage, only
-          // this model for a retirement or rename.
+          // this model for a retirement or rename. A malformed output that
+          // takes a corrective hint indicts neither: it is conditioned on this
+          // request, so the backup may serve it without diverting the route.
           const failedRoute =
-            breakerRoute === null
+            breakerRoute === null || correctiveRetryHint(error) !== undefined
               ? null
               : failureBreakerRoute(breakerRoute, error);
           let failureObservation: BreakerObservation | undefined;
@@ -1730,8 +1761,9 @@ export class RetryProvider implements Provider {
         }
         // Built from the original `messages` each time, so the corrective note
         // appears exactly once however many attempts fail this way.
-        if (isUnparseableToolArgsError(error)) {
-          messagesForAttempt = withUnparseableToolArgsHint(messages);
+        const hint = correctiveRetryHint(error);
+        if (hint !== undefined) {
+          messagesForAttempt = withRetryHint(messages, hint);
         }
         const { delay, retryAfterHeader } = retryPlan(error, attempt);
         log.warn(

package/src/providers/search-provider-catalog.ts

@@ -187,6 +187,16 @@ export const SEARCH_PROVIDER_CATALOG: readonly SearchProviderCatalogEntry[] = [
     supportsApiBase: true,
     defaultApiBase: "https://api.search.tinyfish.ai",
   },
+  {
+    id: "exa",
+    displayName: "Exa",
+    kind: "byok",
+    apiKeyPrefix: "Exa API key...",
+    envVar: "EXA_API_KEY",
+    secretKey: "exa",
+    fallbackOrder: 9,
+    privacyPolicyUrl: "https://exa.ai/privacy-policy",
+  },
 ];
 
 /** Provider ids accepted by the web-search config schema. */

package/src/providers/vellum-model-routing.test.ts

@@ -73,6 +73,7 @@ describe("vellum-model-routing", () => {
       "gemini",
       "openai",
       "together",
+      "typesafe",
       "vellum",
     ]);
   });

package/src/runtime/__tests__/agent-wake-archived-gate.test.ts

@@ -0,0 +1,90 @@
+/**
+ * The `sidebar-done` gate on the wake's archived-conversation rejection.
+ *
+ * `defaultResolveTarget` is module-private, so it is exercised through
+ * `wakeAgentForOpportunity()` called without explicit deps. The hydrate step
+ * after the archived check is stubbed to throw, which the resolver catches
+ * and reports as `not_found` — a flag-on result of `not_found` therefore
+ * proves the wake got PAST the archived check and tried to hydrate, while a
+ * result of `archived` proves it did not.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+let sidebarDoneEnabled = false;
+mock.module("../../config/sidebar-done-gate.js", () => ({
+  SIDEBAR_DONE_FLAG_KEY: "sidebar-done",
+  isSidebarDoneEnabled: () => sidebarDoneEnabled,
+}));
+
+const ARCHIVED_CONVERSATION_ID = "conv-archived-wake";
+
+const getConversationMock = mock((id: string) =>
+  id === ARCHIVED_CONVERSATION_ID
+    ? { id, archivedAt: 1_700_000_000_000 }
+    : undefined,
+);
+const actualCrud = await import("../../persistence/conversation-crud.js");
+mock.module("../../persistence/conversation-crud.js", () => ({
+  ...actualCrud,
+  getConversation: getConversationMock,
+}));
+
+const getOrCreateConversationMock = mock(async () => {
+  throw new Error("hydrate stub");
+});
+const actualStore = await import("../../daemon/conversation-store.js");
+mock.module("../../daemon/conversation-store.js", () => ({
+  ...actualStore,
+  getOrCreateConversation: getOrCreateConversationMock,
+}));
+
+import { wakeAgentForOpportunity } from "../agent-wake.js";
+
+describe("agent-wake archived conversations under sidebar-done", () => {
+  beforeEach(() => {
+    getConversationMock.mockClear();
+    getOrCreateConversationMock.mockClear();
+  });
+
+  test("rejects the wake with reason archived when the flag is off", async () => {
+    sidebarDoneEnabled = false;
+
+    const result = await wakeAgentForOpportunity({
+      conversationId: ARCHIVED_CONVERSATION_ID,
+      hint: "scheduled run",
+      source: "schedule",
+    });
+
+    expect(result.invoked).toBe(false);
+    expect(result.reason).toBe("archived");
+    expect(getOrCreateConversationMock).not.toHaveBeenCalled();
+  });
+
+  test("proceeds past the archived check when the flag is on", async () => {
+    sidebarDoneEnabled = true;
+
+    const result = await wakeAgentForOpportunity({
+      conversationId: ARCHIVED_CONVERSATION_ID,
+      hint: "scheduled run",
+      source: "schedule",
+    });
+
+    expect(result.reason).not.toBe("archived");
+    expect(getOrCreateConversationMock).toHaveBeenCalledTimes(1);
+  });
+
+  test("still reports not_found for a conversation that does not exist", async () => {
+    sidebarDoneEnabled = true;
+
+    const result = await wakeAgentForOpportunity({
+      conversationId: "conv-missing",
+      hint: "scheduled run",
+      source: "schedule",
+    });
+
+    expect(result.invoked).toBe(false);
+    expect(result.reason).toBe("not_found");
+    expect(getOrCreateConversationMock).not.toHaveBeenCalled();
+  });
+});

package/src/runtime/__tests__/question-resolution.test.ts

@@ -73,6 +73,38 @@ describe("resolvePendingQuestion", () => {
     });
   });
 
+  test("chat_reply: the typed text answers the first question, the rest stay unanswered", () => {
+    const resolved: QuestionPromptResult[] = [];
+    registerQuestion(
+      "req-1",
+      [
+        { id: "q1", options: ["a"] },
+        { id: "q2", options: ["b"] },
+      ],
+      (v) => resolved.push(v as QuestionPromptResult),
+    );
+
+    const outcome = resolvePendingQuestion("req-1", {
+      kind: "chat_reply",
+      text: "tuesday, and keep it short",
+    });
+
+    expect(outcome.status).toBe("resolved");
+    expect(resolved[0]).toEqual({
+      overall: "completed",
+      entries: [
+        {
+          questionId: "q1",
+          decision: "free_text",
+          text: "tuesday, and keep it short",
+        },
+        { questionId: "q2", decision: "skipped" },
+      ],
+      answeredInChat: true,
+    });
+    expect(pendingInteractions.get("req-1")).toBeUndefined();
+  });
+
   test("not_found: unknown or wrong-kind requestId leaves nothing resolved", () => {
     expect(resolvePendingQuestion("missing", { kind: "close" })).toEqual({
       status: "not_found",

package/src/runtime/agent-wake.ts

@@ -84,6 +84,7 @@ import {
 } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
+import { isSidebarDoneEnabled } from "../config/sidebar-done-gate.js";
 import { conversationSupportsDynamicUi } from "../daemon/channel-ui-capability.js";
 import type { Conversation } from "../daemon/conversation.js";
 import type { QueueDrainReason } from "../daemon/conversation-queue-manager.js";
@@ -506,7 +507,8 @@ export interface WakeDeps {
   /**
    * Resolve the live {@link Conversation} for a wake invocation.
    * Returns `null` if the conversation doesn't exist, `"archived"` if it
-   * exists but is archived, or the `Conversation` to proceed with the wake.
+   * exists but is archived and the `sidebar-done` gate is off, or the
+   * `Conversation` to proceed with the wake.
    *
    * Receives the full {@link WakeOptions} so the default resolver can
    * thread `trustContext` into `getOrCreateConversation`. Without that
@@ -546,7 +548,12 @@ async function defaultResolveTarget(
     if (!existing) {
       return null;
     }
-    if (existing.archivedAt != null) {
+    // Under the `sidebar-done` gate an archived conversation is one the user
+    // marked Done, not one they half-deleted: its schedules, channel threads
+    // and background tools keep working, and the first message the wake
+    // produces for the user brings the conversation back to the list
+    // (`resurfaceArchivedConversation`).
+    if (existing.archivedAt != null && !isSidebarDoneEnabled()) {
       log.info(
         { conversationId },
         "agent-wake: conversation is archived; rejecting wake",

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

@@ -325,6 +325,144 @@ describe("authenticateRequest for /v1/host-browser-result", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// Dev bypass covers only a request that supplied no Authorization header. A
+// bearer sent to a platform pod (the gateway's exchange token, or a trusted
+// contact's) is verified on its own terms.
+// ---------------------------------------------------------------------------
+
+describe("authenticateRequest with auth disabled and a bearer present", () => {
+  beforeEach(() => {
+    authDisabled = true;
+  });
+
+  test("uses the token's claims rather than the dev-bypass context", () => {
+    const token = mintValidToken({ sub: "actor:self:contact-principal" });
+
+    const req = new Request("http://localhost/v1/messages", {
+      method: "POST",
+      headers: { Authorization: `Bearer ${token}` },
+    });
+
+    const result = authenticateRequest(req);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.context.actorPrincipalId).toBe("contact-principal");
+      expect(result.context.policyEpoch).toBe(CURRENT_POLICY_EPOCH);
+    }
+  });
+
+  test("accepts the gateway's exchange token", () => {
+    const token = mintValidToken({
+      sub: "svc:gateway:self",
+      scope_profile: "gateway_service_v1",
+    });
+
+    const req = new Request("http://localhost/v1/messages", {
+      method: "POST",
+      headers: { Authorization: `Bearer ${token}` },
+    });
+
+    const result = authenticateRequest(req);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.context.principalType).toBe("svc_gateway");
+    }
+  });
+
+  test("accepts a gateway-audience token through the fallback", () => {
+    const token = mintValidToken({
+      aud: "vellum-gateway",
+      sub: "actor:self:local-client",
+    });
+
+    const req = new Request("http://localhost/v1/messages", {
+      method: "POST",
+      headers: { Authorization: `Bearer ${token}` },
+    });
+
+    const result = authenticateRequest(req);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.context.actorPrincipalId).toBe("local-client");
+      expect(result.context.assistantId).toBe(DAEMON_INTERNAL_ASSISTANT_ID);
+    }
+  });
+
+  test.each([
+    ["malformed", () => "not-a-token.xxxxxxxxxxxxx"],
+    [
+      "expired",
+      () => mintValidToken({ exp: Math.floor(Date.now() / 1000) - 100 }),
+    ],
+    [
+      "wrong-audience",
+      () => mintValidToken({ aud: "vellum-other" as TokenAudience }),
+    ],
+    ["unparseable-sub", () => mintValidToken({ sub: "garbage" })],
+  ])("refuses a %s token rather than falling back", (_label, build) => {
+    const req = new Request("http://localhost/v1/messages", {
+      method: "POST",
+      headers: { Authorization: `Bearer ${build()}` },
+    });
+
+    const result = authenticateRequest(req);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.response.status).toBe(401);
+    }
+  });
+
+  test("still returns the dev-bypass context when no bearer is sent", () => {
+    const req = new Request("http://localhost/v1/messages", {
+      method: "POST",
+    });
+
+    const result = authenticateRequest(req);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.context.actorPrincipalId).toBe("dev-bypass");
+    }
+  });
+
+  test("verifies a lowercase bearer scheme rather than bypassing it", () => {
+    const token = mintValidToken({ sub: "actor:self:contact-principal" });
+
+    const req = new Request("http://localhost/v1/messages", {
+      method: "POST",
+      headers: { Authorization: `bearer ${token}` },
+    });
+
+    const result = authenticateRequest(req);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.context.actorPrincipalId).toBe("contact-principal");
+    }
+  });
+
+  test.each([
+    ["lowercase scheme with a bad token", "bearer not-a-jwt.xxxxxxxx"],
+    ["empty credential", "Bearer "],
+    ["non-bearer scheme", "Basic dXNlcjpwYXNz"],
+    ["an empty header value", ""],
+    ["a whitespace-only header value", "   "],
+  ])(
+    "refuses %s instead of granting the dev-bypass context",
+    (_label, header) => {
+      const req = new Request("http://localhost/v1/messages", {
+        method: "POST",
+        headers: { Authorization: header },
+      });
+
+      const result = authenticateRequest(req);
+      expect(result.ok).toBe(false);
+      if (!result.ok) {
+        expect(result.response.status).toBe(401);
+      }
+    },
+  );
+});
+
 // ---------------------------------------------------------------------------
 // oauth_proxy_v1 grants: the narrow bearer a third-party CLI presents to the
 // OAuth passthrough route. Accepted on either audience, and carrying nothing

package/src/runtime/auth/middleware.ts

@@ -17,9 +17,10 @@
  * Replaces both the legacy bearer shared-secret check and the
  * actor-token HMAC middleware with a single JWT verification path.
  *
- * When DISABLE_HTTP_AUTH is set (platform-managed deployments), JWT
- * verification is skipped and a synthetic AuthContext is constructed
- * so downstream code always has a typed context to consume.
+ * When DISABLE_HTTP_AUTH is set (platform-managed deployments), a request
+ * carrying no bearer gets a synthetic AuthContext so downstream code always
+ * has a typed context to consume. A request that carries one is verified
+ * normally, and a bad token is refused rather than falling back.
  */
 
 import { isHttpAuthDisabled } from "../../config/env.js";
@@ -73,17 +74,18 @@ function buildDevBypassContext(): AuthContext {
  * The caller should return the error Response directly to the client.
  */
 export function authenticateRequest(req: Request): AuthenticateResult {
-  // Dev bypass: skip JWT verification entirely
-  if (isHttpAuthDisabled()) {
-    return { ok: true, context: buildDevBypassContext() };
-  }
-
-  const path = new URL(req.url).pathname;
-
   const rawToken = extractBearerToken(req);
   if (!rawToken) {
+    // Dev bypass covers only a request that supplied no Authorization header
+    // at all. A header that is present but unusable (empty or whitespace-only
+    // value, a non-bearer scheme, a malformed credential) is refused rather
+    // than handed the guardian context. `has` rather than `get`: an empty
+    // value reads back as "" and would otherwise pass as absent.
+    if (isHttpAuthDisabled() && !req.headers.has("authorization")) {
+      return { ok: true, context: buildDevBypassContext() };
+    }
     log.warn(
-      { reason: "missing_token", path },
+      { reason: "missing_token", path: new URL(req.url).pathname },
       "Auth denied: missing Authorization header",
     );
     return {
@@ -100,6 +102,8 @@ export function authenticateRequest(req: Request): AuthenticateResult {
     };
   }
 
+  const path = new URL(req.url).pathname;
+
   // Verify the JWT — prefer vellum-daemon audience (gateway-proxied requests
   // and daemon-minted tokens), but also accept vellum-gateway audience for
   // direct local clients (macOS SettingsStore) that hold a guardian-issued JWT

package/src/runtime/middleware/auth.ts

@@ -156,8 +156,14 @@ export function isPrivateNetworkOrigin(req: Request): boolean {
 /**
  * Extract and validate a bearer token from the Authorization header.
  * Returns the token string if present, or null.
+ *
+ * The scheme is matched case-insensitively, per RFC 7235 and to match the
+ * gateway's own parsing. An empty credential returns null.
  */
 export function extractBearerToken(req: Request): string | null {
   const authHeader = req.headers.get("authorization");
-  return authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : null;
+  if (!authHeader?.toLowerCase().startsWith("bearer ")) {
+    return null;
+  }
+  return authHeader.slice(7) || null;
 }