@vellumai/assistant 0.10.3 → 0.10.4-dev.202607010028.1a4efcc

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

@@ -1,203 +0,0 @@
-/**
- * Unit tests for the `host.memory.*` skill IPC routes.
- *
- * Every daemon delegate is mocked with `mock.module` so the test exercises
- * only the route layer — param parsing, delegate call shape, return shape.
- * Deep behavioral coverage for `addMessage` / `wakeAgentForOpportunity`
- * lives in their own modules.
- */
-
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-// ---------------------------------------------------------------------------
-// Module-level stubs — installed before importing the module under test
-// ---------------------------------------------------------------------------
-
-const addMessageSpy = mock(
-  async (
-    _conversationId: string,
-    _role: string,
-    _content: string,
-    _options?: {
-      metadata?: Record<string, unknown>;
-      skipIndexing?: boolean;
-      clientMessageId?: string;
-    },
-  ) => ({ id: "msg-xyz", createdAt: 123 }),
-);
-mock.module("../../../memory/conversation-crud.js", () => ({
-  addMessage: addMessageSpy,
-  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
-}));
-
-const wakeAgentSpy = mock(
-  async (_opts: { conversationId: string; hint: string; source: string }) => ({
-    invoked: true,
-    producedToolCalls: false,
-  }),
-);
-mock.module("../../../runtime/agent-wake.js", () => ({
-  wakeAgentForOpportunity: wakeAgentSpy,
-}));
-
-// ---------------------------------------------------------------------------
-// Module under test — imported after every stub is in place
-// ---------------------------------------------------------------------------
-
-import {
-  memoryAddMessageRoute,
-  memorySkillRoutes,
-  memoryWakeAgentForOpportunityRoute,
-} from "../memory.js";
-
-beforeEach(() => {
-  addMessageSpy.mockClear();
-  wakeAgentSpy.mockClear();
-});
-
-describe("memorySkillRoutes registry", () => {
-  test("exposes both canonical method names", () => {
-    const methods = memorySkillRoutes.map((r) => r.method).sort();
-    expect(methods).toEqual([
-      "host.memory.addMessage",
-      "host.memory.wakeAgentForOpportunity",
-    ]);
-  });
-});
-
-describe("host.memory.addMessage", () => {
-  test("forwards all fields to addMessage as options object and returns its result", async () => {
-    const result = await memoryAddMessageRoute.handler({
-      conversationId: "conv-1",
-      role: "user",
-      content: "hello",
-      metadata: { foo: "bar" },
-      skipIndexing: true,
-    });
-
-    expect(addMessageSpy).toHaveBeenCalledTimes(1);
-    const call = addMessageSpy.mock.calls[0];
-    expect(call[0]).toBe("conv-1");
-    expect(call[1]).toBe("user");
-    expect(call[2]).toBe("hello");
-    expect(call[3]).toEqual({
-      metadata: { foo: "bar" },
-      skipIndexing: true,
-      clientMessageId: undefined,
-    });
-    expect(result).toEqual({ id: "msg-xyz", createdAt: 123 });
-  });
-
-  test("accepts omitted optional fields", async () => {
-    await memoryAddMessageRoute.handler({
-      conversationId: "conv-2",
-      role: "assistant",
-      content: "ack",
-    });
-
-    expect(addMessageSpy).toHaveBeenCalledTimes(1);
-    const call = addMessageSpy.mock.calls[0];
-    expect(call[3]).toEqual({
-      metadata: undefined,
-      skipIndexing: undefined,
-      clientMessageId: undefined,
-    });
-  });
-
-  test("rejects missing conversationId", async () => {
-    await expect(
-      memoryAddMessageRoute.handler({ role: "user", content: "x" }),
-    ).rejects.toThrow();
-  });
-
-  test("rejects empty conversationId", async () => {
-    await expect(
-      memoryAddMessageRoute.handler({
-        conversationId: "",
-        role: "user",
-        content: "x",
-      }),
-    ).rejects.toThrow();
-  });
-
-  test("rejects missing role", async () => {
-    await expect(
-      memoryAddMessageRoute.handler({
-        conversationId: "c",
-        content: "x",
-      }),
-    ).rejects.toThrow();
-  });
-
-  test("rejects missing content", async () => {
-    await expect(
-      memoryAddMessageRoute.handler({
-        conversationId: "c",
-        role: "user",
-      }),
-    ).rejects.toThrow();
-  });
-
-  test("rejects the non-renderable system role", async () => {
-    // GIVEN the messages store is UI-facing (ConversationMessage), so only
-    // renderable turns may be persisted via this facet
-    // WHEN a skill attempts to add a system row
-    // THEN the route rejects it instead of persisting agent-context scaffolding
-    await expect(
-      memoryAddMessageRoute.handler({
-        conversationId: "c",
-        role: "system",
-        content: "agent-context scaffolding",
-      }),
-    ).rejects.toThrow();
-    expect(addMessageSpy).not.toHaveBeenCalled();
-  });
-});
-
-describe("host.memory.wakeAgentForOpportunity", () => {
-  test("forwards WakeOptions and returns void (drops WakeResult)", async () => {
-    const result = await memoryWakeAgentForOpportunityRoute.handler({
-      conversationId: "conv-1",
-      hint: "new email arrived",
-      source: "skill-test",
-    });
-
-    expect(wakeAgentSpy).toHaveBeenCalledTimes(1);
-    expect(wakeAgentSpy.mock.calls[0]?.[0]).toEqual({
-      conversationId: "conv-1",
-      hint: "new email arrived",
-      source: "skill-test",
-    });
-    // Contract is `void` — daemon's WakeResult is discarded on purpose.
-    expect(result).toBeUndefined();
-  });
-
-  test("rejects missing conversationId", async () => {
-    await expect(
-      memoryWakeAgentForOpportunityRoute.handler({
-        hint: "h",
-        source: "s",
-      }),
-    ).rejects.toThrow();
-  });
-
-  test("rejects empty hint", async () => {
-    await expect(
-      memoryWakeAgentForOpportunityRoute.handler({
-        conversationId: "c",
-        hint: "",
-        source: "s",
-      }),
-    ).rejects.toThrow();
-  });
-
-  test("rejects empty source", async () => {
-    await expect(
-      memoryWakeAgentForOpportunityRoute.handler({
-        conversationId: "c",
-        hint: "h",
-        source: "",
-      }),
-    ).rejects.toThrow();
-  });
-});

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

