@vellumai/assistant 0.8.1 → 0.8.3

package/src/plugins/types.ts

@@ -42,7 +42,11 @@ import type {
   ToolDefinition,
 } from "../providers/types.js";
 import type { SkillRoute } from "../runtime/skill-route-registry.js";
-import type { Tool, ToolContext, ToolExecutionResult } from "../tools/types.js";
+import type {
+  LoadedPluginTool,
+  ToolContext,
+  ToolExecutionResult,
+} from "../tools/types.js";
 import { AssistantError, ErrorCode } from "../util/errors.js";
 
 // ─── Manifest ────────────────────────────────────────────────────────────────
@@ -60,22 +64,13 @@ import { AssistantError, ErrorCode } from "../util/errors.js";
 export interface PluginManifest {
   /** Unique plugin identifier (kebab-case). Duplicate names fail registration. */
   name: string;
-  /** Plugin version (semver). Informational — the registry compares
-   *  capability versions via `requires`, not this field. */
-  version: string;
   /**
-   * Capabilities this plugin exposes to other plugins.
-   *
-   * **Reserved for future cross-plugin composition — not currently consumed
-   * by any runtime code.** The field is declared so future cross-plugin work
-   * can land without a manifest version bump, but today nothing reads it and
-   * plugins must not depend on it for capability discovery. See
-   * `assistant/docs/plugins.md` (Cross-plugin communication) for the
-   * rationale.
+   * Plugin version (semver). Informational. Host-compat negotiation lives
+   * in the plugin's `package.json` `peerDependencies["@vellumai/plugin-api"]`
+   * range — checked by the external-plugin loader against the assistant's
+   * own version at load time.
    */
-  provides?: Record<string, string>;
-  /** Capabilities this plugin needs from the assistant runtime. */
-  requires: Record<string, string>;
+  version: string;
   /** Credential keys the plugin needs resolved before `init()` runs. */
   requiresCredential?: string[];
   /**
@@ -844,6 +839,24 @@ export interface TurnInjectionInputs {
    * knows no human is present to answer clarification questions.
    */
   readonly isNonInteractive?: boolean;
+  /**
+   * True when the active conversation's type is "background" or "scheduled"
+   * (see `isBackgroundConversationType`). Read by the `background-turn`
+   * injector to wrap the tail user message with a contextual reminder when
+   * the turn is also non-interactive.
+   */
+  readonly isBackgroundConversation?: boolean;
+  /**
+   * Active documents open in this conversation — surfaced by the
+   * `active-documents` injector so the assistant can target existing docs
+   * with `document_update` instead of creating duplicates.
+   */
+  readonly activeDocuments?: ReadonlyArray<{
+    surfaceId: string;
+    title: string;
+    wordCount: number;
+    updatedAt: number;
+  }> | null;
 }
 
 export interface DiskPressureInjectionContext {
@@ -995,15 +1008,18 @@ export interface Injector {
 // catalog-discoverable skills today.
 
 /**
- * Tool registration contributed by a plugin. Uses the canonical {@link Tool}
- * interface from the tool registry — the bootstrap stamps `origin: "plugin"`
- * and `ownerPluginId: <plugin.name>` before handing the batch to
- * `registerPluginTools`, which keeps plugin ref-counts and conflict detection
- * in a namespace disjoint from real skills. Plugin authors supply the
- * functional fields (`name`, `description`, `getDefinition`, `execute`, etc.)
- * and leave the ownership metadata to the bootstrap to set authoritatively.
+ * Tool registration contributed by a plugin. Uses the narrow
+ * {@link LoadedPluginTool} shape. External plugin authors declare the
+ * nameless `PluginTool` file shape; the loader derives `name` from the
+ * `tools/<name>.ts` basename before storing it on `plugin.tools`. Authors
+ * also leave category / ownership metadata to the bootstrap, which stamps
+ * `category: "plugin"`, `origin: "plugin"`, and
+ * `ownerPluginId: <plugin.name>` before handing the batch to
+ * `registerPluginTools`. The registration boundary synthesizes
+ * `getDefinition()` from `{name, description, input_schema}` so the canonical
+ * {@link Tool} interface used by the internal registry stays unchanged.
  */
-export type PluginToolRegistration = Tool;
+export type PluginToolRegistration = LoadedPluginTool;
 /**
  * HTTP route registration contributed by a plugin. Plugins express routes as
  * {@link SkillRoute} values — the same shape the skill-route registry
@@ -1075,9 +1091,7 @@ export interface PluginSkillRegistration {
  * Unknown keys are populated by the loader for forward compatibility
  * but are not invoked by today's runtime.
  */
-export type PluginHookFn<TCtx = unknown> = (
-  ctx: TCtx,
-) => Promise<TCtx | void>;
+export type PluginHookFn<TCtx = unknown> = (ctx: TCtx) => Promise<TCtx | void>;
 
 /**
  * Map of lifecycle hooks contributed by a plugin. Keys match file

package/src/plugins/user-loader.ts

@@ -49,7 +49,8 @@ import { join } from "node:path";
 import { pathToFileURL } from "node:url";
 
 import { getLogger } from "../util/logger.js";
-import { getWorkspaceDir } from "../util/platform.js";
+import { getWorkspacePluginsDir } from "../util/platform.js";
+import { ensurePluginApiShim } from "./ensure-plugin-api-shim.js";
 import { loadExternalPlugin } from "./external-plugin-loader.js";
 import { closeRegistration } from "./registry.js";
 
@@ -93,7 +94,25 @@ export async function loadUserPlugins(
 ): Promise<void> {
   const importTimeoutMs = options.importTimeoutMs ?? USER_PLUGIN_IMPORT_TIMEOUT_MS;
 
-  const pluginsDir = join(getWorkspaceDir(), "plugins");
+  // Materialize the workspace-level `@vellumai/plugin-api` shim *before*
+  // we dynamic-import any user plugins. The shim file must exist on disk
+  // before the first plugin's `import "@vellumai/plugin-api"` is parsed.
+  //
+  // Wrapped in try/catch because per `AGENTS.md` the daemon must never
+  // block startup. A shim-write failure (ENOSPC, read-only workspace,
+  // perms) is logged and we continue — plugins that try to import the
+  // public specifier will fail individually inside the per-plugin import
+  // loop below, which is already isolated.
+  try {
+    await ensurePluginApiShim();
+  } catch (err) {
+    log.warn(
+      { err },
+      "loadUserPlugins: plugin-api shim materialization failed — continuing with degraded plugin support",
+    );
+  }
+
+  const pluginsDir = getWorkspacePluginsDir();
 
   if (!existsSync(pluginsDir)) {
     // The clean-install case. Closing the registration window keeps the

package/src/proactive-artifact/aux-message-injector.ts

@@ -8,6 +8,10 @@
 
 import { createAssistantMessage } from "../agent/message-types.js";
 import { findConversation } from "../daemon/conversation-store.js";
+import {
+  conversationMessagesSyncTag,
+  SYNC_TAGS,
+} from "../daemon/message-types/sync.js";
 import { addMessage } from "../memory/conversation-crud.js";
 import type { BroadcastFn } from "../notifications/adapters/macos.js";
 import { getLogger } from "../util/logger.js";
@@ -71,4 +75,11 @@ export async function injectAuxAssistantMessage(params: {
     type: "conversation_list_invalidated",
     reason: "reordered",
   });
+  params.broadcastMessage({
+    type: "sync_changed",
+    tags: [
+      SYNC_TAGS.conversationsList,
+      conversationMessagesSyncTag(params.conversationId),
+    ],
+  });
 }

package/src/proactive-artifact/job.test.ts

@@ -1,5 +1,10 @@
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
+import {
+  conversationMessagesSyncTag,
+  SYNC_TAGS,
+} from "../daemon/message-types/sync.js";
+
 // ── Mock state ──────────────────────────────────────────────────────────
 
 // Provider mock
@@ -691,7 +696,7 @@ describe("runProactiveArtifactJob", () => {
 });
 
 describe("injectAuxAssistantMessage", () => {
-  test("idle conversation: persists with skipIndexing, pushes to getMessages(), broadcasts delta + complete(aux) + list_invalidated", async () => {
+  test("idle conversation: persists with skipIndexing, pushes to getMessages(), broadcasts delta + complete(aux) + list sync", async () => {
     const messages: unknown[] = [];
     mockConversations.set("conv-inject-1", {
       processing: false,
@@ -714,7 +719,7 @@ describe("injectAuxAssistantMessage", () => {
     // Pushed to in-memory messages
     expect(messages).toHaveLength(1);
 
-    // Broadcasts: delta, complete(aux), list_invalidated
+    // Broadcasts: delta, complete(aux), list invalidation + sync tag
     const deltaMsg = broadcastCalls.find(
       (c) => c.type === "assistant_text_delta",
     );
@@ -734,6 +739,15 @@ describe("injectAuxAssistantMessage", () => {
     );
     expect(listMsg).toBeDefined();
     expect(listMsg!.reason).toBe("reordered");
+
+    const syncMsg = broadcastCalls.find((c) => c.type === "sync_changed");
+    expect(syncMsg).toEqual({
+      type: "sync_changed",
+      tags: [
+        SYNC_TAGS.conversationsList,
+        conversationMessagesSyncTag("conv-inject-1"),
+      ],
+    });
   });
 
   test("processing → idle: waits for processing to become false before persisting", async () => {
@@ -824,13 +838,22 @@ describe("injectAuxAssistantMessage", () => {
       broadcastCalls.filter((c) => c.type === "message_complete"),
     ).toHaveLength(0);
 
-    // But list_invalidated IS sent (always sent regardless of processing state)
+    // But list invalidation + sync tag ARE sent regardless of processing state.
     expect(
       broadcastCalls.filter((c) => c.type === "conversation_list_invalidated"),
     ).toHaveLength(1);
+    expect(broadcastCalls.filter((c) => c.type === "sync_changed")).toEqual([
+      {
+        type: "sync_changed",
+        tags: [
+          SYNC_TAGS.conversationsList,
+          conversationMessagesSyncTag("conv-inject-3"),
+        ],
+      },
+    ]);
   });
 
-  test("inactive/unloaded conversation: persists + list_invalidated only", async () => {
+  test("inactive/unloaded conversation: persists + list sync only", async () => {
     // No conversation in the store
     await injectAuxAssistantMessage({
       conversationId: "conv-inject-4",
@@ -850,10 +873,19 @@ describe("injectAuxAssistantMessage", () => {
       broadcastCalls.filter((c) => c.type === "message_complete"),
     ).toHaveLength(0);
 
-    // But list_invalidated IS sent
+    // But list invalidation + sync tag ARE sent
     expect(
       broadcastCalls.filter((c) => c.type === "conversation_list_invalidated"),
     ).toHaveLength(1);
+    expect(broadcastCalls.filter((c) => c.type === "sync_changed")).toEqual([
+      {
+        type: "sync_changed",
+        tags: [
+          SYNC_TAGS.conversationsList,
+          conversationMessagesSyncTag("conv-inject-4"),
+        ],
+      },
+    ]);
   });
 });
 

package/src/prompts/__tests__/system-prompt.test.ts

@@ -1,10 +1,9 @@
 /**
- * Tests for the Background Conversation gating in buildSystemPrompt.
- *
- * The Background Conversation guidance is gated on
- * `options.isBackgroundConversation === true`.  Interactive (default)
- * conversations must pay zero token cost — the section must be entirely
- * absent unless the flag is explicitly true.
+ * Smoke tests for buildSystemPrompt — covers tool-routing-guidance
+ * exclusions and other call-shape invariants. Background-conversation
+ * guidance is no longer rendered into the system prompt; see
+ * `__tests__/injector-background-turn.test.ts` for the per-turn
+ * user-message injection that replaced it.
  */
 
 import { mkdirSync } from "node:fs";
@@ -58,48 +57,16 @@ mock.module("../../config/loader.js", () => ({
   setNestedValue: () => {},
 }));
 
-const { buildSystemPrompt, SYSTEM_PROMPT_CACHE_BOUNDARY } =
-  await import("../system-prompt.js");
+const { buildSystemPrompt } = await import("../system-prompt.js");
 
-describe("buildSystemPrompt — Background Conversation gating", () => {
+describe("buildSystemPrompt — tool routing guidance", () => {
   beforeEach(() => {
     mkdirSync(TEST_DIR, { recursive: true });
   });
 
-  test("isBackgroundConversation: true — appends the Background Conversation section", () => {
-    const result = buildSystemPrompt({ isBackgroundConversation: true });
-    expect(result).toContain("## Background Conversation");
-    expect(result).toContain("`notifications` skill");
-    expect(result).toContain("assistant notifications send");
-  });
-
-  test("isBackgroundConversation: false — section is omitted", () => {
-    const result = buildSystemPrompt({ isBackgroundConversation: false });
-    expect(result).not.toContain("## Background Conversation");
-  });
-
-  test("options undefined — section is omitted (interactive default)", () => {
-    const result = buildSystemPrompt(undefined);
-    expect(result).not.toContain("## Background Conversation");
-  });
-
-  test("options provided without the flag — section is omitted", () => {
+  test("does not include ask_question routing guidance", () => {
     const result = buildSystemPrompt({});
-    expect(result).not.toContain("## Background Conversation");
-  });
-
-  test("section lives in the static (cached) block, not the dynamic suffix", () => {
-    // The section is deterministic for a given conversationType, so it
-    // belongs in staticParts to share the cache block with other
-    // call-time-stable instructions.
-    const result = buildSystemPrompt({ isBackgroundConversation: true });
-    const boundaryIdx = result.indexOf(SYSTEM_PROMPT_CACHE_BOUNDARY);
-    expect(boundaryIdx).toBeGreaterThan(-1);
-    const staticBlock = result.slice(0, boundaryIdx);
-    const dynamicBlock = result.slice(
-      boundaryIdx + SYSTEM_PROMPT_CACHE_BOUNDARY.length,
-    );
-    expect(staticBlock).toContain("## Background Conversation");
-    expect(dynamicBlock).not.toContain("## Background Conversation");
+    expect(result).not.toContain("## Clarifying questions");
+    expect(result).not.toContain("ask_question");
   });
 });

package/src/prompts/__tests__/task-progress-hint-section.test.ts

@@ -0,0 +1,95 @@
+/**
+ * Tests for the task_progress hint in the 01-parallel-tool-calls workspace
+ * system prompt section.
+ *
+ * Verifies that the task_progress guidance renders unconditionally in the
+ * system prompt — no `enabled` frontmatter gating, no options dependency.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+const noopLogger: Record<string, unknown> = new Proxy(
+  {} as Record<string, unknown>,
+  {
+    get: (_target, prop) => (prop === "child" ? () => noopLogger : () => {}),
+  },
+);
+
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const realLogger = require("../../util/logger.js");
+mock.module("../../util/logger.js", () => ({
+  ...realLogger,
+  getLogger: () => noopLogger,
+  getCliLogger: () => noopLogger,
+  truncateForLog: (v: string) => v,
+  initLogger: () => {},
+  pruneOldLogFiles: () => 0,
+}));
+
+const mockLoadedConfig: Record<string, unknown> = {};
+
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    services: {
+      inference: {
+        mode: "your-own",
+        provider: "anthropic",
+        model: "claude-opus-4-6",
+      },
+      "image-generation": {
+        mode: "your-own",
+        provider: "gemini",
+        model: "gemini-3.1-flash-image-preview",
+      },
+      "web-search": { mode: "your-own", provider: "inference-provider-native" },
+    },
+  }),
+  loadConfig: () => mockLoadedConfig,
+  loadRawConfig: () => ({}),
+  saveConfig: () => {},
+  saveRawConfig: () => {},
+  invalidateConfigCache: () => {},
+  getNestedValue: () => undefined,
+  setNestedValue: () => {},
+}));
+
+const { buildSystemPrompt, ensurePromptFiles, SYSTEM_PROMPT_CACHE_BOUNDARY } =
+  await import("../system-prompt.js");
+
+describe("task_progress hint in parallel-tool-calls section", () => {
+  beforeEach(() => {
+    ensurePromptFiles();
+  });
+
+  test("buildSystemPrompt() includes task_progress guidance", () => {
+    const result = buildSystemPrompt();
+    expect(result).toContain("task_progress");
+    expect(result).toContain("No exceptions");
+  });
+
+  test("renders unconditionally — no options required", () => {
+    const result = buildSystemPrompt(undefined);
+    expect(result).toContain("task_progress");
+  });
+
+  test("renders regardless of options passed", () => {
+    const withClientFlag = buildSystemPrompt({ hasNoClient: true });
+    const withoutClientFlag = buildSystemPrompt({ hasNoClient: false });
+    const withExcludePrefix = buildSystemPrompt({
+      excludeCustomPrefix: true,
+    });
+
+    expect(withClientFlag).toContain("task_progress");
+    expect(withoutClientFlag).toContain("task_progress");
+    expect(withExcludePrefix).toContain("task_progress");
+  });
+
+  test("hint lives in the static (cached) block before SYSTEM_PROMPT_CACHE_BOUNDARY", () => {
+    const result = buildSystemPrompt();
+    const boundaryIdx = result.indexOf(SYSTEM_PROMPT_CACHE_BOUNDARY);
+    expect(boundaryIdx).toBeGreaterThan(-1);
+    const staticBlock = result.slice(0, boundaryIdx);
+    expect(staticBlock).toContain("task_progress");
+  });
+});

package/src/prompts/normalize-onboarding.ts

@@ -62,6 +62,29 @@ export interface NormalizedOnboarding {
   dailyTools: string[];
   tone?: string;
   assistantName?: string;
+  googleConnected?: boolean;
+  googleServices?: string[];
+}
+
+const SCOPE_SERVICE_MAP: Record<string, string> = {
+  "gmail.readonly": "Gmail",
+  "gmail.modify": "Gmail",
+  "gmail.send": "Gmail",
+  "gmail.settings.basic": "Gmail",
+  "calendar.readonly": "Calendar",
+  "calendar.events": "Calendar",
+  drive: "Drive",
+};
+
+export function deriveGoogleServices(scopes?: string[]): string[] {
+  if (!scopes?.length) return ["Gmail", "Calendar", "Drive"];
+  const services = new Set<string>();
+  for (const scope of scopes) {
+    const suffix = scope.replace("https://www.googleapis.com/auth/", "");
+    const service = SCOPE_SERVICE_MAP[suffix];
+    if (service) services.add(service);
+  }
+  return services.size > 0 ? [...services] : ["Gmail", "Calendar", "Drive"];
 }
 
 /**
@@ -76,5 +99,9 @@ export function normalizeOnboardingContext(
     dailyTools: normalizeTools(ctx.tools),
     tone: ctx.tone,
     assistantName: ctx.assistantName,
+    googleConnected: ctx.googleConnected,
+    googleServices: ctx.googleConnected
+      ? deriveGoogleServices(ctx.googleScopes)
+      : undefined,
   };
 }