create-syrinx-agent 4.4.0

package/src/options.ts

@@ -0,0 +1,176 @@
+// SPDX-License-Identifier: MIT
+//
+// The flag matrix, verified against packages/* — do not invent provider
+// names here. What's implemented per stage lives in the provider registries
+// in providers/*.ts, not here: this module only parses and validates shape.
+
+import { resolve } from "node:path";
+
+import { CliError, EXIT_CODES } from "./exit-codes.js";
+
+export const STT_PROVIDERS = ["deepgram", "google", "elevenlabs", "grok"] as const;
+export const TTS_PROVIDERS = ["cartesia", "elevenlabs", "gemini", "openai-tts", "grok"] as const;
+export const REALTIME_PROVIDERS = ["realtime", "grok"] as const;
+export const REASONER_PROVIDERS = ["aisdk", "kuralle", "mastra"] as const;
+export const VAD_PROVIDERS = ["silero-vad"] as const;
+export const ENDPOINTING_PROVIDERS = ["pipecat-smart-turn", "vap"] as const;
+export const TRANSPORTS = ["browser", "twilio", "telnyx", "smartpbx"] as const;
+export const RUNTIMES = ["node", "cloudflare"] as const;
+
+export type SttProvider = (typeof STT_PROVIDERS)[number];
+export type TtsProvider = (typeof TTS_PROVIDERS)[number];
+export type RealtimeProvider = (typeof REALTIME_PROVIDERS)[number];
+export type ReasonerProvider = (typeof REASONER_PROVIDERS)[number];
+export type VadProvider = (typeof VAD_PROVIDERS)[number];
+export type EndpointingProvider = (typeof ENDPOINTING_PROVIDERS)[number];
+export type Transport = (typeof TRANSPORTS)[number];
+export type Runtime = (typeof RUNTIMES)[number];
+
+/** Flags as parsed off the command line — everything optional, everything a string. */
+export interface RawFlags {
+  readonly stt?: string | undefined;
+  readonly tts?: string | undefined;
+  readonly realtime?: string | undefined;
+  readonly reasoner?: string | undefined;
+  readonly vad?: string | undefined;
+  readonly endpointing?: string | undefined;
+  readonly transport?: string | undefined;
+  readonly runtime?: string | undefined;
+  readonly preset?: string | undefined;
+  readonly name?: string | undefined;
+  readonly yes?: boolean | undefined;
+  readonly "no-install"?: boolean | undefined;
+  readonly "skip-install"?: boolean | undefined;
+  readonly "dry-run"?: boolean | undefined;
+}
+
+/** A resolved, valid selection — either cascade (stt+tts+reasoner) or speech-to-speech (realtime). */
+export type ResolvedOptions =
+  | {
+      readonly mode: "cascade";
+      readonly stt: SttProvider;
+      readonly tts: TtsProvider;
+      readonly reasoner: ReasonerProvider;
+      readonly vad: VadProvider | undefined;
+      readonly endpointing: EndpointingProvider | undefined;
+      readonly transport: Transport;
+      readonly runtime: Runtime;
+      readonly name: string;
+      /** Absolute path the project is written to. NOT `name` — see resolveOptions. */
+      readonly targetDir: string;
+      readonly skipInstall: boolean;
+      readonly dryRun: boolean;
+    }
+  | {
+      readonly mode: "realtime";
+      readonly realtime: RealtimeProvider;
+      readonly transport: Transport;
+      readonly runtime: Runtime;
+      readonly name: string;
+      /** Absolute path the project is written to. NOT `name` — see resolveOptions. */
+      readonly targetDir: string;
+      readonly skipInstall: boolean;
+      readonly dryRun: boolean;
+    };
+
+interface Preset {
+  readonly stt?: SttProvider;
+  readonly tts?: TtsProvider;
+  readonly reasoner?: ReasonerProvider;
+  readonly transport?: Transport;
+  readonly runtime?: Runtime;
+}
+
+// Presets are flag bundles, not a separate code path — every field here is
+// exactly a field an explicit flag can also set, and an explicit flag wins.
+const PRESETS: Readonly<Record<string, Preset>> = {
+  phone: { stt: "deepgram", tts: "cartesia", reasoner: "aisdk", transport: "twilio", runtime: "node" },
+};
+
+function memberOf<T extends readonly string[]>(list: T, value: string, flagName: string): T[number] {
+  if (!(list as readonly string[]).includes(value)) {
+    throw new CliError(EXIT_CODES.USAGE, `--${flagName} must be one of: ${list.join(", ")} (got "${value}")`);
+  }
+  return value as T[number];
+}
+
+/**
+ * Merge a preset under explicit flags (explicit always wins), validate shape,
+ * and refuse the one hard conflict: --realtime combined with --stt/--tts.
+ * Missing required fields in cascade mode are a USAGE error — this generator
+ * never prompts, see help.ts's documented contract.
+ */
+export function resolveOptions(raw: RawFlags, positionals: readonly string[]): ResolvedOptions {
+  if (raw.preset !== undefined && !(raw.preset in PRESETS)) {
+    throw new CliError(EXIT_CODES.USAGE, `--preset must be one of: ${Object.keys(PRESETS).join(", ")} (got "${raw.preset}")`);
+  }
+  const preset = raw.preset !== undefined ? PRESETS[raw.preset] : undefined;
+
+  const sttRaw = raw.stt ?? preset?.stt;
+  const ttsRaw = raw.tts ?? preset?.tts;
+  const reasonerRaw = raw.reasoner ?? preset?.reasoner;
+  const realtimeRaw = raw.realtime;
+
+  if (realtimeRaw !== undefined && (sttRaw !== undefined || ttsRaw !== undefined)) {
+    throw new CliError(
+      EXIT_CODES.USAGE,
+      `--realtime is a speech-to-speech pipeline with no separate STT/TTS stages — it cannot be combined with ${[
+        sttRaw !== undefined ? "--stt" : undefined,
+        ttsRaw !== undefined ? "--tts" : undefined,
+      ]
+        .filter((v): v is string => v !== undefined)
+        .join(" and ")}.`,
+    );
+  }
+
+  const transport = memberOf(TRANSPORTS, raw.transport ?? preset?.transport ?? "browser", "transport");
+  const runtime = memberOf(RUNTIMES, raw.runtime ?? preset?.runtime ?? "node", "runtime");
+  const skipInstall = raw["no-install"] === true || raw["skip-install"] === true;
+  const dryRun = raw["dry-run"] === true;
+  const targetDir = positionals[0];
+  const name = raw.name ?? (targetDir !== undefined ? targetDir.split("/").filter(Boolean).at(-1) : undefined);
+  if (name === undefined || name.length === 0) {
+    throw new CliError(EXIT_CODES.USAGE, "a target directory or --name is required, e.g. `create-syrinx-agent my-agent`");
+  }
+  // Where the files actually go. Distinct from `name`, which is only what the
+  // project calls itself: writing to `./<name>` would silently ignore an absolute
+  // or nested target and scatter a project into whatever directory you ran from.
+  const resolvedTarget = resolve(process.cwd(), targetDir ?? name);
+
+  if (realtimeRaw !== undefined) {
+    const realtime = memberOf(REALTIME_PROVIDERS, realtimeRaw, "realtime");
+    return { mode: "realtime", realtime, transport, runtime, name, targetDir: resolvedTarget, skipInstall, dryRun };
+  }
+
+  const missing = [
+    sttRaw === undefined ? "--stt" : undefined,
+    ttsRaw === undefined ? "--tts" : undefined,
+    reasonerRaw === undefined ? "--reasoner" : undefined,
+  ].filter((v): v is string => v !== undefined);
+  if (missing.length > 0) {
+    throw new CliError(
+      EXIT_CODES.USAGE,
+      `missing required flag(s): ${missing.join(", ")} (or pass --realtime for a speech-to-speech pipeline, or --preset <name>)`,
+    );
+  }
+
+  const stt = memberOf(STT_PROVIDERS, sttRaw as string, "stt");
+  const tts = memberOf(TTS_PROVIDERS, ttsRaw as string, "tts");
+  const reasoner = memberOf(REASONER_PROVIDERS, reasonerRaw as string, "reasoner");
+  const vad = raw.vad !== undefined ? memberOf(VAD_PROVIDERS, raw.vad, "vad") : undefined;
+  const endpointing = raw.endpointing !== undefined ? memberOf(ENDPOINTING_PROVIDERS, raw.endpointing, "endpointing") : undefined;
+
+  return { mode: "cascade", stt, tts, reasoner, vad, endpointing, transport, runtime, name, targetDir: resolvedTarget, skipInstall, dryRun };
+}
+
+/** Non-fatal warnings for combinations that generate but aren't fully verified. */
+export function warningsFor(opts: ResolvedOptions): readonly string[] {
+  const warnings: string[] = [];
+  if (opts.runtime === "cloudflare" && opts.transport === "telnyx") {
+    warnings.push(
+      "runtime=cloudflare + transport=telnyx is generated but not yet bound on the Workers edge — deploy-unverified. " +
+        "See @kuralle-syrinx/server-workers for current Cloudflare transport coverage before deploying.",
+    );
+  }
+  return warnings;
+}

