@vellumai/assistant 0.10.3 → 0.10.4-staging.1

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

@@ -1,138 +0,0 @@
-import { beforeEach, describe, expect, test } from "bun:test";
-
-import type {
-  Message,
-  PostModelCallContext,
-  PreModelCallContext,
-  UserPromptSubmitContext,
-} from "@vellumai/plugin-api";
-
-import {
-  getCapture,
-  resetAdvisorStateForTests,
-} from "../advisor-state-store.js";
-import postModelCall from "../hooks/post-model-call.js";
-import preModelCall from "../hooks/pre-model-call.js";
-import userPromptSubmit from "../hooks/user-prompt-submit.js";
-import { STEERING_MARKER } from "../steering.js";
-
-const logger = { info() {}, warn() {}, error() {}, debug() {} };
-const userMsg = (t: string): Message => ({
-  role: "user",
-  content: [{ type: "text", text: t }],
-});
-
-beforeEach(() => {
-  resetAdvisorStateForTests();
-});
-
-describe("pre-model-call hook", () => {
-  test("records the original system prompt and injects steering on mainAgent", async () => {
-    const ctx = {
-      conversationId: "c1",
-      callSite: "mainAgent",
-      systemPrompt: "BASE PROMPT",
-      deferAssistantOutput: false,
-      logger,
-    } as unknown as PreModelCallContext;
-
-    await preModelCall(ctx);
-
-    expect(ctx.systemPrompt).toContain(STEERING_MARKER);
-    expect(ctx.systemPrompt?.startsWith("BASE PROMPT")).toBe(true);
-    expect(getCapture("c1")?.systemPrompt).toBe("BASE PROMPT");
-  });
-
-  test("ignores non-mainAgent calls", async () => {
-    const ctx = {
-      conversationId: "bg",
-      callSite: "inference",
-      systemPrompt: "BG",
-      deferAssistantOutput: false,
-      logger,
-    } as unknown as PreModelCallContext;
-
-    await preModelCall(ctx);
-    expect(ctx.systemPrompt).toBe("BG");
-    expect(getCapture("bg")).toBeUndefined();
-  });
-});
-
-describe("post-model-call hook", () => {
-  const base = {
-    content: [],
-    stopReason: "end_turn",
-    decision: "stop" as const,
-    logger,
-  };
-
-  test("snapshots the transcript on mainAgent", async () => {
-    const messages = [userMsg("hi")];
-    await postModelCall({
-      ...base,
-      conversationId: "c1",
-      callSite: "mainAgent",
-      messages,
-    } as unknown as PostModelCallContext);
-    expect(getCapture("c1")?.messages).toEqual(messages);
-  });
-
-  test("appends the model's current turn (ctx.content) to the snapshot", async () => {
-    const messages = [userMsg("task")];
-    const assistantTurn: Message = {
-      role: "assistant",
-      content: [
-        { type: "text", text: "thinking about it" },
-        { type: "tool_use", id: "t1", name: "advisor", input: {} },
-      ],
-    };
-    await postModelCall({
-      ...base,
-      content: assistantTurn.content,
-      conversationId: "c4",
-      callSite: "mainAgent",
-      messages,
-    } as unknown as PostModelCallContext);
-    const captured = getCapture("c4")?.messages;
-    expect(captured).toHaveLength(2);
-    expect(captured?.[1]).toEqual(assistantTurn);
-  });
-
-  test("ignores the advisor's own inference sub-call (recursion safety) and errors", async () => {
-    await postModelCall({
-      ...base,
-      conversationId: "c2",
-      callSite: "inference",
-      messages: [userMsg("hi")],
-    } as unknown as PostModelCallContext);
-    expect(getCapture("c2")).toBeUndefined();
-
-    await postModelCall({
-      ...base,
-      conversationId: "c3",
-      callSite: "mainAgent",
-      messages: [userMsg("hi")],
-      error: new Error("boom"),
-      stopReason: null,
-    } as unknown as PostModelCallContext);
-    expect(getCapture("c3")).toBeUndefined();
-  });
-});
-
-describe("user-prompt-submit hook", () => {
-  test("seeds the capture with the inbound history", async () => {
-    const messages = [userMsg("task")];
-    await userPromptSubmit({
-      conversationId: "c1",
-      latestMessages: messages,
-      originalMessages: messages,
-      prompt: "task",
-      userMessageId: "u1",
-      requestId: "r1",
-      modelProfileKey: null,
-      isNonInteractive: false,
-      logger,
-    } as unknown as UserPromptSubmitContext);
-    expect(getCapture("c1")?.messages).toEqual(messages);
-  });
-});

