@vellumai/assistant 0.8.6 → 0.8.7

package/src/ipc/skill-routes/__tests__/providers.test.ts

@@ -114,12 +114,14 @@ describe("host.providers.llm.complete", () => {
     expect(sendMessageSpy).toHaveBeenCalledTimes(1);
     const call = sendMessageSpy.mock.calls[0] as unknown as [
       unknown[],
-      unknown,
-      string | undefined,
-      unknown,
+      {
+        systemPrompt?: string;
+        tools?: unknown[];
+        config?: Record<string, unknown>;
+      },
     ];
     expect(Array.isArray(call[0])).toBe(true);
-    expect(call[2]).toBe("you are helpful");
+    expect(call[1]?.systemPrompt).toBe("you are helpful");
     expect(response).toEqual({
       content: [{ type: "text", text: "hello" }],
       model: "stub-model",
@@ -138,13 +140,11 @@ describe("host.providers.llm.complete", () => {
 
     const call = sendMessageSpy.mock.calls[0] as unknown as [
       unknown[],
-      unknown[],
-      string | undefined,
-      { config?: Record<string, unknown> } | undefined,
+      { tools?: unknown[]; config?: Record<string, unknown> },
     ];
-    expect(Array.isArray(call[1])).toBe(true);
-    expect((call[1] as unknown[]).length).toBe(1);
-    expect(call[3]?.config).toEqual({
+    expect(Array.isArray(call[1]?.tools)).toBe(true);
+    expect(call[1]?.tools?.length).toBe(1);
+    expect(call[1]?.config).toEqual({
       model: "override-model",
       callSite: "mainAgent",
     });

package/src/ipc/skill-routes/__tests__/registries.test.ts

@@ -21,6 +21,7 @@ import {
   getTool,
   getToolOwner,
 } from "../../../tools/registry.js";
+import { RiskLevel } from "../../../tools/types.js";
 import {
   __getActiveSessionCountForTesting,
   __resetActiveSessionsForTesting,
@@ -85,7 +86,7 @@ describe("host.registries.register_tools", () => {
     });
   });
 
-  test("proxy execute throws when no supervisor is attached", async () => {
+  test("proxy execute surfaces an error result when no supervisor is attached", async () => {
     await registerToolsRoute.handler({
       skillId: "stub-skill",
       tools: [
@@ -101,16 +102,19 @@ describe("host.registries.register_tools", () => {
 
     const installed = getTool("skill_stub_tool");
     expect(installed).toBeDefined();
-    await expect(
-      installed!.execute(
-        {},
-        {
-          workingDir: "/tmp",
-          conversationId: "c",
-          trustClass: "guardian",
-        },
-      ),
-    ).rejects.toThrow(/requires an attached MeetHostSupervisor/i);
+    // Skill tools arrive without an `execute` closure (closures don't cross
+    // IPC). `finalizeTool` synthesizes a no-op error result so unsupervised
+    // invocations surface a clear "not wired up" signal to the model.
+    const result = await installed!.execute(
+      {},
+      {
+        workingDir: "/tmp",
+        conversationId: "c",
+        trustClass: "guardian",
+      },
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toMatch(/no execute implementation/i);
   });
 
   test("rejects empty tool list", async () => {
@@ -119,13 +123,19 @@ describe("host.registries.register_tools", () => {
     ).rejects.toThrow();
   });
 
-  test("rejects missing required fields", async () => {
-    await expect(
-      registerToolsRoute.handler({
-        skillId: "any-skill",
-        tools: [{ name: "missing_rest" }],
-      }),
-    ).rejects.toThrow();
+  test("fills defaults for partial tool entries", async () => {
+    // Wire and author share one schema (`ToolDefinitionSchema`, all-optional)
+    // and the daemon runs `finalizeTool` on every incoming tool. So a
+    // partial entry doesn't reject — defaults fill in for missing fields.
+    const result = (await registerToolsRoute.handler({
+      skillId: "partial-skill",
+      tools: [{ name: "partial_tool" }],
+    })) as { registered: string[] };
+    expect(result.registered).toEqual(["partial_tool"]);
+    const installed = getTool("partial_tool");
+    expect(installed).toBeDefined();
+    expect(installed!.defaultRiskLevel).toBe(RiskLevel.Medium);
+    expect(installed!.executionTarget).toBe("sandbox");
   });
 
   test("rejects missing skillId", async () => {

package/src/ipc/skill-routes/memory.ts

@@ -16,22 +16,24 @@ import type { SkillIpcRoute } from "../skill-ipc-types.js";
 // -- Param schemas --------------------------------------------------------
 
 /**
- * Shape mirrors the daemon's `addMessage()` positional signature:
- * `(conversationId, role, content, metadata?, opts?)`. `role` is
- * constrained to the `MessageRole` union. Metadata is a free-form
- * record (validated downstream by `messageMetadataSchema` with a
- * warn-and-store fallback). Only `skipIndexing` is recognised in `opts`.
+ * IPC params for `addMessage()`. `role` is constrained to the
+ * `MessageRole` union. `metadata` is a free-form record (validated
+ * downstream by `messageMetadataSchema` with a warn-and-store fallback).
+ * `skipIndexing` and `clientMessageId` mirror `AddMessageOptions`.
+ *
+ * The `opts` field is a backward-compat shim: the macOS app and platform
+ * do not release together, so a skill-host built against an older contract
+ * may still send `{ opts: { skipIndexing } }` instead of the flat shape.
+ * The handler flattens it via `skipIndexing ?? opts?.skipIndexing`.
  */
 const MemoryAddMessageParams = z.object({
   conversationId: z.string().min(1),
   role: z.enum(["user", "assistant", "system"]),
   content: z.string(),
   metadata: z.record(z.string(), z.unknown()).optional(),
-  opts: z
-    .object({
-      skipIndexing: z.boolean().optional(),
-    })
-    .optional(),
+  skipIndexing: z.boolean().optional(),
+  clientMessageId: z.string().optional(),
+  opts: z.object({ skipIndexing: z.boolean().optional() }).optional(),
 });
 
 /** Mirrors `WakeOptions` from `runtime/agent-wake.ts`. */
@@ -44,9 +46,20 @@ const MemoryWakeOpportunityParams = z.object({
 // -- Handlers -------------------------------------------------------------
 
 async function handleAddMessage(params?: Record<string, unknown>) {
-  const { conversationId, role, content, metadata, opts } =
-    MemoryAddMessageParams.parse(params);
-  return addMessage(conversationId, role, content, metadata, opts);
+  const {
+    conversationId,
+    role,
+    content,
+    metadata,
+    skipIndexing,
+    clientMessageId,
+    opts,
+  } = MemoryAddMessageParams.parse(params);
+  return addMessage(conversationId, role, content, {
+    metadata,
+    skipIndexing: skipIndexing ?? opts?.skipIndexing,
+    clientMessageId,
+  });
 }
 
 async function handleWakeAgentForOpportunity(

package/src/ipc/skill-routes/providers.ts

@@ -39,7 +39,7 @@ import type { SkillIpcRoute } from "../skill-ipc-types.js";
 
 /**
  * LLM completion request. The IPC surface only accepts the serializable
- * subset of `Provider.sendMessage(messages, tools?, systemPrompt?, options?)`.
+ * subset of `Provider.sendMessage(messages, options?)`.
  * Non-serializable fields (`onEvent`, `signal`) are intentionally omitted —
  * streaming deltas and per-call cancellation belong on future streaming
  * routes, not this one-shot RPC.
@@ -76,12 +76,11 @@ async function handleLlmComplete(params?: Record<string, unknown>) {
       `host.providers.llm.complete: no provider configured for callSite '${callSite}'`,
     );
   }
-  return provider.sendMessage(
-    messages as Message[],
-    tools as ToolDefinition[] | undefined,
+  return provider.sendMessage(messages as Message[], {
+    tools: tools as ToolDefinition[] | undefined,
     systemPrompt,
-    { config: { ...((config as SendMessageConfig) ?? {}), callSite } },
-  );
+    config: { ...((config as SendMessageConfig) ?? {}), callSite },
+  });
 }
 
 function handleSttListProviderIds(): string[] {

package/src/ipc/skill-routes/registries.ts

@@ -22,36 +22,15 @@ import { z } from "zod";
 import type { MeetHostSupervisor } from "../../daemon/meet-host-supervisor.js";
 import { registerShutdownHook } from "../../daemon/shutdown-registry.js";
 import { registerSkillRoute } from "../../runtime/skill-route-registry.js";
-import { resolveExecutionTarget } from "../../tools/execution-target.js";
 import { registerSkillTools } from "../../tools/registry.js";
-import type { ExecutionTarget, Tool } from "../../tools/types.js";
-import { RiskLevel } from "../../tools/types.js";
+import { finalizeTool } from "../../tools/tool-defaults.js";
+import { ToolDefinitionSchema } from "../../tools/types.js";
 import { getLogger } from "../../util/logger.js";
 import type { SkillIpcRoute } from "../skill-ipc-types.js";
 import type { SkillIpcConnection } from "../skill-server.js";
 
 const log = getLogger("skill-routes-registries");
 
-// ── Wire-level schemas ────────────────────────────────────────────────
-
-/**
- * Serialized tool manifest entry sent over IPC. Mirrors the subset of
- * {@link Tool} a skill process can describe without carrying the tool's
- * executable closure across the socket; the closure is synthesized
- * daemon-side (see {@link buildProxyTool}) to forward invocations back
- * over IPC.
- */
-const ToolManifestSchema = z.object({
-  name: z.string().min(1),
-  description: z.string(),
-  input_schema: z.record(z.string(), z.unknown()),
-  defaultRiskLevel: z.enum(["low", "medium", "high"]),
-  category: z.string().min(1),
-  executionTarget: z.enum(["sandbox", "host"]).optional(),
-});
-
-export type ToolManifest = z.infer<typeof ToolManifestSchema>;
-
 // `skillId` lives at the params level rather than per-tool: a single
 // `register_tools` IPC frame is always one skill's batch, ownership flows
 // through `registerSkillTools(skillId, tools)` into the registry's
@@ -61,7 +40,7 @@ export type ToolManifest = z.infer<typeof ToolManifestSchema>;
 // in-process on the assistant side.
 const RegisterToolsParams = z.object({
   skillId: z.string().min(1),
-  tools: z.array(ToolManifestSchema).min(1),
+  tools: z.array(ToolDefinitionSchema).min(1),
 });
 
 const RegisterSkillRouteParams = z.object({
@@ -170,39 +149,6 @@ export function __getActiveSessionCountForTesting(): number {
   return activeSessions.size;
 }
 
-// ── Proxy-tool construction ───────────────────────────────────────────
-
-/**
- * Build a daemon-side {@link Tool} whose `execute` routes back to the
- * remote skill over IPC. PR 28 replaces the stub body with a real
- * `skill.dispatch_tool` round-trip; until then we keep a shape-complete
- * proxy in the registry so the rest of the tool-manifest plumbing can be
- * exercised end-to-end.
- */
-function buildProxyTool(manifest: ToolManifest): Tool {
-  // RiskLevel is a string enum whose values are "low" | "medium" | "high",
-  // matching the schema above exactly — the cast is a no-op at runtime.
-  return {
-    name: manifest.name,
-    description: manifest.description,
-    input_schema: manifest.input_schema as object,
-    category: manifest.category,
-    defaultRiskLevel: manifest.defaultRiskLevel as RiskLevel,
-    executionTarget: resolveExecutionTarget({
-      name: manifest.name,
-      executionTarget: manifest.executionTarget as ExecutionTarget | undefined,
-    }),
-    execute: async () => {
-      // Only reached when no supervisor is attached (tests/boot race);
-      // the supervisor short-circuit above replaces this with the
-      // manifest's dispatching execute closure on the production path.
-      throw new Error(
-        `Skill tool "${manifest.name}" invocation requires an attached MeetHostSupervisor`,
-      );
-    },
-  };
-}
-
 // ── Handlers ──────────────────────────────────────────────────────────
 
 async function handleRegisterTools(
@@ -212,6 +158,13 @@ async function handleRegisterTools(
   const { skillId, tools } = RegisterToolsParams.parse(params);
   const conn = connection as SkillIpcConnection | undefined;
 
+  // Finalize before branching so both the supervisor short-circuit and
+  // the in-memory registration path see a `Tool[]` with guaranteed
+  // `name`. The execute closure arrives as a no-op error closure from
+  // `finalizeTool`; the production (supervisor) path replaces it with
+  // the dispatching closure installed by the manifest loader at boot.
+  const proxies = tools.map((t) => finalizeTool(t));
+
   // Supervisor short-circuit: when a supervisor is registered, the
   // manifest loader has already installed proxy tools at daemon boot.
   // Re-installing here would double-register and clobber the manifest's
@@ -222,16 +175,15 @@ async function handleRegisterTools(
     if (conn) sessionSupervisor.setActiveConnection(conn);
     log.info(
       {
-        count: tools.length,
-        names: tools.map((t) => t.name),
+        count: proxies.length,
+        names: proxies.map((t) => t.name),
         ownerSkillId: skillId,
       },
       "Supervisor active: skipping in-memory tool re-registration; manifest proxies serve dispatches",
     );
-    return { registered: tools.map((t) => t.name) };
+    return { registered: proxies.map((t) => t.name) };
   }
 
-  const proxies = tools.map(buildProxyTool);
   // `registerExternalTools` is only consumed inside `initializeTools()` at
   // daemon boot; IPC children connect after boot, so route through
   // `registerSkillTools` into the live registry the agent-loop reads from.

package/src/live-voice/__tests__/live-voice-archive.test.ts

@@ -47,13 +47,16 @@ async function createMessage(role: "user" | "assistant" = "user") {
     conversation.id,
     role,
     role === "user" ? "Example user utterance" : "Example assistant response",
-    role === "user"
-      ? { userMessageChannel: "vellum", userMessageInterface: "macos" }
-      : {
-          assistantMessageChannel: "vellum",
-          assistantMessageInterface: "macos",
-        },
-    { skipIndexing: true },
+    {
+      metadata:
+        role === "user"
+          ? { userMessageChannel: "vellum", userMessageInterface: "macos" }
+          : {
+              assistantMessageChannel: "vellum",
+              assistantMessageInterface: "macos",
+            },
+      skipIndexing: true,
+    },
   );
   return { conversation, message };
 }
@@ -371,15 +374,25 @@ describe("live voice audio archive", () => {
       conversation.id,
       "user",
       "Example source utterance",
-      { userMessageChannel: "vellum", userMessageInterface: "macos" },
-      { skipIndexing: true },
+      {
+        metadata: {
+          userMessageChannel: "vellum",
+          userMessageInterface: "macos",
+        },
+        skipIndexing: true,
+      },
     );
     const targetMessage = await addMessage(
       conversation.id,
       "user",
       "Example target utterance",
-      { userMessageChannel: "vellum", userMessageInterface: "macos" },
-      { skipIndexing: true },
+      {
+        metadata: {
+          userMessageChannel: "vellum",
+          userMessageInterface: "macos",
+        },
+        skipIndexing: true,
+      },
     );
 
     const archived = archiveLiveVoiceUserUtteranceAudio({

package/src/memory/__tests__/conversation-queries.test.ts

@@ -155,7 +155,7 @@ describe("countConversations", () => {
     const priv = createConversation("private-1");
     setConversationType(priv.id, "private");
 
-    expect(countConversations(true)).toBe(2);
+    expect(countConversations("background")).toBe(2);
   });
 
   test("includes standard conversations with group_id system:background in background count", () => {
@@ -170,13 +170,13 @@ describe("countConversations", () => {
     createConversation("foreground-1");
 
     // WHEN counting background conversations
-    const bgCount = countConversations(true);
+    const bgCount = countConversations("background");
 
     // THEN the heartbeat conversation is included
     expect(bgCount).toBe(1);
 
     // AND excluded from the foreground count
-    expect(countConversations(false)).toBe(1);
+    expect(countConversations("standard")).toBe(1);
   });
 
   test("excludes standard conversations with group_id system:background from foreground count", () => {
@@ -191,7 +191,59 @@ describe("countConversations", () => {
 
     // WHEN counting foreground conversations
     // THEN the heartbeat is excluded
-    expect(countConversations(false)).toBe(2);
+    expect(countConversations("standard")).toBe(2);
+  });
+
+  test('"scheduled" count returns only scheduled rows', () => {
+    // GIVEN one scheduled, one background, and one foreground conversation
+    createConversation({ title: "sched-1", conversationType: "scheduled" });
+    createConversation({ title: "bg-1", conversationType: "background" });
+    createConversation("foreground-1");
+
+    // WHEN counting scheduled conversations
+    // THEN only the scheduled row is counted (background is excluded)
+    expect(countConversations("scheduled")).toBe(1);
+  });
+
+  describe("archiveStatus", () => {
+    test("defaults to active — archived rows are excluded from the count", () => {
+      // GIVEN one live and one archived foreground conversation
+      createConversation("live-1");
+      const archived = createConversation("archived-1");
+      rawRun(
+        "UPDATE conversations SET archived_at = ? WHERE id = ?",
+        Date.now(),
+        archived.id,
+      );
+
+      expect(countConversations()).toBe(1);
+    });
+
+    test('archiveStatus "archived" returns the archived count only', () => {
+      createConversation("live-1");
+      const a1 = createConversation("archived-1");
+      const a2 = createConversation("archived-2");
+      rawRun(
+        "UPDATE conversations SET archived_at = ? WHERE id IN (?, ?)",
+        Date.now(),
+        a1.id,
+        a2.id,
+      );
+
+      expect(countConversations("standard", "archived")).toBe(2);
+    });
+
+    test('archiveStatus "all" returns both', () => {
+      createConversation("live-1");
+      const archived = createConversation("archived-1");
+      rawRun(
+        "UPDATE conversations SET archived_at = ? WHERE id = ?",
+        Date.now(),
+        archived.id,
+      );
+
+      expect(countConversations("standard", "all")).toBe(2);
+    });
   });
 });
 
@@ -215,7 +267,7 @@ describe("listConversations", () => {
     createConversation("foreground-1");
 
     // WHEN listing background conversations
-    const bgList = listConversations(100, true);
+    const bgList = listConversations(100, "background");
 
     // THEN both background and heartbeat conversations are returned
     expect(bgList).toHaveLength(2);
@@ -236,7 +288,7 @@ describe("listConversations", () => {
     createConversation("foreground-1");
 
     // WHEN listing foreground conversations
-    const fgList = listConversations(100, false);
+    const fgList = listConversations(100, "standard");
 
     // THEN only the foreground conversation is returned
     expect(fgList).toHaveLength(1);
@@ -252,16 +304,148 @@ describe("listConversations", () => {
     );
 
     // WHEN listing background conversations
-    const bgList = listConversations(100, true);
+    const bgList = listConversations(100, "background");
 
     // THEN it appears in the background list
     expect(bgList).toHaveLength(1);
     expect(bgList[0]!.title).toBe("schedule-routed");
 
     // AND not in the foreground list
-    const fgList = listConversations(100, false);
+    const fgList = listConversations(100, "standard");
     expect(fgList).toHaveLength(0);
   });
+
+  test('"scheduled" fetch returns only scheduled rows and excludes plain background', () => {
+    // GIVEN a scheduled conversation, a background conversation, and a foreground one
+    createConversation({ title: "sched-1", conversationType: "scheduled" });
+    createConversation({ title: "bg-1", conversationType: "background" });
+    createConversation("foreground-1");
+
+    // WHEN listing scheduled conversations
+    const scheduledList = listConversations(100, "scheduled");
+
+    // THEN only the scheduled conversation is returned
+    expect(scheduledList).toHaveLength(1);
+    expect(scheduledList[0]!.title).toBe("sched-1");
+  });
+
+  test('"scheduled" fetch includes standard rows routed to group_id system:scheduled but not system:background', () => {
+    // GIVEN a standard conversation routed to system:scheduled
+    const scheduledRouted = createConversation("schedule-routed");
+    rawRun(
+      "UPDATE conversations SET group_id = 'system:scheduled' WHERE id = ?",
+      scheduledRouted.id,
+    );
+
+    // AND a standard conversation routed to system:background
+    const backgroundRouted = createConversation("background-routed");
+    rawRun(
+      "UPDATE conversations SET group_id = 'system:background' WHERE id = ?",
+      backgroundRouted.id,
+    );
+
+    // WHEN listing scheduled conversations
+    const scheduledList = listConversations(100, "scheduled");
+
+    // THEN only the system:scheduled row appears
+    expect(scheduledList).toHaveLength(1);
+    expect(scheduledList[0]!.title).toBe("schedule-routed");
+  });
+
+  test('"scheduled" fetch excludes subagent runs', () => {
+    // GIVEN a scheduled conversation produced by a subagent
+    createConversation({
+      title: "subagent-sched",
+      conversationType: "scheduled",
+      source: "subagent",
+    });
+
+    // WHEN listing scheduled conversations
+    const scheduledList = listConversations(100, "scheduled");
+
+    // THEN the subagent run is excluded
+    expect(scheduledList).toHaveLength(0);
+  });
+
+  describe("archiveStatus", () => {
+    test("defaults to active — archived rows are excluded", () => {
+      // GIVEN a live conversation and an archived one
+      createConversation("live-1");
+      const archived = createConversation("archived-1");
+      rawRun(
+        "UPDATE conversations SET archived_at = ? WHERE id = ?",
+        Date.now(),
+        archived.id,
+      );
+
+      // WHEN listing without an explicit archiveStatus
+      const rows = listConversations(100, "standard");
+
+      // THEN only the live conversation appears
+      expect(rows).toHaveLength(1);
+      expect(rows[0]!.title).toBe("live-1");
+    });
+
+    test('archiveStatus "archived" returns only archived rows', () => {
+      // GIVEN a live conversation and an archived one
+      createConversation("live-1");
+      const archived = createConversation("archived-1");
+      rawRun(
+        "UPDATE conversations SET archived_at = ? WHERE id = ?",
+        Date.now(),
+        archived.id,
+      );
+
+      // WHEN listing with archiveStatus "archived"
+      const rows = listConversations(100, "standard", 0, "archived");
+
+      // THEN only the archived conversation appears
+      expect(rows).toHaveLength(1);
+      expect(rows[0]!.title).toBe("archived-1");
+    });
+
+    test('archiveStatus "all" returns both active and archived rows', () => {
+      // GIVEN a live conversation and an archived one
+      createConversation("live-1");
+      const archived = createConversation("archived-1");
+      rawRun(
+        "UPDATE conversations SET archived_at = ? WHERE id = ?",
+        Date.now(),
+        archived.id,
+      );
+
+      // WHEN listing with archiveStatus "all"
+      const rows = listConversations(100, "standard", 0, "all");
+
+      // THEN both conversations appear
+      expect(rows).toHaveLength(2);
+      const titles = rows.map((c) => c.title);
+      expect(titles).toContain("live-1");
+      expect(titles).toContain("archived-1");
+    });
+
+    test('archiveStatus "archived" composes with background-only', () => {
+      // GIVEN an archived background conversation and an archived foreground one
+      const archivedBg = createConversation({
+        title: "archived-bg",
+        conversationType: "background",
+      });
+      const archivedFg = createConversation("archived-fg");
+      rawRun(
+        "UPDATE conversations SET archived_at = ? WHERE id IN (?, ?)",
+        Date.now(),
+        archivedBg.id,
+        archivedFg.id,
+      );
+
+      // WHEN listing archived background conversations
+      const rows = listConversations(100, "background", 0, "archived");
+
+      // THEN only the archived background row appears
+      expect(rows).toHaveLength(1);
+      expect(rows[0]!.title).toBe("archived-bg");
+    });
+  });
 });
 
 describe("listConversationsBySource", () => {