@vellumai/assistant 0.10.2 → 0.10.3-dev.202606252046.9075fd5

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

@@ -37,8 +37,8 @@
  *   (optionally overriding the profile) and run inference through the
  *   workspace's configured profiles and credentials — no plugin-supplied API key
  *
- * - {@link PluginInitContext} — passed to `init` hook at bootstrap
- * - {@link PluginShutdownContext} — passed to `shutdown` hook at teardown
+ * - {@link InitContext} — passed to `init` hook at bootstrap
+ * - {@link ShutdownContext} — passed to `shutdown` hook at teardown
  * - {@link UserPromptSubmitContext} — passed to `user-prompt-submit` hook,
  *   fired immediately before the agent loop receives a user's prompt
  * - {@link PostCompactContext} — passed to `post-compact` hook, fired after
@@ -55,7 +55,7 @@
  * - {@link PostModelCallContext} — passed to `post-model-call` hook, fired at
  *   every model-call outcome (a finalized reply or a provider rejection) to
  *   transform content and decide whether to retry
- * - {@link PluginHookFn} — signature every lifecycle hook implements
+ * - {@link HookFunction} — signature every lifecycle hook implements
  * - {@link PluginLogger} — pino-compatible logger shape on the contexts
  * - {@link ToolDefinition} — author-facing tool spec (default-export shape
  *   for both plugin tool files and workspace tool files)
