@vellumai/assistant 0.10.9-staging.1 → 0.10.9

package/src/monitoring/plugin-source-watch.ts

@@ -157,6 +157,46 @@ export function createSourceWatchState(): SourceWatchState {
   };
 }
 
+/**
+ * Compile every multi-file app bundled by a plugin from its `apps/<app>/src`
+ * into the sibling `apps/<app>/dist`. Single-file apps (a root `index.html`,
+ * no `src/`) need no build and are skipped.
+ *
+ * Runs here — off the daemon's hot path — because the monitor has just detected
+ * the change. The generated `dist/` is excluded from the source fingerprint
+ * ({@link isGeneratedAppBuildDir}), so writing it does not re-trigger a pass.
+ * The bundler (esbuild) is imported lazily so the monitor only pulls it in when
+ * a plugin actually ships a buildable app.
+ */
+export async function compilePluginApps(pluginDir: string): Promise<void> {
+  const appsDir = join(pluginDir, "apps");
+  let appEntries: string[];
+  try {
+    appEntries = readdirSync(appsDir);
+  } catch {
+    return; // No apps/ directory — nothing to build.
+  }
+  const buildable = appEntries.filter((app) => {
+    const appDir = join(appsDir, app);
+    try {
+      return statSync(appDir).isDirectory() && existsSync(join(appDir, "src"));
+    } catch {
+      return false;
+    }
+  });
+  if (buildable.length === 0) {
+    return;
+  }
+  const { compileApp } = await import("../bundler/app-compiler.js");
+  for (const app of buildable) {
+    const appDir = join(appsDir, app);
+    const result = await compileApp(appDir);
+    if (!result.ok) {
+      log.warn({ appDir, errors: result.errors }, "plugin app compile failed");
+    }
+  }
+}
+
 /**
  * Run one detection pass: walk, compare against the last published state,
  * and rewrite the sentinel if anything changed. Returns whether a rewrite
@@ -202,6 +242,19 @@ export function runSourceWatchPass(state: SourceWatchState): boolean {
       { generation: state.generation, changedDirs },
       "plugin source change published",
     );
+
+    // Rebuild multi-file apps for each changed, enabled plugin. Fire-and-forget
+    // so a slow build never stalls the watch loop; the generated dist is
+    // excluded from the fingerprint, so it does not re-trigger this pass.
+    for (const dir of changedDirs) {
+      const version = current[dir];
+      if (version !== undefined && !version.disabled) {
+        void compilePluginApps(dir).catch((err) => {
+          log.error({ err, dir }, "plugin app compile pass failed");
+        });
+      }
+    }
+
     return true;
   } catch (err) {
     log.error({ err }, "plugin source watch pass failed — will retry");

package/src/oauth/seed-providers.ts

@@ -131,6 +131,12 @@ export const PROVIDER_SEED_DATA: Record<
         headerName: "Authorization",
         valuePrefix: "Bearer ",
       },
+      {
+        hostPattern: "docs.googleapis.com",
+        injectionType: "header",
+        headerName: "Authorization",
+        valuePrefix: "Bearer ",
+      },
     ],
     revokeUrl: "https://oauth2.googleapis.com/revoke",
     revokeBodyTemplate: { token: "{access_token}" },

package/src/persistence/embeddings/__tests__/messages-lexical-index.test.ts

@@ -143,6 +143,9 @@ describe("MessagesLexicalIndex", () => {
     expect(config.vectors).toBeUndefined();
     expect("vectors" in config).toBe(false);
 
+    // Explicit segment count — never Qdrant's CPU-count auto-detection.
+    expect(config.optimizers_config).toEqual({ default_segment_number: 2 });
+
     // Payload indexes on conversation_id (keyword) + created_at (integer).
     const fields = payloadIndexCalls.map((c) => c.field_name);
     expect(fields).toContain("conversation_id");

package/src/persistence/embeddings/messages-lexical-index.ts

@@ -23,6 +23,14 @@ export const MESSAGES_LEXICAL_COLLECTION = "messages_lexical";
  */
 const MESSAGE_POINT_NAMESPACE = "b6d0d3e2-1f1a-4c3e-9a7c-0e2f5a8d4c11";
 
