@vellumai/assistant 0.8.8 → 0.8.9-dev.202606091926.ebb2d62

package/src/daemon/wake-target-adapter.ts

@@ -1,253 +0,0 @@
-/**
- * Adapter that wraps a live {@link Conversation} as a {@link WakeTarget}
- * for `wakeAgentForOpportunity()`.
- *
- * Extracted from `server.ts` so that `runtime/agent-wake.ts` can import
- * the resolver directly instead of going through a DI callback registered
- * at daemon startup.
- */
-
-import type { AgentEvent } from "../agent/loop.js";
-import {
-  addMessage,
-  getConversation,
-  provenanceFromTrustContext,
-} from "../memory/conversation-crud.js";
-import { syncMessageToDisk } from "../memory/conversation-disk-view.js";
-import { backfillMessageIdOnLogs } from "../memory/llm-request-log-store.js";
-import type { WakeTarget } from "../runtime/agent-wake.js";
-import { broadcastMessage } from "../runtime/assistant-event-hub.js";
-import { getLogger } from "../util/logger.js";
-import type { Conversation } from "./conversation.js";
-import type { ServerMessage } from "./message-protocol.js";
-
-const log = getLogger("wake-target-adapter");
-
-/**
- * Translate a raw {@link AgentEvent} from the agent loop into the
- * corresponding {@link ServerMessage} wire frame. The normal user-turn
- * path does this via the full state-aware handler in
- * `conversation-agent-loop-handlers.ts`; the wake path has no tool
- * accounting, title generation, or activity-state tracking to worry
- * about, so we only need the subset that produces client-visible
- * frames. Events that have no client-visible wire shape (usage, error,
- * preview/input-json deltas, etc.) are dropped — they produce no UI.
- *
- * Keeping this translator co-located with the wake adapter preserves
- * the runtime/daemon layering: `runtime/agent-wake.ts` never imports
- * `message-protocol.ts` or wire shapes, and the daemon owns all
- * translation from agent-loop semantics to client frames.
- */
-function translateAgentEventToServerMessage(
-  event: AgentEvent,
-  conversationId: string,
-): ServerMessage | null {
-  switch (event.type) {
-    case "text_delta":
-      return {
-        type: "assistant_text_delta",
-        text: event.text,
-        conversationId,
-      };
-    case "thinking_delta":
-      return {
-        type: "assistant_thinking_delta",
-        thinking: event.thinking,
-        conversationId,
-      };
-    case "tool_use":
-      return {
-        type: "tool_use_start",
-        toolName: event.name,
-        input: event.input,
-        conversationId,
-        toolUseId: event.id,
-      };
-    case "tool_use_preview_start":
-      return {
-        type: "tool_use_preview_start",
-        toolUseId: event.toolUseId,
-        toolName: event.toolName,
-        conversationId,
-      };
-    case "tool_output_chunk":
-      return {
-        type: "tool_output_chunk",
-        chunk: event.chunk,
-        conversationId,
-        toolUseId: event.toolUseId,
-      };
-    case "tool_result": {
-      const imageBlocks = event.contentBlocks?.filter(
-        (b): b is Extract<typeof b, { type: "image" }> => b.type === "image",
-      );
-      const imageDataList = imageBlocks?.length
-        ? imageBlocks.map((b) => b.source.data)
-        : undefined;
-      return {
-        type: "tool_result",
-        toolName: "",
-        result: event.content,
-        isError: event.isError,
-        diff: event.diff,
-        status: event.status,
-        conversationId,
-        imageData: imageDataList?.[0],
-        imageDataList,
-        toolUseId: event.toolUseId,
-      };
-    }
-    case "server_tool_start":
-      return {
-        type: "tool_use_start",
-        toolName: event.name,
-        input: event.input,
-        conversationId,
-        toolUseId: event.toolUseId,
-      };
-    case "server_tool_complete": {
-      let resultText = "";
-      if (Array.isArray(event.content) && event.content.length > 0) {
-        resultText = (event.content as unknown[])
-          .filter(
-            (r): r is { type: string; title: string; url: string } =>
-              typeof r === "object" &&
-              r != null &&
-              (r as { type?: string }).type === "web_search_result",
-          )
-          .map((r) => `${r.title}\n${r.url}`)
-          .join("\n\n");
-      }
-      return {
-        type: "tool_result",
-        toolName: "web_search",
-        result: resultText,
-        isError: event.isError,
-        conversationId,
-        toolUseId: event.toolUseId,
-      };
-    }
-    case "message_complete":
-      return {
-        type: "message_complete",
-        conversationId,
-      };
-    case "input_json_delta":
-    case "usage":
-    case "error":
-    case "provider_error":
-    case "max_tokens_reached":
-    case "context_compacting":
-    case "compaction_circuit_open":
-    case "compaction_circuit_closed":
-    case "compaction_completed":
-    case "history_stripped":
-    case "agent_loop_exit":
-      return null;
-    case "llm_call_started":
-      // The wake path persists its assistant tail via `persistTailMessage`
-      // (an `addMessage`-shaped call below) rather than via the main
-      // event-handler's `reserve` → `updateContent` pipeline, so there is
-      // no row to reserve here. Translation returns null and the wake
-      // path's existing end-of-turn persist continues to mint the row.
-      // Following up with full wake-path pre-allocation parity is tracked
-      // as a B3 follow-up.
-      return null;
-  }
-}
-
-/**
- * Adapt a live {@link Conversation} to the narrow {@link WakeTarget}
- * surface expected by `wakeAgentForOpportunity()`.
- */
-export function conversationToWakeTarget(
-  conversation: Conversation,
-): WakeTarget {
-  return {
-    conversationId: conversation.conversationId,
-    agentLoop: conversation.agentLoop,
-    getMessages: () => conversation.getMessages(),
-    pushMessage: (msg) => {
-      conversation.messages.push(msg);
-    },
-    onWakeProducedOutput: (source, hint, surfaceId) => {
-      broadcastMessage({
-        type: "ui_surface_show",
-        conversationId: conversation.conversationId,
-        surfaceId,
-        surfaceType: "card",
-        data: {
-          title: "Conversation Woke",
-          body: hint,
-          metadata: [{ label: "Source", value: source }],
-        },
-        display: "inline",
-      });
-    },
-    emitAgentEvent: (event) => {
-      const frame = translateAgentEventToServerMessage(
-        event,
-        conversation.conversationId,
-      );
-      if (!frame) return;
-      broadcastMessage(frame);
-    },
-    isProcessing: () => conversation.isProcessing(),
-    markProcessing: (on) => {
-      conversation.setProcessing(on);
-    },
-    setTrustContext: (ctx) => conversation.setTrustContext(ctx),
-    setWakeAllowedTools: (tools) => {
-      const previous = conversation.subagentAllowedTools;
-      conversation.setSubagentAllowedTools(new Set(tools));
-      return () => {
-        conversation.setSubagentAllowedTools(previous);
-      };
-    },
-    persistTailMessage: async (message) => {
-      const turnChannelCtx = conversation.getTurnChannelContext();
-      const turnInterfaceCtx = conversation.getTurnInterfaceContext();
-      const metadata: Record<string, unknown> = {
-        ...provenanceFromTrustContext(conversation.trustContext),
-        userMessageChannel: turnChannelCtx?.userMessageChannel ?? "vellum",
-        assistantMessageChannel:
-          turnChannelCtx?.assistantMessageChannel ?? "vellum",
-        userMessageInterface: turnInterfaceCtx?.userMessageInterface ?? "web",
-        assistantMessageInterface:
-          turnInterfaceCtx?.assistantMessageInterface ?? "web",
-      };
-      const persisted = await addMessage(
-        conversation.conversationId,
-        message.role,
-        JSON.stringify(message.content),
-        { metadata },
-      );
-      if (message.role === "assistant") {
-        try {
-          backfillMessageIdOnLogs(conversation.conversationId, persisted.id);
-        } catch (err) {
-          log.warn(
-            { err, conversationId: conversation.conversationId },
-            "wake adapter: backfill messageId on LLM logs failed (non-fatal)",
-          );
-        }
-      }
-      try {
-        const convRow = getConversation(conversation.conversationId);
-        if (convRow) {
-          syncMessageToDisk(
-            conversation.conversationId,
-            persisted.id,
-            convRow.createdAt,
-          );
-        }
-      } catch (err) {
-        log.warn(
-          { err, conversationId: conversation.conversationId },
-          "wake adapter: syncMessageToDisk failed (non-fatal)",
-        );
-      }
-    },
-    drainQueue: () => conversation.drainQueue(),
-  };
-}

