@vellumai/assistant 0.10.1 → 0.10.2-dev.202606241651.2d2b40d

package/src/onboarding/schedule-checkin.ts

@@ -0,0 +1,190 @@
+/**
+ * Schedules the onboarding "Day 2 Check-in" calendar event server-side.
+ *
+ * Flow:
+ *   1. Resolve the Google OAuth connection, requiring the calendar.events scope.
+ *      No connection / missing scope → a `scheduled: false` result (never an
+ *      error): the web caller treats this as a best-effort skip.
+ *   2. List tomorrow's timed events in the 8am–8pm window (user's timezone) to
+ *      derive busy intervals. Uses events.list rather than freeBusy.query
+ *      because the onboarding grant is the narrow `calendar.events` scope, which
+ *      authorizes events.list/insert but not freeBusy.query.
+ *   3. Choose the first open 15-minute slot (12pm–5pm, widening to 8am–8pm).
+ *   4. Create the event with the locked title + HTML description, sendUpdates=all.
+ *
+ * Authenticates via `resolveOAuthConnection("google")` + `connection.request()`,
+ * the same path the calendar watcher uses — no skill subprocess.
+ */
+
+import { canonicalizeTimeZone } from "../daemon/date-context.js";
+import type { OAuthConnection } from "../oauth/connection.js";
+import { resolveOAuthConnection } from "../oauth/connection-resolver.js";
+import { getLogger } from "../util/logger.js";
+import {
+  buildCheckinDescription,
+  buildCheckinTitle,
+  checkinAvailabilityWindow,
+  type CheckinNames,
+  chooseCheckinSlot,
+  extractBusyFromEvents,
+  type GcalEvent,
+} from "./checkin-event.js";
+
+const log = getLogger("onboarding:schedule-checkin");
+
+const GOOGLE_CALENDAR_BASE_URL = "https://www.googleapis.com/calendar/v3";
+const GOOGLE_CALENDAR_EVENTS_SCOPE =
+  "https://www.googleapis.com/auth/calendar.events";
+/** Calendar shares the Google OAuth connection with Gmail. */
+const GOOGLE_PROVIDER = "google";
+const PRIMARY_CALENDAR_ID = "primary";
+
+export interface ScheduleCheckinInput extends CheckinNames {
+  /** IANA timezone reported by the client (e.g. "America/New_York"). */
+  timeZone?: string;
+  /** Override "now" for deterministic tests. Defaults to the current time. */
+  nowMs?: number;
+}
+
+export type ScheduleCheckinResult =
+  | {
+      scheduled: true;
+      eventId: string;
+      htmlLink: string | null;
+      /** Event start, ISO 8601 (UTC). */
+      start: string;
+      /** Event end, ISO 8601 (UTC). */
+      end: string;
+      timeZone: string;
+    }
+  | {
+      scheduled: false;
+      /**
+       * Why nothing was booked. `calendar_unavailable` covers both "not
+       * connected" and "calendar scope not granted" — the client surfaces a
+       * single best-effort skip either way.
+       */
+      reason: "calendar_unavailable";
+    };
+
+interface EventsListResponse {
+  items?: GcalEvent[];
+}
+
+/** Subset of the events.insert response we surface back to the caller. */
+interface CreatedEvent {
+  id?: string;
+  htmlLink?: string;
+}
+
+/**
+ * Schedule the Day 2 check-in. Resolves to a `scheduled: false` result when no
+ * calendar is connected; throws only on unexpected Calendar API failures (the
+ * route handler maps those to a 5xx, the web caller swallows them).
+ */
+export async function scheduleOnboardingCheckin(
+  input: ScheduleCheckinInput,
+): Promise<ScheduleCheckinResult> {
+  const timeZone =
+    canonicalizeTimeZone(input.timeZone) ??
+    // Fall back to the daemon host timezone when the client didn't report one.
+    Intl.DateTimeFormat().resolvedOptions().timeZone ??
+    "UTC";
+  const nowMs = input.nowMs ?? Date.now();
+
+  let connection: OAuthConnection;
+  try {
+    connection = await resolveOAuthConnection(GOOGLE_PROVIDER, {
+      requiredScopes: [GOOGLE_CALENDAR_EVENTS_SCOPE],
+    });
+  } catch (err) {
+    // No active connection or the calendar scope wasn't granted — skip quietly.
+    log.info(
+      { err: err instanceof Error ? err.message : String(err) },
+      "Check-in skipped: Google Calendar not available",
+    );
+    return { scheduled: false, reason: "calendar_unavailable" };
+  }
+
+  const { timeMinMs, timeMaxMs } = checkinAvailabilityWindow(nowMs, timeZone);
+
+  const eventsResp = await connection.request({
+    method: "GET",
+    path: `/calendars/${encodeURIComponent(PRIMARY_CALENDAR_ID)}/events`,
+    query: {
+      timeMin: new Date(timeMinMs).toISOString(),
+      timeMax: new Date(timeMaxMs).toISOString(),
+      // Expand recurring events into instances so each occurrence is a concrete
+      // busy interval in the window.
+      singleEvents: "true",
+      orderBy: "startTime",
+      maxResults: "250",
+    },
+    baseUrl: GOOGLE_CALENDAR_BASE_URL,
+    headers: { "Content-Type": "application/json" },
+  });
+  if (eventsResp.status < 200 || eventsResp.status >= 300) {
+    throw new Error(
+      `Calendar events.list ${eventsResp.status}: ${stringifyBody(eventsResp.body)}`,
+    );
+  }
+
+  const busy = extractBusyFromEvents(
+    (eventsResp.body as EventsListResponse).items ?? [],
+  );
+  const slot = chooseCheckinSlot(nowMs, timeZone, busy);
+
+  const uuid = crypto.randomUUID();
+  const eventResp = await connection.request({
+    method: "POST",
+    path: `/calendars/${encodeURIComponent(PRIMARY_CALENDAR_ID)}/events`,
+    query: { sendUpdates: "all" },
+    baseUrl: GOOGLE_CALENDAR_BASE_URL,
+    headers: { "Content-Type": "application/json" },
+    body: {
+      summary: buildCheckinTitle(input),
+      description: buildCheckinDescription(uuid),
+      start: {
+        dateTime: new Date(slot.startMs).toISOString(),
+        timeZone,
+      },
+      end: {
+        dateTime: new Date(slot.endMs).toISOString(),
+        timeZone,
+      },
+    },
+  });
+  if (eventResp.status < 200 || eventResp.status >= 300) {
+    throw new Error(
+      `Calendar event create ${eventResp.status}: ${stringifyBody(eventResp.body)}`,
+    );
+  }
+
+  const event = eventResp.body as CreatedEvent;
+  if (!event.id) {
+    throw new Error("Calendar event create returned no event id");
+  }
+
+  log.info(
+    {
+      eventId: event.id,
+      start: new Date(slot.startMs).toISOString(),
+      window: slot.window,
+      timeZone,
+    },
+    "Scheduled onboarding Day 2 check-in",
+  );
+
+  return {
+    scheduled: true,
+    eventId: event.id,
+    htmlLink: event.htmlLink ?? null,
+    start: new Date(slot.startMs).toISOString(),
+    end: new Date(slot.endMs).toISOString(),
+    timeZone,
+  };
+}
+
+function stringifyBody(body: unknown): string {
+  return typeof body === "string" ? body : JSON.stringify(body ?? "");
+}

