@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/calls/telephony-stt-routing.ts

@@ -1,145 +0,0 @@
-/**
- * Telephony STT routing resolver.
- *
- * Maps the `services.stt.provider` value to a discriminated telephony
- * setup strategy that downstream TwiML generation and media-stream
- * adapters can consume without re-deriving provider semantics.
- *
- * Two strategy variants exist:
- *
- * - **`conversation-relay-native`** — the STT provider is natively
- *   supported by Twilio ConversationRelay. TwiML includes
- *   `transcriptionProvider` / `speechModel` attributes and Twilio
- *   handles audio ingestion. Used for `deepgram` and `google-gemini`.
- *
- * - **`media-stream-custom`** — the STT provider is not natively
- *   supported by Twilio. A `<Stream>` media-stream is opened instead
- *   and the daemon transcribes audio server-side via the provider's
- *   batch API. Used for `openai-whisper` and `xai`.
- *
- * Strategy selection and model normalization are driven entirely by
- * the provider catalog's `telephonyRouting` metadata — this module
- * contains no hardcoded provider-to-Twilio maps.
- */
-
-import { getConfig } from "../config/loader.js";
-import {
-  getProviderEntry,
-  type TwilioNativeProvider,
-} from "../providers/speech-to-text/provider-catalog.js";
-import type { SttProviderId } from "../stt/types.js";
-
-// ---------------------------------------------------------------------------
-// Strategy types
-// ---------------------------------------------------------------------------
-
-/**
- * Twilio-native ConversationRelay transcription provider name.
- *
- * Re-exported from the provider catalog for downstream consumers that
- * reference the strategy types without importing the catalog directly.
- */
-export type TwilioNativeTranscriptionProvider = TwilioNativeProvider;
-
-/**
- * The configured STT provider maps to a Twilio-native
- * ConversationRelay transcription path.
- */
-export interface ConversationRelayNativeStrategy {
-  readonly strategy: "conversation-relay-native";
-  /** Provider ID from `services.stt.provider`. */
-  readonly providerId: SttProviderId;
-  /** Twilio-native provider name for the TwiML attribute. */
-  readonly transcriptionProvider: TwilioNativeTranscriptionProvider;
-  /** ASR model identifier, or undefined to use the provider default. */
-  readonly speechModel: string | undefined;
-}
-
-/**
- * The configured STT provider requires a media-stream for custom
- * server-side transcription.
- */
-export interface MediaStreamCustomStrategy {
-  readonly strategy: "media-stream-custom";
-  /** Provider ID from `services.stt.provider`. */
-  readonly providerId: SttProviderId;
-}
-
-/**
- * Discriminated union of telephony setup strategies.
- */
-export type TelephonySttStrategy =
-  | ConversationRelayNativeStrategy
-  | MediaStreamCustomStrategy;
-
-/**
- * Result of resolving a telephony STT routing decision.
- *
- * - `resolved` — the provider was recognized and a strategy was determined.
- * - `unknown-provider` — the provider ID is not in the catalog or has no
- *   telephony routing mapping.
- */
-export type TelephonySttRoutingResult =
-  | { status: "resolved"; strategy: TelephonySttStrategy }
-  | { status: "unknown-provider"; providerId: string; reason: string };
-
-// ---------------------------------------------------------------------------
-// Public resolver
-// ---------------------------------------------------------------------------
-
-/**
- * Resolve the telephony STT routing strategy from `services.stt.provider`.
- *
- * Reads the active provider from config, checks the provider catalog for
- * validity, then derives the telephony strategy from the catalog entry's
- * `telephonyRouting` metadata.
- */
-export function resolveTelephonySttRouting(): TelephonySttRoutingResult {
-  const config = getConfig();
-  const providerId = config.services.stt.provider;
-
-  // Validate the provider exists in the catalog.
-  const entry = getProviderEntry(providerId as SttProviderId);
-  if (!entry) {
-    return {
-      status: "unknown-provider",
-      providerId,
-      reason: `STT provider "${providerId}" is not in the provider catalog`,
-    };
-  }
-
-  const { telephonyRouting } = entry;
-
-  // Derive strategy from catalog routing metadata.
-  if (telephonyRouting.strategyKind === "conversation-relay-native") {
-    const mapping = telephonyRouting.twilioNativeMapping;
-
-    // Defensive: conversation-relay-native entries must have a mapping.
-    if (!mapping) {
-      return {
-        status: "unknown-provider",
-        providerId: entry.id,
-        reason: `Provider "${entry.id}" declares conversation-relay-native strategy but has no twilioNativeMapping`,
-      };
-    }
-
-    return {
-      status: "resolved",
-      strategy: {
-        strategy: "conversation-relay-native",
-        providerId: entry.id,
-        transcriptionProvider: mapping.provider,
-        speechModel: mapping.defaultSpeechModel,
-      },
-    };
-  }
-
-  // media-stream-custom path.
-  return {
-    status: "resolved",
-    strategy: {
-      strategy: "media-stream-custom",
-      providerId: entry.id,
-    },
-  };
-}

