agent-voice 0.1.0

package/dist/ask-MG4CURKM.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+import {
+  createAudioPlayer,
+  createAudioRecorder,
+  createRealtimeSession
+} from "./chunk-4RFF3WHI.js";
+import {
+  DEFAULT_VOICE
+} from "./chunk-EF2ZPBZD.js";
+
+// src/ask.ts
+async function ask(message, options = {}) {
+  const {
+    voice = DEFAULT_VOICE,
+    timeout = 30,
+    ack = false,
+    auth,
+    createPlayer = createAudioPlayer,
+    createRecorder = createAudioRecorder
+  } = options;
+  const player = createPlayer();
+  player.start();
+  return new Promise((resolve, reject) => {
+    let recorder = null;
+    let transcript = "";
+    let timeoutTimer = null;
+    let speechDetected = false;
+    let cleaned = false;
+    let resolved = false;
+    async function cleanup() {
+      if (cleaned) return;
+      cleaned = true;
+      if (timeoutTimer) clearTimeout(timeoutTimer);
+      recorder?.stop();
+      recorder?.close();
+      await player.drain();
+      session.close();
+    }
+    function finish() {
+      if (resolved) return;
+      resolved = true;
+      cleanup().then(() => resolve(transcript));
+    }
+    const session = createRealtimeSession({
+      voice,
+      mode: "default",
+      ack,
+      auth,
+      onAudioDelta(pcm16) {
+        player.write(pcm16);
+      },
+      onTranscript(text) {
+        transcript = text;
+        if (!ack) finish();
+      },
+      onSpeechStarted() {
+        speechDetected = true;
+        if (timeoutTimer) {
+          clearTimeout(timeoutTimer);
+          timeoutTimer = null;
+        }
+      },
+      onInitialResponseDone() {
+        setTimeout(() => {
+          recorder = createRecorder();
+          recorder.onData((pcm16) => {
+            session.sendAudio(pcm16);
+          });
+          recorder.start();
+        }, 500);
+        timeoutTimer = setTimeout(() => {
+          if (!speechDetected) {
+            cleanup();
+            reject(new Error(`No speech detected within ${timeout}s timeout`));
+          }
+        }, timeout * 1e3);
+      },
+      onDone() {
+        if (ack) finish();
+      },
+      async onError(error) {
+        await cleanup();
+        reject(new Error(error));
+      }
+    });
+    session.connect().then(() => {
+      session.sendMessage(message);
+    }, reject);
+  });
+}
+export {
+  ask
+};

package/dist/auth-KIIHTB6C.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import {
+  writeAuthConfig
+} from "./chunk-GUTKT66X.js";
+import "./chunk-EF2ZPBZD.js";
+
+// src/auth.ts
+import { input, password } from "@inquirer/prompts";
+import OpenAI from "openai";
+var DEFAULT_BASE_URL = "https://api.openai.com/v1";
+async function verifyAuth(apiKey, baseURL) {
+  const client = new OpenAI({ apiKey, baseURL });
+  await client.models.list();
+}
+async function auth() {
+  const baseUrl = await input({
+    message: "Base URL",
+    default: DEFAULT_BASE_URL
+  });
+  const apiKey = await password({
+    message: "API key"
+  });
+  if (!apiKey) {
+    throw new Error("API key is required.");
+  }
+  process.stderr.write("Verifying...\n");
+  await verifyAuth(apiKey, baseUrl);
+  const config = { apiKey };
+  if (baseUrl !== DEFAULT_BASE_URL) {
+    config.baseUrl = baseUrl;
+  }
+  writeAuthConfig(config);
+  process.stderr.write("Auth config saved to ~/.agent-voice/config.json\n");
+}
+export {
+  auth
+};