package/src/providers/realtime.ts

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: MIT
+//
+// Speech-to-speech (realtime) registry, verified against
+// packages/realtime/src/from-openai-realtime.ts and
+// packages/grok/src/from-grok-realtime.ts. Mirrors
+// examples/02-hello-voice-headless/scripts/run-realtime-oneturn-smoke.ts:
+// `fromXRealtime({ apiKey, socketFactory })` -> `RealtimeAdapter`, wrapped in
+// `new RealtimeBridge(adapter)` and registered on the "realtime" slot with
+// `endpointingOwner: "timer"`.
+
+import type { RealtimeProvider } from "../options.js";
+import type { RealtimeProviderEmission } from "./types.js";
+
+const PKG_VERSION = "^4.3.0";
+
+export const REALTIME_PROVIDERS: Readonly<Record<RealtimeProvider, RealtimeProviderEmission | undefined>> = {
+  realtime: {
+    packageName: "@kuralle-syrinx/realtime",
+    packageVersion: PKG_VERSION,
+    envKeys: [{ key: "OPENAI_API_KEY", required: true }],
+    importLines: [`import { fromOpenAIRealtime } from "@kuralle-syrinx/realtime";`],
+    adapterExpr: (envRef, socketFactoryIdent) => `fromOpenAIRealtime({ apiKey: ${envRef("OPENAI_API_KEY")}, socketFactory: ${socketFactoryIdent} })`,
+  },
+  grok: {
+    packageName: "@kuralle-syrinx/grok",
+    packageVersion: PKG_VERSION,
+    envKeys: [{ key: "XAI_API_KEY", required: true }],
+    importLines: [`import { fromGrokRealtime } from "@kuralle-syrinx/grok/realtime";`],
+    adapterExpr: (envRef, socketFactoryIdent) => `fromGrokRealtime({ apiKey: ${envRef("XAI_API_KEY")}, socketFactory: ${socketFactoryIdent} })`,
+  },
+};

