@vellumai/assistant 0.10.7 → 0.10.8-dev.202607102228.5945895

package/src/providers/vercel-ai-gateway/client.ts

@@ -0,0 +1,142 @@
+import { AnthropicProvider } from "../anthropic/client.js";
+import {
+  isAnthropicModel,
+  retagDelegateError,
+  toAnthropicMessagesBaseURL,
+} from "../anthropic-gateway-shared.js";
+import {
+  clampReasoningEffort,
+  EFFORT_TO_REASONING_EFFORT,
+  OpenAIChatCompletionsProvider,
+} from "../openai/chat-completions-provider.js";
+import { isThinkingConfigEnabled } from "../thinking-config.js";
+import type {
+  Message,
+  ProviderResponse,
+  SendMessageOptions,
+} from "../types.js";
+
+export interface VercelAIGatewayProviderOptions {
+  baseURL?: string;
+  streamTimeoutMs?: number;
+  useNativeWebSearch?: boolean;
+}
+
+const DEFAULT_VERCEL_AI_GATEWAY_BASE_URL = "https://ai-gateway.vercel.sh/v1";
+
+export class VercelAIGatewayProvider extends OpenAIChatCompletionsProvider {
+  private readonly gatewayApiKey: string;
+  private readonly defaultModel: string;
+  private readonly resolvedBaseURL: string;
+  private readonly providerStreamTimeoutMs: number | undefined;
+  private readonly useNativeWebSearch: boolean;
+  private anthropicInner: AnthropicProvider | undefined;
+
+  constructor(
+    apiKey: string,
+    model: string,
+    options: VercelAIGatewayProviderOptions = {},
+  ) {
+    const baseURL =
+      options.baseURL?.trim() || DEFAULT_VERCEL_AI_GATEWAY_BASE_URL;
+    super(apiKey, model, {
+      baseURL,
+      providerName: "vercel-ai-gateway",
+      providerLabel: "Vercel AI Gateway",
+      streamTimeoutMs: options.streamTimeoutMs,
+      // Vercel's OpenAI-compat endpoint streams reasoning text in
+      // `delta.reasoning` (see its Advanced Configuration docs).
+      assistantReasoningField: "reasoning",
+      backfillEmptyAssistantContent: true,
+    });
+    this.gatewayApiKey = apiKey;
+    this.defaultModel = model;
+    this.resolvedBaseURL = baseURL;
+    this.providerStreamTimeoutMs = options.streamTimeoutMs;
+    this.useNativeWebSearch = options.useNativeWebSearch ?? false;
+  }
+
+  // When routing to an `anthropic/*` model, actual API calls hit the Anthropic
+  // Messages endpoint, which charges for images using dimension-based pricing
+  // (~width*height/750 tokens) rather than the generic `base64/4` heuristic.
+  // Expose this so the local token estimator picks the matching rules and
+  // `shouldCompact()` doesn't over-count image tokens by ~100×.
+  get tokenEstimationProvider(): string {
+    return isAnthropicModel(this.defaultModel) ? "anthropic" : this.name;
+  }
+
+  // Native web search is only wired through the Anthropic Messages delegate;
+  // the OpenAI-compat path has no native search tool mapping.
+  get supportsNativeWebSearch(): boolean {
+    return this.useNativeWebSearch && isAnthropicModel(this.defaultModel);
+  }
+
+  override async sendMessage(
+    messages: Message[],
+    options?: SendMessageOptions,
+  ): Promise<ProviderResponse> {
+    const effectiveModel = this.resolveEffectiveModel(options);
+    try {
+      if (isAnthropicModel(effectiveModel)) {
+        return await this.getAnthropicInner().sendMessage(messages, options);
+      }
+      return await super.sendMessage(messages, options);
+    } catch (error) {
+      retagDelegateError(error, this.name);
+    }
+  }
+
+  // Vercel's OpenAI-compat endpoint documents reasoning control as a top-level
+  // `reasoning` object ({ enabled?, effort?, max_tokens?, exclude? }) rather
+  // than the flat OpenAI `reasoning_effort` field, so nest the mapped effort
+  // under `reasoning.effort` — the base class skips its flat emission when a
+  // nested effort is present. `enabled: true` rides along when thinking is
+  // explicitly on; otherwise the field is omitted entirely so models that
+  // reject reasoning params don't 400. Anthropic models never reach this path
+  // (they go through the AnthropicProvider delegate).
+  protected override buildExtraCreateParams(
+    options?: SendMessageOptions,
+  ): Record<string, unknown> {
+    const config = options?.config as Record<string, unknown> | undefined;
+    const effort = config?.effort as string | undefined;
+    const mappedEffort = effort
+      ? EFFORT_TO_REASONING_EFFORT[effort]
+      : undefined;
+    const reasoning: Record<string, unknown> = {};
+    if (isThinkingConfigEnabled(config?.thinking)) {
+      reasoning.enabled = true;
+    }
+    if (mappedEffort) {
+      reasoning.effort = clampReasoningEffort(
+        mappedEffort,
+        this.resolveMaxReasoningEffort(this.resolveEffectiveModel(options)),
+      );
+    }
+    return Object.keys(reasoning).length > 0 ? { reasoning } : {};
+  }
+
+  private resolveEffectiveModel(options?: SendMessageOptions): string {
+    const config = options?.config as Record<string, unknown> | undefined;
+    const override =
+      typeof config?.model === "string" && config.model.trim().length > 0
+        ? config.model.trim()
+        : undefined;
+    return override ?? this.defaultModel;
+  }
+
+  private getAnthropicInner(): AnthropicProvider {
+    if (!this.anthropicInner) {
+      this.anthropicInner = new AnthropicProvider(
+        this.gatewayApiKey,
+        this.defaultModel,
+        {
+          baseURL: toAnthropicMessagesBaseURL(this.resolvedBaseURL),
+          streamTimeoutMs: this.providerStreamTimeoutMs,
+          authToken: this.gatewayApiKey,
+          useNativeWebSearch: this.useNativeWebSearch,
+        },
+      );
+    }
+    return this.anthropicInner;
+  }
+}