@@ -1,111 +0,0 @@
-/**
- * Unit tests for the `host.platform.*` skill IPC routes. Mocks the platform
- * path helpers and runtime-mode resolver so route behavior is verified
- * independently of the real filesystem or `IS_CONTAINERIZED` env setting.
- */
-
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-
-import type { DaemonRuntimeMode } from "../../../runtime/runtime-mode.js";
-
-// ---------------------------------------------------------------------------
-// Mock platform + runtime-mode helpers
-// ---------------------------------------------------------------------------
-
-let mockWorkspaceDir = "/tmp/workspace";
-let mockVellumRoot = "/tmp/.vellum";
-let mockRuntimeMode: DaemonRuntimeMode = "bare-metal";
-
-mock.module("../../../util/platform.js", () => ({
-  getWorkspaceDir: () => mockWorkspaceDir,
-  vellumRoot: () => mockVellumRoot,
-}));
-
-mock.module("../../../runtime/runtime-mode.js", () => ({
-  getDaemonRuntimeMode: () => mockRuntimeMode,
-}));
-
-const {
-  hostPlatformWorkspaceDirRoute,
-  hostPlatformVellumRootRoute,
-  hostPlatformRuntimeModeRoute,
-  platformRoutes,
-} = await import("../platform.js");
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-beforeEach(() => {
-  mockWorkspaceDir = "/tmp/workspace";
-  mockVellumRoot = "/tmp/.vellum";
-  mockRuntimeMode = "bare-metal";
-});
-
-afterEach(() => {
-  mockWorkspaceDir = "/tmp/workspace";
-  mockVellumRoot = "/tmp/.vellum";
-  mockRuntimeMode = "bare-metal";
-});
-
-describe("host.platform.workspaceDir IPC route", () => {
-  test("method is host.platform.workspaceDir", () => {
-    expect(hostPlatformWorkspaceDirRoute.method).toBe(
-      "host.platform.workspaceDir",
-    );
-  });
-
-  test("returns the workspace directory from the platform helper", async () => {
-    mockWorkspaceDir = "/Users/alice/.vellum/workspace";
-
-    const result = await hostPlatformWorkspaceDirRoute.handler();
-
-    expect(result).toBe("/Users/alice/.vellum/workspace");
-  });
-});
-
-describe("host.platform.vellumRoot IPC route", () => {
-  test("method is host.platform.vellumRoot", () => {
-    expect(hostPlatformVellumRootRoute.method).toBe("host.platform.vellumRoot");
-  });
-
-  test("returns the vellum root from the platform helper", async () => {
-    mockVellumRoot = "/Users/alice/.vellum";
-
-    const result = await hostPlatformVellumRootRoute.handler();
-
-    expect(result).toBe("/Users/alice/.vellum");
-  });
-});
-
-describe("host.platform.runtimeMode IPC route", () => {
-  test("method is host.platform.runtimeMode", () => {
-    expect(hostPlatformRuntimeModeRoute.method).toBe(
-      "host.platform.runtimeMode",
-    );
-  });
-
-  test("returns 'bare-metal' when the daemon runs outside a container", async () => {
-    mockRuntimeMode = "bare-metal";
-
-    const result = await hostPlatformRuntimeModeRoute.handler();
-
-    expect(result).toBe("bare-metal");
-  });
-
-  test("returns 'docker' when the daemon runs inside a container", async () => {
-    mockRuntimeMode = "docker";
-
-    const result = await hostPlatformRuntimeModeRoute.handler();
-
-    expect(result).toBe("docker");
-  });
-});
-
-describe("platformRoutes", () => {
-  test("exports all three platform routes", () => {
-    expect(platformRoutes).toContain(hostPlatformWorkspaceDirRoute);
-    expect(platformRoutes).toContain(hostPlatformVellumRootRoute);
-    expect(platformRoutes).toContain(hostPlatformRuntimeModeRoute);
-  });
-});

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