package/src/memory/v3/__tests__/assign.test.ts

@@ -1,242 +0,0 @@
-/**
- * Tests for the v3 page→leaf classifier. Uses a stub provider so no live LLM
- * is hit. Pages are written into a temp workspace.
- */
-
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-
-import type {
-  Message,
-  Provider,
-  ProviderResponse,
-  SendMessageOptions,
-  ToolUseContent,
-} from "../../../providers/types.js";
-import { readPage, writePage } from "../../v2/page-store.js";
-import type { ConceptPageFrontmatter } from "../../v2/types.js";
-import type { LeafNode, LeafTree } from "../types.js";
-
-// Stub the provider layer before importing `assign.js` so its static import
-// chain (which transitively pulls in CES/credential workspace packages that
-// aren't built in a fresh worktree) never loads. The classifier is
-// provider-injectable, so every test passes its own stub provider — the real
-// `getConfiguredProvider` is never exercised here.
-mock.module("../../../providers/provider-send-message.js", () => ({
-  getConfiguredProvider: async () => null,
-  extractToolUse: (response: ProviderResponse) =>
-    response.content.find((b): b is ToolUseContent => b.type === "tool_use"),
-  userMessage: (text: string): Message => ({
-    role: "user",
-    content: [{ type: "text", text }],
-  }),
-}));
-
-const { assignPages } = await import("../assign.js");
-
-function makeLeaf(path: string, description: string): LeafNode {
-  return {
-    path,
-    frontmatter: { path, in_core: false },
-    description,
-    members: [],
-    domain: path.split("/")[0],
-  };
-}
-
-function makeTree(leaves: LeafNode[]): LeafTree {
-  return {
-    leaves: new Map(leaves.map((l) => [l.path, l])),
-    byPage: new Map(),
-  };
-}
-
-/** Sorted by path: [1] domain-a/topic-x, [2] domain-a/topic-y, [3] domain-b/topic-z */
-function threeLeafTree(): LeafTree {
-  return makeTree([
-    makeLeaf("domain-b/topic-z", "about z"),
-    makeLeaf("domain-a/topic-x", "about x"),
-    makeLeaf("domain-a/topic-y", "about y"),
-  ]);
-}
-
-function stubProvider(
-  handler: (
-    messages: Message[],
-    options?: SendMessageOptions,
-  ) => ProviderResponse | Promise<ProviderResponse>,
-): Provider {
-  return {
-    name: "stub",
-    sendMessage: async (messages, options) => handler(messages, options),
-  } as Provider;
-}
-
-function response(content: ProviderResponse["content"]): ProviderResponse {
-  return {
-    content,
-    model: "stub-model",
-    stopReason: "tool_use",
-    usage: { inputTokens: 0, outputTokens: 0 },
-  };
-}
-
-function toolResponse(ids: unknown[]): ProviderResponse {
-  return response([
-    { type: "tool_use", id: "tu-1", name: "assign_leaves", input: { ids } },
-  ]);
-}
-
-function textResponse(text: string): ProviderResponse {
-  return response([{ type: "text", text }]);
-}
-
-let workspaceDir: string;
-
-beforeEach(async () => {
-  workspaceDir = await mkdtemp(join(tmpdir(), "v3-assign-"));
-});
-
-afterEach(async () => {
-  await rm(workspaceDir, { recursive: true, force: true });
-});
-
-async function makePage(
-  slug: string,
-  frontmatter: Partial<ConceptPageFrontmatter>,
-  body = "page body",
-): Promise<void> {
-  await writePage(workspaceDir, {
-    slug,
-    frontmatter: { edges: [], ref_files: [], ref_urls: [], ...frontmatter },
-    body,
-  });
-}
-
-describe("assignPages", () => {
-  test("unions classified picks with prior picks, never overwriting", async () => {
-    await makePage("page-a", { leaves: ["domain-a/topic-x"] });
-    // Classifier returns [2] -> domain-a/topic-y and [1] -> already present.
-    const provider = stubProvider(() => toolResponse([2, 1]));
-
-    const results = await assignPages({
-      tree: threeLeafTree(),
-      workspaceDir,
-      slugs: ["page-a"],
-      provider,
-      throttleMs: 0,
-    });
-
-    expect(results).toEqual([
-      {
-        slug: "page-a",
-        before: ["domain-a/topic-x"],
-        after: ["domain-a/topic-x", "domain-a/topic-y"],
-        failed: false,
-      },
-    ]);
-
-    const written = await readPage(workspaceDir, "page-a");
-    expect(written?.frontmatter.leaves).toEqual([
-      "domain-a/topic-x",
-      "domain-a/topic-y",
-    ]);
-  });
-
-  test("classification failure leaves the page's leaves unchanged", async () => {
-    await makePage("page-a", { leaves: ["domain-b/topic-z"] });
-
-    // (a) provider throws
-    const throwing = stubProvider(() => {
-      throw new Error("boom");
-    });
-    let results = await assignPages({
-      tree: threeLeafTree(),
-      workspaceDir,
-      slugs: ["page-a"],
-      provider: throwing,
-      throttleMs: 0,
-    });
-    expect(results[0]).toEqual({
-      slug: "page-a",
-      before: ["domain-b/topic-z"],
-      after: ["domain-b/topic-z"],
-      failed: true,
-    });
-    expect(
-      (await readPage(workspaceDir, "page-a"))?.frontmatter.leaves,
-    ).toEqual(["domain-b/topic-z"]);
-
-    // (b) no tool use
-    results = await assignPages({
-      tree: threeLeafTree(),
-      workspaceDir,
-      slugs: ["page-a"],
-      provider: stubProvider(() => textResponse("no tool here")),
-      throttleMs: 0,
-    });
-    expect(results[0].failed).toBe(true);
-    expect(
-      (await readPage(workspaceDir, "page-a"))?.frontmatter.leaves,
-    ).toEqual(["domain-b/topic-z"]);
-
-    // (c) empty ids
-    results = await assignPages({
-      tree: threeLeafTree(),
-      workspaceDir,
-      slugs: ["page-a"],
-      provider: stubProvider(() => toolResponse([])),
-      throttleMs: 0,
-    });
-    expect(results[0].failed).toBe(true);
-    expect(
-      (await readPage(workspaceDir, "page-a"))?.frontmatter.leaves,
-    ).toEqual(["domain-b/topic-z"]);
-  });
-
-  test("deterministic id->path mapping, dropping out-of-range and 0 ids", async () => {
-    await makePage("page-a", {});
-    // 0 and 99 are invalid; 3 -> domain-b/topic-z; 1 -> domain-a/topic-x.
-    const provider = stubProvider(() => toolResponse([0, 99, 3, 1, -1, 2.5]));
-
-    const results = await assignPages({
-      tree: threeLeafTree(),
-      workspaceDir,
-      slugs: ["page-a"],
-      provider,
-      throttleMs: 0,
-    });
-
-    expect(results[0].after).toEqual(["domain-b/topic-z", "domain-a/topic-x"]);
-    expect(results[0].failed).toBe(false);
-  });
-
-  test("defaults to pages with empty or missing leaves", async () => {
-    await makePage("page-empty", { leaves: [] });
-    await makePage("page-missing", {});
-    await makePage("page-classified", { leaves: ["domain-a/topic-x"] });
-
-    const seen: string[] = [];
-    const provider = stubProvider((messages) => {
-      const text = messages[0]?.content
-        .map((b) => (b.type === "text" ? b.text : ""))
-        .join("");
-      seen.push(text);
-      return toolResponse([2]);
-    });
-
-    const results = await assignPages({
-      tree: threeLeafTree(),
-      workspaceDir,
-      provider,
-      throttleMs: 0,
-    });
-
-    const slugs = results.map((r) => r.slug).sort();
-    expect(slugs).toEqual(["page-empty", "page-missing"]);
-    // The classified page was never sent to the provider.
-    expect(seen.length).toBe(2);
-  });
-});