package/src/plugins/defaults/advisor/advisor-gate.ts

@@ -1,29 +0,0 @@
-/**
- * Per-chat-profile gate for the advisor.
- *
- * The advisor is active or not depending on the chat profile the turn routes
- * to (`ProfileEntry.advisorEnabled`). Default-on: the advisor runs unless a
- * profile sets `advisorEnabled: false` explicitly — absent/null both mean on,
- * preserving the prior always-on behavior for profiles that never set it.
- */
-
-import { resolveDefaultProfileKey } from "../../../config/llm-resolver.js";
-import { getConfig } from "../../../config/loader.js";
-
-/**
- * Whether the advisor is enabled for the chat profile this turn uses.
- *
- * `modelProfile` is the call's already-resolved profile — `PreModelCallContext.modelProfile`
- * from the steering hook, or `ToolContext.overrideProfile` from the tool. Pass
- * `null` when no per-turn override applies, in which case the workspace active
- * profile — or the `mainAgent` call-site default — applies.
- */
-export function advisorEnabledForProfile(modelProfile: string | null): boolean {
-  const { llm } = getConfig();
-  const key =
-    modelProfile ??
-    llm.activeProfile ??
-    resolveDefaultProfileKey("mainAgent", llm);
-  const entry = key ? llm.profiles[key] : undefined;
-  return entry?.advisorEnabled !== false;
-}

package/src/plugins/defaults/advisor/advisor-state-store.ts

@@ -1,94 +0,0 @@
-/**
- * Per-conversation capture store for the advisor plugin.
- *
- * A tool's `execute` does not receive the conversation transcript — only
- * lifecycle hooks do. So the hooks snapshot what the executor saw (the system
- * prompt from `pre-model-call`, the running transcript from `post-model-call`)
- * into this module-level store, keyed by conversation id, and the `advisor`
- * tool reads the latest snapshot when the model calls it. This reproduces the
- * advisor-tool property that the model calls the tool with no arguments and the
- * full context is supplied for it.
- *
- * Bounded by a small LRU so a long-lived daemon does not accumulate state for
- * every conversation it has ever served.
- */
-
-import type { Message } from "../../../providers/types.js";
-
-export interface AdvisorCapture {
-  /** The executor's system prompt (steering stripped), or null if unseen. */
-  systemPrompt: string | null;
-  /** The transcript the executor most recently saw on a `mainAgent` call. */
-  messages: Message[];
-  /** Last-write timestamp, used for LRU eviction. */
-  updatedAt: number;
-}
-
-const MAX_CONVERSATIONS = 200;
-const store = new Map<string, AdvisorCapture>();
-
-/** Move an entry to most-recently-used and evict the oldest past the cap. */
-function bump(conversationId: string, entry: AdvisorCapture): void {
-  entry.updatedAt = Date.now();
-  store.delete(conversationId);
-  store.set(conversationId, entry);
-  while (store.size > MAX_CONVERSATIONS) {
-    const oldest = store.keys().next().value;
-    if (oldest === undefined) break;
-    store.delete(oldest);
-  }
-}
-
-function ensure(conversationId: string): AdvisorCapture {
-  return (
-    store.get(conversationId) ?? {
-      systemPrompt: null,
-      messages: [],
-      updatedAt: Date.now(),
-    }
-  );
-}
-
-/**
- * Seed the capture at the start of a user turn with the inbound history, so an
- * advisor call on the very first model turn still has context even before
- * `post-model-call` snapshots the running transcript.
- */
-export function seedCapture(
-  conversationId: string,
-  messages: ReadonlyArray<Message>,
-): void {
-  const entry = ensure(conversationId);
-  entry.messages = [...messages];
-  bump(conversationId, entry);
-}
-
-/** Record the executor's system prompt (steering already stripped). */
-export function recordSystemPrompt(
-  conversationId: string,
-  systemPrompt: string | null,
-): void {
-  const entry = ensure(conversationId);
-  entry.systemPrompt = systemPrompt;
-  bump(conversationId, entry);
-}
-
-/** Snapshot the transcript the executor just saw (before tools run). */
-export function recordMessages(
-  conversationId: string,
-  messages: ReadonlyArray<Message>,
-): void {
-  const entry = ensure(conversationId);
-  entry.messages = [...messages];
-  bump(conversationId, entry);
-}
-
-/** The latest capture for a conversation, or `undefined` if none recorded. */
-export function getCapture(conversationId: string): AdvisorCapture | undefined {
-  return store.get(conversationId);
-}
-
-/** Test-only: clear all captured state. */
-export function resetAdvisorStateForTests(): void {
-  store.clear();
-}

