@mycadet/assistant 0.12.10 → 0.13.0

package/src/tts/__tests__/cadet-provider.test.ts

@@ -1,253 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-let mockSynthesizeResult: unknown;
-let synthesizeCalls: Array<{
-  text: string;
-  format: string;
-  signal?: AbortSignal;
-}> = [];
-
-mock.module("../../cloud/cloud-speech.js", () => ({
-  managedSpeechSynthesize: async (input: {
-    text: string;
-    format: string;
-    signal?: AbortSignal;
-  }) => {
-    synthesizeCalls.push(input);
-    return mockSynthesizeResult;
-  },
-}));
-
-let mockRelayConnection: {
-  wsBaseUrl: string;
-  httpBaseUrl: string;
-  mintServiceToken: () => string;
-} | null = null;
-
-mock.module(
-  "../../providers/speech-to-text/cadet-speech-relay-connection.js",
-  () => ({
-    resolveSpeechRelayConnection: async () => mockRelayConnection,
-    mapTunnelError: (e: { code: string }) => ({
-      category: "provider-error",
-      message: `mapped:${e.code}`,
-    }),
-    probeTunnelRejection: async () => mockProbeRejection,
-  }),
-);
-let mockProbeRejection: { code: string; detail?: string } | null = null;
-
-let socketCalls: Array<{ url: string; text: string }> = [];
-let mockSocketResult: () => Promise<Buffer> = async () => Buffer.from("pcm");
-
-mock.module("../providers/cadet-tts-socket.js", () => ({
-  synthesizeOverCadetTtsSocket: async (opts: {
-    url: string;
-    text: string;
-    onChunk?: (c: Uint8Array) => void;
-  }) => {
-    socketCalls.push({ url: opts.url, text: opts.text });
-    const audio = await mockSocketResult();
-    opts.onChunk?.(audio);
-    return audio;
-  },
-}));
-
-import {
-  cadetTtsProviderDefinition,
-  createCadetProvider,
-} from "../providers/cadet-provider.js";
-import type { TtsSynthesisRequest } from "../types.js";
-
-const MP3_BYTES = Buffer.from([0x49, 0x44, 0x33]);
-
-function request(
-  overrides: Partial<TtsSynthesisRequest> = {},
-): TtsSynthesisRequest {
-  return {
-    text: "hello",
-    useCase: "message-playback",
-    ...overrides,
-  } as TtsSynthesisRequest;
-}
-
-describe("cadet TTS adapter", () => {
-  beforeEach(() => {
-    synthesizeCalls = [];
-    socketCalls = [];
-    mockProbeRejection = null;
-    mockSocketResult = async () => Buffer.from("pcm");
-    mockRelayConnection = {
-      wsBaseUrl: "ws://gateway.test",
-      httpBaseUrl: "http://gateway.test",
-      mintServiceToken: () => "tok-1",
-    };
-    mockSynthesizeResult = {
-      ok: true,
-      value: { audio: MP3_BYTES, contentType: "audio/mpeg" },
-    };
-  });
-
-  test("message playback synthesizes mp3 and round-trips audio", async () => {
-    const provider = createCadetProvider();
-    const result = await provider.synthesize(request());
-
-    expect(synthesizeCalls).toEqual([{ text: "hello", format: "mp3" }]);
-    expect(Buffer.compare(result.audio, MP3_BYTES)).toBe(0);
-    expect(result.contentType).toBe("audio/mpeg");
-  });
-
-  test("PCM hint maps to the cloud's fixed 16 kHz PCM format", async () => {
-    const provider = createCadetProvider();
-    await provider.synthesize(request({ outputFormat: "pcm" }));
-
-    expect(synthesizeCalls[0].format).toBe("pcm_16000");
-    expect(
-      provider.resolveOutputSampleRateHz?.(request({ outputFormat: "pcm" })),
-    ).toBe(16000);
-    // Contract: undefined for non-PCM output.
-    expect(provider.resolveOutputSampleRateHz?.(request())).toBeUndefined();
-  });
-
-  test("forwards the abort signal to the cloud call", async () => {
-    const controller = new AbortController();
-    const provider = createCadetProvider();
-    await provider.synthesize(request({ signal: controller.signal }));
-
-    expect(synthesizeCalls[0].signal).toBe(controller.signal);
-  });
-
-  test("insufficient balance throws a top-up message", async () => {
-    mockSynthesizeResult = {
-      ok: false,
-      kind: "platform-error",
-      status: 402,
-      code: "insufficient_balance",
-      message: "balance",
-    };
-    const provider = createCadetProvider();
-    await expect(provider.synthesize(request())).rejects.toThrow(
-      /Cadet credits/,
-    );
-  });
-
-  test("unavailable platform throws a connect-your-account message", async () => {
-    mockSynthesizeResult = {
-      ok: false,
-      kind: "unavailable",
-      message: "No Cadet Cloud connection.",
-    };
-    const provider = createCadetProvider();
-    await expect(provider.synthesize(request())).rejects.toThrow(
-      /cloud connect/,
-    );
-  });
-});
-
-describe("cadet TTS streaming", () => {
-  beforeEach(() => {
-    synthesizeCalls = [];
-    socketCalls = [];
-    mockProbeRejection = null;
-    mockSocketResult = async () => Buffer.from("pcm");
-    mockRelayConnection = {
-      wsBaseUrl: "ws://gateway.test",
-      httpBaseUrl: "http://gateway.test",
-      mintServiceToken: () => "tok-1",
-    };
-    mockSynthesizeResult = {
-      ok: true,
-      value: { audio: MP3_BYTES, contentType: "audio/mpeg" },
-    };
-  });
-
-  test("PCM streaming dials the gateway relay with token and audio params", async () => {
-    const provider = createCadetProvider();
-    const chunks: Uint8Array[] = [];
-
-    const result = await provider.synthesizeStream!(
-      request({ outputFormat: "pcm" }),
-      (c) => chunks.push(c),
-    );
-
-    expect(socketCalls).toHaveLength(1);
-    const url = new URL(socketCalls[0]!.url);
-    expect(url.origin).toBe("ws://gateway.test");
-    expect(url.pathname).toBe("/v1/speech/tts/stream");
-    expect(url.searchParams.get("key")).toBe("tok-1");
-    expect(url.searchParams.get("encoding")).toBe("linear16");
-    expect(url.searchParams.get("sample_rate")).toBe("16000");
-    // Raw PCM, not Deepgram's default WAV container — RIFF headers would
-    // play as static on the headerless media-stream path.
-    expect(url.searchParams.get("container")).toBe("none");
-    expect(result.contentType).toBe("audio/pcm");
-    expect(chunks).toHaveLength(1);
-    // Batch path untouched.
-    expect(synthesizeCalls).toHaveLength(0);
-  });
-
-  test("non-PCM streaming delegates to the batch path with one chunk", async () => {
-    const provider = createCadetProvider();
-    const chunks: Uint8Array[] = [];
-
-    const result = await provider.synthesizeStream!(request(), (c) =>
-      chunks.push(c),
-    );
-
-    expect(socketCalls).toHaveLength(0);
-    expect(synthesizeCalls).toEqual([{ text: "hello", format: "mp3" }]);
-    expect(result.contentType).toBe("audio/mpeg");
-    expect(chunks).toHaveLength(1);
-  });
-
-  test("a rejected dial surfaces the relay's mapped rejection via the probe", async () => {
-    mockSocketResult = async () => {
-      throw new Error("socket closed before Flushed");
-    };
-    mockProbeRejection = { code: "insufficient_balance" };
-    const provider = createCadetProvider();
-
-    await expect(
-      provider.synthesizeStream!(request({ outputFormat: "pcm" }), () => {}),
-    ).rejects.toThrow("mapped:insufficient_balance");
-  });
-
-  test("no relay connection throws a connect-your-account message", async () => {
-    mockRelayConnection = null;
-    const provider = createCadetProvider();
-
-    await expect(
-      provider.synthesizeStream!(request({ outputFormat: "pcm" }), () => {}),
-    ).rejects.toThrow(/cloud connect/);
-  });
-
-  test("streaming capability is advertised", () => {
-    expect(createCadetProvider().capabilities.supportsStreaming).toBe(true);
-  });
-});
-
-describe("cadet TTS definition", () => {
-  test("declares streaming synthesized-play with PCM media-stream playback", () => {
-    expect(cadetTtsProviderDefinition.capabilities.supportsStreaming).toBe(
-      true,
-    );
-    expect(cadetTtsProviderDefinition.callMode).toBe("synthesized-play");
-    expect(cadetTtsProviderDefinition.allowNativeFallback).toBe(false);
-    expect(cadetTtsProviderDefinition.mediaStreamPlayback.outputFormat).toBe(
-      "pcm",
-    );
-    // True since cloud voice selection: clients gate their voice dropdown
-    // on this flag (old daemons report false and show no selector).
-    expect(cadetTtsProviderDefinition.supportsVoiceSelection).toBe(true);
-  });
-
-  test("requires only the cloud connection credential", () => {
-    expect(cadetTtsProviderDefinition.secretRequirements).toEqual([
-      {
-        credentialStoreKey: "credential/cadet/assistant_api_key",
-        displayName: "Cadet account connection",
-        setCommand: "assistant cloud connect",
-      },
-    ]);
-  });
-});