package/dist/chunk-4RFF3WHI.js

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+import {
+  CHANNELS,
+  SAMPLE_RATE
+} from "./chunk-EF2ZPBZD.js";
+
+// src/audio.ts
+import { AudioIO, SampleFormat16Bit } from "naudiodon2";
+function createAudioPlayer() {
+  const stream = AudioIO({
+    outOptions: {
+      channelCount: CHANNELS,
+      sampleFormat: SampleFormat16Bit,
+      sampleRate: SAMPLE_RATE,
+      closeOnError: true
+    }
+  });
+  let closed = false;
+  return {
+    write(pcm16) {
+      return stream.write(pcm16);
+    },
+    start() {
+      stream.start();
+    },
+    drain() {
+      if (closed) return Promise.resolve();
+      closed = true;
+      return new Promise((resolve) => {
+        stream.quit(() => resolve());
+      });
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      stream.quit();
+    }
+  };
+}
+function createAudioRecorder() {
+  const stream = AudioIO({
+    inOptions: {
+      channelCount: CHANNELS,
+      sampleFormat: SampleFormat16Bit,
+      sampleRate: SAMPLE_RATE,
+      closeOnError: true
+    }
+  });
+  let stopped = false;
+  return {
+    onData(cb) {
+      stream.on("data", cb);
+    },
+    start() {
+      stream.start();
+    },
+    stop() {
+      if (stopped) return;
+      stopped = true;
+      stream.quit();
+    },
+    close() {
+      if (stopped) return;
+      stopped = true;
+      stream.quit();
+    }
+  };
+}
+
+// src/realtime.ts
+import { OpenAIRealtimeWS } from "openai/beta/realtime/ws";
+var SYSTEM_INSTRUCTIONS = `
+# Role
+Voice relay between an AI agent and a human.
+
+# Instructions
+- When given a text message, read it aloud EXACTLY as written. Do not add, remove, or rephrase anything.
+- After the human responds, acknowledge briefly \u2014 a few words only. Vary your phrasing.
+- NEVER repeat back what the user said verbatim.
+- NEVER ask follow-up questions.
+- Keep every response under one sentence.
+
+# Tone
+- Calm, neutral, concise.
+`.trim();
+function createRealtimeSession(options) {
+  let rt;
+  let responseCount = 0;
+  function configureSession() {
+    const turnDetection = options.mode === "say" ? null : {
+      type: "semantic_vad",
+      eagerness: "medium",
+      create_response: options.ack,
+      interrupt_response: true
+    };
+    rt.send({
+      type: "session.update",
+      session: {
+        instructions: SYSTEM_INSTRUCTIONS,
+        voice: options.voice,
+        input_audio_format: "pcm16",
+        output_audio_format: "pcm16",
+        input_audio_transcription: { model: "gpt-4o-transcribe" },
+        turn_detection: turnDetection
+      }
+    });
+  }
+  function bindEvents() {
+    rt.on("response.audio.delta", (event) => {
+      const pcm16 = Buffer.from(event.delta, "base64");
+      options.onAudioDelta(pcm16);
+    });
+    rt.on("conversation.item.input_audio_transcription.completed", (event) => {
+      options.onTranscript(event.transcript);
+    });
+    rt.on("input_audio_buffer.speech_started", () => {
+      options.onSpeechStarted();
+    });
+    rt.on("response.done", () => {
+      responseCount++;
+      if (responseCount === 1) {
+        options.onInitialResponseDone();
+      } else if (responseCount === 2) {
+        options.onDone();
+      }
+    });
+    rt.on("error", (event) => {
+      options.onError(event.error?.message ?? "Unknown realtime error");
+    });
+  }
+  return {
+    connect() {
+      return new Promise((resolve, reject) => {
+        const client = options.auth ? {
+          apiKey: options.auth.apiKey,
+          baseURL: options.auth.baseUrl ?? "https://api.openai.com/v1"
+        } : void 0;
+        rt = new OpenAIRealtimeWS({ model: "gpt-4o-realtime-preview" }, client);
+        rt.socket.on("open", () => {
+          configureSession();
+          bindEvents();
+          resolve();
+        });
+        rt.socket.on("error", (err) => {
+          reject(new Error(`WebSocket connection failed: ${err.message}`));
+        });
+      });
+    },
+    sendMessage(text) {
+      rt.send({
+        type: "conversation.item.create",
+        item: {
+          type: "message",
+          role: "user",
+          content: [
+            {
+              type: "input_text",
+              text: `Read this aloud exactly as written, word for word. Do not add, remove, or change anything:
+
+${text}`
+            }
+          ]
+        }
+      });
+      rt.send({ type: "response.create" });
+    },
+    sendAudio(pcm16) {
+      rt.send({
+        type: "input_audio_buffer.append",
+        audio: pcm16.toString("base64")
+      });
+    },
+    close() {
+      rt?.close();
+    }
+  };
+}
+
+export {
+  createAudioPlayer,
+  createAudioRecorder,
+  createRealtimeSession
+};