package/src/contacts/__tests__/contacts-write-revoke-relay.test.ts

@@ -1,128 +0,0 @@
-/**
- * Tests for the gateway-first member-revoke relay.
- *
- * revokeMemberChannel downgrades the channel's ACL status through the gateway
- * (source of truth) via `ipcCallPersistent("mark_channel_revoked", ...)` first,
- * then mirrors the downgrade to the assistant DB best-effort. A local mirror
- * failure is swallowed so the gateway-owned outcome stands.
- */
-
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-import type { ContactWriteResult } from "../types.js";
-
-type IpcCall = { method: string; params?: Record<string, unknown> };
-
-let ipcCalls: IpcCall[] = [];
-let ipcOk = true;
-
-const ipcCallPersistentMock = mock(
-  async (method: string, params?: Record<string, unknown>) => {
-    ipcCalls.push({ method, params });
-    return {
-      ok: ipcOk,
-      didWrite: ipcOk,
-      channel: {
-        id: (params?.contactChannelId as string) ?? "ch1",
-        contactId: "c1",
-        type: "telegram",
-        address: "addr",
-        status: "revoked",
-        revokedReason: (params?.reason as string) ?? null,
-      },
-    };
-  },
-);
-const actualGatewayClient = await import("../../ipc/gateway-client.js");
-mock.module("../../ipc/gateway-client.js", () => ({
-  ...actualGatewayClient,
-  ipcCallPersistent: ipcCallPersistentMock,
-}));
-
-
-// Local resolver primitive — resolves the native contact/channel by id; the
-// gateway owns the ACL downgrade, so it takes no reason and mutates nothing.
-const revokeMemberResult: ContactWriteResult = {
-  contact: { id: "c1" } as ContactWriteResult["contact"],
-  channel: { id: "ch1" } as ContactWriteResult["channel"],
-};
-const revokeMemberMock = mock((_memberId: string) => revokeMemberResult);
-const actualContactsWrite = await import("../contacts-write.js");
-mock.module("../contacts-write.js", () => ({
-  ...actualContactsWrite,
-  revokeMember: revokeMemberMock,
-}));
-
-const { revokeMemberChannel } = await import("../member-write-relay.js");
-
-describe("revokeMemberChannel gateway-first relay", () => {
-  beforeEach(() => {
-    ipcCalls = [];
-    ipcOk = true;
-    ipcCallPersistentMock.mockClear();
-    revokeMemberMock.mockClear();
-    revokeMemberMock.mockImplementation(() => revokeMemberResult);
-  });
-
-  test("relays the revoke to the gateway before mirroring locally", async () => {
-    const result = await revokeMemberChannel("ch1", "removed");
-
-    expect(ipcCalls).toEqual([
-      {
-        method: "mark_channel_revoked",
-        params: { contactChannelId: "ch1", reason: "removed" },
-      },
-    ]);
-    expect(revokeMemberMock).toHaveBeenCalledTimes(1);
-    expect(revokeMemberMock).toHaveBeenCalledWith("ch1");
-    expect(result).toBe(revokeMemberResult);
-  });
-
-  test("strips the composite contactId:channelId prefix before the relay", async () => {
-    await revokeMemberChannel("c1:ch1");
-
-    expect(ipcCalls[0]?.params?.contactChannelId).toBe("ch1");
-    // The local resolver still receives the original composite id it accepts.
-    expect(revokeMemberMock).toHaveBeenCalledWith("c1:ch1");
-  });
-
-  test("always relays — never skips based on local mirror status", async () => {
-    // The gateway owns the ACL outcome; the relay must fire even if the local
-    // mirror lags (says revoked) while the gateway row is still active.
-    await revokeMemberChannel("ch1");
-
-    expect(ipcCalls).toEqual([
-      {
-        method: "mark_channel_revoked",
-        params: { contactChannelId: "ch1", reason: undefined },
-      },
-    ]);
-    expect(revokeMemberMock).toHaveBeenCalledTimes(1);
-  });
-
-  test("swallows a local-mirror failure without throwing; the gateway revoke stands", async () => {
-    revokeMemberMock.mockImplementation(() => {
-      throw new Error("local mirror exploded");
-    });
-
-    const result = await revokeMemberChannel("ch1", "removed");
-
-    expect(ipcCalls).toHaveLength(1);
-    expect(result).toBeNull();
-  });
-
-  test("throws when the gateway relay returns ok: false", async () => {
-    ipcOk = false;
-
-    let thrown: Error | undefined;
-    try {
-      await revokeMemberChannel("ch1");
-    } catch (err) {
-      thrown = err as Error;
-    }
-
-    expect(thrown).toBeDefined();
-    // Local mirror must not run when the gateway refuses the downgrade.
-    expect(revokeMemberMock).not.toHaveBeenCalled();
-  });
-});