package/src/runtime/__tests__/actor-trust-resolver.test.ts

@@ -0,0 +1,132 @@
+/**
+ * Pins the residual sync resolver: guardian-or-unknown from the cached
+ * guardian delivery snapshot, no member classification. Member ACL trust
+ * (trusted_contact / unverified_contact) is verdict-only — pinned by
+ * `trust-verdict-consumer.test.ts`.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+let mockGuardianList: Array<Record<string, unknown>> | undefined = [];
+
+mock.module("../../contacts/guardian-delivery-reader.js", () => ({
+  peekCachedGuardianDelivery: () => mockGuardianList,
+  guardianForChannel: (
+    list: Array<Record<string, unknown>>,
+    channelType: string,
+  ) => list.find((g) => g.channelType === channelType && g.status === "active"),
+}));
+
+const { resolveActorTrust } = await import("../actor-trust-resolver.js");
+const { __resetMemberVerdictCacheForTest, setMemberVerdict } =
+  await import("../member-verdict-cache.js");
+
+const GUARDIAN_ADDRESS = "vellum-principal-guardian";
+
+function guardianDelivery(): Record<string, unknown> {
+  return {
+    channelType: "vellum",
+    contactId: "guardian-contact",
+    principalId: GUARDIAN_ADDRESS,
+    address: GUARDIAN_ADDRESS,
+    externalChatId: "guardian-chat",
+    status: "active",
+  };
+}
+
+describe("resolveActorTrust", () => {
+  beforeEach(() => {
+    mockGuardianList = [];
+    __resetMemberVerdictCacheForTest();
+  });
+
+  test("sender matching the cached guardian delivery → guardian", () => {
+    mockGuardianList = [guardianDelivery()];
+
+    const result = resolveActorTrust({
+      assistantId: "self",
+      sourceChannel: "vellum",
+      conversationExternalId: "local",
+      actorExternalId: GUARDIAN_ADDRESS,
+    });
+
+    expect(result.trustClass).toBe("guardian");
+    expect(result.guardianBindingMatch?.guardianExternalUserId).toBe(
+      GUARDIAN_ADDRESS,
+    );
+    expect(result.guardianPrincipalId).toBe(GUARDIAN_ADDRESS);
+    expect(result.actorMetadata.trustStatus).toBe("guardian");
+  });
+
+  test("non-guardian sender → unknown even with a warmed member-verdict entry", () => {
+    // Member classification is verdict-only: the resolver must not read the
+    // member-verdict cache or elevate past unknown.
+    mockGuardianList = [guardianDelivery()];
+    setMemberVerdict("vellum", "some-other-principal", {
+      trustClass: "unknown",
+      canonicalSenderId: "some-other-principal",
+      contactId: "contact-1",
+      channelId: "channel-1",
+      status: "active",
+      policy: "allow",
+    });
+
+    const result = resolveActorTrust({
+      assistantId: "self",
+      sourceChannel: "vellum",
+      conversationExternalId: "local",
+      actorExternalId: "some-other-principal",
+    });
+
+    expect(result.trustClass).toBe("unknown");
+    expect(result.memberRecord).toBeNull();
+    // The guardian binding is still surfaced for routing even on a non-match.
+    expect(result.guardianBindingMatch?.guardianExternalUserId).toBe(
+      GUARDIAN_ADDRESS,
+    );
+  });
+
+  test("cold guardian cache → unknown (no binding match)", () => {
+    mockGuardianList = undefined;
+
+    const result = resolveActorTrust({
+      assistantId: "self",
+      sourceChannel: "vellum",
+      conversationExternalId: "local",
+      actorExternalId: GUARDIAN_ADDRESS,
+    });
+
+    expect(result.trustClass).toBe("unknown");
+    expect(result.guardianBindingMatch).toBeNull();
+  });
+
+  test("no sender identity → unknown with null canonicalSenderId", () => {
+    mockGuardianList = [guardianDelivery()];
+
+    const result = resolveActorTrust({
+      assistantId: "self",
+      sourceChannel: "vellum",
+      conversationExternalId: "local",
+      actorExternalId: "   ",
+    });
+
+    expect(result.trustClass).toBe("unknown");
+    expect(result.canonicalSenderId).toBeNull();
+    expect(result.memberRecord).toBeNull();
+  });
+
+  test("sender metadata passes through; identifier prefers @username", () => {
+    const result = resolveActorTrust({
+      assistantId: "self",
+      sourceChannel: "vellum",
+      conversationExternalId: "local",
+      actorExternalId: "principal-x",
+      actorUsername: "alice",
+      actorDisplayName: "Alice",
+    });
+
+    expect(result.actorMetadata.identifier).toBe("@alice");
+    expect(result.actorMetadata.displayName).toBe("Alice");
+    expect(result.actorMetadata.senderDisplayName).toBe("Alice");
+    expect(result.actorMetadata.memberDisplayName).toBeUndefined();
+  });
+});

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

@@ -6,7 +6,7 @@
  * yields a live `Conversation`. These tests build a lightweight structural
  * double typed as `Conversation` (`makeWakeConversation`) that stubs only the
  * handful of members the wake touches — `getMessages`, `messages.push`,
- * `isProcessing`/`setProcessing`, `currentTurnTrustContext`,
+ * `isProcessing`/`setProcessing`/`waitForIdle`, `currentTurnTrustContext`,
  * `setSubagentAllowedTools`, `drainQueue`, `maybeCompact`,
  * `contextWindowManager.estimateInputTokens`, and a scripted `agentLoop.run()`.
  *
@@ -115,6 +115,18 @@ interface WakeConversationProbe {
    * sizes against the wake's window instead of mainAgent's.
    */
   maybeCompactSizings: unknown[];