@@ -1,265 +0,0 @@
-/**
- * Unit tests for the `host.providers.*` skill IPC routes.
- *
- * Every daemon delegate is mocked with `mock.module` so the test exercises
- * only the route layer — param parsing, delegate call shape, return shape.
- * Deep behavioral coverage lives in each delegate's own module tests.
- */
-
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-// ---------------------------------------------------------------------------
-// Module-level stubs — installed before importing the module under test
-// ---------------------------------------------------------------------------
-
-const sendMessageSpy = mock(async () => ({
-  content: [{ type: "text", text: "hello" }],
-  model: "stub-model",
-  usage: { inputTokens: 1, outputTokens: 2 },
-  stopReason: "end_turn",
-}));
-const stubProvider: unknown = {
-  name: "stub-provider",
-  sendMessage: sendMessageSpy,
-};
-const getConfiguredProviderSpy = mock(async () => stubProvider);
-mock.module("../../../providers/provider-send-message.js", () => ({
-  getConfiguredProvider: getConfiguredProviderSpy,
-}));
-
-const sttListProviderIdsSpy = mock(() => ["openai-whisper", "deepgram"]);
-const sttSupportsBoundarySpy = mock(() => true);
-mock.module("../../../providers/speech-to-text/provider-catalog.js", () => ({
-  listProviderIds: sttListProviderIdsSpy,
-  supportsBoundary: sttSupportsBoundarySpy,
-}));
-
-const getTtsProviderSpy = mock((id: string) => ({
-  id,
-  capabilities: {},
-  synthesize: async () => ({}),
-}));
-mock.module("../../../tts/provider-registry.js", () => ({
-  getTtsProvider: getTtsProviderSpy,
-}));
-
-const resolveTtsConfigSpy = mock(() => ({
-  provider: "elevenlabs",
-  providerConfig: { voiceId: "stub-voice" },
-}));
-mock.module("../../../tts/tts-config-resolver.js", () => ({
-  resolveTtsConfig: resolveTtsConfigSpy,
-}));
-
-const getConfigSpy = mock(() => ({ services: { tts: {} } }));
-mock.module("../../../config/loader.js", () => ({
-  getConfig: getConfigSpy,
-}));
-
-const getProviderKeyAsyncSpy = mock(async (id: string) =>
-  id === "present" ? "secret-key" : undefined,
-);
-mock.module("../../../security/secure-keys.js", () => ({
-  getProviderKeyAsync: getProviderKeyAsyncSpy,
-}));
-
-// ---------------------------------------------------------------------------
-// Module under test — imported after every stub is in place
-// ---------------------------------------------------------------------------
-
-import {
-  providerSkillRoutes,
-  providersLlmCompleteRoute,
-  providersSecureKeysGetProviderKeyRoute,
-  providersSttListProviderIdsRoute,
-  providersSttSupportsBoundaryRoute,
-  providersTtsGetRoute,
-  providersTtsResolveConfigRoute,
-} from "../providers.js";
-
-beforeEach(() => {
-  sendMessageSpy.mockClear();
-  getConfiguredProviderSpy.mockClear();
-  sttListProviderIdsSpy.mockClear();
-  sttSupportsBoundarySpy.mockClear();
-  getTtsProviderSpy.mockClear();
-  resolveTtsConfigSpy.mockClear();
-  getConfigSpy.mockClear();
-  getProviderKeyAsyncSpy.mockClear();
-});
-
-describe("providerSkillRoutes registry", () => {
-  test("exposes every documented method name", () => {
-    const methods = providerSkillRoutes.map((r) => r.method).sort();
-    expect(methods).toEqual([
-      "host.providers.llm.complete",
-      "host.providers.secureKeys.getProviderKey",
-      "host.providers.stt.listProviderIds",
-      "host.providers.stt.supportsBoundary",
-      "host.providers.tts.get",
-      "host.providers.tts.resolveConfig",
-    ]);
-  });
-});
-
-describe("host.providers.llm.complete", () => {
-  test("resolves the provider by callSite and forwards request args", async () => {
-    const response = await providersLlmCompleteRoute.handler({
-      callSite: "mainAgent",
-      messages: [{ role: "user", content: [{ type: "text", text: "hi" }] }],
-      systemPrompt: "you are helpful",
-    });
-
-    expect(getConfiguredProviderSpy).toHaveBeenCalledWith("mainAgent");
-    expect(sendMessageSpy).toHaveBeenCalledTimes(1);
-    const call = sendMessageSpy.mock.calls[0] as unknown as [
-      unknown[],
-      {
-        systemPrompt?: string;
-        tools?: unknown[];
-        config?: Record<string, unknown>;
-      },
-    ];
-    expect(Array.isArray(call[0])).toBe(true);
-    expect(call[1]?.systemPrompt).toBe("you are helpful");
-    expect(response).toEqual({
-      content: [{ type: "text", text: "hello" }],
-      model: "stub-model",
-      usage: { inputTokens: 1, outputTokens: 2 },
-      stopReason: "end_turn",
-    });
-  });
-
-  test("passes tools + config through when provided", async () => {
-    await providersLlmCompleteRoute.handler({
-      callSite: "mainAgent",
-      messages: [],
-      tools: [{ name: "echo", description: "", input_schema: {} }],
-      config: { model: "override-model" },
-    });
-
-    const call = sendMessageSpy.mock.calls[0] as unknown as [
-      unknown[],
-      { tools?: unknown[]; config?: Record<string, unknown> },
-    ];
-    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",
-    });
-  });
-
-  test("rejects an unknown callSite", async () => {
-    await expect(
-      providersLlmCompleteRoute.handler({
-        callSite: "not-a-callsite",
-        messages: [],
-      }),
-    ).rejects.toThrow();
-  });
-
-  test("throws when no provider is configured for the callSite", async () => {
-    getConfiguredProviderSpy.mockImplementationOnce(async () => null);
-    await expect(
-      providersLlmCompleteRoute.handler({
-        callSite: "mainAgent",
-        messages: [],
-      }),
-    ).rejects.toThrow(/no provider configured/);
-  });
-});
-
-describe("host.providers.stt.listProviderIds", () => {
-  test("returns a fresh array of ids", () => {
-    const result = providersSttListProviderIdsRoute.handler();
-    expect(result).toEqual(["openai-whisper", "deepgram"]);
-    expect(sttListProviderIdsSpy).toHaveBeenCalled();
-  });
-});
-
-describe("host.providers.stt.supportsBoundary", () => {
-  test("delegates with positional (id, boundary) and returns the bool", () => {
-    sttSupportsBoundarySpy.mockImplementationOnce(() => true);
-    const result = providersSttSupportsBoundaryRoute.handler({
-      id: "openai-whisper",
-      boundary: "daemon-streaming",
-    });
-
-    expect(result).toBe(true);
-    const call = sttSupportsBoundarySpy.mock.calls[0] as unknown as [
-      string,
-      string,
-    ];
-    expect(call[0]).toBe("openai-whisper");
-    expect(call[1]).toBe("daemon-streaming");
-  });
-
-  test("rejects missing id", () => {
-    expect(() =>
-      providersSttSupportsBoundaryRoute.handler({ boundary: "x" }),
-    ).toThrow();
-  });
-
-  test("rejects missing boundary", () => {
-    expect(() =>
-      providersSttSupportsBoundaryRoute.handler({ id: "y" }),
-    ).toThrow();
-  });
-});
-
-describe("host.providers.tts.resolveConfig", () => {
-  test("returns a serializable config object from resolveTtsConfig(getConfig())", () => {
-    const result = providersTtsResolveConfigRoute.handler();
-    expect(result).toEqual({
-      provider: "elevenlabs",
-      providerConfig: { voiceId: "stub-voice" },
-    });
-    expect(getConfigSpy).toHaveBeenCalled();
-    expect(resolveTtsConfigSpy).toHaveBeenCalled();
-  });
-});
-
-describe("host.providers.tts.get", () => {
-  test("returns a handle serialized as { id } after resolving the provider", () => {
-    const result = providersTtsGetRoute.handler({ id: "elevenlabs" });
-    expect(result).toEqual({ id: "elevenlabs" });
-    expect(getTtsProviderSpy).toHaveBeenCalledWith("elevenlabs");
-  });
-
-  test("propagates unknown-id errors from the registry", () => {
-    getTtsProviderSpy.mockImplementationOnce(() => {
-      throw new Error('Unknown TTS provider "ghost".');
-    });
-    expect(() => providersTtsGetRoute.handler({ id: "ghost" })).toThrow(
-      /Unknown TTS provider/,
-    );
-  });
-
-  test("rejects empty id", () => {
-    expect(() => providersTtsGetRoute.handler({ id: "" })).toThrow();
-  });
-});
-
-describe("host.providers.secureKeys.getProviderKey", () => {
-  test("returns the stored key for a known provider", async () => {
-    const result = await providersSecureKeysGetProviderKeyRoute.handler({
-      id: "present",
-    });
-    expect(result).toBe("secret-key");
-    expect(getProviderKeyAsyncSpy).toHaveBeenCalledWith("present");
-  });
-
-  test("normalizes daemon's undefined to null for absent keys", async () => {
-    const result = await providersSecureKeysGetProviderKeyRoute.handler({
-      id: "absent",
-    });
-    expect(result).toBeNull();
-  });
-
-  test("rejects empty id", async () => {
-    await expect(
-      providersSecureKeysGetProviderKeyRoute.handler({ id: "" }),
-    ).rejects.toThrow();
-  });
-});