package/src/memory/v3/__tests__/capabilities.test.ts

@@ -1,118 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import {
-  CAPABILITIES_LEAF_PATH,
-  type CapabilityResolvers,
-  injectCapabilitiesLeaf,
-  isCapabilitySlug,
-  renderCapabilityContent,
-} from "../capabilities.js";
-import { buildNeedleIndex } from "../needle.js";
-import type { LeafPath, LeafTree, Slug } from "../types.js";
-
-function emptyTree(): LeafTree {
-  return { leaves: new Map(), byPage: new Map<Slug, LeafPath[]>() };
-}
-
-describe("isCapabilitySlug", () => {
-  test("true for skill and CLI-command slugs, false otherwise", () => {
-    expect(isCapabilitySlug("skills/meet-join")).toBe(true);
-    expect(isCapabilitySlug("cli-commands/schedules")).toBe(true);
-    expect(isCapabilitySlug("relationship/vows")).toBe(false);
-    expect(isCapabilitySlug("some-page")).toBe(false);
-  });
-});
-
-describe("injectCapabilitiesLeaf", () => {
-  test("registers an always-on leaf with the synthetic slugs as members", () => {
-    const tree = emptyTree();
-    const core = new Set<LeafPath>();
-    injectCapabilitiesLeaf(tree, core, ["skills/foo", "cli-commands/bar"]);
-
-    const leaf = tree.leaves.get(CAPABILITIES_LEAF_PATH);
-    expect(leaf?.frontmatter.in_core).toBe(true);
-    expect(leaf?.members).toEqual(["skills/foo", "cli-commands/bar"]);
-    expect(core.has(CAPABILITIES_LEAF_PATH)).toBe(true);
-  });
-
-  test("unions the leaf into each member's byPage entry without dropping existing leaves", () => {
-    const tree = emptyTree();
-    tree.byPage.set("skills/foo", ["other/leaf"]);
-    injectCapabilitiesLeaf(tree, new Set<LeafPath>(), [
-      "skills/foo",
-      "cli-commands/bar",
-    ]);
-
-    expect(tree.byPage.get("skills/foo")).toEqual([
-      "other/leaf",
-      CAPABILITIES_LEAF_PATH,
-    ]);
-    expect(tree.byPage.get("cli-commands/bar")).toEqual([
-      CAPABILITIES_LEAF_PATH,
-    ]);
-  });
-
-  test("is idempotent — re-injecting does not duplicate the byPage entry", () => {
-    const tree = emptyTree();
-    const core = new Set<LeafPath>();
-    injectCapabilitiesLeaf(tree, core, ["skills/foo"]);
-    injectCapabilitiesLeaf(tree, core, ["skills/foo"]);
-    expect(tree.byPage.get("skills/foo")).toEqual([CAPABILITIES_LEAF_PATH]);
-  });
-
-  test("stays always-on even with no installed skills/commands", () => {
-    const tree = emptyTree();
-    const core = new Set<LeafPath>();
-    injectCapabilitiesLeaf(tree, core, []);
-    expect(tree.leaves.get(CAPABILITIES_LEAF_PATH)?.members).toEqual([]);
-    expect(core.has(CAPABILITIES_LEAF_PATH)).toBe(true);
-  });
-});
-
-describe("renderCapabilityContent", () => {
-  const resolvers: CapabilityResolvers = {
-    skill: (slug) =>
-      slug === "skills/foo" ? { id: "foo", content: "foo capability" } : null,
-    cli: (slug) =>
-      slug === "cli-commands/bar"
-        ? { id: "bar", content: "bar capability" }
-        : null,
-  };
-
-  test("renders a skill slug with a Skill header", () => {
-    expect(renderCapabilityContent("skills/foo", resolvers)).toBe(
-      "# Skill: foo\nfoo capability",
-    );
-  });
-
-  test("renders a CLI-command slug with a CLI header", () => {
-    expect(renderCapabilityContent("cli-commands/bar", resolvers)).toBe(
-      "# CLI command: bar\nbar capability",
-    );
-  });
-
-  test("degrades to '' for a capability slug the cache cannot resolve", () => {
-    expect(renderCapabilityContent("skills/missing", resolvers)).toBe("");
-  });
-
-  test("returns null for a non-capability slug so the caller reads the on-disk page", () => {
-    expect(renderCapabilityContent("relationship/vows", resolvers)).toBeNull();
-  });
-});
-
-describe("needle indexes injected capability members", () => {
-  test("a skill slug is lexically retrievable by its title and summary", async () => {
-    const tree = emptyTree();
-    injectCapabilitiesLeaf(tree, new Set<LeafPath>(), ["skills/meet-join"]);
-
-    const needle = await buildNeedleIndex(
-      tree,
-      async () => "Join and transcribe a video meeting",
-    );
-
-    // By slug-derived title token.
-    expect(needle.query("meet", 5)).toContain("skills/meet-join");
-    // By summary token.
-    expect(needle.query("transcribe", 5)).toContain("skills/meet-join");
-  });
-});