+  /**
+   * Options passed to each `conversation.waitForIdle()` call — the wake's
+   * pre-run busy gate. Lets tests pin the wait budget the wake hands to the
+   * conversation's event-driven wait.
+   */
+  waitForIdleCalls: Array<{ timeoutMs: number }>;
+  /**
+   * Count of `setProcessing(true)` calls that landed while the lock was
+   * already held — a stomp on a competing turn's just-acquired lock. Must
+   * stay 0: the wake re-checks `isProcessing()` before acquiring.
+   */
+  processingLockStomps: number;
 }
 
 const wakeConvRegistry = new Map<string, WakeConversationProbe>();
@@ -400,6 +412,17 @@ function makeWakeConversation(options: {
   estimatedInputTokens?: number;
   /** Seed for the conversation's resting `trustContext`. */
   initialTrustContext?: unknown;
+  /**
+   * Replaces the double's default `waitForIdle` behavior (fast-path `true`
+   * when idle, `true` on the `setProcessing(false)` transition, `false`
+   * after a real `timeoutMs` timer). Lets the timeout test script the
+   * `false` outcome without waiting out the production budget. Calls are
+   * recorded in `waitForIdleCalls` either way.
+   */
+  waitForIdleImpl?: (waitOptions: {
+    timeoutMs: number;
+    signal?: AbortSignal;
+  }) => Promise<boolean>;
 }): WakeConversation {
   const conversationId = options.conversationId ?? "conv-test";
   const probe: WakeConversationProbe = {
@@ -419,10 +442,13 @@ function makeWakeConversation(options: {
     persistedAtEachEmit: [],
     maybeCompactOrders: [],
     maybeCompactSizings: [],
+    waitForIdleCalls: [],
+    processingLockStomps: 0,
   };
   wakeConvRegistry.set(conversationId, probe);
 
   let processing = options.isProcessing ?? false;
+  const idleWaiters = new Set<() => void>();
   let order = 0;
   let activeAllowedTools = options.initialAllowedTools;
   let wakePersonaOverride: unknown;
@@ -515,9 +541,47 @@ function makeWakeConversation(options: {
     getMessages: () => messages,
     isProcessing: () => processing,
     setProcessing: (on: boolean) => {
+      if (on && processing) {
+        probe.processingLockStomps += 1;
+      }
       processing = on;
       probe.processingToggles.push(on);
       probe.callSequence.push(on ? "processing:true" : "processing:false");
+      // Mirrors Conversation.setProcessing: a clear releases pending
+      // waitForIdle waiters (copy-and-clear, like the real notifier).
+      if (!on) {
+        const waiters = [...idleWaiters];
+        idleWaiters.clear();
+        for (const notify of waiters) {
+          notify();
+        }
+      }
+    },
+    // Mirrors Conversation.waitForIdle for the signal-less shape the wake
+    // uses: fast-path `true` when idle, `true` on the setProcessing(false)
+    // transition, `false` when `timeoutMs` elapses first.
+    waitForIdle: (waitOptions: {
+      timeoutMs: number;
+      signal?: AbortSignal;
+    }): Promise<boolean> => {
+      probe.waitForIdleCalls.push({ timeoutMs: waitOptions.timeoutMs });
+      if (options.waitForIdleImpl) {
+        return options.waitForIdleImpl(waitOptions);
+      }
+      if (!processing) {
+        return Promise.resolve(true);
+      }
+      return new Promise<boolean>((resolve) => {
+        const timer = setTimeout(() => {
+          idleWaiters.delete(notify);
+          resolve(false);
+        }, waitOptions.timeoutMs);
+        const notify = () => {
+          clearTimeout(timer);
+          resolve(true);
+        };
+        idleWaiters.add(notify);
+      });
     },
     get currentTurnTrustContext() {
       return currentTurnTrustContext;
@@ -1768,11 +1832,166 @@ describe("wakeAgentForOpportunity", () => {
     await new Promise((resolve) => setTimeout(resolve, 20));
     expect(settled).toBe(false);
 
-    // "User turn" completes — wake now proceeds.
+    // "User turn" completes — wake now proceeds. The release notification
+    // resolves the wait; the double's only other exit is its (untriggered)
+    // 30s timeout timer, so the wake proceeding here proves the wait is
+    // event-driven rather than clock-driven.
     conversation.setProcessing(false);
     const result = await wakePromise;
     expect(result.invoked).toBe(true);
     expect(result.producedToolCalls).toBe(false);
+    expect(conversation.waitForIdleCalls).toEqual([{ timeoutMs: 30_000 }]);
+  });
+
+  test("re-waits when a competing idle waiter takes the lock before the wake's continuation runs", async () => {
+    // Idle waiters are notified FIFO from the same `setProcessing(false)`
+    // transition. A waiter registered before the wake (e.g. a queued voice
+    // turn) can take the lock synchronously in its continuation — the wake
+    // must observe the re-taken lock, re-wait, and acquire only after the
+    // competitor's real release.
+    const conversation = makeWakeConversation({
+      conversationId: "conv-contended",
+      isProcessing: true,
+      scriptedAssistant: {
+        role: "assistant",
+        content: [{ type: "text", text: "reply" }],
+      },
+    });
+
+    // Competing turn: registered FIRST, so it is notified first and grabs
+    // the lock synchronously in its continuation.
+    void conversation.waitForIdle({ timeoutMs: 30_000 }).then(() => {
+      conversation.setProcessing(true);
+    });
+
+    const wakePromise = wakeAgentForOpportunity(
+      {
+        conversationId: "conv-contended",
+        hint: "co-woken opportunity",
+        source: "unit-test",
+      },
+      { resolveTarget: async () => conversation },
+    );
+    // Let the wake reach its waitForIdle registration (behind the competitor's).
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    expect(conversation.waitForIdleCalls).toHaveLength(2);
+
+    // The original turn releases. The competitor is notified first and
+    // re-takes the lock; the wake must NOT start its agent loop.
+    conversation.setProcessing(false);
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    expect(conversation.runCalls).toHaveLength(0);
+    expect(conversation.isProcessing()).toBe(true);
+    // The wake went back to waiting, on the remaining budget.
+    expect(conversation.waitForIdleCalls).toHaveLength(3);
+    expect(conversation.waitForIdleCalls[2]!.timeoutMs).toBeGreaterThan(0);
+    expect(conversation.waitForIdleCalls[2]!.timeoutMs).toBeLessThanOrEqual(
+      30_000,
+    );
+
+    // The competitor's real release lets the wake proceed.
+    conversation.setProcessing(false);
+    const result = await wakePromise;
+    expect(result.invoked).toBe(true);
+    expect(conversation.runCalls).toHaveLength(1);
+    // Lock hand-offs stayed clean — release, competitor take, competitor
+    // release, wake take, wake release — with no acquisition landing while
+    // the lock was already held.
+    expect(conversation.processingToggles).toEqual([
+      false,
+      true,
+      false,
+      true,
+      false,
+    ]);
+    expect(conversation.processingLockStomps).toBe(0);
+  });
+
+  test("acquires the lock only after a passing isProcessing() re-check, on the remaining budget", async () => {
+    // Scripted waitForIdle resolves `true` while the lock is still held —
+    // the exact state a wake continuation observes when a competing waiter
+    // was notified first. The wake must not trust the resolution alone: it
+    // re-checks `isProcessing()`, re-waits on the remaining budget, and
+    // acquires only once the check passes.
+    let fakeNow = 1_000_000;
+    let waitCalls = 0;
+    const conversation = makeWakeConversation({
+      conversationId: "conv-recheck",
+      isProcessing: true,
+      scriptedAssistant: {
+        role: "assistant",
+        content: [{ type: "text", text: "reply" }],
+      },
+      waitForIdleImpl: async () => {
+        waitCalls += 1;
+        if (waitCalls === 1) {
+          // Resolve true with the lock still held (a competitor re-took
+          // it), burning 5s of the wake's 30s budget.
+          fakeNow += 5_000;
+          return true;
+        }
+        // The competitor releases for real before the second wait resolves.
+        conversation.setProcessing(false);
+        return true;
+      },
+    });
+
+    const result = await wakeAgentForOpportunity(
+      {
+        conversationId: "conv-recheck",
+        hint: "co-woken opportunity",
+        source: "unit-test",
+      },
+      { resolveTarget: async () => conversation, now: () => fakeNow },
+    );
+
+    expect(result.invoked).toBe(true);
+    // The lying first resolution did not start the loop — the wake re-waited
+    // on the remaining budget (30s total minus the 5s already burned).
+    expect(waitCalls).toBe(2);
+    expect(conversation.waitForIdleCalls).toEqual([
+      { timeoutMs: 30_000 },
+      { timeoutMs: 25_000 },
+    ]);
+    expect(conversation.runCalls).toHaveLength(1);
+    // setProcessing(true) never landed while the lock was held.
+    expect(conversation.processingLockStomps).toBe(0);
+  });
+
+  test("returns reason 'timeout' when the lock stays contended past the wait budget", async () => {
+    // The re-check loop is budget-bounded: when every wakeup finds the lock
+    // re-taken and the 30s total budget runs out, the wake skips with the
+    // same "timeout" outcome as a plain busy conversation.
+    let fakeNow = 0;
+    const conversation = makeWakeConversation({
+      conversationId: "conv-contended-timeout",
+      isProcessing: true,
+      runImpl: async (input) => runResult(input),
+      waitForIdleImpl: async () => {
+        // Always resolves true with the lock still held, burning 20s each
+        // time — the second wakeup lands past the 30s deadline.
+        fakeNow += 20_000;
+        return true;
+      },
+    });
+
+    const result = await wakeAgentForOpportunity(
+      { conversationId: "conv-contended-timeout", hint: "x", source: "y" },
+      { resolveTarget: async () => conversation, now: () => fakeNow },
+    );
+
+    expect(result).toEqual({
+      invoked: false,
+      producedToolCalls: false,
+      reason: "timeout",
+    });
+    // The agent loop never ran and the lock was never touched.
+    expect(conversation.runCalls).toHaveLength(0);
+    expect(conversation.processingToggles).toEqual([]);
+    expect(conversation.waitForIdleCalls).toEqual([
+      { timeoutMs: 30_000 },
+      { timeoutMs: 10_000 },
+    ]);
   });
 
   test("returns invoked: false with reason 'not_found' when the conversation cannot be resolved", async () => {
@@ -1788,34 +2007,31 @@ describe("wakeAgentForOpportunity", () => {
   });
 
   test("returns invoked: false with reason 'timeout' when the target stays busy past the wait-until-idle window", async () => {
-    // Resolver returns a target that is permanently `processing`. Fast-
-    // forward the injected `now` past the 30s deadline so waitUntilIdle
-    // returns false. Without the distinct `timeout` reason, callers
-    // cannot tell this case apart from "not_found".
+    // Resolver returns a target that is permanently `processing`. The
+    // scripted `waitForIdle` resolves `false` — the real Conversation's
+    // timeout outcome — without holding the test for the 30s production
+    // budget. Without the distinct `timeout` reason, callers cannot tell
+    // this case apart from "not_found".
     const conversation = makeWakeConversation({
       conversationId: "conv-busy",
       isProcessing: true,
       runImpl: async (input) => runResult(input),
+      waitForIdleImpl: async () => false,
     });
-    let t = 0;
-    const now = () => {
-      // First call establishes the deadline at +30_000. Every subsequent
-      // call jumps past the deadline so the polling loop exits after one
-      // 50ms tick.
-      const v = t;
-      t += 31_000;
-      return v;
-    };
 
     const result = await wakeAgentForOpportunity(
       { conversationId: "conv-busy", hint: "x", source: "y" },
-      { resolveTarget: async () => conversation, now },
+      { resolveTarget: async () => conversation },
     );
     expect(result).toEqual({
       invoked: false,
       producedToolCalls: false,
       reason: "timeout",
     });
+    // The wake handed the conversation's event-driven wait its full 30s
+    // budget, and did not start the agent loop on the busy conversation.
+    expect(conversation.waitForIdleCalls).toEqual([{ timeoutMs: 30_000 }]);
+    expect(conversation.runCalls).toHaveLength(0);
   });
 
   test("agent loop error is treated as a no-op", async () => {

package/src/runtime/__tests__/background-job-runner.test.ts

@@ -13,7 +13,7 @@
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import type { TrustContext } from "../../daemon/trust-context.js";
+import type { TrustContext } from "../../daemon/trust-context-types.js";
 
 // ── Module mocks ─────────────────────────────────────────────────────
 
@@ -47,7 +47,10 @@ let processMessageImpl: (
   conversationId: string,
   content: string,
   options: Record<string, unknown> | undefined,
-) => Promise<{ messageId: string }> = async () => ({ messageId: "msg-1" });
+) => Promise<{
+  messageId: string;
+  turnFailure?: { failureCode?: string };
+}> = async () => ({ messageId: "msg-1" });
 const processMessageCalls: Array<{
   conversationId: string;
   content: string;
@@ -179,6 +182,33 @@ describe("runBackgroundJob", () => {
     });
   });
 
+  test("threads allowedTools + toolGateMode into processMessage options when set", async () => {
+    await runBackgroundJob(
+      baseOpts({
+        allowedTools: ["file_read", "bash"],
+        toolGateMode: "wire",
+      }),
+    );
+
+    expect(processMessageCalls).toHaveLength(1);
+    expect(processMessageCalls[0].options).toMatchObject({
+      allowedTools: ["file_read", "bash"],
+      toolGateMode: "wire",
+    });
+  });
+
+  test("omits allowedTools/toolGateMode from processMessage options when unset (ordinary jobs unchanged)", async () => {
+    await runBackgroundJob(baseOpts());
+
+    expect(processMessageCalls).toHaveLength(1);
+    const opts = processMessageCalls[0].options as {
+      allowedTools?: unknown;
+      toolGateMode?: unknown;
+    };
+    expect(opts.allowedTools).toBeUndefined();
+    expect(opts.toolGateMode).toBeUndefined();
+  });
+
   test("generic exception: returns ok=false with errorKind=exception and emits activity.failed with dedupeKey", async () => {
     processMessageImpl = async () => {
       throw new Error("boom");
@@ -215,6 +245,45 @@ describe("runBackgroundJob", () => {
     );
   });
 
+  test("non-throwing turn failure: returns ok=false with errorKind=model_provider and emits activity.failed", async () => {
+    // A failed LLM call (e.g. an invalid provider) does NOT throw — the turn
+    // persists a synthetic error message and processMessage resolves with a
+    // `turnFailure`. The runner must surface this as a failure, not ok=true.
+    processMessageImpl = async () => ({
+      messageId: "msg-failed-turn",
+      turnFailure: { failureCode: "provider_error" },
+    });
+
+    const result = await runBackgroundJob(baseOpts());
+
+    expect(result.ok).toBe(false);
+    expect(result.errorKind).toBe("model_provider");
+    expect(result.error?.message).toContain("provider_error");
+    expect(result.conversationId).toBe(STUB_CONVERSATION_ID);
+
+    expect(emitCalls).toHaveLength(1);
+    expect(emitCalls[0].sourceEventName).toBe("activity.failed");
+    expect(
+      (emitCalls[0].contextPayload as { errorKind: string }).errorKind,
+    ).toBe("model_provider");
+  });
+
+  test("non-throwing turn failure with deferNotifications drops buffered notifications", async () => {
+    processMessageImpl = async () => ({
+      messageId: "msg-failed-turn",
+      turnFailure: { failureCode: "provider_error" },
+    });
+
+    const result = await runBackgroundJob(
+      baseOpts({ deferNotifications: true }),
+    );
+
+    expect(result.ok).toBe(false);
+    // Only the runner's failure signal emits — no committed "success" signal.
+    expect(emitCalls).toHaveLength(1);
+    expect(emitCalls[0].sourceEventName).toBe("activity.failed");
+  });
+
   test("timeout: returns ok=false with errorKind=timeout and emits activity.failed", async () => {
     // Never resolve — force timeout to win the race.
     processMessageImpl = () => new Promise(() => {});