package/dist/chunk-EF2ZPBZD.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+
+// src/types.ts
+var SAMPLE_RATE = 24e3;
+var CHANNELS = 1;
+var BIT_DEPTH = 16;
+var VOICES = [
+  "alloy",
+  "ash",
+  "ballad",
+  "coral",
+  "echo",
+  "fable",
+  "nova",
+  "onyx",
+  "sage",
+  "shimmer",
+  "verse"
+];
+var DEFAULT_VOICE = "ash";
+
+export {
+  SAMPLE_RATE,
+  CHANNELS,
+  BIT_DEPTH,
+  VOICES,
+  DEFAULT_VOICE
+};

package/dist/chunk-GUTKT66X.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+import {
+  DEFAULT_VOICE
+} from "./chunk-EF2ZPBZD.js";
+
+// src/config.ts
+import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CONFIG_DIR = join(homedir(), ".agent-voice");
+var CONFIG_PATH = join(CONFIG_DIR, "config.json");
+function readConfig() {
+  try {
+    return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeAuthConfig(auth) {
+  const config = readConfig();
+  config.auth = auth;
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_PATH, `${JSON.stringify(config, null, 2)}
+`, {
+    mode: 384
+  });
+  chmodSync(CONFIG_PATH, 384);
+}
+function resolveAuth() {
+  const config = readConfig();
+  if (config.auth?.apiKey) {
+    return config.auth;
+  }
+  if (process.env.OPENAI_API_KEY) {
+    return { apiKey: process.env.OPENAI_API_KEY };
+  }
+  throw new Error(
+    "No API key found. Run `agent-voice auth` or set OPENAI_API_KEY."
+  );
+}
+function writeVoiceConfig(voice) {
+  const config = readConfig();
+  config.voice = voice;
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_PATH, `${JSON.stringify(config, null, 2)}
+`, {
+    mode: 384
+  });
+  chmodSync(CONFIG_PATH, 384);
+}
+function resolveVoice() {
+  const config = readConfig();
+  return config.voice ?? DEFAULT_VOICE;
+}
+
+export {
+  readConfig,
+  writeAuthConfig,
+  resolveAuth,
+  writeVoiceConfig,
+  resolveVoice
+};