package/src/providers/reasoner.ts

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: MIT
+//
+// Reasoner registry. `undefined` for a provider not yet wired into the
+// generator — kuralle needs a real @kuralle-agents/core Runtime instance
+// (fromKuralleRuntime(runtime, opts)), which this generator does not yet
+// scaffold; see the report for why.
+//
+// Every entry's `reasonerExpr` produces a bare `Reasoner` (packages/core's
+// stream seam). The cascade template wraps it in `new ReasoningBridge(...)`
+// for the node runtime; the Cloudflare template passes it straight to
+// `withVoice`'s `reasoner: (env) => ...` — both consume the same expression.
+// `ReasoningBridge` itself is NOT imported here: the cascade agent-module
+// template always imports it from @kuralle-syrinx/aisdk (it is the generic
+// VoicePlugin wrapper around any Reasoner, independent of which provider
+// produced it — mirrors examples/.../university-support-mastra.ts, which
+// depends on @kuralle-syrinx/aisdk purely for this wrapper).
+
+import type { ReasonerProvider } from "../options.js";
+import type { ReasonerProviderEmission } from "./types.js";
+
+const PKG_VERSION = "^4.3.0";
+const OPENAI_SDK_VERSION = "^3.0.67";
+const AI_SDK_VERSION = "^6.0.0";
+const MASTRA_CORE_VERSION = "^1.41.0";
+
+export const SYSTEM_PROMPT_CONST = "SYSTEM_PROMPT";
+
+export const REASONER_PROVIDERS: Readonly<Record<ReasonerProvider, ReasonerProviderEmission | undefined>> = {
+  // packages/aisdk/src/from-ai-sdk.ts: fromStreamText(config) -> Reasoner.
+  // Mirrors examples/02-hello-voice-headless/src/hello-voice-agent.ts.
+  aisdk: {
+    packageName: "@kuralle-syrinx/aisdk",
+    packageVersion: PKG_VERSION,
+    extraPackages: { "@ai-sdk/openai": OPENAI_SDK_VERSION, ai: AI_SDK_VERSION },
+    envKeys: [{ key: "OPENAI_API_KEY", required: true }],
+    importLines: () => [
+      `import { fromStreamText } from "@kuralle-syrinx/aisdk";`,
+      `import { createOpenAI } from "@ai-sdk/openai";`,
+    ],
+    preludeLines: (envRef) => [`const openai = createOpenAI({ apiKey: ${envRef("OPENAI_API_KEY")} });`],
+    reasonerExpr: `fromStreamText({ model: openai("gpt-4.1-mini"), system: ${SYSTEM_PROMPT_CONST} })`,
+  },
+  // packages/mastra/src/from-mastra.ts: fromMastraAgent(agent) -> Reasoner.
+  // Mirrors examples/02-hello-voice-headless/src/university-support-mastra.ts.
+  mastra: {
+    packageName: "@kuralle-syrinx/mastra",
+    packageVersion: PKG_VERSION,
+    extraPackages: { "@ai-sdk/openai": OPENAI_SDK_VERSION, "@mastra/core": MASTRA_CORE_VERSION },
+    envKeys: [{ key: "OPENAI_API_KEY", required: true }],
+    importLines: () => [
+      `import { fromMastraAgent, type MastraAgentLike } from "@kuralle-syrinx/mastra";`,
+      `import { createOpenAI } from "@ai-sdk/openai";`,
+      `import { Agent as MastraAgent } from "@mastra/core/agent";`,
+    ],
+    preludeLines: (envRef) => [
+      `const openai = createOpenAI({ apiKey: ${envRef("OPENAI_API_KEY")} });`,
+      `const mastraAgent = new MastraAgent({`,
+      `  id: "syrinx-agent",`,
+      `  name: "syrinx-agent",`,
+      `  instructions: ${SYSTEM_PROMPT_CONST},`,
+      `  model: openai("gpt-4.1-mini"),`,
+      `});`,
+    ],
+    // Structural cast to MastraAgentLike, same pattern the reference agent uses —
+    // fromMastraAgent types against a structural interface, not @mastra/core's own type.
+    reasonerExpr: `fromMastraAgent(mastraAgent as unknown as MastraAgentLike)`,
+  },
+  kuralle: undefined,
+};