package/src/plugins/defaults/advisor/config.ts

@@ -1,21 +0,0 @@
-/**
- * Static behavioral configuration for the advisor.
- *
- * The advisor *model* is no longer hardcoded here: it routes through the
- * dedicated `advisor` call site, whose default profile (`quality-optimized`)
- * lives in CALL_SITE_DEFAULTS and is overridden per workspace by
- * `llm.advisorProfile`. Whether the advisor is active is decided per chat
- * profile by `ProfileEntry.advisorEnabled` (default on).
- */
-export const ADVISOR_CONFIG = {
-  // No advisor-specific output cap: the consult omits `max_tokens` (so the
-  // resolver applies the profile's normal output budget) and the request text
-  // carries no word limit. The advisor decides its own length.
-  /** Abort the consult if the sub-call runs longer than this. */
-  timeoutMs: 60_000,
-  /**
-   * Global kill-switch for the steering injection. The per-chat-profile
-   * `advisorEnabled` toggle gates it further; this stays as a hard off switch.
-   */
-  steeringEnabled: true,
-} as const;

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

@@ -1,197 +0,0 @@
-/**
- * Run one advisor consult.
- *
- * Routed entirely through the assistant's own inference: `getConfiguredProvider`
- * resolves the general-purpose `inference` call site (with the advisor profile
- * applied as an `overrideProfile`) to a provider/model/credentials from the
- * configured profiles — managed-proxy or BYOK, no separate API key. The consult
- * then runs a tool-less, capped one-shot completion through `provider.sendMessage`
- * and returns the text.
- */
-
-import { getConfig } from "../../../config/loader.js";
-import type { LLMCallSite } from "../../../config/schemas/llm.js";
-import {
-  extractAllText,
-  getConfiguredProvider,
-  userMessage,
-} from "../../../providers/provider-send-message.js";
-import type {
-  Message,
-  ProviderEvent,
-  ToolDefinition,
-} from "../../../providers/types.js";
-import { ADVISOR_CONFIG } from "./config.js";
-import { advisorRequestText, buildAdvisorSystem } from "./steering.js";
-import { toAdvisorMessages } from "./transcript.js";
-
-// Dedicated advisor call site. Its default profile (`quality-optimized`) lives
-// in CALL_SITE_DEFAULTS; a workspace overrides which profile the advisor runs
-// on via `llm.advisorProfile`, which we float above the call-site layers.
-const ADVISOR_CALL_SITE: LLMCallSite = "advisor";
-
-/**
- * The single tool the consult may attach: a `web_search`-named tool that
- * provider-native search (Anthropic/OpenAI) substitutes for its server-side
- * web tool. Only passed when `provider.supportsNativeWebSearch` is true, so the
- * provider runs the search itself and returns results inline — no agent loop,
- * which keeps the consult a one-shot completion.
- */
-const ADVISOR_WEB_SEARCH_TOOL: ToolDefinition = {
-  name: "web_search",
-  description:
-    "Search the web for current information to ground your guidance.",
-  input_schema: {
-    type: "object",
-    properties: {
-      query: { type: "string", description: "The search query." },
-    },
-    required: ["query"],
-  },
-};
-
-/**
- * Resolve the routing override for the advisor consult. When the workspace has
- * set `llm.advisorProfile`, force it above the call-site layers so it is
- * authoritative; otherwise return `{}` so the `advisor` call site resolves to
- * its default profile.
- */
-function advisorOverride(): {
-  overrideProfile?: string;
-  forceOverrideProfile?: boolean;
-} {
-  const advisorProfile = getConfig().llm.advisorProfile;
-  return advisorProfile
-    ? { overrideProfile: advisorProfile, forceOverrideProfile: true }
-    : {};
-}
-
-export interface ConsultParams {
-  systemPrompt: string | null;
-  messages: ReadonlyArray<Message>;
-  /**
-   * The agent's runtime context (available tools and skills, workspace/project
-   * context, recalled memory), gathered by the tool from its `ToolContext`.
-   * Embedded in the advisor's system prompt so its advice is grounded in what
-   * the agent can actually do. Omitted/null when nothing could be gathered.
-   */
-  runtimeContext?: string | null;
-  signal?: AbortSignal;
-  /**
-   * Optional sink for the advisor's live activity as it generates: incremental
-   * advice text, the reasoning summary (when surfaced), and a note per web
-   * search. Wiring this to the tool's `onOutput` surfaces the consult live as
-   * `tool_output_chunk` while the advisor is still working; the complete
-   * guidance is still returned as the resolved string. See `advisorActivitySink`.
-   */
-  onText?: (chunk: string) => void;
-}
-
-/** Combine the caller's signal with a consult timeout. */
-function withTimeout(signal: AbortSignal | undefined, ms: number): AbortSignal {
-  const timeout = AbortSignal.timeout(ms);
-  return signal ? AbortSignal.any([signal, timeout]) : timeout;
-}
-
-/**
- * Build the streaming sink for a consult: forward the advisor's live activity
- * to `onText` so the tool-output drawer streams throughout the consult instead
- * of sitting silent until the final advice lands.
- *
- * The consult searches the web (up to 5×) and reasons over full context before
- * writing its guidance. Forwarding the visible advice text alone would leave
- * the drawer blank for that whole prefix, so the sink also surfaces the
- * reasoning summary (when the model emits one) and a one-line note per web
- * search — a success note with the query, or a failure note when the search
- * errors. The complete guidance is still returned by `consultAdvisor`; the
- * renderer swaps it in once the tool result arrives.
- */
-function advisorActivitySink(
-  onText: (chunk: string) => void,
-): (event: ProviderEvent) => void {
-  return (event) => {
-    switch (event.type) {
-      case "text_delta":
-        if (event.text) onText(event.text);
-        break;
-      case "thinking_delta":
-        if (event.thinking) onText(event.thinking);
-        break;
-      case "server_tool_start":
-        if (event.name === "web_search") onText("\n🔎 Searching the web…\n");
-        break;
-      case "server_tool_complete": {
-        const rawQuery = event.resolvedInput?.["query"];
-        const query = typeof rawQuery === "string" ? rawQuery.trim() : "";
-        if (event.isError) {
-          // A failed search (e.g. `query_too_long`, `max_uses_exceeded`) must
-          // not be announced as a success — the advisor proceeds without it.
-          onText(
-            query
-              ? `\n⚠️ Web search failed: ${query}\n`
-              : "\n⚠️ Web search failed.\n",
-          );
-        } else if (query) {
-          onText(`\n🔎 Searched: ${query}\n`);
-        }
-        break;
-      }
-      default:
-        break;
-    }
-  };
-}
-
-/**
- * Returns the advisor's guidance text, or a short benign notice when the
- * advisor can't run. Callers should surface the string as a non-error tool
- * result so the executor continues regardless.
- */
-export async function consultAdvisor(params: ConsultParams): Promise<string> {
-  const history = toAdvisorMessages(params.messages);
-  if (history.length === 0) {
-    return "(advisor: no conversation context is available yet)";
-  }
-
-  const override = advisorOverride();
-
-  const provider = await getConfiguredProvider(ADVISOR_CALL_SITE, override);
-  if (!provider) {
-    return "(advisor unavailable: no inference provider is configured)";
-  }
-
-  // Append the consult instruction as the final user turn, then run a
-  // completion through the resolved provider. No `max_tokens` is set, so the
-  // resolver applies the profile's normal output budget rather than an
-  // advisor-specific cap.
-  const messages: Message[] = [...history, userMessage(advisorRequestText())];
-
-  // Give the advisor live web access when — and only when — the resolved
-  // provider runs search server-side (provider-native). Passing a `web_search`
-  // tool to a non-native provider would surface a client tool call this
-  // one-shot consult cannot execute, so we gate strictly on the capability and
-  // otherwise keep the consult tool-less.
-  const webEnabled = provider.supportsNativeWebSearch === true;
-
-  const { onText } = params;
-  const response = await provider.sendMessage(messages, {
-    systemPrompt: buildAdvisorSystem(
-      params.systemPrompt,
-      params.runtimeContext,
-    ),
-    ...(webEnabled ? { tools: [ADVISOR_WEB_SEARCH_TOOL] } : {}),
-    // Stream the consult's activity live (advice text, reasoning summary, and a
-    // note per web search) so the drawer isn't blank while the advisor searches
-    // and reasons before writing its guidance. See `advisorActivitySink`.
-    onEvent: onText ? advisorActivitySink(onText) : undefined,
-    config: {
-      callSite: ADVISOR_CALL_SITE,
-      ...override,
-      tool_choice: webEnabled ? { type: "auto" } : { type: "none" },
-    },
-    signal: withTimeout(params.signal, ADVISOR_CONFIG.timeoutMs),
-  });
-
-  const advice = extractAllText(response).trim();
-  return advice.length > 0 ? advice : "(advisor returned no guidance)";
-}