package/src/tts/providers/cadet-provider.ts

@@ -1,244 +0,0 @@
-/**
- * Cadet Cloud TTS: synthesis through the cloud's cloud speech
- * surfaces (Cadet-held Deepgram key, billed to Cadet credits). No provider
- * API key exists on this machine — the cloud connection is the credential.
- *
- * Two paths:
- * - Batch `synthesize` (read-aloud, mp3 surfaces) via the Django endpoint.
- * - Streaming `synthesizeStream` (live voice, telephony PCM) via the
- *   gateway's speech relay (gateway → tunnel → Deepgram; tunnel contact is
- *   gateway-only — the daemon holds no tunnel address and no speech
- *   credential).
- *
- * `allowNativeFallback: false` means synthesis failures propagate to the
- * caller's error handler, so failures here throw with user-actionable
- * messages rather than returning silence.
- */
-
-import {
-  type CloudSpeechResult,
-  type CloudSpeechTtsFormat,
-  managedSpeechSynthesize,
-} from "../../cloud/cloud-speech.js";
-import { getConfig } from "../../config/loader.js";
-import {
-  mapTunnelError,
-  probeTunnelRejection,
-  resolveSpeechRelayConnection,
-} from "../../providers/speech-to-text/cadet-speech-relay-connection.js";
-import { getLogger } from "../../util/logger.js";
-import type { TtsProviderDefinition } from "../provider-definition.js";
-import type {
-  TtsProvider,
-  TtsProviderCapabilities,
-  TtsSynthesisRequest,
-  TtsSynthesisResult,
-} from "../types.js";
-import { synthesizeOverCadetTtsSocket } from "./cadet-tts-socket.js";
-
-const log = getLogger("cadet-tts");
-
-const TTS_STREAM_PATH = "/v1/speech/tts/stream";
-
-/**
- * The cloud's PCM format is fixed at 16 kHz, 16-bit LE mono — the
- * media-stream transcoder needs to know the rate regardless of hints.
- */
-const CADET_PCM_SAMPLE_RATE_HZ = 16_000;
-
-type CloudSpeechFailure = Extract<CloudSpeechResult<never>, { ok: false }>;
-
-/**
- * Map the synthesis request onto the cloud's format vocabulary.
- *
- * The PCM hint (media-stream playback) maps to raw 16 kHz PCM for mu-law
- * transcoding; every other use case gets mp3.
- */
-function resolveManagedFormat(
-  request: TtsSynthesisRequest,
-): CloudSpeechTtsFormat {
-  return request.outputFormat === "pcm" ? "pcm_16000" : "mp3";
-}
-
-/**
- * The configured cloud voice, if any. A request-level voiceId wins over
- * config; undefined means the cloud's default voice.
- */
-function resolveCloudVoice(request: TtsSynthesisRequest): string | undefined {
-  return request.voiceId ?? getConfig().services.tts.providers.cadet.model;
-}
-
-function synthesisError(failure: CloudSpeechFailure): Error {
-  if (failure.code === "insufficient_balance") {
-    return new Error(
-      "Cadet credits are exhausted — add funds to your Cadet account to continue using cloud speech.",
-    );
-  }
-  if (failure.kind === "unavailable") {
-    return new Error(
-      `Cloud speech is unavailable: ${failure.message} Run 'assistant cloud connect' to connect your Cadet account.`,
-    );
-  }
-  return new Error(failure.message);
-}
-
-async function performSynthesis(
-  request: TtsSynthesisRequest,
-): Promise<TtsSynthesisResult> {
-  const result = await managedSpeechSynthesize({
-    text: request.text,
-    format: resolveManagedFormat(request),
-    model: resolveCloudVoice(request),
-    signal: request.signal,
-  });
-  if (!result.ok) {
-    throw synthesisError(result);
-  }
-  return {
-    audio: result.value.audio,
-    contentType: result.value.contentType,
-  };
-}
-
-/**
- * Stream one PCM utterance through the gateway's speech relay. Non-PCM
- * requests delegate to the batch path — streaming exists for realtime PCM
- * consumers (live voice, telephony), and the relay's format is pinned to
- * linear16.
- */
-async function performStreamingSynthesis(
-  request: TtsSynthesisRequest,
-  onChunk: (chunk: Uint8Array) => void,
-): Promise<TtsSynthesisResult> {
-  if (request.outputFormat !== "pcm") {
-    const result = await performSynthesis(request);
-    onChunk(result.audio);
-    return result;
-  }
-
-  const connection = await resolveSpeechRelayConnection();
-  if (!connection) {
-    throw new Error(
-      "Cloud speech is unavailable: the assistant cannot reach its speech relay. Run 'assistant cloud connect' to connect your Cadet account.",
-    );
-  }
-
-  const params = new URLSearchParams({
-    key: connection.mintServiceToken(),
-    encoding: "linear16",
-    sample_rate: String(CADET_PCM_SAMPLE_RATE_HZ),
-    // Deepgram defaults linear16 to a WAV container; the media-stream path
-    // consumes headerless PCM, so RIFF header bytes would play as static.
-    container: "none",
-  });
-  const voice = resolveCloudVoice(request);
-  if (voice) {
-    params.set("model", voice);
-  }
-  const url = `${connection.wsBaseUrl}${TTS_STREAM_PATH}?${params.toString()}`;
-
-  log.info(
-    { textLength: request.text.length },
-    "Starting managed streaming TTS synthesis",
-  );
-
-  try {
-    const audio = await synthesizeOverCadetTtsSocket({
-      url,
-      text: request.text,
-      onChunk,
-      signal: request.signal,
-      makeTimeoutError: (timeoutMs) =>
-        new Error(`Managed streaming TTS timed out after ${timeoutMs}ms`),
-      makeStreamError: (detail) =>
-        new Error(`Managed streaming TTS failed: ${detail}`),
-      makeEmptyError: () =>
-        new Error("Managed streaming TTS returned no audio"),
-      makeRelayError: (code, detail) =>
-        new Error(mapTunnelError({ code, detail }).message),
-    });
-    return {
-      audio,
-      contentType: "audio/pcm",
-    };
-  } catch (err) {
-    if (request.signal?.aborted) {
-      throw err;
-    }
-    // A rejected upgrade hides the relay's {code, detail}; replay the gate
-    // as a plain GET (the gateway probes tunnel's own gate too) so auth and
-    // balance failures surface with their mapped messages. The probe must
-    // carry the same voice model — a model-specific rejection (e.g.
-    // missing_price) only reproduces when the probe asks for that model.
-    const probeParams = new URLSearchParams({
-      key: connection.mintServiceToken(),
-    });
-    if (voice) {
-      probeParams.set("model", voice);
-    }
-    const rejection = await probeTunnelRejection(
-      `${connection.httpBaseUrl}${TTS_STREAM_PATH}?${probeParams.toString()}`,
-    );
-    if (rejection) {
-      throw new Error(mapTunnelError(rejection).message);
-    }
-    throw err;
-  }
-}
-
-export function createCadetProvider(): TtsProvider {
-  const capabilities: TtsProviderCapabilities = {
-    supportsStreaming: true,
-    supportedFormats: ["mp3", "pcm"],
-  };
-
-  return {
-    id: "cadet",
-    capabilities,
-    // Per the TtsProvider contract this returns undefined for non-PCM
-    // output; the cloud's PCM format is pinned to 16 kHz.
-    resolveOutputSampleRateHz: (request) =>
-      request.outputFormat === "pcm" ? CADET_PCM_SAMPLE_RATE_HZ : undefined,
-    synthesize: performSynthesis,
-    synthesizeStream: performStreamingSynthesis,
-  };
-}
-
-/**
- * The complete Cadet Cloud provider definition — catalog metadata plus
- * the runtime adapter — assembled into the canonical catalog by
- * `provider-catalog.ts`.
- */
-export const cadetTtsProviderDefinition: TtsProviderDefinition = {
-  id: "cadet",
-  displayName: "Cadet",
-  subtitle:
-    "Text-to-speech through your Cadet account — billed to Cadet credits, no separate API key needed.",
-  // Advertises cloud voice selection (`services.tts.providers.cadet.model`)
-  // to clients; web gates its voice dropdown on this flag, so daemons that
-  // predate the field never show a selector whose writes they would ignore.
-  supportsVoiceSelection: true,
-  apiKeyPlaceholder: "Connected via your Cadet account",
-  credentialsGuide: {
-    description:
-      "Connect this assistant to your Cadet account; cloud speech uses that connection instead of a provider API key.",
-    url: "https://cloud.mycadet.ai/",
-    linkLabel: "Open Cadet Cloud",
-  },
-  callMode: "synthesized-play",
-  allowNativeFallback: false,
-  capabilities: {
-    supportsStreaming: true,
-    supportedFormats: ["mp3", "pcm"],
-  },
-  // The adapter honours the PCM hint via the cloud's pcm_16000 format.
-  mediaStreamPlayback: { outputFormat: "pcm" },
-  secretRequirements: [
-    {
-      credentialStoreKey: "credential/cadet/assistant_api_key",
-      displayName: "Cadet account connection",
-      setCommand: "assistant cloud connect",
-    },
-  ],
-  adapter: createCadetProvider(),
-};