package/dist/cli.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { closeSync, openSync, writeSync } from "fs";
+import { Command } from "commander";
+var savedStdoutFd = openSync("/dev/fd/1", "w");
+closeSync(1);
+openSync("/dev/null", "w");
+function writeResult(text) {
+  writeSync(savedStdoutFd, `${text}
+`);
+  closeSync(savedStdoutFd);
+}
+var { ask } = await import("./ask-MG4CURKM.js");
+var { say } = await import("./say-KJWVP5OC.js");
+var { resolveAuth, resolveVoice, writeVoiceConfig } = await import("./config-6FQI6YPB.js");
+var { VOICES } = await import("./types-UKEQRG2U.js");
+async function readStdin() {
+  if (process.stdin.isTTY) return "";
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8").trim();
+}
+async function getMessage(flag) {
+  if (flag) return flag;
+  const stdin = await readStdin();
+  if (stdin) return stdin;
+  throw new Error("No message provided. Use -m or pipe via stdin.");
+}
+var program = new Command().name("agent-voice").description("AI agent voice interaction CLI");
+program.command("auth").description("Configure API key and base URL").action(async () => {
+  try {
+    const { auth } = await import("./auth-KIIHTB6C.js");
+    await auth();
+    process.exit(0);
+  } catch (err) {
+    process.stderr.write(`${err instanceof Error ? err.message : err}
+`);
+    process.exit(1);
+  }
+});
+var defaultVoice = resolveVoice();
+var voicesCmd = program.command("voices").description("List available voices");
+voicesCmd.action(() => {
+  for (const v of VOICES) {
+    const marker = v === defaultVoice ? " (default)" : "";
+    process.stderr.write(`${v}${marker}
+`);
+  }
+  process.exit(0);
+});
+voicesCmd.command("set <voice>").description("Set the default voice").action((voice) => {
+  if (!VOICES.includes(voice)) {
+    process.stderr.write(
+      `Unknown voice "${voice}". Available: ${VOICES.join(", ")}
+`
+    );
+    process.exit(1);
+  }
+  writeVoiceConfig(voice);
+  process.stderr.write(`Default voice set to "${voice}".
+`);
+  process.exit(0);
+});
+program.command("ask").description("Speak a message and listen for a response").option("-m, --message <text>", "Text message to speak").option("--voice <name>", "OpenAI voice", defaultVoice).option("--timeout <seconds>", "Seconds to wait for user speech", "30").option("--ack", "Speak an acknowledgment after the user responds").action(async (opts) => {
+  try {
+    const auth = resolveAuth();
+    const message = await getMessage(opts.message);
+    const transcript = await ask(message, {
+      voice: opts.voice,
+      timeout: Number.parseInt(opts.timeout, 10),
+      ack: opts.ack ?? false,
+      auth
+    });
+    writeResult(transcript);
+    process.exit(0);
+  } catch (err) {
+    process.stderr.write(`${err instanceof Error ? err.message : err}
+`);
+    process.exit(1);
+  }
+});
+program.command("say").description("Speak a message without listening for a response").option("-m, --message <text>", "Text message to speak").option("--voice <name>", "OpenAI voice", defaultVoice).action(async (opts) => {
+  try {
+    const auth = resolveAuth();
+    const message = await getMessage(opts.message);
+    await say(message, { voice: opts.voice, auth });
+    process.exit(0);
+  } catch (err) {
+    process.stderr.write(`${err instanceof Error ? err.message : err}
+`);
+    process.exit(1);
+  }
+});
+program.parse();

package/dist/config-6FQI6YPB.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import {
+  readConfig,
+  resolveAuth,
+  resolveVoice,
+  writeAuthConfig,
+  writeVoiceConfig
+} from "./chunk-GUTKT66X.js";
+import "./chunk-EF2ZPBZD.js";
+export {
+  readConfig,
+  resolveAuth,
+  resolveVoice,
+  writeAuthConfig,
+  writeVoiceConfig
+};

package/dist/index.d.ts

@@ -0,0 +1,42 @@
+type AudioPlayer = {
+    write(pcm16: Buffer): boolean;
+    start(): void;
+    drain(): Promise<void>;
+    close(): void;
+};
+type AudioRecorder = {
+    onData(cb: (pcm16: Buffer) => void): void;
+    start(): void;
+    stop(): void;
+    close(): void;
+};
+
+type AuthConfig = {
+    apiKey: string;
+    baseUrl?: string;
+};
+declare function resolveAuth(): AuthConfig;
+declare function resolveVoice(): string;
+
+type AskOptions = {
+    voice?: string;
+    timeout?: number;
+    ack?: boolean;
+    auth?: AuthConfig;
+    createPlayer?: () => AudioPlayer;
+    createRecorder?: () => AudioRecorder;
+};
+declare function ask(message: string, options?: AskOptions): Promise<string>;
+
+type SayOptions = {
+    voice?: string;
+    auth?: AuthConfig;
+    createPlayer?: () => AudioPlayer;
+};
+declare function say(message: string, options?: SayOptions): Promise<void>;
+
+declare const VOICES: readonly ["alloy", "ash", "ballad", "coral", "echo", "fable", "nova", "onyx", "sage", "shimmer", "verse"];
+type Voice = (typeof VOICES)[number];
+declare const DEFAULT_VOICE: Voice;
+
+export { type AskOptions, type AuthConfig, DEFAULT_VOICE, type SayOptions, VOICES, type Voice, ask, resolveAuth, resolveVoice, say };