package/src/permissions/question-prompter.test.ts

@@ -9,7 +9,7 @@ import type {
 
 // Use a tiny timeout so the setTimeout branch fires quickly in tests
 const mockConfig = {
-  timeouts: { permissionTimeoutSec: 0.05 },
+  timeouts: { questionResponseTimeoutSec: 0.05 },
 };
 // Preserve every other export from the real config/loader so other
 // tests in the same `bun test` run (which share module-level mocks)

package/src/permissions/question-prompter.ts

@@ -156,9 +156,12 @@ export interface QuestionBatchMetadata {
  * the whole batch to `/v1/question-response` when the user is done — no
  * per-question accumulator, no partial state machine.
  *
- * Timeout reuses `getConfig().timeouts.permissionTimeoutSec` (default 5 min) —
- * questions are user-prompts in the same UX family as permission prompts and
- * secret prompts, so they share the same idle-timeout knob.
+ * The idle timeout is a backstop (`getConfig().timeouts.questionResponseTimeoutSec`,
+ * default 30 min), not the primary way a prompt is dismissed. An interactive
+ * user who moves on instead of answering enqueues another message, which
+ * supersedes the open prompt at the enqueue handler (see conversation-routes.ts);
+ * a non-interactive turn resolves immediately at the tool. The backstop only
+ * fires when a prompt is left open with no response and no follow-up message.
  */
 export class QuestionPrompter {
   async prompt(params: QuestionPromptParams): Promise<QuestionPromptResult> {
@@ -199,7 +202,7 @@ export class QuestionPrompter {
     const requestId = uuid();
 
     return new Promise<QuestionPromptResult>((resolve, reject) => {
-      const timeoutMs = getConfig().timeouts.permissionTimeoutSec * 1000;
+      const timeoutMs = getConfig().timeouts.questionResponseTimeoutSec * 1000;
 
       // Closure-scoped idempotency guard. Every resolution path (timeout,
       // abort, route resolution via `rpcResolve`/`rpcReject`) routes through

package/src/plugin-api/index.ts

@@ -130,12 +130,12 @@ export type {
 } from "../runtime/assistant-event-hub.js";
 export { assistantEventHub } from "../runtime/assistant-event-hub.js";
 export { getModelProfiles } from "./model-profiles.js";
-// Check whether a profile's resolved model can process image input. Resolves
-// the effective (provider, model) by merging over the workspace default and
-// inferring the provider for model-only profiles, then looks up the model
-// catalog's `supportsVision` flag. Handles mix profiles (true if any arm
-// supports vision). Fail-open for unknown models. Pair with
-// `getModelProfiles()` to inspect the active or candidate profiles.
+// Check whether a model or profile can process image input. Accepts a concrete
+// model id, a profile key, or a `ModelProfileInfo`; a bare string is resolved
+// as a model id first and then as a profile key. Profile resolution merges over
+// the workspace default and infers the provider for model-only profiles, then
+// looks up the model catalog's `supportsVision` flag (mix profiles are
+// vision-capable if any arm is). Returns false when nothing resolves.
 export { doesSupportVision } from "./vision-support.js";
 // Resolve a provider for a call site (optionally overriding the profile) so a
 // plugin can run inference through the workspace's configured profiles and

package/src/plugin-api/types.ts

@@ -72,15 +72,13 @@ export type PluginHookFn<TCtx = unknown> = (
 // ─── Init context ────────────────────────────────────────────────────────────
 
 /**
- * Context passed to `Plugin.init()` during bootstrap. Carries resolved
- * config/credentials, a pino-compatible logger scoped to the plugin, a
- * per-plugin writable data directory, and the assistant's version metadata.
+ * Context passed to `Plugin.init()` during bootstrap. Carries the resolved
+ * config, a pino-compatible logger scoped to the plugin, a per-plugin
+ * writable data directory, and the assistant's version metadata.
  */
 export interface PluginInitContext {
   /** Parsed config for this plugin (may be `unknown` until the manifest validates). */
   config: unknown;
-  /** Resolved credential values keyed by the entries of `manifest.requiresCredential`. */
-  credentials: Record<string, string>;
   /** Pino-compatible child logger bound to `{ plugin: <name> }`. */
   logger: PluginLogger;
   /** Absolute path to `<workspaceDir>/plugins-data/<plugin>/` (created by bootstrap). */

package/src/plugin-api/vision-support.test.ts

@@ -84,16 +84,16 @@ describe("doesSupportVision", () => {
     expect(doesSupportVision(profile("text-profile"))).toBe(false);
   });
 
-  test("fails open (true) for an unknown profile key not in config", () => {
+  test("returns false for an unknown profile key not in config", () => {
     setMockConfig({});
-    expect(doesSupportVision(profile("nonexistent"))).toBe(true);
+    expect(doesSupportVision(profile("nonexistent"))).toBe(false);
   });
 
-  test("fails open (true) for an unknown provider/model pair", () => {
+  test("returns false for an unknown provider/model pair", () => {
     setMockConfig({
       "unknown-model": { provider: "unknown-provider", model: "unknown-model" },
     });
-    expect(doesSupportVision(profile("unknown-model"))).toBe(true);
+    expect(doesSupportVision(profile("unknown-model"))).toBe(false);
   });
 
   test("inherits provider from llm.default when profile only sets model", () => {
@@ -147,3 +147,27 @@ describe("doesSupportVision", () => {
     expect(doesSupportVision(profile("mix-profile"))).toBe(false);
   });
 });
+
+describe("doesSupportVision with a bare string", () => {
+  test("returns true for a known vision-capable model id", () => {
+    expect(doesSupportVision("claude-opus-4-6")).toBe(true);
+  });
+
+  test("returns false for a known text-only model id", () => {
+    expect(doesSupportVision("accounts/fireworks/models/glm-5p2")).toBe(false);
+  });
+
+  test("falls back to resolving the string as a profile key", () => {
+    // "vision-profile" is not a catalog model id, so it resolves as a profile
+    // key → anthropic/claude-opus-4-6 (vision-capable).
+    setMockConfig({
+      "vision-profile": { provider: "anthropic", model: "claude-opus-4-6" },
+    });
+    expect(doesSupportVision("vision-profile")).toBe(true);
+  });
+
+  test("returns false for a string that is neither a model nor a profile", () => {
+    setMockConfig({});
+    expect(doesSupportVision("some-unknown-string")).toBe(false);
+  });
+});

package/src/plugin-api/vision-support.ts

@@ -3,10 +3,17 @@
  *
  * A plugin that gates image processing on vision capability (e.g. an
  * image-to-text fallback for text-only models) calls {@link doesSupportVision}
- * instead of hardcoding model names. The function resolves the effective
- * (provider, model) for a profile — merging with `llm.default` to fill gaps,
- * inferring the provider for model-only profiles via the catalog — and then
- * looks up `supportsVision` in the model catalog.
+ * instead of hardcoding model names. One entry point serves both shapes a
+ * caller might hold:
+ * - a concrete model id (e.g. the provider-reported model that just ran), and
+ * - a profile — either a {@link ModelProfileInfo} or a bare profile key —
+ *   resolved through `llm.profiles` to an effective `(provider, model)`.
+ *
+ * A bare string is tried as a model id first and then as a profile key, so the
+ * two callers share one function. Resolution returns `false` when nothing
+ * resolves (rather than failing open): a consumer gating an image→text
+ * fallback wants an unknown model treated as "can't show images" — caption it —
+ * over silently shipping a raw image to a provider that may reject it.
  */
 
 import { getConfig } from "../config/loader.js";
@@ -17,46 +24,74 @@ import {
 import type { ModelProfileInfo } from "./types.js";
 
 /**
- * Whether a profile's resolved model can process image input.
+ * Whether the given model or profile can process image input.
  *
- * Resolution mirrors the host's call-site resolver:
- * - The profile's `(provider, model)` fields are merged over `llm.default` so
- *   a profile that only sets `model` (or only `provider`) inherits the other
- *   from the workspace default.
- * - When `provider` is still missing but `model` is a known catalog model,
- *   the provider is inferred via `getCatalogProviderForModel` (same logic as
- *   the resolver's `withImpliedProviderForKnownModel`).
- * - For a mix profile, returns `true` if any constituent arm supports vision
- *   (the mix can route to it) and `false` only if every arm is text-only.
- * - Unknown `(provider, model)` pairs default to `true` (fail-open), matching
- *   the config GET route's `enrichProfilesWithVisionFlag`.
+ * `modelOrProfile` may be a concrete model id, a profile key, or a
+ * {@link ModelProfileInfo}. A bare string is resolved as a model id first and,
+ * failing that, as a profile key. Returns `false` when nothing resolves.
+ */
+export function doesSupportVision(
+  modelOrProfile: ModelProfileInfo | string,
+): boolean {
+  if (typeof modelOrProfile === "string") {
+    // Concrete model id first, then fall back to treating it as a profile key.
+    return (
+      modelVision(modelOrProfile) ?? profileVision(modelOrProfile) ?? false
+    );
+  }
+  return profileVision(modelOrProfile.key) ?? false;
+}
+
+/**
+ * Catalog vision flag for a concrete model id, or `undefined` when the catalog
+ * doesn't know the model. The same model id carries the same capability under
+ * every provider that offers it, so the first catalog match wins.
  */
-export function doesSupportVision(profile: ModelProfileInfo): boolean {
+function modelVision(model: string): boolean | undefined {
+  for (const provider of PROVIDER_CATALOG) {
+    const catalogModel = provider.models.find((m) => m.id === model);
+    if (catalogModel != null) return catalogModel.supportsVision ?? false;
+  }
+  return undefined;
+}
+
+/**
+ * Resolve a profile key through `llm.profiles` to its vision capability, or
+ * `undefined` when the key is unknown or resolves to a model the catalog
+ * doesn't know. A mix profile resolves to `true` if any arm supports vision
+ * (the mix can route to it) and `false` only once every arm is a known
+ * text-only model.
+ */
+function profileVision(profileKey: string): boolean | undefined {
   const { llm } = getConfig();
-  const entry = llm.profiles[profile.key];
-  if (entry == null) return true;
+  const entry = llm.profiles[profileKey];
+  if (entry == null) return undefined;
 
-  // Mix: fail-open if any arm supports vision.
   if (entry.mix != null) {
-    return entry.mix.some((arm) => {
+    let sawUnknown = false;
+    for (const arm of entry.mix) {
       const armEntry = llm.profiles[arm.profile];
-      if (armEntry == null) return true;
-      return resolveEntrySupportsVision(armEntry, llm);
-    });
+      const armVision =
+        armEntry == null ? undefined : resolveEntryVision(armEntry, llm);
+      if (armVision === true) return true;
+      if (armVision == null) sawUnknown = true;
+    }
+    return sawUnknown ? undefined : false;
   }
 
-  return resolveEntrySupportsVision(entry, llm);
+  return resolveEntryVision(entry, llm);
 }
 
 /**
  * Resolve whether a concrete (non-mix) profile entry supports vision by
- * merging its fields over `llm.default` and inferring the provider when
- * only the model is set.
+ * merging its fields over `llm.default` and inferring the provider when only
+ * the model is set. Returns `undefined` when the effective `(provider, model)`
+ * can't be determined or isn't in the catalog.
  */
-function resolveEntrySupportsVision(
+function resolveEntryVision(
   entry: { provider?: string; model?: string },
   llm: { default?: { provider?: string; model?: string } },
-): boolean {
+): boolean | undefined {
   const provider = entry.provider ?? llm.default?.provider;
   const model = entry.model ?? llm.default?.model;
 
@@ -67,12 +102,12 @@ function resolveEntrySupportsVision(
     (typeof model === "string" ? getCatalogProviderForModel(model) : undefined);
 
   if (typeof effectiveProvider !== "string" || typeof model !== "string") {
-    return true; // fail-open
+    return undefined;
   }
 
   const catalogProvider = PROVIDER_CATALOG.find(
     (p) => p.id === effectiveProvider,
   );
   const catalogModel = catalogProvider?.models.find((m) => m.id === model);
-  return catalogModel?.supportsVision ?? true;
+  return catalogModel?.supportsVision;
 }

package/src/plugins/defaults/advisor/__tests__/consult.test.ts

@@ -8,12 +8,26 @@ let sendMessageArgs: Record<string, unknown> | null = null;
 let responseText = "Use a channel-based worker pool; drain on shutdown.";
 let sendMessageError: Error | null = null;
 let providerResolves = true;
+let providerSupportsWeb = false;
+let streamDeltas: string[] = [];
+let streamEvents: Array<Record<string, unknown>> = [];
 
 const fakeProvider = {
   name: "mock-advisor-provider",
+  get supportsNativeWebSearch() {
+    return providerSupportsWeb;
+  },
   async sendMessage(messages: unknown, options: unknown) {
     sendMessageArgs = { messages, options } as Record<string, unknown>;
     if (sendMessageError) throw sendMessageError;
+    const onEvent = (
+      options as { onEvent?: (e: Record<string, unknown>) => void }
+    ).onEvent;
+    if (onEvent) {
+      // Activity (search/thinking) streams before the final advice text.
+      for (const ev of streamEvents) onEvent(ev);
+      for (const text of streamDeltas) onEvent({ type: "text_delta", text });
+    }
     return {
       content: [{ type: "text", text: responseText }],
       model: "mock-model",
@@ -29,6 +43,14 @@ mock.module("../../../../providers/provider-send-message.js", () => ({
   getConfiguredProvider: async () => (providerResolves ? fakeProvider : null),
 }));
 
+// Keep the tool tests focused on the consult wiring: stub the context pack so
+// they don't reach into the registry / workspace / memory sources (those have
+// their own coverage). The consult itself never imports this module.
+mock.module("../context-pack.js", () => ({
+  buildAdvisorContext: async () => null,
+  deriveRecallQuery: () => null,
+}));
+
 const { consultAdvisor } = await import("../consult.js");
 const advisorTool = (await import("../tools/advisor.js")).default;
 const { recordSystemPrompt, recordMessages, resetAdvisorStateForTests } =
@@ -49,6 +71,9 @@ beforeEach(() => {
   responseText = "Use a channel-based worker pool; drain on shutdown.";
   sendMessageError = null;
   providerResolves = true;
+  providerSupportsWeb = false;
+  streamDeltas = [];
+  streamEvents = [];
   resetAdvisorStateForTests();
 });
 
@@ -100,6 +125,104 @@ describe("consultAdvisor", () => {
     expect(options.systemPrompt).toContain("You are a coding agent.");
   });
 
+  test("stays tool-less when the provider has no native web search", async () => {
+    providerSupportsWeb = false;
+    await consultAdvisor({ systemPrompt: null, messages: [userMsg("hi")] });
+    const options = sendMessageArgs?.options as { tools?: unknown };
+    expect(options.tools).toBeUndefined();
+    expect(optionConfig().tool_choice).toEqual({ type: "none" });
+  });
+
+  test("enables native web search when the provider supports it", async () => {
+    providerSupportsWeb = true;
+    await consultAdvisor({ systemPrompt: null, messages: [userMsg("hi")] });
+
+    const options = sendMessageArgs?.options as {
+      tools?: Array<{ name: string }>;
+    };
+    expect(options.tools?.map((t) => t.name)).toEqual(["web_search"]);
+    // tool_choice must not be `none`, or the provider suppresses its server tool.
+    expect(optionConfig().tool_choice).toEqual({ type: "auto" });
+  });
+
+  test("streams web-search activity to onText, not just the final advice", async () => {
+    providerSupportsWeb = true;
+    streamEvents = [
+      { type: "server_tool_start", name: "web_search", toolUseId: "s1", input: {} },
+      {
+        type: "server_tool_complete",
+        toolUseId: "s1",
+        isError: false,
+        resolvedInput: { query: "vellum streaming" },
+      },
+    ];
+    streamDeltas = ["Here is ", "the advice."];
+    const chunks: string[] = [];
+
+    await consultAdvisor({
+      systemPrompt: null,
+      messages: [userMsg("hi")],
+      onText: (c) => chunks.push(c),
+    });
+
+    const joined = chunks.join("");
+    // The drawer isn't silent during the search prefix...
+    expect(joined).toContain("Searching the web");
+    expect(joined).toContain("Searched: vellum streaming");
+    // ...and the advice text still streams.
+    expect(joined).toContain("Here is the advice.");
+  });
+
+  test("surfaces a failure note (not 'Searched') when a web search errors", async () => {
+    providerSupportsWeb = true;
+    streamEvents = [
+      { type: "server_tool_start", name: "web_search", toolUseId: "s1", input: {} },
+      {
+        type: "server_tool_complete",
+        toolUseId: "s1",
+        isError: true,
+        errorCode: "query_too_long",
+        resolvedInput: { query: "an overly long query" },
+      },
+    ];
+    streamDeltas = ["Proceeding without search."];
+    const chunks: string[] = [];
+
+    await consultAdvisor({
+      systemPrompt: null,
+      messages: [userMsg("hi")],
+      onText: (c) => chunks.push(c),
+    });
+
+    const joined = chunks.join("");
+    expect(joined).toContain("Web search failed");
+    expect(joined).not.toContain("🔎 Searched:");
+    // The consult still continues and streams its guidance.
+    expect(joined).toContain("Proceeding without search.");
+  });
+
+  test("streams the model's reasoning summary to onText", async () => {
+    streamEvents = [{ type: "thinking_delta", thinking: "weighing tradeoffs" }];
+    const chunks: string[] = [];
+    await consultAdvisor({
+      systemPrompt: null,
+      messages: [userMsg("hi")],
+      onText: (c) => chunks.push(c),
+    });
+    expect(chunks.join("")).toContain("weighing tradeoffs");
+  });
+
+  test("embeds the runtime context in the advisor system prompt", async () => {
+    await consultAdvisor({
+      systemPrompt: "You are a coding agent.",
+      messages: [userMsg("hi")],
+      runtimeContext: "## Available tools\n- bash — run commands",
+    });
+    const options = sendMessageArgs?.options as { systemPrompt: string };
+    expect(options.systemPrompt).toContain("<agent_runtime_context>");
+    expect(options.systemPrompt).toContain("- bash — run commands");
+  });
+
   test("soft-fails when no provider is configured", async () => {
     providerResolves = false;
     const advice = await consultAdvisor({
@@ -123,6 +246,29 @@ describe("consultAdvisor", () => {
     });
     expect(advice).toContain("no guidance");
   });
+
+  test("streams the model's text deltas to `onText` as it generates", async () => {
+    streamDeltas = ["Use a ", "channel-based ", "worker pool."];
+    const chunks: string[] = [];
+
+    const advice = await consultAdvisor({
+      systemPrompt: null,
+      messages: [userMsg("hi")],
+      onText: (c) => chunks.push(c),
+    });
+
+    // Each visible delta is forwarded live...
+    expect(chunks).toEqual(["Use a ", "channel-based ", "worker pool."]);
+    // ...and the complete guidance is still returned.
+    expect(advice).toBe(responseText);
+  });
+
+  test("registers no `onEvent` sink when `onText` is absent", async () => {
+    streamDeltas = ["x"];
+    await consultAdvisor({ systemPrompt: null, messages: [userMsg("hi")] });
+    const options = sendMessageArgs?.options as { onEvent?: unknown };
+    expect(options.onEvent).toBeUndefined();
+  });
 });
 
 describe("advisor tool.execute", () => {
@@ -150,4 +296,19 @@ describe("advisor tool.execute", () => {
     expect(result?.content).toContain("advisor unavailable");
     expect(result?.content).toContain("kaboom");
   });
+
+  test("streams the consult live via `ctx.onOutput`", async () => {
+    recordMessages("c3", [userMsg("hi")]);
+    streamDeltas = ["plan: ", "do X"];
+    const out: string[] = [];
+
+    const result = await advisorTool.execute?.({}, {
+      conversationId: "c3",
+      onOutput: (c: string) => out.push(c),
+    } as never);
+
+    expect(out).toEqual(["plan: ", "do X"]);
+    expect(result?.isError).toBe(false);
+    expect(result?.content).toBe(responseText);
+  });
 });