package/src/providers/stt.ts

@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: MIT
+//
+// STT stage registry, verified against packages/{deepgram,google,elevenlabs,grok}/src.
+// `undefined` for a provider not yet wired into the generator.
+
+import type { SttProvider } from "../options.js";
+import type { StageProvider } from "./types.js";
+
+const PKG_VERSION = "^4.3.0";
+
+export const STT_STAGE_PROVIDERS: Readonly<Record<SttProvider, StageProvider | undefined>> = {
+  // packages/deepgram/src/stt.ts: DeepgramSTTPlugin, endpointingCapability.owner === "provider_stt".
+  // Config fields mirror examples/02-hello-voice-headless/src/hello-voice-agent.ts.
+  deepgram: {
+    packageName: "@kuralle-syrinx/deepgram",
+    packageVersion: PKG_VERSION,
+    className: "DeepgramSTTPlugin",
+    envKeys: [{ key: "DEEPGRAM_API_KEY", required: true }],
+    usesSocketFactory: true,
+    ownsEndpointing: true,
+    configFields: (envRef) => [
+      `api_key: ${envRef("DEEPGRAM_API_KEY")}`,
+      `model: "nova-3"`,
+      `sample_rate: 16000`,
+      `emit_eos_on_final: true`,
+    ],
+  },
+  // packages/google/src/index.ts: GoogleSTTPlugin (Cloud Speech-to-Text v2).
+  // api_key + project_id are required config; endpointingCapability.owner === "provider_stt".
+  google: {
+    packageName: "@kuralle-syrinx/google",
+    packageVersion: PKG_VERSION,
+    className: "GoogleSTTPlugin",
+    envKeys: [
+      { key: "GOOGLE_CLOUD_SPEECH_API_KEY", required: true },
+      { key: "GOOGLE_CLOUD_PROJECT_ID", required: true },
+    ],
+    usesSocketFactory: true,
+    ownsEndpointing: true,
+    configFields: (envRef) => [
+      `api_key: ${envRef("GOOGLE_CLOUD_SPEECH_API_KEY")}`,
+      `project_id: ${envRef("GOOGLE_CLOUD_PROJECT_ID")}`,
+      `sample_rate: 16000`,
+    ],
+  },
+  // packages/elevenlabs/src/stt.ts: ElevenLabsSTTPlugin (Scribe v2 Realtime).
+  elevenlabs: {
+    packageName: "@kuralle-syrinx/elevenlabs",
+    packageVersion: PKG_VERSION,
+    importFrom: "@kuralle-syrinx/elevenlabs/stt",
+    className: "ElevenLabsSTTPlugin",
+    envKeys: [{ key: "ELEVENLABS_API_KEY", required: true }],
+    usesSocketFactory: true,
+    ownsEndpointing: true,
+    configFields: (envRef) => [`api_key: ${envRef("ELEVENLABS_API_KEY")}`],
+  },
+  // packages/grok/src/stt.ts: GrokSTTPlugin. endpointingCapability.owner === "provider_stt".
+  grok: {
+    packageName: "@kuralle-syrinx/grok",
+    packageVersion: PKG_VERSION,
+    importFrom: "@kuralle-syrinx/grok/stt",
+    className: "GrokSTTPlugin",
+    envKeys: [{ key: "XAI_API_KEY", required: true }],
+    usesSocketFactory: true,
+    ownsEndpointing: true,
+    configFields: (envRef) => [`api_key: ${envRef("XAI_API_KEY")}`, `language: "en"`],
+  },
+};