package/dist/index.js

@@ -0,0 +1,361 @@
+// src/audio.ts
+import { AudioIO, SampleFormat16Bit } from "naudiodon2";
+
+// src/types.ts
+var SAMPLE_RATE = 24e3;
+var CHANNELS = 1;
+var VOICES = [
+  "alloy",
+  "ash",
+  "ballad",
+  "coral",
+  "echo",
+  "fable",
+  "nova",
+  "onyx",
+  "sage",
+  "shimmer",
+  "verse"
+];
+var DEFAULT_VOICE = "ash";
+
+// src/audio.ts
+function createAudioPlayer() {
+  const stream = AudioIO({
+    outOptions: {
+      channelCount: CHANNELS,
+      sampleFormat: SampleFormat16Bit,
+      sampleRate: SAMPLE_RATE,
+      closeOnError: true
+    }
+  });
+  let closed = false;
+  return {
+    write(pcm16) {
+      return stream.write(pcm16);
+    },
+    start() {
+      stream.start();
+    },
+    drain() {
+      if (closed) return Promise.resolve();
+      closed = true;
+      return new Promise((resolve) => {
+        stream.quit(() => resolve());
+      });
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      stream.quit();
+    }
+  };
+}
+function createAudioRecorder() {
+  const stream = AudioIO({
+    inOptions: {
+      channelCount: CHANNELS,
+      sampleFormat: SampleFormat16Bit,
+      sampleRate: SAMPLE_RATE,
+      closeOnError: true
+    }
+  });
+  let stopped = false;
+  return {
+    onData(cb) {
+      stream.on("data", cb);
+    },
+    start() {
+      stream.start();
+    },
+    stop() {
+      if (stopped) return;
+      stopped = true;
+      stream.quit();
+    },
+    close() {
+      if (stopped) return;
+      stopped = true;
+      stream.quit();
+    }
+  };
+}
+
+// src/realtime.ts
+import { OpenAIRealtimeWS } from "openai/beta/realtime/ws";
+var SYSTEM_INSTRUCTIONS = `
+# Role
+Voice relay between an AI agent and a human.
+
+# Instructions
+- When given a text message, read it aloud EXACTLY as written. Do not add, remove, or rephrase anything.
+- After the human responds, acknowledge briefly \u2014 a few words only. Vary your phrasing.
+- NEVER repeat back what the user said verbatim.
+- NEVER ask follow-up questions.
+- Keep every response under one sentence.
+
+# Tone
+- Calm, neutral, concise.
+`.trim();
+function createRealtimeSession(options) {
+  let rt;
+  let responseCount = 0;
+  function configureSession() {
+    const turnDetection = options.mode === "say" ? null : {
+      type: "semantic_vad",
+      eagerness: "medium",
+      create_response: options.ack,
+      interrupt_response: true
+    };
+    rt.send({
+      type: "session.update",
+      session: {
+        instructions: SYSTEM_INSTRUCTIONS,
+        voice: options.voice,
+        input_audio_format: "pcm16",
+        output_audio_format: "pcm16",
+        input_audio_transcription: { model: "gpt-4o-transcribe" },
+        turn_detection: turnDetection
+      }
+    });
+  }
+  function bindEvents() {
+    rt.on("response.audio.delta", (event) => {
+      const pcm16 = Buffer.from(event.delta, "base64");
+      options.onAudioDelta(pcm16);
+    });
+    rt.on("conversation.item.input_audio_transcription.completed", (event) => {
+      options.onTranscript(event.transcript);
+    });
+    rt.on("input_audio_buffer.speech_started", () => {
+      options.onSpeechStarted();
+    });
+    rt.on("response.done", () => {
+      responseCount++;
+      if (responseCount === 1) {
+        options.onInitialResponseDone();
+      } else if (responseCount === 2) {
+        options.onDone();
+      }
+    });
+    rt.on("error", (event) => {
+      options.onError(event.error?.message ?? "Unknown realtime error");
+    });
+  }
+  return {
+    connect() {
+      return new Promise((resolve, reject) => {
+        const client = options.auth ? {
+          apiKey: options.auth.apiKey,
+          baseURL: options.auth.baseUrl ?? "https://api.openai.com/v1"
+        } : void 0;
+        rt = new OpenAIRealtimeWS({ model: "gpt-4o-realtime-preview" }, client);
+        rt.socket.on("open", () => {
+          configureSession();
+          bindEvents();
+          resolve();
+        });
+        rt.socket.on("error", (err) => {
+          reject(new Error(`WebSocket connection failed: ${err.message}`));
+        });
+      });
+    },
+    sendMessage(text) {
+      rt.send({
+        type: "conversation.item.create",
+        item: {
+          type: "message",
+          role: "user",
+          content: [
+            {
+              type: "input_text",
+              text: `Read this aloud exactly as written, word for word. Do not add, remove, or change anything:
+
+${text}`
+            }
+          ]
+        }
+      });
+      rt.send({ type: "response.create" });
+    },
+    sendAudio(pcm16) {
+      rt.send({
+        type: "input_audio_buffer.append",
+        audio: pcm16.toString("base64")
+      });
+    },
+    close() {
+      rt?.close();
+    }
+  };
+}
+
+// src/ask.ts
+async function ask(message, options = {}) {
+  const {
+    voice = DEFAULT_VOICE,
+    timeout = 30,
+    ack = false,
+    auth,
+    createPlayer = createAudioPlayer,
+    createRecorder = createAudioRecorder
+  } = options;
+  const player = createPlayer();
+  player.start();
+  return new Promise((resolve, reject) => {
+    let recorder = null;
+    let transcript = "";
+    let timeoutTimer = null;
+    let speechDetected = false;
+    let cleaned = false;
+    let resolved = false;
+    async function cleanup() {
+      if (cleaned) return;
+      cleaned = true;
+      if (timeoutTimer) clearTimeout(timeoutTimer);
+      recorder?.stop();
+      recorder?.close();
+      await player.drain();
+      session.close();
+    }
+    function finish() {
+      if (resolved) return;
+      resolved = true;
+      cleanup().then(() => resolve(transcript));
+    }
+    const session = createRealtimeSession({
+      voice,
+      mode: "default",
+      ack,
+      auth,
+      onAudioDelta(pcm16) {
+        player.write(pcm16);
+      },
+      onTranscript(text) {
+        transcript = text;
+        if (!ack) finish();
+      },
+      onSpeechStarted() {
+        speechDetected = true;
+        if (timeoutTimer) {
+          clearTimeout(timeoutTimer);
+          timeoutTimer = null;
+        }
+      },
+      onInitialResponseDone() {
+        setTimeout(() => {
+          recorder = createRecorder();
+          recorder.onData((pcm16) => {
+            session.sendAudio(pcm16);
+          });
+          recorder.start();
+        }, 500);
+        timeoutTimer = setTimeout(() => {
+          if (!speechDetected) {
+            cleanup();
+            reject(new Error(`No speech detected within ${timeout}s timeout`));
+          }
+        }, timeout * 1e3);
+      },
+      onDone() {
+        if (ack) finish();
+      },
+      async onError(error) {
+        await cleanup();
+        reject(new Error(error));
+      }
+    });
+    session.connect().then(() => {
+      session.sendMessage(message);
+    }, reject);
+  });
+}
+
+// src/config.ts
+import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CONFIG_DIR = join(homedir(), ".agent-voice");
+var CONFIG_PATH = join(CONFIG_DIR, "config.json");
+function readConfig() {
+  try {
+    return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function resolveAuth() {
+  const config = readConfig();
+  if (config.auth?.apiKey) {
+    return config.auth;
+  }
+  if (process.env.OPENAI_API_KEY) {
+    return { apiKey: process.env.OPENAI_API_KEY };
+  }
+  throw new Error(
+    "No API key found. Run `agent-voice auth` or set OPENAI_API_KEY."
+  );
+}
+function resolveVoice() {
+  const config = readConfig();
+  return config.voice ?? DEFAULT_VOICE;
+}
+
+// src/say.ts
+async function say(message, options = {}) {
+  const {
+    voice = DEFAULT_VOICE,
+    auth,
+    createPlayer = createAudioPlayer
+  } = options;
+  const player = createPlayer();
+  player.start();
+  return new Promise((resolve, reject) => {
+    let cleaned = false;
+    function cleanup() {
+      if (cleaned) return;
+      cleaned = true;
+      session.close();
+    }
+    const session = createRealtimeSession({
+      voice,
+      mode: "say",
+      ack: false,
+      auth,
+      onAudioDelta(pcm16) {
+        player.write(pcm16);
+      },
+      onTranscript() {
+      },
+      onSpeechStarted() {
+      },
+      async onInitialResponseDone() {
+        try {
+          await player.drain();
+        } catch {
+          player.close();
+        }
+        cleanup();
+        resolve();
+      },
+      onDone() {
+      },
+      onError(error) {
+        player.close();
+        cleanup();
+        reject(new Error(error));
+      }
+    });
+    session.connect().then(() => {
+      session.sendMessage(message);
+    }, reject);
+  });
+}
+export {
+  DEFAULT_VOICE,
+  VOICES,
+  ask,
+  resolveAuth,
+  resolveVoice,
+  say
+};

package/dist/say-KJWVP5OC.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+import {
+  createAudioPlayer,
+  createRealtimeSession
+} from "./chunk-4RFF3WHI.js";
+import {
+  DEFAULT_VOICE
+} from "./chunk-EF2ZPBZD.js";
+
+// src/say.ts
+async function say(message, options = {}) {
+  const {
+    voice = DEFAULT_VOICE,
+    auth,
+    createPlayer = createAudioPlayer
+  } = options;
+  const player = createPlayer();
+  player.start();
+  return new Promise((resolve, reject) => {
+    let cleaned = false;
+    function cleanup() {
+      if (cleaned) return;
+      cleaned = true;
+      session.close();
+    }
+    const session = createRealtimeSession({
+      voice,
+      mode: "say",
+      ack: false,
+      auth,
+      onAudioDelta(pcm16) {
+        player.write(pcm16);
+      },
+      onTranscript() {
+      },
+      onSpeechStarted() {
+      },
+      async onInitialResponseDone() {
+        try {
+          await player.drain();
+        } catch {
+          player.close();
+        }
+        cleanup();
+        resolve();
+      },
+      onDone() {
+      },
+      onError(error) {
+        player.close();
+        cleanup();
+        reject(new Error(error));
+      }
+    });
+    session.connect().then(() => {
+      session.sendMessage(message);
+    }, reject);
+  });
+}
+export {
+  say
+};

package/dist/types-UKEQRG2U.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import {
+  BIT_DEPTH,
+  CHANNELS,
+  DEFAULT_VOICE,
+  SAMPLE_RATE,
+  VOICES
+} from "./chunk-EF2ZPBZD.js";
+export {
+  BIT_DEPTH,
+  CHANNELS,
+  DEFAULT_VOICE,
+  SAMPLE_RATE,
+  VOICES
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "agent-voice",
+  "version": "0.1.0",
+  "description": "CLI for AI agents to interact with humans via voice",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "bin": {
+    "agent-voice": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@inquirer/prompts": "^8.2.0",
+    "commander": "^13.1.0",
+    "naudiodon2": "^2.1.0",
+    "openai": "^4.96.0",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "@changesets/cli": "^2.29.8",
+    "@types/node": "^22.12.0",
+    "@types/ws": "^8.5.14",
+    "dotenv-cli": "^11.0.0",
+    "lefthook": "^2.1.0",
+    "tsup": "^8.3.6",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.3",
+    "vitest": "^4.0.18"
+  },
+  "scripts": {
+    "dev": "dotenv -e .env.local -- tsx src/cli.ts",
+    "agent-voice": "dotenv -e .env.local -- tsx src/cli.ts",
+    "build": "tsup",
+    "check": "biome check --write .",
+    "typecheck": "tsc --noEmit",
+    "test": "dotenv -e .env.local -- vitest run",
+    "test:watch": "dotenv -e .env.local -- vitest",
+    "release": "pnpm build && changeset publish"
+  }
+}