+/**
+ * Explicit segment count for the collection. Left unset, Qdrant sizes the
+ * segment count to the node's CPU count, and each segment carries a fixed
+ * storage preallocation — a small sparse-only collection then idles at
+ * hundreds of MB. Matches the v2 concept-pages collection.
+ */
+const DEFAULT_SEGMENT_NUMBER = 2;
+
 export interface MessagesLexicalIndexConfig {
   url: string;
   collection?: string;
@@ -113,6 +121,9 @@ export class MessagesLexicalIndex {
           // payloads.
           sparse: { index: { on_disk: this.onDisk } },
         },
+        optimizers_config: {
+          default_segment_number: DEFAULT_SEGMENT_NUMBER,
+        },
         on_disk_payload: this.onDisk,
       });
     } catch (err) {

package/src/plugin-api/conversation-turn.ts

@@ -0,0 +1,234 @@
+/**
+ * Plugin-facing facade for running a full conversation agent-loop turn.
+ *
+ * This is the conversation-scoped equivalent of the daemon's
+ * `processMessage` path: it persists a user message, runs the agent loop
+ * (with all its machinery -- system prompt construction, conversation
+ * history, tool use cycles, compaction, injections), and returns the
+ * assistant's full content-block response.
+ *
+ * Plugins that need to drive conversation turns (e.g. meeting-bot
+ * flushing a transcript excerpt) should prefer this over the stateless
+ * `provider.sendMessage()` call, which has no history, no tools, and no
+ * context management.
+ */
+
+import type { LLMCallSite } from "../config/schemas/llm.js";
+import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { UserMessageAttachment } from "../daemon/message-types/shared.js";
+import type { ContentBlock, MediaSource } from "../providers/types.js";
+
+// ---------------------------------------------------------------------------
+// Public types
+// ---------------------------------------------------------------------------
+
+export interface RunConversationTurnOptions {
+  /**
+   * Conversation to run the turn in. If omitted, a new conversation is
+   * created (its ID is generated with `uuidv7` and returned in the result).
+   */
+  conversationId?: string;
+  /**
+   * User message content blocks for this turn. Text blocks become the
+   * user message body; image/file blocks are resolved to inline
+   * attachments. Other block types (tool_use, tool_result, thinking) are
+   * ignored as they are not valid user input.
+   */
+  content: ContentBlock[];
+  /**
+   * LLM call-site for inference profile resolution. Defaults to
+   * `"mainAgent"` inside the agent loop when omitted.
+   */
+  callSite?: LLMCallSite;
+  /**
+   * Abort signal. When aborted, the conversation's internal abort
+   * controller fires, terminating the in-flight agent loop.
+   */
+  signal?: AbortSignal;
+}
+
+export interface RunConversationTurnResult {
+  /** The assistant's full content blocks for this turn (text, tool_use, etc.). */
+  content: ContentBlock[];
+  /** The user message row ID assigned by the persistence layer. */
+  userMessageId: string;
+  /** The conversation this turn ran in. */
+  conversationId: string;
+  /** True when the message was queued because the conversation was busy. */
+  queued?: boolean;
+}
+
+// ---------------------------------------------------------------------------
+// Content conversion
+// ---------------------------------------------------------------------------
+
+/**
+ * Extract a plain-text content string and attachment list from
+ * {@link ContentBlock} input. Text blocks are concatenated (newline
+ * separated); image and file blocks are converted to
+ * {@link UserMessageAttachment} entries with their media source resolved
+ * to inline base64. Other block types are ignored.
+ */
+function extractContentAndAttachments(
+  blocks: ContentBlock[],
+  resolveMedia: (source: MediaSource) => { data: string; media_type: string } | null,
+): { text: string; attachments: UserMessageAttachment[] } {
+  const textParts: string[] = [];
+  const attachments: UserMessageAttachment[] = [];
+
+  for (const block of blocks) {
+    if (block.type === "text") {
+      textParts.push(block.text);
+    } else if (block.type === "image" || block.type === "file") {
+      const source = block.source;
+      const resolved = resolveMedia(source);
+      if (resolved) {
+        attachments.push({
+          filename:
+            source.filename ?? (block.type === "image" ? "image" : "file"),
+          mimeType: resolved.media_type,
+          data: resolved.data,
+          ...(block.type === "file" && block.extracted_text
+            ? { extractedText: block.extracted_text }
+            : {}),
+        });
+      }
+    }
+  }
+
+  return { text: textParts.join("\n"), attachments };
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Run a full conversation agent-loop turn: persist the user message, execute
+ * the agent loop (history, tools, compaction, injections), and return the
+ * assistant's full content-block response.
+ *
+ * When `conversationId` is omitted, a new conversation is created and its ID
+ * is returned in the result.
+ *
+ * Events are fanned out to SSE/event-hub subscribers via `broadcastMessage`
+ * (the same path the daemon's HTTP message route uses) while also being
+ * collected internally so the caller receives the final response content.
+ * For streaming use cases, subscribe to the conversation's events via the
+ * host event hub (`assistantEventHub`).
+ *
+ * If the conversation is currently processing another turn, the message is
+ * queued via `enqueueMessage` and the result carries `queued: true` with
+ * empty content -- the queued turn will execute automatically when the
+ * current turn finishes.
+ */
+export async function runConversationTurn(
+  options: RunConversationTurnOptions,
+): Promise<RunConversationTurnResult> {
+  const { v7: uuidv7 } = await import("uuid");
+  const { getOrCreateConversation } = await import(
+    "../daemon/conversation-store.js"
+  );
+  const { broadcastMessage } = await import(
+    "../runtime/assistant-event-hub.js"
+  );
+  const { resolveMediaSourceData } = await import(
+    "../providers/media-resolve.js"
+  );
+  const { getMessageById, getMessages } = await import(
+    "../persistence/conversation-crud.js"
+  );
+
+  const conversationId = options.conversationId ?? uuidv7();
+  const conversation = await getOrCreateConversation(conversationId);
+
+  // Wire the external abort signal to the conversation's internal abort
+  // controller so aborting the signal terminates the in-flight agent loop.
+  if (options.signal) {
+    options.signal.addEventListener("abort", () => {
+      conversation.abortController?.abort();
+    });
+  }
+
+  // Convert ContentBlock[] input to the text + attachments shape the
+  // conversation's processMessage path expects.
+  const { text, attachments } = extractContentAndAttachments(
+    options.content,
+    resolveMediaSourceData,
+  );
+
+  // Build the event emitter: fan out to SSE/event-hub subscribers via
+  // broadcastMessage, then invoke the collector callback. This mirrors the
+  // buildEventEmitter pattern from process-message.ts so plugin-driven
+  // turns reach the same subscribers as HTTP-driven turns.
+  let assistantMessageId: string | undefined;
+  const onEvent = (msg: ServerMessage): void => {
+    broadcastMessage(msg, conversationId);
+    if (msg.type === "message_complete" && msg.messageId) {
+      assistantMessageId = msg.messageId;
+    }
+  };
+
+  // When the conversation is busy, enqueue the message instead of rejecting.
+  // The queue is drained automatically when the current turn finishes.
+  if (conversation.isProcessing()) {
+    const requestId = uuidv7();
+    const enqueueResult = conversation.enqueueMessage({
+      content: text,
+      attachments,
+      onEvent,
+      requestId,
+      isInteractive: false,
+    });
+    if (enqueueResult.rejected) {
+      throw new Error(
+        "Conversation is busy and its message queue is full. Try again later.",
+      );
+    }
+    return {
+      content: [],
+      userMessageId: requestId,
+      conversationId,
+      queued: true,
+    };
+  }
+
+  const userMessageId = await conversation.processMessage({
+    content: text,
+    attachments,
+    onEvent,
+    isInteractive: false,
+    ...(options.callSite ? { callSite: options.callSite } : {}),
+  });
+
+  // Retrieve the assistant's full content blocks from the persisted
+  // message row. The message_complete event carries the assistant
+  // message ID; if it was captured, use it directly. Otherwise fall back
+  // to scanning the conversation's messages for the first assistant
+  // message after our user message.
+  let assistantContent: ContentBlock[] = [];
+  if (assistantMessageId) {
+    const assistantRow = getMessageById(assistantMessageId, conversationId);
+    if (assistantRow) {
+      assistantContent = assistantRow.content;
+    }
+  }
+  if (assistantContent.length === 0) {
+    const allMessages = getMessages(conversationId);
+    const userIdx = allMessages.findIndex((m) => m.id === userMessageId);
+    if (userIdx >= 0) {
+      for (let i = allMessages.length - 1; i > userIdx; i--) {
+        if (allMessages[i].role === "assistant") {
+          assistantContent = allMessages[i].content;
+          break;
+        }
+      }
+    }
+  }
+
+  return {
+    content: assistantContent,
+    userMessageId,
+    conversationId,
+  };
+}

package/src/plugin-api/index.ts

@@ -244,3 +244,15 @@ export {
 export type { SynthesizeTextOptions } from "../tts/synthesize-text.js";
 export { synthesizeText, TtsSynthesisError } from "../tts/synthesize-text.js";
 export type { TtsSynthesisResult } from "../tts/types.js";
+// Conversation agent-loop turn — run a full conversation turn (persist user
+// message, execute the agent loop with history/tools/compaction/injections,
+// return the assistant's full content-block response). Accepts ContentBlock[]
+// input (text, images, files) and an optional conversationId (creates a new
+// conversation when omitted). Plugins that need to drive conversation turns
+// (e.g. meeting-bot flushing a transcript excerpt) should prefer this over the
+// stateless `provider.sendMessage()` call.
+export type {
+  RunConversationTurnOptions,
+  RunConversationTurnResult,
+} from "./conversation-turn.js";
+export { runConversationTurn } from "./conversation-turn.js";

package/src/plugins/__tests__/source-fingerprint.test.ts

@@ -81,6 +81,47 @@ describe("snapshotPluginSource", () => {
     expect(names).not.toContain("/.disabled");
   });
 
+  test("excludes generated apps/<app>/dist but tracks app src and top-level dist", () => {
+    const dir = makePluginDir();
+    // App source is tracked.
+    mkdirSync(join(dir, "apps", "dash", "src"), { recursive: true });
+    writeStamped(
+      join(dir, "apps", "dash", "src", "main.tsx"),
+      "export default 1;",
+    );
+    // Generated app build output is excluded (the watcher writes it).
+    mkdirSync(join(dir, "apps", "dash", "dist"), { recursive: true });
+    writeStamped(
+      join(dir, "apps", "dash", "dist", "main.js"),
+      "console.log(1)",
+    );
+    // A plugin's own top-level dist/ is NOT an app build dir — still tracked.
+    mkdirSync(join(dir, "dist"), { recursive: true });
+    writeStamped(join(dir, "dist", "bundle.js"), "x");
+
+    const names = snapshotPluginSource(dir).evictionPaths.map((p) =>
+      p.slice(dir.length),
+    );
+    expect(names).toContain("/apps/dash/src/main.tsx");
+    expect(names).toContain("/dist/bundle.js");
+    expect(names).not.toContain("/apps/dash/dist/main.js");
+
+    // Editing the generated dist does not move the fingerprint (no re-trigger)...
+    const base = snapshotPluginSource(dir).fingerprint;
+    writeStamped(
+      join(dir, "apps", "dash", "dist", "main.js"),
+      "console.log(2)",
+    );
+    expect(snapshotPluginSource(dir).fingerprint).toBe(base);
+
+    // ...but editing the app source does.
+    writeStamped(
+      join(dir, "apps", "dash", "src", "main.tsx"),
+      "export default 2;",
+    );
+    expect(snapshotPluginSource(dir).fingerprint).not.toBe(base);
+  });
+
   test("is stable across identical walks and moves on edit, add, delete, and rename", () => {
     const dir = makePluginDir();
     const helper = join(dir, "hooks", "helper.ts");

package/src/plugins/defaults/memory/__tests__/memory-retrospective-job.test.ts

@@ -92,6 +92,21 @@ let messagesByConversationId: Record<string, StubMessage[]> = {};
 // the real registry's semantics for conversations not in memory.
 let loadedConversations: Record<string, { processing: boolean }> = {};
 
+const watchdogEvents: Array<{
+  checkName: string;
+  value?: number | null;
+  detail?: Record<string, unknown> | null;
+}> = [];
+mock.module("../../../../telemetry/watchdog-events-store.js", () => ({
+  recordWatchdogEvent: (record: {
+    checkName: string;
+    value?: number | null;
+    detail?: Record<string, unknown> | null;
+  }) => {
+    watchdogEvents.push(record);
+  },
+}));
+
 mock.module("../../../../daemon/conversation-registry.js", () => ({
   findConversation: (id: string | undefined) => {
     if (!id) return undefined;
@@ -360,6 +375,7 @@ function priorRetroMessage(rememberContents: string[]) {
 
 describe("memoryRetrospectiveJob", () => {
   beforeEach(() => {
+    watchdogEvents.length = 0;
     mockState = null;
     stateUpserts = [];
     lastRunAtBumps = [];
@@ -416,6 +432,16 @@ describe("memoryRetrospectiveJob", () => {
     expect(lastRunAtBumps).toHaveLength(0);
     expect(wakeCalls).toHaveLength(0);
     expect(forkCalls).toHaveLength(0);
+    // Every job run emits exactly one outcome counter for the health chart.
+    expect(
+      watchdogEvents.filter((e) => e.checkName === "memory_retrospective_run"),
+    ).toEqual([
+      {
+        checkName: "memory_retrospective_run",
+        value: 1,
+        detail: { outcome: "no_new_messages" },
+      },
+    ]);
   });
 
   test("a slice whose only row is the retrospective's own skill card is no new work", async () => {
@@ -532,6 +558,17 @@ describe("memoryRetrospectiveJob", () => {
     const outcome = await memoryRetrospectiveJob(makeJob(), stubConfig);
 
     expect(outcome.kind).toBe("wake_failed");
+    // The outcome counter carries the wake-failure reason so a fleet-wide
+    // spike is attributable (e.g. provider outage vs busy conversations).
+    expect(
+      watchdogEvents.filter((e) => e.checkName === "memory_retrospective_run"),
+    ).toEqual([
+      {
+        checkName: "memory_retrospective_run",
+        value: 1,
+        detail: { outcome: "wake_failed", reason: "timeout" },
+      },
+    ]);
     if (outcome.kind === "wake_failed") {
       expect(outcome.reason).toBe("timeout");
     }
@@ -549,6 +586,17 @@ describe("memoryRetrospectiveJob", () => {
     expect(stateUpserts).toHaveLength(0);
     expect(lastRunAtBumps).toHaveLength(1);
     expect(deletedConversationIds).toEqual(["fork-conv-1"]);
+    // A thrown run still records an outcome counter (as "error") before the
+    // rethrow — exception-flavored outages must show in the health metric.
+    expect(
+      watchdogEvents.filter((e) => e.checkName === "memory_retrospective_run"),
+    ).toEqual([
+      {
+        checkName: "memory_retrospective_run",
+        value: 1,
+        detail: { outcome: "error", reason: "LLM provider 503" },
+      },
+    ]);
   });
 
   test("missing conversationId payload: no_new_messages, no side effects", async () => {

package/src/plugins/defaults/memory/__tests__/memory-retrospective-skill-card.test.ts

@@ -35,6 +35,21 @@ type ConversationStub = {
 } | null;
 let conversationOverrides: Record<string, ConversationStub> = {};
 
+const watchdogEvents: Array<{
+  checkName: string;
+  value?: number | null;
+  detail?: Record<string, unknown> | null;
+}> = [];
+mock.module("../../../../telemetry/watchdog-events-store.js", () => ({
+  recordWatchdogEvent: (record: {
+    checkName: string;
+    value?: number | null;
+    detail?: Record<string, unknown> | null;
+  }) => {
+    watchdogEvents.push(record);
+  },
+}));
+
 mock.module("../../../../persistence/conversation-crud.js", () => ({
   getMessagesAfter: (_id: string, _afterId: string | null) => [],
   getMessages: (_id: string) => [],
@@ -156,6 +171,7 @@ function makeInsertJob(payload: Record<string, unknown>): MemoryJob {
 
 describe("memory-retrospective skill card", () => {
   beforeEach(() => {
+    watchdogEvents.length = 0;
     addMessageCalls = [];
     addMessageThrowsFor = null;
     addMessageDeduplicatesFor = null;
@@ -191,7 +207,7 @@ describe("memory-retrospective skill card", () => {
         type: "ui_surface",
         surfaceId: "skill-card-run-conv-1",
         surfaceType: "skill_card",
-        title: "New skill learned",
+        title: "I just learned how to do 2 new things",
         display: "inline",
         data: {
           skills: [
@@ -214,7 +230,7 @@ describe("memory-retrospective skill card", () => {
       // surface-capable clients skip it via the `_surfaceFallback` flag.
       {
         type: "text",
-        text: "New skill learned: Skill A, Skill B",
+        text: "I just learned how to do Skill A, Skill B",
         _surfaceFallback: true,
       },
     ]);
@@ -317,6 +333,31 @@ describe("memory-retrospective skill card", () => {
     expect(publishedConversationIds).toHaveLength(0);
   });
 
+  test("a delivered card emits the skill_card_delivered counter; a dedup does not", async () => {
+    await insertSkillCardMessage("conv-source", "conv-run-telemetry", [
+      { skillId: "s-1", name: "Skill One", description: "d1" },
+      { skillId: "s-2", name: "Skill Two", description: "d2" },
+    ]);
+    expect(
+      watchdogEvents.filter((e) => e.checkName === "skill_card_delivered"),
+    ).toEqual([
+      {
+        checkName: "skill_card_delivered",
+        value: 2,
+        detail: { skill_count: 2 },
+      },
+    ]);
+
+    // Retried delivery for the same run dedups on clientMessageId — the
+    // counter must not fire again.
+    await insertSkillCardMessage("conv-source", "conv-run-telemetry", [
+      { skillId: "s-1", name: "Skill One", description: "d1" },
+    ]);
+    expect(
+      watchdogEvents.filter((e) => e.checkName === "skill_card_delivered"),
+    ).toHaveLength(1);
+  });
+
   test("insert is best-effort: a persistence failure never throws", async () => {
     addMessageThrowsFor = "src-conv-9";
 
@@ -359,7 +400,7 @@ describe("memory-retrospective skill card", () => {
         type: "ui_surface",
         surfaceId: "skill-card-run-conv-1",
         surfaceType: "skill_card",
-        title: "New skill learned",
+        title: "I just learned how to do Skill A",
         display: "inline",
         data: {
           skills: [
@@ -374,7 +415,7 @@ describe("memory-retrospective skill card", () => {
       },
       {
         type: "text",
-        text: "New skill learned: Skill A",
+        text: "I just learned how to do Skill A",
         _surfaceFallback: true,
       },
     ]);
@@ -448,7 +489,7 @@ describe("memory-retrospective skill card", () => {
     ]);
     expect(blocks[1]).toEqual({
       type: "text",
-      text: "New skill learned: Skill A, Skill B",
+      text: "I just learned how to do Skill A, Skill B",
       _surfaceFallback: true,
     });
     expect(publishedConversationIds).toEqual(["src-conv-9"]);

package/src/plugins/defaults/memory/graph/tool-handlers.ts

@@ -242,7 +242,7 @@ export function handleDeleteMemory(
     return {
       success: false,
       message:
-        "No memory found matching that content. Use `vellum memory list` to find the exact text first.",
+        "No memory found matching that content. Use `assistant memory nodes list` to find the exact text first.",
     };
   }
 
@@ -317,7 +317,7 @@ export function handleUpdateMemory(
     return {
       success: false,
       message:
-        "No memory found matching old_content. Use `vellum memory list` to find the exact text first.",
+        "No memory found matching old_content. Use `assistant memory nodes list` to find the exact text first.",
     };
   }