package/src/providers/tts.ts

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: MIT
+//
+// TTS stage registry, verified against packages/{cartesia,elevenlabs,gemini,openai-tts,grok}/src.
+
+import type { TtsProvider } from "../options.js";
+import type { StageProvider } from "./types.js";
+
+const PKG_VERSION = "^4.3.0";
+
+export const TTS_STAGE_PROVIDERS: Readonly<Record<TtsProvider, StageProvider | undefined>> = {
+  // packages/cartesia/src/index.ts: CartesiaTTSPlugin. Config mirrors hello-voice-agent.ts.
+  cartesia: {
+    packageName: "@kuralle-syrinx/cartesia",
+    packageVersion: PKG_VERSION,
+    className: "CartesiaTTSPlugin",
+    envKeys: [
+      { key: "CARTESIA_API_KEY", required: true },
+      { key: "CARTESIA_VOICE_ID", required: true },
+    ],
+    usesSocketFactory: true,
+    ownsEndpointing: false,
+    configFields: (envRef) => [`api_key: ${envRef("CARTESIA_API_KEY")}`, `voice_id: ${envRef("CARTESIA_VOICE_ID")}`],
+  },
+  // packages/elevenlabs/src/tts.ts: ElevenLabsTTSPlugin.
+  elevenlabs: {
+    packageName: "@kuralle-syrinx/elevenlabs",
+    packageVersion: PKG_VERSION,
+    importFrom: "@kuralle-syrinx/elevenlabs/tts",
+    className: "ElevenLabsTTSPlugin",
+    envKeys: [
+      { key: "ELEVENLABS_API_KEY", required: true },
+      { key: "ELEVENLABS_VOICE_ID", required: true },
+    ],
+    usesSocketFactory: true,
+    ownsEndpointing: false,
+    configFields: (envRef) => [`api_key: ${envRef("ELEVENLABS_API_KEY")}`, `voice_id: ${envRef("ELEVENLABS_VOICE_ID")}`],
+  },
+  // packages/gemini/src/index.ts: GeminiTTSPlugin. HTTP-based (@google/genai) — no SocketFactory.
+  gemini: {
+    packageName: "@kuralle-syrinx/gemini",
+    packageVersion: PKG_VERSION,
+    className: "GeminiTTSPlugin",
+    envKeys: [{ key: "GOOGLE_GENERATIVE_AI_API_KEY", required: true }],
+    usesSocketFactory: false,
+    ownsEndpointing: false,
+    configFields: (envRef) => [`api_key: ${envRef("GOOGLE_GENERATIVE_AI_API_KEY")}`],
+  },
+  // packages/openai-tts/src/index.ts: OpenAICompatibleTTSPlugin. HTTP-based — no SocketFactory.
+  "openai-tts": {
+    packageName: "@kuralle-syrinx/openai-tts",
+    packageVersion: PKG_VERSION,
+    className: "OpenAICompatibleTTSPlugin",
+    envKeys: [{ key: "OPENAI_API_KEY", required: true }],
+    usesSocketFactory: false,
+    ownsEndpointing: false,
+    configFields: (envRef) => [`api_key: ${envRef("OPENAI_API_KEY")}`],
+  },
+  // packages/grok/src/tts.ts: GrokTTSPlugin.
+  grok: {
+    packageName: "@kuralle-syrinx/grok",
+    packageVersion: PKG_VERSION,
+    importFrom: "@kuralle-syrinx/grok/tts",
+    className: "GrokTTSPlugin",
+    envKeys: [{ key: "XAI_API_KEY", required: true }],
+    usesSocketFactory: true,
+    ownsEndpointing: false,
+    configFields: (envRef) => [`api_key: ${envRef("XAI_API_KEY")}`, `voice_id: "eve"`],
+  },
+};