package/src/daemon/__tests__/daemon-skill-host.test.ts

@@ -1,273 +0,0 @@
-/**
- * Smoke test for `createDaemonSkillHost`.
- *
- * The goal here is narrow: construct the host with a stub skillId and
- * shallow-assert that every facet and method lines up with the
- * `SkillHost` contract. We stub every delegate module with `mock.module`
- * so the test neither touches real singletons (config loader, event hub,
- * SQLite, provider registries) nor requires workspace initialization.
- *
- * Deep behavioral coverage for each delegate lives in that delegate's own
- * test — this file is just a wiring check.
- */
-
-import { describe, expect, mock, test } from "bun:test";
-
-// ---------------------------------------------------------------------------
-// Module-level stubs — installed before importing the module under test
-// ---------------------------------------------------------------------------
-
-const loggerSpy = {
-  debug: mock(() => {}),
-  info: mock(() => {}),
-  warn: mock(() => {}),
-  error: mock(() => {}),
-};
-const getLoggerSpy = mock((_name: string) => loggerSpy);
-mock.module("../../util/logger.js", () => ({
-  getLogger: getLoggerSpy,
-}));
-
-mock.module("../../config/loader.js", () => ({
-  getConfig: () => ({
-    services: { tts: { provider: "elevenlabs" }, nested: { value: 42 } },
-  }),
-  getNestedValue: (obj: Record<string, unknown>, path: string) => {
-    const keys = path.split(".");
-    let cur: unknown = obj;
-    for (const k of keys) {
-      if (cur == null || typeof cur !== "object") return undefined;
-      cur = (cur as Record<string, unknown>)[k];
-    }
-    return cur;
-  },
-}));
-
-mock.module("../../config/assistant-feature-flags.js", () => ({
-  isAssistantFeatureFlagEnabled: (key: string) => key === "enabled-flag",
-}));
-
-mock.module("../identity-helpers.js", () => ({
-  // Default returns null so we can assert normalization to undefined.
-  getAssistantName: () => null,
-}));
-
-mock.module("../../util/platform.js", () => ({
-  getWorkspaceDir: () => "/tmp/workspace",
-  vellumRoot: () => "/tmp/vellum",
-}));
-
-mock.module("../../runtime/runtime-mode.js", () => ({
-  getDaemonRuntimeMode: () => "bare-metal",
-}));
-
-mock.module("../../providers/provider-send-message.js", () => ({
-  getConfiguredProvider: async () => ({ id: "stub-provider" }),
-  userMessage: (text: string) => ({ role: "user", content: text }),
-  extractToolUse: () => undefined,
-  createTimeout: () => ({
-    signal: new AbortController().signal,
-    cleanup: () => {},
-  }),
-}));
-
-mock.module("../../providers/speech-to-text/provider-catalog.js", () => ({
-  listProviderIds: () => ["whisper"],
-  supportsBoundary: () => true,
-}));
-
-mock.module("../../providers/speech-to-text/resolve.js", () => ({
-  resolveStreamingTranscriber: async () => ({ kind: "stream" }),
-}));
-
-mock.module("../../tts/provider-registry.js", () => ({
-  getTtsProvider: (id: string) => ({ id }),
-}));
-
-mock.module("../../tts/tts-config-resolver.js", () => ({
-  resolveTtsConfig: () => ({ provider: "elevenlabs" }),
-}));
-
-mock.module("../../security/secure-keys.js", () => ({
-  // Default returns undefined so we can assert normalization to null.
-  getProviderKeyAsync: async () => undefined,
-}));
-
-mock.module("../../persistence/conversation-crud.js", () => ({
-  addMessage: async () => ({ id: "msg-123" }),
-  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
-}));
-
-mock.module("../../runtime/agent-wake.js", () => ({
-  wakeAgentForOpportunity: async () => ({ invoked: true }),
-}));
-
-const publishSpy = mock(async () => {});
-const subscribeSpy = mock(() => ({ dispose: () => {}, active: true }));
-mock.module("../../runtime/assistant-event-hub.js", () => ({
-  assistantEventHub: {
-    publish: publishSpy,
-    subscribe: subscribeSpy,
-  },
-  broadcastMessage: async () => {},
-}));
-
-mock.module("../../runtime/assistant-event.js", () => ({
-  buildAssistantEvent: (message: unknown, conversationId?: string) => ({
-    id: "evt-1",
-    conversationId,
-    emittedAt: "2024-01-01T00:00:00.000Z",
-    message,
-  }),
-}));
-
-mock.module("../../runtime/assistant-scope.js", () => ({
-  DAEMON_INTERNAL_ASSISTANT_ID: "self",
-}));
-
-const registerExternalToolsSpy = mock(() => {});
-mock.module("../../tools/registry.js", () => ({
-  registerExternalTools: registerExternalToolsSpy,
-}));
-
-const registerSkillRouteSpy = mock(() => Object.freeze({}));
-mock.module("../../runtime/skill-route-registry.js", () => ({
-  registerSkillRoute: registerSkillRouteSpy,
-}));
-
-const registerShutdownHookSpy = mock(() => {});
-mock.module("../shutdown-registry.js", () => ({
-  registerShutdownHook: registerShutdownHookSpy,
-}));
-
-class StubSpeakerTracker {}
-mock.module("../../calls/speaker-identification.js", () => ({
-  SpeakerIdentityTracker: StubSpeakerTracker,
-}));
-
-// ---------------------------------------------------------------------------
-// Module under test — imported after every stub is in place
-// ---------------------------------------------------------------------------
-
-import { createDaemonSkillHost } from "../daemon-skill-host.js";
-
-describe("createDaemonSkillHost", () => {
-  const host = createDaemonSkillHost("meet-join");
-
-  test("exposes every facet", () => {
-    expect(host.logger).toBeDefined();
-    expect(host.config).toBeDefined();
-    expect(host.identity).toBeDefined();
-    expect(host.platform).toBeDefined();
-    expect(host.providers).toBeDefined();
-    expect(host.memory).toBeDefined();
-    expect(host.events).toBeDefined();
-    expect(host.registries).toBeDefined();
-    expect(host.speakers).toBeDefined();
-  });
-
-  test("logger.get prefixes the scope with the skillId", () => {
-    const log = host.logger.get("test-scope");
-    log.debug("d", { k: "v" });
-    log.info("i");
-    log.warn("w");
-    log.error("e");
-    expect(getLoggerSpy).toHaveBeenCalledWith("meet-join:test-scope");
-    expect(loggerSpy.debug).toHaveBeenCalled();
-    expect(loggerSpy.info).toHaveBeenCalled();
-    expect(loggerSpy.warn).toHaveBeenCalled();
-    expect(loggerSpy.error).toHaveBeenCalled();
-  });
-
-  test("config.isFeatureFlagEnabled delegates to the feature-flag helper", () => {
-    expect(host.config.isFeatureFlagEnabled("enabled-flag")).toBe(true);
-    expect(host.config.isFeatureFlagEnabled("other-flag")).toBe(false);
-  });
-
-  test("config.getSection walks dotted paths into the resolved config", () => {
-    expect(
-      host.config.getSection<{ provider: string }>("services.tts"),
-    ).toEqual({ provider: "elevenlabs" });
-    expect(host.config.getSection<number>("services.nested.value")).toBe(42);
-    expect(host.config.getSection("services.missing.path")).toBeUndefined();
-  });
-
-  test("identity normalizes a null assistant name to undefined", () => {
-    expect(host.identity.getAssistantName()).toBeUndefined();
-  });
-
-  test("platform methods return the stubbed values", () => {
-    expect(host.platform.workspaceDir()).toBe("/tmp/workspace");
-    expect(host.platform.vellumRoot()).toBe("/tmp/vellum");
-    expect(host.platform.runtimeMode()).toBe("bare-metal");
-  });
-
-  test("providers.stt lists ids and answers boundary questions", () => {
-    expect(host.providers.stt.listProviderIds()).toEqual(["whisper"]);
-    expect(host.providers.stt.supportsBoundary("whisper")).toBe(true);
-  });
-
-  test("providers.tts exposes get + resolveConfig", () => {
-    expect(host.providers.tts.get("elevenlabs")).toEqual({ id: "elevenlabs" });
-    expect(host.providers.tts.resolveConfig()).toEqual({
-      provider: "elevenlabs",
-    });
-  });
-
-  test("providers.secureKeys normalizes undefined to null", async () => {
-    await expect(
-      host.providers.secureKeys.getProviderKey("x"),
-    ).resolves.toBeNull();
-  });
-
-  test("providers.llm exposes the four message helpers", () => {
-    expect(typeof host.providers.llm.getConfigured).toBe("function");
-    expect(typeof host.providers.llm.userMessage).toBe("function");
-    expect(typeof host.providers.llm.extractToolUse).toBe("function");
-    const { signal, cleanup } = host.providers.llm.createTimeout(1000);
-    expect(signal).toBeInstanceOf(AbortSignal);
-    expect(typeof cleanup).toBe("function");
-    cleanup();
-  });
-
-  test("memory.addMessage and wakeAgentForOpportunity are callable", async () => {
-    await expect(
-      host.memory.addMessage("c1", "user", "hi"),
-    ).resolves.toBeDefined();
-    await expect(
-      host.memory.wakeAgentForOpportunity({ conversationId: "c1" }),
-    ).resolves.toBeUndefined();
-  });
-
-  test("events.publish, subscribe, and buildEvent plumb through the hub", async () => {
-    const evt = host.events.buildEvent({ type: "ping" }, "c1");
-    expect(evt.conversationId).toBe("c1");
-    await host.events.publish(evt);
-    expect(publishSpy).toHaveBeenCalled();
-    const sub = host.events.subscribe({}, () => undefined);
-    expect(sub.active).toBe(true);
-    expect(subscribeSpy).toHaveBeenCalled();
-  });
-
-  test("registries expose the three registration methods", () => {
-    host.registries.registerTools(() => []);
-    expect(registerExternalToolsSpy).toHaveBeenCalled();
-    const handle = host.registries.registerSkillRoute({
-      pattern: /^\/foo/,
-      methods: ["GET"],
-      handler: async () => new Response("ok"),
-    });
-    expect(handle).toBeDefined();
-    expect(registerSkillRouteSpy).toHaveBeenCalled();
-    const hook = async () => {};
-    host.registries.registerShutdownHook("test-hook", hook);
-    expect(registerShutdownHookSpy).toHaveBeenCalledWith(
-      "meet-join:test-hook",
-      hook,
-    );
-  });
-
-  test("speakers.createTracker yields a concrete tracker instance", () => {
-    expect(host.speakers.createTracker()).toBeInstanceOf(StubSpeakerTracker);
-  });
-});