@iinm/plain-agent 1.7.19 → 1.7.20

package/src/voiceInputOpenAI.mjs

@@ -1,16 +1,10 @@
 import {
-  createCJKSpaceNormalizer,
-  detectRecorder,
-  failVoiceSessionAsync,
-  getRecorderCandidates,
-  isCommandAvailable,
   isObjectLike,
-  startRecorder,
-  VOICE_DEBUG,
+  startWebSocketVoiceSession,
 } from "./voiceInputSession.mjs";
 
 /**
- * @import { VoiceRecorderConfig, VoiceSession, VoiceSessionCallbacks } from "./voiceInputSession.mjs"
+ * @import { VoiceProviderHooks, VoiceRecorderConfig, VoiceSession, VoiceSessionCallbacks } from "./voiceInputSession.mjs"
  */
 
 /**
@@ -40,222 +34,71 @@ const OPENAI_LABEL = "OpenAI Realtime";
  * @returns {VoiceSession}
  */
 export function startOpenAIVoiceSession({ config, callbacks }) {
-  const recorder =
-    config.recorder ??
-    detectRecorder(getRecorderCandidates(OPENAI_SAMPLE_RATE));
-  if (!recorder) {
-    return failVoiceSessionAsync(
-      callbacks,
-      new Error(
-        "No voice recorder found. Install arecord, sox, or ffmpeg (or set `voiceInput.recorder`).",
-      ),
-    );
-  }
-
-  if (!isCommandAvailable(recorder.command)) {
-    return failVoiceSessionAsync(
-      callbacks,
-      new Error(
-        `Voice recorder command "${recorder.command}" not found on PATH.`,
-      ),
-    );
-  }
-
-  const model = config.model ?? OPENAI_DEFAULT_MODEL;
-  const base = config.baseURL ?? OPENAI_DEFAULT_WS;
-
-  let stopped = false;
-  let closeEmitted = false;
-  let ready = false;
-  /** @type {Buffer[]} */
-  const pendingAudio = [];
-  const normalizer = createCJKSpaceNormalizer();
-
-  const emitClose = () => {
-    if (closeEmitted) return;
-    closeEmitted = true;
-    callbacks.onClose?.();
-  };
-
-  // Node's global WebSocket (undici) accepts a non-standard `headers`
-  // option. The built-in typings only declare the standards-compliant
-  // constructor, so cast through `WebSocket`-as-constructor.
-  const Ctor = /** @type {new (url: string, opts?: unknown) => WebSocket} */ (
-    /** @type {unknown} */ (WebSocket)
-  );
-  const ws = new Ctor(`${base}?intent=transcription`, {
-    headers: {
-      Authorization: `Bearer ${config.apiKey}`,
-      "OpenAI-Beta": "realtime=v1",
-    },
-  });
-  ws.binaryType = "arraybuffer";
-
-  const rec = startRecorder({
-    recorder,
-    onAudio(chunk) {
-      if (stopped) return;
-      if (ready && ws.readyState === WebSocket.OPEN) {
-        sendAudio(chunk);
-      } else {
-        pendingAudio.push(chunk);
-      }
+  /** @type {VoiceProviderHooks<VoiceInputOpenAIConfig>} */
+  const hooks = {
+    label: OPENAI_LABEL,
+    sampleRate: OPENAI_SAMPLE_RATE,
+    buildWsUrl(config) {
+      const base = config.baseURL ?? OPENAI_DEFAULT_WS;
+      return `${base}?intent=transcription`;
     },
-    onError(err) {
-      if (!stopped) callbacks.onError(err);
-      stop();
+    buildWsOptions(config) {
+      return {
+        headers: {
+          Authorization: `Bearer ${config.apiKey}`,
+          "OpenAI-Beta": "realtime=v1",
+        },
+      };
     },
-    onExit() {
-      stop();
+    buildSetupMessage(config) {
+      const model = config.model ?? OPENAI_DEFAULT_MODEL;
+      /** @type {{ model: string, language?: string }} */
+      const transcription = { model };
+      if (config.language) transcription.language = config.language;
+      // The `?intent=transcription` endpoint uses the flat transcription-session
+      // schema, not the nested `session.audio.input.*` realtime schema.
+      return {
+        type: "transcription_session.update",
+        session: {
+          input_audio_format: "pcm16",
+          input_audio_transcription: transcription,
+          turn_detection: { type: "server_vad" },
+        },
+      };
     },
-  });
-
-  /**
-   * @param {Buffer} chunk
-   */
-  function sendAudio(chunk) {
-    const payload = {
-      type: "input_audio_buffer.append",
-      audio: chunk.toString("base64"),
-    };
-    try {
-      ws.send(JSON.stringify(payload));
-    } catch {
-      // connection may have just closed
-    }
-  }
-
-  ws.addEventListener("open", () => {
-    /** @type {{ model: string, language?: string }} */
-    const transcription = { model };
-    if (config.language) transcription.language = config.language;
-    // The `?intent=transcription` endpoint uses the flat transcription-session
-    // schema, not the nested `session.audio.input.*` realtime schema.
-    const setup = {
-      type: "transcription_session.update",
-      session: {
-        input_audio_format: "pcm16",
-        input_audio_transcription: transcription,
-        turn_detection: { type: "server_vad" },
-      },
-    };
-    try {
-      ws.send(JSON.stringify(setup));
-    } catch (err) {
-      callbacks.onError(
-        new Error(
-          `Failed to send setup message: ${err instanceof Error ? err.message : String(err)}`,
-        ),
-      );
-      stop();
-    }
-  });
-
-  ws.addEventListener("message", (event) => {
-    if (stopped) return;
-    let raw = "";
-    let message;
-    try {
-      raw =
-        typeof event.data === "string"
-          ? event.data
-          : Buffer.from(/** @type {ArrayBuffer} */ (event.data)).toString(
-              "utf8",
-            );
-      message = JSON.parse(raw);
-    } catch (err) {
-      callbacks.onError(
-        new Error(
-          `Failed to parse server message: ${err instanceof Error ? err.message : String(err)}`,
-        ),
-      );
-      return;
-    }
-    if (!isObjectLike(message)) return;
-    if (VOICE_DEBUG) {
-      process.stderr.write(`[voiceInput] <- ${raw.slice(0, 800)}\n`);
-    }
-
-    if (message.type === "error" && isObjectLike(message.error)) {
-      const detail =
-        typeof message.error.message === "string"
-          ? message.error.message
-          : JSON.stringify(message.error);
-      callbacks.onError(new Error(`${OPENAI_LABEL} error: ${detail}`));
-      return;
-    }
-
-    if (
-      !ready &&
-      (message.type === "transcription_session.created" ||
-        message.type === "transcription_session.updated")
-    ) {
-      ready = true;
-      for (const chunk of pendingAudio.splice(0)) {
-        if (ws.readyState === WebSocket.OPEN) sendAudio(chunk);
-      }
-      return;
-    }
-
-    if (
-      message.type === "conversation.item.input_audio_transcription.delta" &&
-      typeof message.delta === "string" &&
-      message.delta.length > 0
-    ) {
-      const normalized = normalizer.push(message.delta);
-      if (normalized.length > 0) {
-        callbacks.onTranscript(normalized);
-      }
-    }
-  });
-
-  ws.addEventListener("error", (event) => {
-    if (stopped) return;
-    const message =
-      /** @type {{ message?: string }} */ (event).message ?? "WebSocket error";
-    callbacks.onError(new Error(`${OPENAI_LABEL} WebSocket error: ${message}`));
-    stop();
-  });
-
-  ws.addEventListener("close", (event) => {
-    if (!stopped && event.code !== 1000 && event.code !== 1005) {
-      const reason = event.reason ? `: ${event.reason}` : "";
-      callbacks.onError(
-        new Error(
-          `${OPENAI_LABEL} WebSocket closed (code ${event.code}${reason})`,
-        ),
+    isReadyMessage(message) {
+      return (
+        isObjectLike(message) &&
+        (message.type === "transcription_session.created" ||
+          message.type === "transcription_session.updated")
       );
-    }
-    stopped = true;
-    rec.stop();
-    emitClose();
-  });
-
-  if (VOICE_DEBUG) {
-    process.stderr.write(
-      `[voiceInput] driver=${OPENAI_LABEL} recorder=${recorder.command} ${recorder.args.join(" ")}\n`,
-    );
-  }
-
-  /**
-   * @returns {Promise<void>}
-   */
-  async function stop() {
-    if (stopped) return;
-    stopped = true;
-    rec.stop();
-    if (
-      ws.readyState === WebSocket.OPEN ||
-      ws.readyState === WebSocket.CONNECTING
-    ) {
-      try {
-        ws.close(1000, "client stop");
-      } catch {
-        // ignore
+    },
+    extractError(message) {
+      if (!isObjectLike(message) || message.type !== "error") return undefined;
+      const error = message.error;
+      if (!isObjectLike(error)) return undefined;
+      return typeof error.message === "string"
+        ? error.message
+        : JSON.stringify(error);
+    },
+    extractTranscript(message) {
+      if (
+        isObjectLike(message) &&
+        message.type === "conversation.item.input_audio_transcription.delta" &&
+        typeof message.delta === "string" &&
+        message.delta.length > 0
+      ) {
+        return message.delta;
       }
-    }
-    emitClose();
-  }
+      return undefined;
+    },
+    buildAudioPayload(chunk, _sampleRate) {
+      return {
+        type: "input_audio_buffer.append",
+        audio: chunk.toString("base64"),
+      };
+    },
+  };
 
-  return { stop };
+  return startWebSocketVoiceSession({ hooks, config, callbacks });
 }

package/src/voiceInputSession.mjs

@@ -170,6 +170,10 @@ export function startRecorder({ recorder, onAudio, onError, onExit }) {
 /**
  * Report an error asynchronously and return an already-terminated session.
  *
+ * Calls `onError` followed by `onClose` in a microtask, ensuring the caller
+ * receives a valid {@link VoiceSession} synchronously while still notifying
+ * the consumer of the failure.
+ *
  * @param {VoiceSessionCallbacks} callbacks
  * @param {Error} error
  * @returns {VoiceSession}
@@ -182,6 +186,281 @@ export function failVoiceSessionAsync(callbacks, error) {
   return { stop: async () => {} };
 }
 
+/**
+ * Provider-specific hook contract for {@link startWebSocketVoiceSession}.
+ *
+ * Each hook is called at a specific point in the session lifecycle:
+ *
+ * 1. **Construction** – `buildWsUrl` (and optionally `buildWsOptions`) are
+ *    invoked immediately to create the WebSocket.
+ * 2. **Open** – `buildSetupMessage` is sent as the first JSON message once the
+ *    WebSocket opens.
+ * 3. **Ready** – `isReadyMessage` is tested on every incoming message until it
+ *    returns `true`. At that point the session transitions to *ready* and any
+ *    buffered audio chunks are flushed.
+ * 4. **Streaming** – `buildAudioPayload` is called for every recorder chunk
+ *    while the WebSocket is open and ready.
+ * 5. **Error extraction** – `extractError` is checked on every message before
+ *    transcript extraction. If it returns a string, the session reports an
+ *    error and drops the message.
+ * 6. **Transcription** – `extractTranscript` is called on every message after
+ *    the session is ready. Non-empty results are pushed through the CJK
+ *    space normalizer and then forwarded to `onTranscript`.
+ *
+ * @template TConfig
+ * @typedef {Object} VoiceProviderHooks
+ * @property {string} label - Human-readable provider name (used in logs and
+ *   error messages).
+ * @property {number} sampleRate - PCM sample rate expected by the provider
+ *   (e.g. 16000 for Gemini, 24000 for OpenAI). Passed to the recorder and
+ *   `buildAudioPayload`.
+ * @property {(config: TConfig) => string} buildWsUrl - Returns the full
+ *   WebSocket URL, including any query parameters.
+ * @property {(config: TConfig) => { headers?: Record<string, string> }} [buildWsOptions]
+ *   - Returns optional per-provider WebSocket constructor options. Node's
+ *   global WebSocket (undici) accepts a non-standard `headers` option that
+ *   is not declared in the standard typings.
+ * @property {(config: TConfig) => object} buildSetupMessage - Returns the
+ *   first JSON message sent immediately after the WebSocket opens.
+ * @property {(message: unknown) => boolean} isReadyMessage - Returns `true`
+ *   when the given server message signals that the provider is ready to
+ *   receive audio.
+ * @property {(message: unknown) => string | undefined} extractTranscript -
+ *   Extracts a transcript delta from a server message. Return `undefined`
+ *   when the message carries no transcript.
+ * @property {(message: unknown) => string | undefined} [extractError] -
+ *   Extracts an error description from a server message. Return `undefined`
+ *   when the message carries no error.
+ * @property {(chunk: Buffer, sampleRate: number) => object} buildAudioPayload -
+ *   Wraps a raw PCM chunk into the provider-specific JSON payload. The
+ *   `sampleRate` argument is the same value as `hooks.sampleRate`.
+ */
+
+/**
+ * Shared WebSocket voice session implementation used by both Gemini and
+ * OpenAI drivers.
+ *
+ * Responsibilities of this function:
+ * - Detect and start a suitable system audio recorder.
+ * - Establish the provider WebSocket connection.
+ * - Manage the lifecycle (setup → ready → streaming → close).
+ * - Buffer audio chunks while the connection is not yet ready.
+ * - Apply CJK space normalization to transcript text.
+ *
+ * Responsibilities of the caller (the driver):
+ * - Provide a {@link VoiceProviderHooks} object that knows the provider's
+ *   wire protocol (URLs, headers, message schemas).
+ * - Supply `config` and `callbacks` from the user's call site.
+ *
+ * @template TConfig
+ * @param {object} options
+ * @param {VoiceProviderHooks<TConfig>} options.hooks
+ * @param {TConfig & { recorder?: VoiceRecorderConfig }} options.config
+ * @param {VoiceSessionCallbacks} options.callbacks
+ * @returns {VoiceSession}
+ */
+export function startWebSocketVoiceSession({ hooks, config, callbacks }) {
+  const recorder =
+    config.recorder ?? detectRecorder(getRecorderCandidates(hooks.sampleRate));
+  if (!recorder) {
+    return failVoiceSessionAsync(
+      callbacks,
+      new Error(
+        "No voice recorder found. Install arecord, sox, or ffmpeg (or set `voiceInput.recorder`).",
+      ),
+    );
+  }
+
+  if (!isCommandAvailable(recorder.command)) {
+    return failVoiceSessionAsync(
+      callbacks,
+      new Error(
+        `Voice recorder command "${recorder.command}" not found on PATH.`,
+      ),
+    );
+  }
+
+  let stopped = false;
+  let closeEmitted = false;
+  let ready = false;
+  /** @type {Buffer[]} */
+  const pendingAudio = [];
+  const normalizer = createCJKSpaceNormalizer();
+
+  function emitClose() {
+    if (closeEmitted) return;
+    closeEmitted = true;
+    callbacks.onClose?.();
+  }
+
+  const wsUrl = hooks.buildWsUrl(config);
+  const wsOptions = hooks.buildWsOptions?.(config);
+
+  // Node's global WebSocket (undici) accepts a non-standard `headers`
+  // option. The built-in typings only declare the standards-compliant
+  // constructor, so cast through `WebSocket`-as-constructor.
+  const Ctor = /** @type {new (url: string, opts?: unknown) => WebSocket} */ (
+    /** @type {unknown} */ (WebSocket)
+  );
+  const ws = new Ctor(wsUrl, wsOptions);
+  ws.binaryType = "arraybuffer";
+
+  const rec = startRecorder({
+    recorder,
+    onAudio(chunk) {
+      if (stopped) return;
+      if (ready && ws.readyState === WebSocket.OPEN) {
+        sendAudio(chunk);
+      } else {
+        pendingAudio.push(chunk);
+      }
+    },
+    onError(err) {
+      if (!stopped) callbacks.onError(err);
+      stop();
+    },
+    onExit() {
+      stop();
+    },
+  });
+
+  /**
+   * @param {Buffer} chunk
+   */
+  function sendAudio(chunk) {
+    const payload = hooks.buildAudioPayload(chunk, hooks.sampleRate);
+    try {
+      ws.send(JSON.stringify(payload));
+    } catch (err) {
+      if (VOICE_DEBUG) {
+        process.stderr.write(
+          `[voiceInput] sendAudio dropped: ${formatError(err)}\n`,
+        );
+      }
+    }
+  }
+
+  ws.addEventListener("open", () => {
+    const setup = hooks.buildSetupMessage(config);
+    try {
+      ws.send(JSON.stringify(setup));
+    } catch (err) {
+      callbacks.onError(
+        new Error(`Failed to send setup message: ${formatError(err)}`),
+      );
+      stop();
+    }
+  });
+
+  ws.addEventListener("message", (event) => {
+    if (stopped) return;
+    let raw = "";
+    let message;
+    try {
+      raw =
+        typeof event.data === "string"
+          ? event.data
+          : Buffer.from(/** @type {ArrayBuffer} */ (event.data)).toString(
+              "utf8",
+            );
+      message = JSON.parse(raw);
+    } catch (err) {
+      callbacks.onError(
+        new Error(`Failed to parse server message: ${formatError(err)}`),
+      );
+      return;
+    }
+    if (!isObjectLike(message)) return;
+    if (VOICE_DEBUG) {
+      process.stderr.write(`[voiceInput] <- ${raw.slice(0, 800)}\n`);
+    }
+
+    const errorText = hooks.extractError?.(message);
+    if (errorText) {
+      callbacks.onError(new Error(`${hooks.label} error: ${errorText}`));
+      return;
+    }
+
+    if (!ready && hooks.isReadyMessage(message)) {
+      ready = true;
+      for (const chunk of pendingAudio.splice(0)) {
+        if (ws.readyState === WebSocket.OPEN) sendAudio(chunk);
+      }
+      return;
+    }
+
+    const transcript = hooks.extractTranscript(message);
+    if (transcript && transcript.length > 0) {
+      const normalized = normalizer.push(transcript);
+      if (normalized.length > 0) {
+        callbacks.onTranscript(normalized);
+      }
+    }
+  });
+
+  ws.addEventListener("error", (event) => {
+    if (stopped) return;
+    const message =
+      /** @type {{ message?: string }} */ (event).message ?? "WebSocket error";
+    callbacks.onError(new Error(`${hooks.label} WebSocket error: ${message}`));
+    stop();
+  });
+
+  ws.addEventListener("close", (event) => {
+    if (!stopped && event.code !== 1000 && event.code !== 1005) {
+      const reason = event.reason ? `: ${event.reason}` : "";
+      callbacks.onError(
+        new Error(
+          `${hooks.label} WebSocket closed (code ${event.code}${reason})`,
+        ),
+      );
+    }
+    stopped = true;
+    rec.stop();
+    emitClose();
+  });
+
+  if (VOICE_DEBUG) {
+    process.stderr.write(
+      `[voiceInput] driver=${hooks.label} recorder=${recorder.command} ${recorder.args.join(" ")}\n`,
+    );
+  }
+
+  /**
+   * Stops the recorder and closes the WebSocket.
+   *
+   * **Note on asynchronicity:** This function is `async` only to satisfy the
+   * {@link VoiceSession} interface. It is called without `await` from event
+   * listeners (recorder exit, WebSocket error/close). Callers must not rely
+   * on the returned promise because unhandled rejections would crash the
+   * process. If the function is ever changed to perform real async work,
+   * every call site must wrap it with `.catch(() => {})`.
+   */
+  async function stop() {
+    if (stopped) return;
+    stopped = true;
+    rec.stop();
+    pendingAudio.length = 0;
+    if (
+      ws.readyState === WebSocket.OPEN ||
+      ws.readyState === WebSocket.CONNECTING
+    ) {
+      try {
+        ws.close(1000, "client stop");
+      } catch (err) {
+        if (VOICE_DEBUG) {
+          process.stderr.write(
+            `[voiceInput] ws.close failed: ${formatError(err)}\n`,
+          );
+        }
+      }
+    }
+    emitClose();
+  }
+
+  return { stop };
+}
+
 /**
  * Drop whitespace sitting between two CJK characters. Some providers return
  * Japanese transcripts with morpheme-separating spaces ("そう 、 声 で");
@@ -192,8 +471,14 @@ export function failVoiceSessionAsync(callbacks, error) {
 export function createCJKSpaceNormalizer() {
   let prevChar = "";
   let pendingSpaces = "";
-  const isSpace = (/** @type {string} */ c) =>
-    c === " " || c === "\t" || c === "\u3000";
+
+  /**
+   * @param {string} c
+   * @returns {boolean}
+   */
+  function isSpace(c) {
+    return c === " " || c === "\t" || c === "\u3000";
+  }
 
   return {
     push(text) {
@@ -248,3 +533,11 @@ function isCJKChar(ch) {
 export function isObjectLike(value) {
   return typeof value === "object" && value !== null;
 }
+
+/**
+ * @param {unknown} err
+ * @returns {string}
+ */
+function formatError(err) {
+  return err instanceof Error ? err.message : String(err);
+}

package/bin/plain-notify-terminal-bell

@@ -1,3 +0,0 @@
-#!/usr/bin/env bash
-
-printf "\a"