package/src/providers/types.ts

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: MIT
+//
+// Shared shape for a provider's generated-project footprint: what it depends
+// on, what env keys it needs, and how to emit its plugin construction code.
+// `envRef` is supplied by the caller so the SAME provider entry emits either
+// `process.env["KEY"]` (node runtime) or `env.KEY` (Cloudflare Workers).
+
+export interface EnvKeySpec {
+  readonly key: string;
+  readonly required: boolean;
+  readonly note?: string;
+}
+
+/** An STT or TTS provider's plugin — the cascade's discrete stages. */
+export interface StageProvider {
+  readonly packageName: string;
+  readonly packageVersion: string;
+  /** Import path, when it differs from packageName (e.g. a "/stt" or "/tts" subpath). */
+  readonly importFrom?: string;
+  readonly className: string;
+  readonly envKeys: readonly EnvKeySpec[];
+  /** True when the plugin constructor takes an optional SocketFactory (ws-based providers). */
+  readonly usesSocketFactory: boolean;
+  /** True for an STT plugin that can own endpointing itself (`endpointingCapability.owner === "provider_stt"`). */
+  readonly ownsEndpointing: boolean;
+  /** TS source for each field of the plugin's config object literal (no trailing commas). */
+  readonly configFields: (envRef: (key: string) => string) => readonly string[];
+}
+
+export interface ReasonerProviderEmission {
+  readonly packageName: string;
+  readonly packageVersion: string;
+  readonly extraPackages: Readonly<Record<string, string>>;
+  readonly envKeys: readonly EnvKeySpec[];
+  readonly importLines: (envRef: (key: string) => string) => readonly string[];
+  /** Lines emitted before the session/pipeline is built (e.g. constructing a model client). */
+  readonly preludeLines: (envRef: (key: string) => string) => readonly string[];
+  /** The `Reasoner`-producing expression, e.g. `fromStreamText({ ... })`. */
+  readonly reasonerExpr: string;
+}
+
+export interface RealtimeProviderEmission {
+  readonly packageName: string;
+  readonly packageVersion: string;
+  readonly envKeys: readonly EnvKeySpec[];
+  readonly importLines: readonly string[];
+  /** `socketFactoryIdent` is runtime-dependent ("createNodeWsSocket" | "createWorkersSocket"), supplied by the caller. */
+  readonly adapterExpr: (envRef: (key: string) => string, socketFactoryIdent: string) => string;
+}
+
+export interface SidecarPluginEmission {
+  readonly packageName: string;
+  readonly packageVersion: string;
+  readonly className: string;
+  readonly slot: "vad" | "eos";
+  readonly envKeys: readonly EnvKeySpec[];
+  readonly configFields: (envRef: (key: string) => string) => readonly string[];
+}