@@ -98,16 +98,16 @@ export type {
 export type { LLMCallSite } from "../config/schemas/llm.js";
 export type {
   AgentLoopExitReason,
+  HookFunction,
+  InitContext,
   ModelProfileInfo,
-  PluginHookFn,
-  PluginInitContext,
   PluginLogger,
-  PluginShutdownContext,
   PostCompactContext,
   PostModelCallContext,
   PostModelCallDecision,
   PostToolUseContext,
   PreModelCallContext,
+  ShutdownContext,
   StopContext,
   ToolContext,
   ToolDefinition,
@@ -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

@@ -57,30 +57,28 @@ export interface PluginLogger {
  * empty model that with `| null`, not `| undefined`.
  *
  * Each known hook key has a documented context shape:
- *   - `init` — {@link PluginInitContext}
- *   - `shutdown` — {@link PluginShutdownContext}
+ *   - `init` — {@link InitContext}
+ *   - `shutdown` — {@link ShutdownContext}
  *   - `user-prompt-submit` — {@link UserPromptSubmitContext}
  *   - `pre-model-call` — {@link PreModelCallContext}
  *   - `post-tool-use` — {@link PostToolUseContext}
  *   - `stop` — {@link StopContext}
  *   - `post-model-call` — {@link PostModelCallContext}
  */
-export type PluginHookFn<TCtx = unknown> = (
+export type HookFunction<TCtx = unknown> = (
   ctx: TCtx,
 ) => Promise<Partial<TCtx> | void>;
 
 // ─── 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 {
+export interface InitContext {
   /** 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). */
@@ -127,7 +125,7 @@ export interface ModelProfileInfo {
 
 /**
  * Context passed to the `shutdown` hook during daemon teardown. Kept
- * intentionally narrower than {@link PluginInitContext} — most teardown
+ * intentionally narrower than {@link InitContext} — most teardown
  * paths only need to know which assistant version they're shutting
  * down against (e.g. for version-conditional cleanup of state files
  * written by a previous boot).
@@ -137,7 +135,7 @@ export interface ModelProfileInfo {
  * stash a version stamp at init can compare against the same name on
  * tear-down without keeping their own copy.
  */
-export interface PluginShutdownContext {
+export interface ShutdownContext {
   /** Assistant semver for compatibility checks inside the plugin. */
   assistantVersion: string;
 }
@@ -153,7 +151,7 @@ export interface PluginShutdownContext {
  *
  * The hook may transform `latestMessages` either by mutating it in place
  * (`push` / `splice` / `length = 0`) or by returning a new context with
- * a fresh `latestMessages` array — see {@link PluginHookFn}'s polymorphic
+ * a fresh `latestMessages` array — see {@link HookFunction}'s polymorphic
  * return shape. The daemon threads the final `latestMessages` value into
  * `agentLoop.run()` as the run-messages argument.
  *
@@ -246,7 +244,7 @@ export interface UserPromptSubmitContext {
  * their own injected context the same way.
  *
  * The hook re-injects by mutating `history` in place (or returning a new
- * context with a replacement `history`) — see {@link PluginHookFn}'s
+ * context with a replacement `history`) — see {@link HookFunction}'s
  * polymorphic return shape. The agent loop reads the settled `history` back off
  * the context and resumes the turn from it. Multiple plugins' hooks chain in
  * registration order, each seeing the previous plugin's edits.
@@ -303,7 +301,7 @@ export interface PostCompactContext {
  *
  * The hook may transform the result either by mutating `toolResponse` in
  * place (e.g. reassigning `toolResponse.content`) or by returning a new
- * context with a fresh `toolResponse` — see {@link PluginHookFn}'s
+ * context with a fresh `toolResponse` — see {@link HookFunction}'s
  * polymorphic return shape. The daemon threads the final `toolResponse`
  * into the provider-bound history.
  *

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/empty-response/hooks/post-model-call.ts

@@ -46,7 +46,7 @@
  * ignores the decision — so the hook returns early for both.
  */
 
-import type { PluginHookFn, PostModelCallContext } from "@vellumai/plugin-api";
+import type { HookFunction, PostModelCallContext } from "@vellumai/plugin-api";
 
 import type { ContentBlock, Message } from "../../../../providers/types.js";
 import {
@@ -112,7 +112,7 @@ function currentCycleMessages(
   return messages;
 }
 
-const postModelCall: PluginHookFn<PostModelCallContext> = async (ctx) => {
+const postModelCall: HookFunction<PostModelCallContext> = async (ctx) => {
   // A provider rejection carries no turn content to assess (a recovery hook
   // owns the rejection); the sibling `stop` hook clears the mark when the turn
   // terminates.

package/src/plugins/defaults/empty-response/hooks/stop.ts

@@ -11,11 +11,11 @@
  * refused).
  */
 
-import type { PluginHookFn, StopContext } from "@vellumai/plugin-api";
+import type { HookFunction, StopContext } from "@vellumai/plugin-api";
 
 import { clearEmptyResponseNudged } from "../nudge-state-store.js";
 
-const stop: PluginHookFn<StopContext> = async (ctx) => {
+const stop: HookFunction<StopContext> = async (ctx) => {
   clearEmptyResponseNudged(ctx.conversationId);
 };
 

package/src/plugins/defaults/exploration-drift/hooks/post-tool-use.ts

@@ -1,6 +1,6 @@
 /**
  * Default `post-tool-use` hook: when a turn's exploration tool calls (bash,
- * file_read, file_list) show drift — a long unbroken run with no text sent to
+ * code_search, file_read, file_list) show drift — a long unbroken run with no text sent to
  * the user, or the model re-issuing the exact same call — surface a notice
  * via `additionalContext` that coaches it to (a) give the user a brief
  * progress summary and (b) delegate the rest of the investigation to an
@@ -55,7 +55,7 @@
  * per-tool-result hot path.
  */
 
-import type { PluginHookFn, PostToolUseContext } from "@vellumai/plugin-api";
+import type { HookFunction, PostToolUseContext } from "@vellumai/plugin-api";
 
 import type { Message } from "../../../../providers/types.js";
 
@@ -105,6 +105,7 @@ const LOOP_PRONE_MODEL_PATTERN = /kimi-k2[p.]6|minimax-m3/i;
 /** Read-only exploration tools whose unbroken runs indicate inline drift. */
 const EXPLORATION_TOOL_NAMES: ReadonlySet<string> = new Set([
   "bash",
+  "code_search",
   "file_read",
   "file_list",
 ]);
@@ -232,7 +233,7 @@ function currentCallRepeatCount(
   return count;
 }
 
-const postToolUse: PluginHookFn<PostToolUseContext> = async (ctx) => {
+const postToolUse: HookFunction<PostToolUseContext> = async (ctx) => {
   const usesById = toolUsesById(ctx.messages);
   const currentUse = usesById.get(ctx.toolResponse.tool_use_id);
   if (currentUse === undefined || !EXPLORATION_TOOL_NAMES.has(currentUse.name))

package/src/plugins/defaults/history-repair/hooks/post-model-call.ts

@@ -23,7 +23,7 @@
  * empty-response hook; only a provider rejection is this hook's to act on.
  */
 
-import type { PluginHookFn, PostModelCallContext } from "@vellumai/plugin-api";
+import type { HookFunction, PostModelCallContext } from "@vellumai/plugin-api";
 
 import {
   isOrderingRepairAttempted,
@@ -31,7 +31,7 @@ import {
 } from "../repair-state-store.js";
 import { deepRepairHistory, isRepairableOrderingError } from "../terminal.js";
 
-const postModelCall: PluginHookFn<PostModelCallContext> = async (ctx) => {
+const postModelCall: HookFunction<PostModelCallContext> = async (ctx) => {
   if (
     ctx.error &&
     isRepairableOrderingError(ctx.error.message) &&

package/src/plugins/defaults/history-repair/hooks/stop.ts

@@ -11,11 +11,11 @@
  * retry the loop's per-run backstop refused).
  */
 
-import type { PluginHookFn, StopContext } from "@vellumai/plugin-api";
+import type { HookFunction, StopContext } from "@vellumai/plugin-api";
 
 import { clearOrderingRepairAttempted } from "../repair-state-store.js";
 
-const stop: PluginHookFn<StopContext> = async (ctx) => {
+const stop: HookFunction<StopContext> = async (ctx) => {
   clearOrderingRepairAttempted(ctx.conversationId);
 };