@vellumai/assistant 0.11.4 → 0.11.5-staging.1

package/src/providers/openai/__tests__/tool-choice-mapping.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, test } from "bun:test";
 
 import type { Message, ToolDefinition } from "../../types.js";
 import {
+  isThinkingEnabledOnWire,
   mapNeutralToolChoice,
   OpenAIChatCompletionsProvider,
 } from "../chat-completions-provider.js";
@@ -23,11 +24,17 @@ const USER_MESSAGE: Message[] = [
  * Stub the SDK client so we can capture the outgoing chat.completions.create
  * params without hitting the network.
  */
-function stubChatProvider(): {
+function stubChatProvider(
+  options?: ConstructorParameters<typeof OpenAIChatCompletionsProvider>[2],
+): {
   provider: OpenAIChatCompletionsProvider;
   requests: Array<Record<string, unknown>>;
 } {
-  const provider = new OpenAIChatCompletionsProvider("test-key", "test-model");
+  const provider = new OpenAIChatCompletionsProvider(
+    "test-key",
+    "test-model",
+    options,
+  );
   const requests: Array<Record<string, unknown>> = [];
   (provider as unknown as { client: unknown }).client = {
     chat: {
@@ -49,6 +56,23 @@ function stubChatProvider(): {
   return { provider, requests };
 }
 
+describe("isThinkingEnabledOnWire", () => {
+  test("detects flat reasoning_effort and nested reasoning flags", () => {
+    expect(isThinkingEnabledOnWire({})).toBe(false);
+    expect(isThinkingEnabledOnWire({ reasoning_effort: "none" })).toBe(false);
+    expect(isThinkingEnabledOnWire({ reasoning_effort: "high" })).toBe(true);
+    expect(isThinkingEnabledOnWire({ reasoning: { effort: "none" } })).toBe(
+      false,
+    );
+    expect(isThinkingEnabledOnWire({ reasoning: { effort: "medium" } })).toBe(
+      true,
+    );
+    expect(isThinkingEnabledOnWire({ reasoning: { enabled: true } })).toBe(
+      true,
+    );
+  });
+});
+
 describe("mapNeutralToolChoice (chat-completions wire format)", () => {
   // Each neutral tool_choice variant maps to its OpenAI-compatible form.
   test("maps the Anthropic-shaped union to OpenAI's tool_choice values", () => {
@@ -144,4 +168,103 @@ describe("OpenAIChatCompletionsProvider tool_choice wiring", () => {
     expect(requests[0].tools).toBeUndefined();
     expect(requests[0].tool_choice).toBeUndefined();
   });
+
+  // `"auto"` is the chat-completions default when tools are present. Sending it
+  // alongside reasoning_effort 400s DeepSeek thinking mode, so it is omitted.
+  test("omits redundant tool_choice auto when thinking is on the wire", async () => {
+    const { provider, requests } = stubChatProvider();
+
+    await provider.sendMessage(USER_MESSAGE, {
+      tools: TOOLS,
+      config: { tool_choice: { type: "auto" }, effort: "high" },
+    });
+
+    expect(requests[0].reasoning_effort).toBe("high");
+    expect(requests[0].tool_choice).toBeUndefined();
+    expect(requests[0].tools).toBeDefined();
+  });
+
+  test("omits redundant tool_choice auto when nested reasoning.enabled is set", async () => {
+    const { provider, requests } = stubChatProvider({
+      extraCreateParams: { reasoning: { enabled: true } },
+    });
+
+    await provider.sendMessage(USER_MESSAGE, {
+      tools: TOOLS,
+      config: { tool_choice: { type: "auto" } },
+    });
+
+    expect(requests[0].tool_choice).toBeUndefined();
+  });
+
+  test("forwards tool_choice auto when thinking is off", async () => {
+    const { provider, requests } = stubChatProvider();
+
+    await provider.sendMessage(USER_MESSAGE, {
+      tools: TOOLS,
+      config: { tool_choice: { type: "auto" } },
+    });
+
+    expect(requests[0].tool_choice).toBe("auto");
+  });
+
+  // Catalog providers (Fireworks, Together) honor `none` with thinking.
+  test("forwards tool_choice none with thinking when omitToolChoiceWhenReasoning is off", async () => {
+    const { provider, requests } = stubChatProvider();
+
+    await provider.sendMessage(USER_MESSAGE, {
+      tools: TOOLS,
+      config: { tool_choice: { type: "none" }, effort: "high" },
+    });
+
+    expect(requests[0].reasoning_effort).toBe("high");
+    expect(requests[0].tool_choice).toBe("none");
+  });
+
+  test("forwards a forced tool_choice with thinking when omitToolChoiceWhenReasoning is off", async () => {
+    const { provider, requests } = stubChatProvider();
+
+    await provider.sendMessage(USER_MESSAGE, {
+      tools: TOOLS,
+      config: { tool_choice: { type: "tool", name: "bash" }, effort: "high" },
+    });
+
+    expect(requests[0].tool_choice).toEqual({
+      type: "function",
+      function: { name: "bash" },
+    });
+  });
+
+  test("omits every tool_choice in thinking mode when omitToolChoiceWhenReasoning is on", async () => {
+    const { provider, requests } = stubChatProvider({
+      omitToolChoiceWhenReasoning: true,
+    });
+
+    await provider.sendMessage(USER_MESSAGE, {
+      tools: TOOLS,
+      config: { tool_choice: { type: "none" }, effort: "high" },
+    });
+    await provider.sendMessage(USER_MESSAGE, {
+      tools: TOOLS,
+      config: { tool_choice: { type: "tool", name: "bash" }, effort: "high" },
+    });
+
+    expect(requests[0].reasoning_effort).toBe("high");
+    expect(requests[0].tool_choice).toBeUndefined();
+    expect(requests[1].tool_choice).toBeUndefined();
+  });
+
+  test("still forwards tool_choice when omitToolChoiceWhenReasoning is on but thinking is off", async () => {
+    const { provider, requests } = stubChatProvider({
+      omitToolChoiceWhenReasoning: true,
+    });
+
+    await provider.sendMessage(USER_MESSAGE, {
+      tools: TOOLS,
+      config: { tool_choice: { type: "none" } },
+    });
+
+    expect(requests[0].reasoning_effort).toBeUndefined();
+    expect(requests[0].tool_choice).toBe("none");
+  });
 });

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

@@ -162,14 +162,19 @@ export interface OpenAIChatCompletionsProviderOptions {
   parseThinkTags?: boolean;
   /** Wire field used to replay prior assistant thinking on multi-turn requests.
    *  DeepSeek/Fireworks use `"reasoning_content"`; OpenRouter uses `"reasoning"`.
-   *  When unset, thinking blocks are dropped from outbound assistant messages. */
+   *  When unset, thinking blocks are dropped from outbound assistant messages.
+   *  When set, the field is included only if there is thinking to replay, so a
+   *  standard Chat Completions endpoint does not see an extra key on ordinary
+   *  tool-call turns. DeepSeek thinking mode that requires the field even when
+   *  empty is handled by a one-shot retry. */
   assistantReasoningField?: "reasoning" | "reasoning_content";
   /** Backfill a non-empty placeholder for assistant turns that would otherwise
    *  serialize with neither `content` nor `tool_calls` (e.g. reasoning-only
-   *  turns). Off by default; enabled for OpenRouter, whose downstream providers
-   *  (e.g. DeepSeek) reject such messages with `Invalid assistant message:
-   *  content or tool_calls must be set`. See {@link
-   *  EMPTY_ASSISTANT_TURN_PLACEHOLDER}. */
+   *  turns, or a Stop mid-stream before any text). Off by default; enabled for
+   *  OpenRouter, Vercel AI Gateway, LiteLLM, and custom `openai-compatible`
+   *  endpoints, whose downstream providers (e.g. DeepSeek, vLLM, Portkey)
+   *  reject such messages with `Invalid assistant message: content or
+   *  tool_calls must be set`. See {@link EMPTY_ASSISTANT_TURN_PLACEHOLDER}. */
   backfillEmptyAssistantContent?: boolean;
   /** Present object-typed tool params to the model as JSON-string params and
    *  decode them back to objects on the response. Works around models whose
@@ -177,6 +182,13 @@ export interface OpenAIChatCompletionsProviderOptions {
    *  with minimax-m3 on Fireworks). Off by default; scalars/arrays unaffected.
    *  See {@link coerceObjectParamsToJsonString}. */
   coerceObjectArgsToJsonString?: boolean;
+  /** Drop `tool_choice` when thinking/reasoning is on the wire. Strict
+   *  OpenAI-compatible reasoning upstreams (DeepSeek thinking mode) reject any
+   *  explicit `tool_choice` with `Thinking mode does not support this
+   *  tool_choice`. Off by default so catalog providers that honor the combo
+   *  (Fireworks, Together) keep sending `none` / forced choices. Enabled for
+   *  the generic `openai-compatible` adapter, whose upstream is unknown. */
+  omitToolChoiceWhenReasoning?: boolean;
 }
 
 const log = getLogger("chat-completions");
@@ -219,12 +231,29 @@ export function clampReasoningEffort(
     : value;
 }
 
+/** Human-readable text from an OpenAI-compatible error, including wrapped
+ *  upstream detail (OpenRouter `metadata.raw`). Used by the one-shot
+ *  compatibility retries so a generic SDK wrapper message cannot hide the
+ *  real reason. */
+function openaiCompatErrorHaystack(error: unknown): string {
+  return error instanceof OpenAI.APIError
+    ? normalizedErrorText(normalizeOpenAIAPIError(error))
+    : error instanceof Error
+      ? error.message
+      : String(error);
+}
+
+function isClientErrorStatus(error: unknown): boolean {
+  const status = (error as { status?: unknown }).status;
+  return typeof status === "number" && status >= 400 && status < 500;
+}
+
 /**
  * True when the request carried an explicit reasoning opt-out (`"none"` sent
  * as flat `reasoning_effort` or nested `reasoning.effort`) and the provider
  * rejected it with a 4xx that names the reasoning field. Reasoning-only
  * models (e.g. DeepSeek R1) reject the opt-out rather than ignore it; that
- * one case is worth a single retry with the reasoning params stripped —
+ * one case is worth a single retry with the reasoning params stripped:
  * model-default reasoning beats a hard failure.
  */
 function isReasoningOptOutRejection(error: unknown, params: unknown): boolean {
@@ -240,22 +269,217 @@ function isReasoningOptOutRejection(error: unknown, params: unknown): boolean {
   if (!optedOut) {
     return false;
   }
-  const status = (error as { status?: unknown }).status;
-  if (typeof status !== "number" || status < 400 || status >= 500) {
+  if (!isClientErrorStatus(error)) {
+    return false;
+  }
+  return /reasoning/i.test(openaiCompatErrorHaystack(error));
+}
+
+/**
+ * True when thinking/reasoning is active on the outbound chat-completions
+ * body: a non-`"none"` `reasoning_effort`, a nested `reasoning.effort`, or
+ * `reasoning.enabled: true` (OpenRouter / Vercel AI Gateway).
+ */
+export function isThinkingEnabledOnWire(params: unknown): boolean {
+  const p = params as {
+    reasoning_effort?: unknown;
+    reasoning?: { effort?: unknown; enabled?: unknown } | null;
+  };
+  const nested = p.reasoning;
+  if (nested && typeof nested === "object") {
+    if (nested.enabled === true) {
+      return true;
+    }
+    if (typeof nested.effort === "string" && nested.effort !== "none") {
+      return true;
+    }
+  }
+  return (
+    typeof p.reasoning_effort === "string" && p.reasoning_effort !== "none"
+  );
+}
+
+/**
+ * True when the request sent an explicit `tool_choice` and the provider
+ * rejected it because thinking/reasoning mode forbids that parameter.
+ * DeepSeek thinking mode 400s with `Thinking mode does not support this
+ * tool_choice` for any explicit value, including `"auto"` and `"none"`.
+ * One retry without `tool_choice` lets the same provider succeed instead of
+ * failing over to a different backend.
+ */
+function isThinkingModeToolChoiceRejection(
+  error: unknown,
+  params: unknown,
+): boolean {
+  const p = params as { tool_choice?: unknown };
+  if (p.tool_choice === undefined) {
+    return false;
+  }
+  if (!isClientErrorStatus(error)) {
+    return false;
+  }
+  return /does not support this tool_choice/i.test(
+    openaiCompatErrorHaystack(error),
+  );
+}
+
+type AssistantReasoningExtras = {
+  reasoning?: string;
+  reasoning_content?: string;
+};
+
+function assistantReasoningExtras(
+  msg: OpenAI.Chat.Completions.ChatCompletionMessageParam,
+): AssistantReasoningExtras | null {
+  if (msg.role !== "assistant") {
+    return null;
+  }
+  return msg as OpenAI.Chat.Completions.ChatCompletionAssistantMessageParam &
+    AssistantReasoningExtras;
+}
+
+function paramsMessages(
+  params: unknown,
+): OpenAI.Chat.Completions.ChatCompletionMessageParam[] | undefined {
+  const messages = (params as { messages?: unknown }).messages;
+  return Array.isArray(messages)
+    ? (messages as OpenAI.Chat.Completions.ChatCompletionMessageParam[])
+    : undefined;
+}
+
+function messagesCarryAssistantReasoningField(params: unknown): boolean {
+  const messages = paramsMessages(params);
+  if (!messages) {
+    return false;
+  }
+  return messages.some((msg) => {
+    const extra = assistantReasoningExtras(msg);
+    return (
+      extra !== null &&
+      (extra.reasoning !== undefined || extra.reasoning_content !== undefined)
+    );
+  });
+}
+
+function assistantMessagesNeedReasoningContentBackfill(
+  params: unknown,
+): boolean {
+  const messages = paramsMessages(params);
+  if (!messages) {
+    return false;
+  }
+  return messages.some((msg) => {
+    const extra = assistantReasoningExtras(msg);
+    return (
+      extra !== null &&
+      extra.reasoning_content === undefined &&
+      extra.reasoning === undefined
+    );
+  });
+}
+
+function stripAssistantReasoningFields(params: unknown): boolean {
+  const messages = paramsMessages(params);
+  if (!messages) {
+    return false;
+  }
+  let stripped = false;
+  for (const msg of messages) {
+    const extra = assistantReasoningExtras(msg);
+    if (extra === null) {
+      continue;
+    }
+    if (extra.reasoning_content !== undefined) {
+      delete extra.reasoning_content;
+      stripped = true;
+    }
+    if (extra.reasoning !== undefined) {
+      delete extra.reasoning;
+      stripped = true;
+    }
+  }
+  return stripped;
+}
+
+function backfillEmptyReasoningContent(params: unknown): boolean {
+  const messages = paramsMessages(params);
+  if (!messages) {
+    return false;
+  }
+  let added = false;
+  for (const msg of messages) {
+    const extra = assistantReasoningExtras(msg);
+    if (extra === null) {
+      continue;
+    }
+    if (
+      extra.reasoning_content !== undefined ||
+      extra.reasoning !== undefined
+    ) {
+      continue;
+    }
+    extra.reasoning_content = "";
+    added = true;
+  }
+  return added;
+}
+
+function haystackNamesAssistantReasoningField(haystack: string): boolean {
+  if (/reasoning_content/i.test(haystack)) {
+    return true;
+  }
+  return /\breasoning\b/i.test(haystack) && !/reasoning_effort/i.test(haystack);
+}
+
+/**
+ * True when thinking-mode requires `reasoning_content` on subsequent
+ * assistant messages and this request omitted it. DeepSeek 400s with
+ * `The reasoning_content in the thinking mode must be passed back to the API`.
+ * One retry with an empty string on those assistant messages satisfies the
+ * presence check without putting the extra key on every custom-endpoint turn.
+ */
+function isMissingReasoningContentRejection(
+  error: unknown,
+  params: unknown,
+): boolean {
+  if (!isClientErrorStatus(error)) {
+    return false;
+  }
+  const haystack = openaiCompatErrorHaystack(error);
+  if (
+    !/reasoning_content/i.test(haystack) ||
+    !/must be passed back/i.test(haystack)
+  ) {
+    return false;
+  }
+  return assistantMessagesNeedReasoningContentBackfill(params);
+}
+
+/**
+ * True when the request included an assistant `reasoning` / `reasoning_content`
+ * extra and the provider rejected it as an unknown message property. One retry
+ * without those extras lets a strict Chat Completions schema succeed.
+ */
+function isUnknownAssistantReasoningFieldRejection(
+  error: unknown,
+  params: unknown,
+): boolean {
+  if (!isClientErrorStatus(error)) {
+    return false;
+  }
+  if (!messagesCarryAssistantReasoningField(params)) {
+    return false;
+  }
+  const haystack = openaiCompatErrorHaystack(error);
+  if (/must be passed back/i.test(haystack)) {
     return false;
   }
-  // OpenRouter wraps upstream 4xxs in a generic "Provider returned error" and
-  // stashes the real reason under `metadata.raw`, which `normalizeOpenAIAPIError`
-  // promotes into the normalized fields. Scan those, not just `error.message` —
-  // otherwise the wrapped reasoning rejection is missed and this one-shot
-  // fallback never fires.
-  const haystack =
-    error instanceof OpenAI.APIError
-      ? normalizedErrorText(normalizeOpenAIAPIError(error))
-      : error instanceof Error
-        ? error.message
-        : String(error);
-  return /reasoning/i.test(haystack);
+  if (!haystackNamesAssistantReasoningField(haystack)) {
+    return false;
+  }
+  return /unknown|unexpected|unrecognized|additional propert|extra (?:field|property)|not (?:a )?valid|invalid (?:argument|parameter|field|property)/i.test(
+    haystack,
+  );
 }
 
 /**
@@ -334,6 +558,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
     | undefined;
   private backfillEmptyAssistantContent: boolean;
   private coerceObjectArgsToJsonString: boolean;
+  private omitToolChoiceWhenReasoning: boolean;
 
   constructor(
     apiKey: string,
@@ -363,6 +588,8 @@ export class OpenAIChatCompletionsProvider implements Provider {
       options.backfillEmptyAssistantContent ?? false;
     this.coerceObjectArgsToJsonString =
       options.coerceObjectArgsToJsonString ?? false;
+    this.omitToolChoiceWhenReasoning =
+      options.omitToolChoiceWhenReasoning ?? false;
   }
 
   get defaultModel(): string {
@@ -469,11 +696,24 @@ export class OpenAIChatCompletionsProvider implements Provider {
 
         // Honor a caller-supplied tool_choice (e.g. `{ type: "none" }` to force
         // a text-only answer, or `{ type: "tool", name }` for a forced call).
-        // Only meaningful when tools are present — OpenAI rejects a named or
+        // Only meaningful when tools are present: OpenAI rejects a named or
         // "required" choice with no tools.
+        //
+        // Strict reasoning upstreams (DeepSeek thinking mode) reject any
+        // explicit tool_choice, including `"auto"` (the API default when tools
+        // are present) and `"none"`. Omit `"auto"` whenever thinking is on the
+        // wire. Catalog providers that honor `none` / forced choices still
+        // receive them; the generic openai-compatible adapter drops every
+        // explicit value in thinking mode via `omitToolChoiceWhenReasoning`.
         const toolChoice = mapNeutralToolChoice(configObj?.tool_choice);
         if (toolChoice !== undefined) {
-          params.tool_choice = toolChoice;
+          const thinkingOn = isThinkingEnabledOnWire(params);
+          const skipAutoDefault = thinkingOn && toolChoice === "auto";
+          const skipAllChoices =
+            thinkingOn && this.omitToolChoiceWhenReasoning;
+          if (!skipAutoDefault && !skipAllChoices) {
+            params.tool_choice = toolChoice;
+          }
         }
       }
 
@@ -573,20 +813,54 @@ export class OpenAIChatCompletionsProvider implements Provider {
         try {
           stream = await createStream();
         } catch (error) {
-          if (!isReasoningOptOutRejection(error, params)) {
+          if (isReasoningOptOutRejection(error, params)) {
+            log.warn(
+              {
+                provider: this.name,
+                model: modelOverride ?? this.model,
+                error: error instanceof Error ? error.message : String(error),
+              },
+              "Model rejected the explicit reasoning opt-out; retrying without reasoning params",
+            );
+            delete params.reasoning_effort;
+            delete (params as unknown as Record<string, unknown>).reasoning;
+            stream = await createStream();
+          } else if (isThinkingModeToolChoiceRejection(error, params)) {
+            log.warn(
+              {
+                provider: this.name,
+                model: modelOverride ?? this.model,
+                error: error instanceof Error ? error.message : String(error),
+              },
+              "Upstream rejected tool_choice in thinking mode; retrying without tool_choice",
+            );
+            delete params.tool_choice;
+            stream = await createStream();
+          } else if (isMissingReasoningContentRejection(error, params)) {
+            log.warn(
+              {
+                provider: this.name,
+                model: modelOverride ?? this.model,
+                error: error instanceof Error ? error.message : String(error),
+              },
+              "Upstream requires reasoning_content round-trip; retrying with empty field on assistant messages",
+            );
+            backfillEmptyReasoningContent(params);
+            stream = await createStream();
+          } else if (isUnknownAssistantReasoningFieldRejection(error, params)) {
+            log.warn(
+              {
+                provider: this.name,
+                model: modelOverride ?? this.model,
+                error: error instanceof Error ? error.message : String(error),
+              },
+              "Upstream rejected assistant reasoning field; retrying without it",
+            );
+            stripAssistantReasoningFields(params);
+            stream = await createStream();
+          } else {
             throw error;
           }
-          log.warn(
-            {
-              provider: this.name,
-              model: modelOverride ?? this.model,
-              error: error instanceof Error ? error.message : String(error),
-            },
-            "Model rejected the explicit reasoning opt-out; retrying without reasoning params",
-          );
-          delete params.reasoning_effort;
-          delete (params as unknown as Record<string, unknown>).reasoning;
-          stream = await createStream();
         }
 
         for await (const chunk of stream) {
@@ -1095,6 +1369,14 @@ export class OpenAIChatCompletionsProvider implements Provider {
         content: textParts.length > 0 ? textParts.join("") : null,
       };
 
+    if (toolCalls.length > 0) {
+      result.tool_calls = toolCalls;
+    }
+
+    // Include the configured wire field only when there is thinking to replay.
+    // Ordinary tool-call turns omit it so a strict Chat Completions schema
+    // does not reject an extra key. Empty-field presence for DeepSeek is a
+    // one-shot retry, not the default serialization.
     if (reasoningParts.length > 0 && this.assistantReasoningField) {
       (
         result as OpenAI.Chat.Completions.ChatCompletionAssistantMessageParam & {
@@ -1104,15 +1386,13 @@ export class OpenAIChatCompletionsProvider implements Provider {
       )[this.assistantReasoningField] = reasoningParts.join("");
     }
 
-    if (toolCalls.length > 0) {
-      result.tool_calls = toolCalls;
-    }
-
     // An assistant message must carry `content` or `tool_calls`. A turn with
-    // neither (e.g. reasoning-only) would serialize to null/empty content with
-    // no tool calls, which strict OpenAI-compatible backends reject. Reasoning
-    // lives in a separate field and does not satisfy this constraint. Scoped to
-    // providers that need it (OpenRouter) via `backfillEmptyAssistantContent`.
+    // neither (e.g. reasoning-only, or a Stop before any text) would serialize
+    // to null/empty content with no tool calls, which strict OpenAI-compatible
+    // backends reject. Reasoning lives in a separate field and does not
+    // satisfy this constraint. Scoped to providers that need it (OpenRouter,
+    // Vercel AI Gateway, LiteLLM, openai-compatible) via
+    // `backfillEmptyAssistantContent`.
     if (
       this.backfillEmptyAssistantContent &&
       !result.tool_calls &&

package/src/routes/route-host-protocol.ts

@@ -33,6 +33,13 @@ export interface RouteInvokeParams {
   readonly url: string;
   /** Request header entries as `[name, value]` pairs (preserves duplicates). */
   readonly headers: ReadonlyArray<readonly [string, string]>;
+  /**
+   * Manifest name of the plugin whose namespace the route falls in, absent for
+   * a workspace route. The host marks it as the plugin in context for the
+   * handler's execution, so plugin-scoped host APIs behave the same whether the
+   * handler runs in the host or in-thread on the daemon.
+   */
+  readonly pluginName?: string;
 }
 
 /**

package/src/routes/worker.ts

@@ -24,6 +24,7 @@ import { createServer, type Server, type Socket } from "node:net";
 import type { IpcEnvelope } from "@vellumai/ipc-server-utils";
 import { IpcFrameReader, writeMessage } from "@vellumai/ipc-server-utils";
 
+import { runInPluginContext } from "../plugins/plugin-execution-context.js";
 import { disableStreamSeqStamping } from "../runtime/assistant-stream-state.js";
 import {
   evictRouteSourceTree,
@@ -126,26 +127,46 @@ async function handleInvoke(
     evictRouteSourceTree(sourceRootForHandler(params.filePath));
     lastHandlerMtime.set(params.filePath, params.mtimeMs);
   }
-  const mod = await importRouteModule(params.filePath);
 
-  const handler = mod[params.method];
-  if (typeof handler !== "function") {
-    const allowed = HTTP_METHODS.filter((m) => typeof mod[m] === "function");
+  // A plugin's own routes execute as that plugin, matching the daemon's
+  // in-thread path, so plugin-scoped host APIs a handler reaches
+  // (`resolveCredential`, `indexDocument`) scope to the owning plugin rather
+  // than falling through to their unscoped branch. The context covers the
+  // import as well as the call: a route module can reach a scoped API at
+  // evaluation time, and it is imported once per mtime.
+  const serve = async (): Promise<
+    { ok: true; response: Response } | { ok: false; allowed: string[] }
+  > => {
+    const mod = await importRouteModule(params.filePath);
+    const handler = mod[params.method];
+    if (typeof handler !== "function") {
+      return {
+        ok: false,
+        allowed: HTTP_METHODS.filter((m) => typeof mod[m] === "function"),
+      };
+    }
+    const request = reconstructRequest(params, body);
+    const response = (await (handler as (req: Request) => unknown)(
+      request,
+    )) as Response;
+    return { ok: true, response };
+  };
+  const outcome = await (params.pluginName
+    ? runInPluginContext(params.pluginName, serve)
+    : serve());
+
+  if (!outcome.ok) {
     replyResult(
       socket,
       id,
       405,
-      allowed.length ? [["allow", allowed.join(", ")]] : [],
+      outcome.allowed.length ? [["allow", outcome.allowed.join(", ")]] : [],
       null,
     );
     return;
   }
 
-  const request = reconstructRequest(params, body);
-  const response = (await (handler as (req: Request) => unknown)(
-    request,
-  )) as Response;
-
+  const { response } = outcome;
   const buffer = new Uint8Array(await response.arrayBuffer());
   const headers: [string, string][] = [];
   response.headers.forEach((value, name) => {