package/src/memory/v3/__tests__/core.test.ts

@@ -1,39 +0,0 @@
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, test } from "bun:test";
-
-import { loadCore } from "../core.js";
-
-const BUNDLED_DATA_DIR = join(import.meta.dir, "..", "data");
-
-describe("loadCore", () => {
-  let tmpDirs: string[] = [];
-
-  afterEach(async () => {
-    await Promise.all(
-      tmpDirs.map((d) => rm(d, { recursive: true, force: true })),
-    );
-    tmpDirs = [];
-  });
-
-  async function makeTmpDir(): Promise<string> {
-    const dir = await mkdtemp(join(tmpdir(), "v3-core-"));
-    tmpDirs.push(dir);
-    return dir;
-  }
-
-  test("loads alwaysOn from the supplied dataDir's core.json into a Set", async () => {
-    const core = await loadCore(BUNDLED_DATA_DIR);
-    expect(core).toBeInstanceOf(Set);
-    expect(core.has("domain-a/topic-x")).toBe(true);
-    expect(core.size).toBe(1);
-  });
-
-  test("returns empty set when core.json is missing", async () => {
-    const emptyDataDir = await makeTmpDir();
-    const core = await loadCore(emptyDataDir);
-    expect(core).toBeInstanceOf(Set);
-    expect(core.size).toBe(0);
-  });
-});