package/src/types/tar-stream.d.ts

@@ -1,66 +0,0 @@
-/**
- * Minimal ambient types for `tar-stream` v3, which ships no type definitions.
- *
- * We only declare the surface used by `runtime/migrations/vbundle-tar-stream.ts`
- * (the `extract()` factory and its `"entry"` event shape). If additional usage
- * is needed later, extend this file rather than adding `@types/tar-stream` —
- * the DT types target v2 and do not match v3's streamx-based extractor.
- */
-declare module "tar-stream" {
-  import type { Readable, Writable } from "node:stream";
-
-  export interface TarHeader {
-    name: string;
-    size: number;
-    type:
-      | "file"
-      | "link"
-      | "symlink"
-      | "character-device"
-      | "block-device"
-      | "directory"
-      | "fifo"
-      | "contiguous-file"
-      | "pax-header"
-      | "pax-global-header"
-      | "gnu-long-path"
-      | "gnu-long-link-path"
-      | "other"
-      | string;
-    linkname?: string | null;
-    mode?: number;
-    uid?: number;
-    gid?: number;
-    mtime?: Date;
-    pax?: Record<string, string> | null;
-  }
-
-  export interface ExtractOptions {
-    filenameEncoding?: string;
-    allowUnknownFormat?: boolean;
-  }
-
-  export type EntryCallback = (err?: Error | null) => void;
-
-  export interface Extract extends Writable {
-    on(
-      event: "entry",
-      listener: (
-        header: TarHeader,
-        stream: Readable,
-        next: EntryCallback,
-      ) => void,
-    ): this;
-    on(event: "finish", listener: () => void): this;
-    on(event: "error", listener: (err: Error) => void): this;
-    on(event: "close", listener: () => void): this;
-    on(event: string, listener: (...args: unknown[]) => void): this;
-    destroy(err?: Error): void;
-  }
-
-  export function extract(opts?: ExtractOptions): Extract;
-
-  // `pack` exists but is unused by the runtime migrations code; declare it
-  // permissively so importers that reach for it still type-check.
-  export function pack(opts?: unknown): Writable;
-}