package/src/providers/vad-endpointing.ts

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+//
+// Optional VAD / endpointing sidecar plugins. `vap` is not yet wired into the
+// generator — packages/vap exports an InteractionPolicy (VapInteractionPolicy)
+// rather than a drop-in VoicePlugin like PipecatEOSPlugin, which needs
+// InteractionCoordinator wiring this generator doesn't yet scaffold.
+
+import type { EndpointingProvider, VadProvider } from "../options.js";
+import type { SidecarPluginEmission } from "./types.js";
+
+const PKG_VERSION = "^4.3.0";
+
+export const VAD_SIDECAR_PROVIDERS: Readonly<Record<VadProvider, SidecarPluginEmission | undefined>> = {
+  // packages/silero-vad/src/index.ts: SileroVADPlugin. No API key — a bundled ONNX model.
+  "silero-vad": {
+    packageName: "@kuralle-syrinx/silero-vad",
+    packageVersion: PKG_VERSION,
+    className: "SileroVADPlugin",
+    slot: "vad",
+    envKeys: [],
+    configFields: () => [],
+  },
+};
+
+export const ENDPOINTING_SIDECAR_PROVIDERS: Readonly<Record<EndpointingProvider, SidecarPluginEmission | undefined>> = {
+  // packages/pipecat-smart-turn/src/index.ts: PipecatEOSPlugin. No API key — a bundled ONNX model.
+  "pipecat-smart-turn": {
+    packageName: "@kuralle-syrinx/pipecat-smart-turn",
+    packageVersion: PKG_VERSION,
+    className: "PipecatEOSPlugin",
+    slot: "eos",
+    envKeys: [],
+    configFields: () => [],
+  },
+  vap: undefined,
+};