opencode-speaker 1.0.0

package/dist/index.js

@@ -0,0 +1,1326 @@
+// src/index.ts
+import "source-map-support/register.js";
+
+// src/config.ts
+import { z } from "zod";
+
+// src/ai-sdk/models.ts
+import { openai } from "@ai-sdk/openai";
+import { anthropic } from "@ai-sdk/anthropic";
+import { elevenlabs } from "@ai-sdk/elevenlabs";
+var ConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+};
+var SLUG_RE = /^[a-z][a-z0-9-]*\/[A-Za-z0-9._-]+$/;
+function parseSlug(slug, field) {
+  if (!SLUG_RE.test(slug)) {
+    throw new ConfigError(
+      `${field} must be 'provider/model' (e.g. 'openai/gpt-5'), got '${slug}'`
+    );
+  }
+  const idx = slug.indexOf("/");
+  return [slug.slice(0, idx), slug.slice(idx + 1)];
+}
+function resolveLanguageModel(slug) {
+  const [provider, modelId] = parseSlug(slug, "narrator.model");
+  switch (provider) {
+    case "openai":
+      return openai(modelId);
+    case "anthropic":
+      return anthropic(modelId);
+    default:
+      throw new ConfigError(
+        `Unknown narrator provider '${provider}' in '${slug}'. Supported: openai, anthropic`
+      );
+  }
+}
+function resolveSpeechModel(slug) {
+  const [provider, modelId] = parseSlug(slug, "tts.model");
+  switch (provider) {
+    case "openai":
+      return { provider: "openai", model: openai.speech(modelId) };
+    case "elevenlabs":
+      return { provider: "elevenlabs", model: elevenlabs.speech(modelId) };
+    default:
+      throw new ConfigError(
+        `Unknown TTS provider '${provider}' in '${slug}'. Supported: openai, elevenlabs`
+      );
+  }
+}
+
+// src/events/catalog.ts
+var enabled = (normal, minimal = normal) => ({
+  minimal,
+  normal,
+  verbose: normal
+});
+var EVENT_SPECS = {
+  "session.idle": { mode: "narrate", queuePriority: 2 /* NORMAL */, defaultEnabled: enabled(true, true) },
+  "session.error": { mode: "template", priority: "urgent", queuePriority: 3 /* URGENT */, defaultEnabled: enabled(true, true) },
+  "session.compacted": { mode: "template", queuePriority: 2 /* NORMAL */, defaultEnabled: enabled(true, false) },
+  "session.created": { mode: "template", queuePriority: 2 /* NORMAL */, defaultEnabled: enabled(true, false) },
+  "permission.asked": { mode: "template", priority: "urgent", queuePriority: 3 /* URGENT */, defaultEnabled: enabled(true, true) },
+  "permission.replied": { mode: "template", queuePriority: 2 /* NORMAL */, defaultEnabled: enabled(true, false) },
+  "tool.execute.before": { mode: "template", priority: "chatty", queuePriority: 1 /* CHATTY */, defaultEnabled: enabled(true, false) },
+  "tool.execute.after": { mode: "template", priority: "chatty", queuePriority: 1 /* CHATTY */, defaultEnabled: enabled(true, false) },
+  "file.edited": { mode: "template", priority: "chatty", queuePriority: 1 /* CHATTY */, defaultEnabled: enabled(true, false) },
+  "command.executed": { mode: "template", queuePriority: 2 /* NORMAL */, defaultEnabled: enabled(true, false) },
+  "message.updated": { mode: "verbatim", priority: "chatty", queuePriority: 1 /* CHATTY */, defaultEnabled: enabled(false, false) },
+  "message.reasoning.delta": { mode: "verbatim", priority: "chatty", queuePriority: 1 /* CHATTY */, defaultEnabled: enabled(true, false), synthetic: true },
+  "message.text.delta": { mode: "verbatim", priority: "chatty", queuePriority: 1 /* CHATTY */, defaultEnabled: enabled(false, false), synthetic: true },
+  "todo.completed.item": { mode: "template", priority: "chatty", queuePriority: 1 /* CHATTY */, defaultEnabled: enabled(true, false), synthetic: true },
+  "todo.completed.all": { mode: "narrate", queuePriority: 2 /* NORMAL */, defaultEnabled: enabled(true, true), synthetic: true, narrationOccasion: "The user has finished all todos." }
+};
+function defaultEventsForVerbosity(verbosity) {
+  return Object.fromEntries(
+    Object.entries(EVENT_SPECS).map(([type, spec]) => [
+      type,
+      {
+        enabled: spec.defaultEnabled[verbosity],
+        mode: spec.mode,
+        ...spec.priority ? { priority: spec.priority } : {}
+      }
+    ])
+  );
+}
+function queuePriorityForEvent(type) {
+  return EVENT_SPECS[type]?.queuePriority ?? 2 /* NORMAL */;
+}
+
+// src/config.ts
+var PLUGIN_NAME = "opencode-speaker";
+var DEFAULT_TTS_MODEL = "openai/gpt-4o-mini-tts";
+var DEFAULT_NARRATOR_MODEL = "openai/gpt-4.1-mini";
+var DEFAULT_GREETING = "Welcome to OpenCode Speaker!";
+var ENV_DISABLED = "OPENCODE_VOICE_DISABLED";
+var ENV_MUTE = "OPENCODE_VOICE_MUTE";
+var PrioritySchema = z.enum(["urgent", "normal", "chatty"]).optional();
+var ModeSchema = z.enum(["template", "narrate", "verbatim"]);
+var VerbositySchema = z.enum(["minimal", "normal", "verbose"]);
+var EventConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  mode: ModeSchema.default("template"),
+  priority: PrioritySchema
+});
+var SLUG_MSG = `must be 'provider/model' (e.g. '${DEFAULT_TTS_MODEL}')`;
+var TTSSchema = z.object({
+  model: z.string().regex(SLUG_RE, `tts.model ${SLUG_MSG}`).default(DEFAULT_TTS_MODEL),
+  voice: z.string().optional(),
+  rate: z.number().min(0.5).max(2).default(1),
+  pitch: z.number().min(0.5).max(2).default(1)
+}).default({});
+var NarratorSchema = z.object({
+  model: z.string().regex(SLUG_RE, `narrator.model ${SLUG_MSG}`).default(DEFAULT_NARRATOR_MODEL),
+  timeoutMs: z.number().int().positive().default(5e3),
+  minIntervalMs: z.number().int().min(0).default(3e3)
+}).default({});
+var QueueSchema = z.object({
+  staleMs: z.number().int().min(0).default(8e3)
+}).default({});
+var EventsSchema = z.record(z.string(), EventConfigSchema).default({});
+var VoiceConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  verbosity: VerbositySchema.default("normal"),
+  startMuted: z.boolean().default(false),
+  greeting: z.string().default(DEFAULT_GREETING),
+  tts: TTSSchema,
+  narrator: NarratorSchema,
+  events: EventsSchema,
+  queue: QueueSchema
+});
+function presetEvents(verbosity) {
+  return defaultEventsForVerbosity(verbosity);
+}
+var DEFAULT_CONFIG = VoiceConfigSchema.parse({
+  events: defaultEventsForVerbosity("normal")
+});
+function parseConfig(raw, env = process.env) {
+  const userObj = raw && typeof raw === "object" ? raw : {};
+  const userEvents = userObj.events && typeof userObj.events === "object" ? userObj.events : {};
+  const rawVerbosity = userObj.verbosity;
+  const verbosity = rawVerbosity === "minimal" || rawVerbosity === "verbose" || rawVerbosity === "normal" ? rawVerbosity : "normal";
+  const defaultsForVerbosity = presetEvents(verbosity);
+  const mergedEvents = { ...defaultsForVerbosity };
+  for (const [key, val] of Object.entries(userEvents)) {
+    const defaultEvent = defaultsForVerbosity[key] ?? {};
+    if (val && typeof val === "object" && !Array.isArray(val)) {
+      mergedEvents[key] = { ...defaultEvent, ...val };
+    } else {
+      mergedEvents[key] = val;
+    }
+  }
+  const merged = { ...userObj, events: mergedEvents };
+  const parsed = VoiceConfigSchema.safeParse(merged);
+  if (!parsed.success) {
+    return {
+      ok: false,
+      errors: parsed.error.issues.map((i) => ({
+        path: i.path.join("."),
+        message: i.message
+      }))
+    };
+  }
+  const cfg = parsed.data;
+  if (env[ENV_DISABLED] === "1") cfg.enabled = false;
+  if (env[ENV_MUTE] === "1") cfg.startMuted = true;
+  return { ok: true, config: cfg };
+}
+
+// src/log.ts
+var SENSITIVE_KEYS = /* @__PURE__ */ new Set([
+  "apiKey",
+  "api_key",
+  "apikey",
+  "authorization",
+  "Authorization",
+  "secret",
+  "token",
+  "password"
+]);
+function redact(value) {
+  return redactInner(value, /* @__PURE__ */ new WeakSet());
+}
+function redactInner(value, seen) {
+  if (value === null || typeof value !== "object") return value;
+  if (seen.has(value)) return "[Circular]";
+  seen.add(value);
+  if (Array.isArray(value)) return value.map((v) => redactInner(v, seen));
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    out[k] = SENSITIVE_KEYS.has(k) ? "***" : redactInner(v, seen);
+  }
+  return out;
+}
+var MAX_FIELD_BYTES = 4096;
+function truncatePayload(value) {
+  return truncateInner(value, /* @__PURE__ */ new WeakSet(), false);
+}
+function truncateInner(value, seen, insideErrorStack) {
+  if (typeof value === "string") {
+    if (insideErrorStack) return value;
+    const bytes = Buffer.byteLength(value, "utf8");
+    if (bytes <= MAX_FIELD_BYTES) return value;
+    const head = Buffer.from(value, "utf8").subarray(0, MAX_FIELD_BYTES).toString("utf8");
+    return `${head}\u2026<truncated:${bytes - MAX_FIELD_BYTES} bytes>`;
+  }
+  if (value === null || typeof value !== "object") return value;
+  if (seen.has(value)) return value;
+  seen.add(value);
+  if (Array.isArray(value)) return value.map((v) => truncateInner(v, seen, insideErrorStack));
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    const exempt = k === "stack";
+    out[k] = truncateInner(v, seen, exempt);
+  }
+  return out;
+}
+var FRAME_RE = /^\s*at (?:(.+?) \()?(.+?):(\d+):(\d+)\)?$/;
+function isInternalFile(file) {
+  return file.startsWith("node:") || file.includes("/internal/") || file.endsWith("/log.js") || file.endsWith("/log.ts");
+}
+function parseTopFrame(stack) {
+  if (!stack) return {};
+  const lines = stack.split("\n");
+  for (const raw of lines) {
+    const m = FRAME_RE.exec(raw);
+    if (!m) continue;
+    const file = m[2];
+    if (isInternalFile(file)) continue;
+    return {
+      function: m[1] || void 0,
+      file,
+      line: Number(m[3]),
+      column: Number(m[4])
+    };
+  }
+  return {};
+}
+function nonErrorMessage(value) {
+  try {
+    if (typeof value === "string") return value;
+    if (typeof value === "number" || typeof value === "boolean") return String(value);
+    return JSON.stringify(value);
+  } catch {
+    return Object.prototype.toString.call(value);
+  }
+}
+function serializeError(err) {
+  if (!(err instanceof Error)) {
+    return { name: "NonError", message: nonErrorMessage(err) };
+  }
+  try {
+    return serializeErrorDepth(err, 2);
+  } catch {
+    return { name: err.name ?? "Error", message: err.message ?? "" };
+  }
+}
+function serializeErrorDepth(err, depth) {
+  const stack = err.stack;
+  const out = {
+    name: err.name,
+    message: err.message,
+    ...stack ? { stack } : {},
+    ...parseTopFrame(stack)
+  };
+  const code = err.code;
+  if (code !== void 0) out.code = code;
+  const cause = err.cause;
+  if (depth > 0 && cause instanceof Error) {
+    out.cause = serializeErrorDepth(cause, depth - 1);
+  }
+  return out;
+}
+function createLogger(client, service) {
+  return makeLogger(client, service, void 0);
+}
+function makeLogger(client, service, bindings) {
+  async function emit(level, message, ctx) {
+    try {
+      const body = { service, level, message };
+      const extra = buildExtra(ctx, bindings);
+      if (extra !== void 0) body.extra = extra;
+      await client.app.log({ body });
+    } catch {
+    }
+  }
+  const logger = {
+    debug: (m, e) => emit("debug", m, e),
+    info: (m, e) => emit("info", m, e),
+    warn: (m, e) => emit("warn", m, e),
+    error: (m, e) => emit("error", m, e),
+    child(b) {
+      const merged = { ...bindings ?? {}, ...b };
+      return makeLogger(client, service, merged);
+    }
+  };
+  return logger;
+}
+function buildExtra(ctx, bindings) {
+  try {
+    let normalized;
+    if (ctx instanceof Error) {
+      normalized = { error: serializeError(ctx) };
+    } else if (ctx !== void 0 && ctx !== null && typeof ctx === "object") {
+      const obj = ctx;
+      normalized = { ...obj };
+      if (obj.error instanceof Error) {
+        normalized.error = serializeError(obj.error);
+      }
+    } else if (ctx !== void 0) {
+      normalized = { value: ctx };
+    }
+    if (bindings && Object.keys(bindings).length > 0) {
+      normalized = { ...normalized ?? {}, bindings: { ...bindings } };
+    }
+    if (normalized === void 0) return void 0;
+    return truncatePayload(redact(normalized));
+  } catch {
+    return bindings ? { bindings: { ...bindings } } : void 0;
+  }
+}
+
+// src/queue/speech-queue.ts
+var SpeechQueue = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  queue = [];
+  current = null;
+  muted = false;
+  idleResolvers = [];
+  pumpRunning = false;
+  push(req) {
+    if (this.muted) return;
+    if (this.current && req.priority > this.current.req.priority) {
+      this.queue.unshift(req);
+      this.current.abort.abort();
+      return;
+    }
+    if (req.dedupKey) {
+      const idx = this.queue.findIndex((q) => q.dedupKey === req.dedupKey);
+      if (idx >= 0) {
+        this.queue[idx] = req;
+        return;
+      }
+    }
+    let i = 0;
+    while (i < this.queue.length && this.queue[i].priority >= req.priority) i++;
+    this.queue.splice(i, 0, req);
+    void this.pump();
+  }
+  mute() {
+    this.muted = true;
+    this.queue = [];
+    if (this.current) this.current.abort.abort();
+  }
+  unmute() {
+    this.muted = false;
+  }
+  /**
+   * Interrupt the current utterance and drop the pending queue WITHOUT
+   * changing the muted state. Use this for "stop speaking right now" while
+   * leaving future events free to speak.
+   */
+  stop() {
+    this.queue = [];
+    if (this.current) this.current.abort.abort();
+  }
+  isMuted() {
+    return this.muted;
+  }
+  size() {
+    return this.queue.length + (this.current ? 1 : 0);
+  }
+  /** Resolves when queue is empty and nothing is speaking. */
+  async idle() {
+    if (!this.current && this.queue.length === 0 && !this.pumpRunning) return;
+    return new Promise((resolve) => {
+      this.idleResolvers.push(resolve);
+    });
+  }
+  async pump() {
+    if (this.pumpRunning || this.current) return;
+    this.pumpRunning = true;
+    try {
+      while (this.queue.length > 0 && !this.muted) {
+        const next = this.queue.shift();
+        if (next.priority <= 2 /* NORMAL */ && this.opts.now() - next.enqueuedAt > this.opts.staleMs) {
+          continue;
+        }
+        const abort = new AbortController();
+        this.current = { req: next, abort };
+        try {
+          await this.opts.speak(next, abort.signal);
+        } catch (err) {
+          this.opts.onError?.(err, next);
+        } finally {
+          this.current = null;
+        }
+      }
+    } finally {
+      this.pumpRunning = false;
+      if (!this.current && this.queue.length === 0) {
+        const resolvers = this.idleResolvers;
+        this.idleResolvers = [];
+        for (const r of resolvers) r();
+      }
+    }
+  }
+};
+
+// src/tts/ai-sdk.ts
+import { experimental_generateSpeech as generateSpeech } from "ai";
+function createAiSdkProvider(config) {
+  const { model, provider: providerName, voice: defaultVoice } = config;
+  return {
+    name: providerName,
+    async synthesize(text, opts, signal) {
+      const voice = opts.voice ?? defaultVoice ?? (providerName === "openai" ? "alloy" : void 0);
+      const result = await generateSpeech({
+        model,
+        text,
+        voice,
+        outputFormat: "mp3",
+        speed: opts.rate,
+        abortSignal: signal
+      });
+      return {
+        audio: Buffer.from(result.audio.uint8Array),
+        contentType: result.audio.mediaType ?? "audio/mpeg"
+      };
+    }
+  };
+}
+
+// src/audio/player.ts
+import { writeFile, mkdtemp, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+var LINUX_PLAYERS = ["paplay", "aplay", "ffplay"];
+function createPlayer(opts) {
+  const platform = opts.platform ?? process.platform;
+  let binary = null;
+  async function buffer(stream, signal) {
+    if (Buffer.isBuffer(stream)) return stream;
+    const chunks = [];
+    const reader = stream.getReader();
+    try {
+      while (true) {
+        if (signal.aborted) throw new DOMException("aborted", "AbortError");
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (value) chunks.push(value);
+      }
+    } finally {
+      if (signal.aborted) await reader.cancel().catch(() => void 0);
+    }
+    return Buffer.concat(chunks.map((c) => Buffer.from(c)));
+  }
+  async function writeTemp(buf, contentType) {
+    const ext = contentType.includes("mpeg") ? "mp3" : contentType.includes("wav") ? "wav" : "bin";
+    const dir = await mkdtemp(join(tmpdir(), `${PLUGIN_NAME}-`));
+    const path = join(dir, `audio.${ext}`);
+    await writeFile(path, buf);
+    return { dir, path };
+  }
+  function powershellEncodedCommand(path) {
+    const safePath = JSON.stringify(path.replace(/\\/g, "/"));
+    const script = [
+      "Add-Type -AssemblyName presentationCore",
+      "$p = New-Object System.Windows.Media.MediaPlayer",
+      `$p.Open([Uri]${safePath})`,
+      "$p.Play()",
+      "Start-Sleep -Seconds 30"
+    ].join("; ");
+    return Buffer.from(script, "utf16le").toString("base64");
+  }
+  return {
+    async init() {
+      if (platform === "darwin") {
+        if (!await opts.runner.has("afplay")) {
+          throw new Error("No audio player available (need `afplay`)");
+        }
+        binary = "afplay";
+      } else if (platform === "linux") {
+        for (const b of LINUX_PLAYERS) {
+          if (await opts.runner.has(b)) {
+            binary = b;
+            break;
+          }
+        }
+        if (!binary) {
+          throw new Error(
+            "No audio player available (need one of: paplay, aplay, ffplay)"
+          );
+        }
+      } else if (platform === "win32") {
+        if (!await opts.runner.has("powershell")) {
+          throw new Error("No audio player available (need `powershell`)");
+        }
+        binary = "powershell";
+      } else {
+        throw new Error(`Unsupported platform for audio playback: ${platform}`);
+      }
+    },
+    async play(audio, contentType, signal) {
+      if (!binary) throw new Error("Audio player not initialized");
+      if (signal.aborted) throw new DOMException("aborted", "AbortError");
+      const buf = await buffer(audio, signal);
+      const tmp = await writeTemp(buf, contentType);
+      let cmd;
+      if (binary === "powershell") {
+        cmd = [
+          "powershell",
+          "-NoProfile",
+          "-EncodedCommand",
+          powershellEncodedCommand(tmp.path)
+        ];
+      } else if (binary === "ffplay") {
+        cmd = ["ffplay", "-autoexit", "-nodisp", "-loglevel", "quiet", tmp.path];
+      } else {
+        cmd = [binary, tmp.path];
+      }
+      try {
+        const result = await opts.runner.run(cmd, signal);
+        if (result.exitCode !== 0) {
+          throw new Error(`audio playback failed with exit code ${result.exitCode}`);
+        }
+      } finally {
+        await rm(tmp.dir, { recursive: true, force: true });
+      }
+    }
+  };
+}
+
+// src/audio/runner.ts
+async function defaultRunner() {
+  const { spawn } = await import("child_process");
+  const { access, constants } = await import("fs/promises");
+  const { delimiter, sep } = await import("path");
+  async function has(binary) {
+    const PATH = process.env.PATH ?? "";
+    const exts = process.platform === "win32" ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";") : [""];
+    for (const dir of PATH.split(delimiter)) {
+      for (const ext of exts) {
+        try {
+          await access(`${dir}${sep}${binary}${ext}`, constants.X_OK);
+          return true;
+        } catch {
+        }
+      }
+    }
+    return false;
+  }
+  const ABORT_KILL_MS = 1e3;
+  async function run(cmd, signal) {
+    if (signal.aborted) throw new DOMException("aborted", "AbortError");
+    return await new Promise((resolve, reject) => {
+      const child = spawn(cmd[0], cmd.slice(1), { stdio: "ignore" });
+      let killTimer;
+      const cleanup = () => {
+        signal.removeEventListener("abort", onAbort);
+        if (killTimer) clearTimeout(killTimer);
+      };
+      const onAbort = () => {
+        child.kill("SIGTERM");
+        killTimer = setTimeout(() => child.kill("SIGKILL"), ABORT_KILL_MS);
+      };
+      signal.addEventListener("abort", onAbort);
+      child.on("error", (e) => {
+        cleanup();
+        reject(e);
+      });
+      child.on("exit", (code) => {
+        cleanup();
+        if (signal.aborted) reject(new DOMException("aborted", "AbortError"));
+        else if ((code ?? 0) !== 0) reject(new Error(`process exited with code ${code ?? 0}`));
+        else resolve({ exitCode: 0 });
+      });
+    });
+  }
+  return { has, run };
+}
+
+// src/handlers/index.ts
+import { randomUUID } from "crypto";
+
+// src/handlers/template.ts
+function truncate(s, max) {
+  if (s.length <= max) return s;
+  return s.slice(0, max) + "\u2026";
+}
+function stripMarkdown(text) {
+  return text.replace(/```[\s\S]*?```/g, "").replace(/`([^`]+)`/g, "$1").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/\*([^*]+)\*/g, "$1").replace(/__([^_]+)__/g, "$1").replace(/_([^_]+)_/g, "$1").replace(/!\[[^\]]*\]\([^)]*\)/g, "").replace(/\[([^\]]+)\]\([^)]*\)/g, "$1").replace(/^#+\s+/gm, "").replace(/^\s*[-*+]\s+/gm, "").replace(/\s+/g, " ").trim();
+}
+function basename(p) {
+  const trimmed = p.replace(/[\\/]+$/, "");
+  const i = Math.max(trimmed.lastIndexOf("/"), trimmed.lastIndexOf("\\"));
+  return i >= 0 ? trimmed.slice(i + 1) : trimmed;
+}
+function asString(v) {
+  return typeof v === "string" && v.length > 0 ? v : void 0;
+}
+var templates = {
+  // --- Real OpenCode events ---
+  "session.idle": () => "I'm idle now and waiting for your next instruction.",
+  "session.error": (e) => `I hit a session error: ${truncate(String(e.message ?? "unknown"), 200)}. Check the log for details.`,
+  "session.compacted": () => "I compacted the session, so older context is summarized and I have more room to continue.",
+  "session.created": () => "I'm starting a new session and getting ready to work.",
+  "permission.asked": (e) => `I need your approval before I use ${asString(e.tool) ?? "an operation"}.`,
+  "permission.replied": (e) => {
+    const raw = String(e.decision ?? "responded").toLowerCase();
+    const verb = raw === "allow" || raw === "approve" || raw === "accept" || raw === "yes" || raw === "once" || raw === "always" ? "granted" : raw === "deny" || raw === "reject" || raw === "no" ? "denied" : raw;
+    const tool = asString(e.tool) ?? "the operation";
+    if (verb === "granted") return `I got approval to use ${tool}.`;
+    if (verb === "denied") return `I was denied permission to use ${tool}.`;
+    if (verb === "responded") return `I got a response for ${tool}.`;
+    return `I got a permission response for ${tool}: ${verb}.`;
+  },
+  "tool.execute.before": (e) => `I'm running ${asString(e.tool) ?? "tool"} now.`,
+  "tool.execute.after": (e) => `I finished running ${asString(e.tool) ?? "tool"}.`,
+  "file.edited": (e) => {
+    const raw = String(e.file ?? "");
+    return raw ? `I edited ${basename(raw)}.` : "I edited a file.";
+  },
+  "command.executed": (e) => {
+    const name = String(e.command ?? "").trim();
+    return name ? `I ran ${name}.` : "I ran a command.";
+  },
+  // Note: `message.updated` carries `{ sessionID, info: Message }` — the
+  // message text lives in `info.parts`, not at the top level. Live narration
+  // is handled by the synthesized `message.text.delta` events derived from
+  // `message.part.updated`, so there is intentionally no template here.
+  // --- Synthesized by src/dispatcher.ts ---
+  "message.text.delta": (e) => truncate(stripMarkdown(String(e.text ?? "")), 600),
+  "message.reasoning.delta": (e) => truncate(stripMarkdown(String(e.text ?? "")), 600),
+  "todo.completed.all": (e) => {
+    const n = Number(e.count ?? 0);
+    return n > 0 ? `I've completed all ${n} todos. Nice work.` : "I've completed all todos. Nice work.";
+  },
+  "todo.completed.item": (e) => `I finished this task: ${truncate(stripMarkdown(String(e.content ?? "")), 80)}.`
+};
+function renderTemplate(event) {
+  const fn = templates[event.type];
+  if (!fn) return null;
+  const out = fn(event);
+  return out.length === 0 ? null : out;
+}
+
+// src/handlers/index.ts
+var MODE_RENDERERS = {
+  template: (event) => renderTemplate(event),
+  narrate: async (event, ctx) => {
+    const text = await ctx.narrator.summarize(event, ctx.getContext());
+    return text ?? renderTemplate(event);
+  },
+  verbatim: (event) => truncate(stripMarkdown(String(event.text ?? "")), 300)
+};
+function priorityFromName(name) {
+  if (name === "urgent") return 3 /* URGENT */;
+  if (name === "normal") return 2 /* NORMAL */;
+  if (name === "chatty") return 1 /* CHATTY */;
+  return null;
+}
+function createHandlerRegistry(opts) {
+  return {
+    async handle(event) {
+      const cfg = opts.events[event.type];
+      if (!cfg || !cfg.enabled) return null;
+      const text = await MODE_RENDERERS[cfg.mode](event, opts);
+      if (!text) return null;
+      const priority = priorityFromName(cfg.priority) ?? queuePriorityForEvent(event.type);
+      const overrideKey = event.dedupKey;
+      const dedupKey = typeof overrideKey === "string" ? overrideKey : event.type;
+      return {
+        id: randomUUID(),
+        priority,
+        text,
+        dedupKey,
+        enqueuedAt: Date.now()
+      };
+    }
+  };
+}
+
+// src/handlers/narrator.ts
+import { generateText } from "ai";
+var SYSTEM_PROMPT = [
+  "You are the coding agent. Your words are read aloud by a text-to-speech engine while the",
+  "user looks away from the screen, so speak as yourself in natural spoken English.",
+  "",
+  "happened: what you attempted and changed, the outcome, and any blocker, error, or decision",
+  "that needs the user's attention. Add an obvious next step only if there is one.",
+  "",
+  "Style:",
+  "- First person \u2014 I, me, my. You did the work; never describe yourself in third person or as an AI.",
+  "- Plain prose only: no markdown, code blocks, quotes, bullet points, or headings.",
+  '- Refer to code by purpose ("the auth module", "the new check") rather than identifier.',
+  "  When a specific file name or the exact error message is the key fact, say it plainly.",
+  "- Avoid file paths, type names, and command flags unless one of them is the point.",
+  "- Only describe what the context below shows. Do not invent files, tools, or outcomes.",
+  "- No greetings, sign-offs, or restating these instructions.",
+  "",
+  'Example: "I refactored the credentials loader and its tests pass. No blockers."'
+].join("\n");
+var FACT_FIELDS = ["tool", "file", "command", "message", "errorName", "content"];
+function eventFacts(event) {
+  const lines = [];
+  for (const key of FACT_FIELDS) {
+    const value = event[key];
+    if (typeof value === "string" && value.trim().length > 0) {
+      lines.push(`- ${key}: ${truncate(value, 200)}`);
+    }
+  }
+  if (typeof event.count === "number") lines.push(`- count: ${event.count}`);
+  return lines.join("\n");
+}
+function buildContext(event, ctx) {
+  const text = truncate(ctx.assistantText, 1e4);
+  const tools = ctx.recentTools.slice(-5).map((t) => `- ${t}`).join("\n") || "(none)";
+  const occasion = EVENT_SPECS[event.type]?.narrationOccasion ?? "I just finished a turn.";
+  return [
+    occasion,
+    "",
+    "What I produced recently:",
+    text || "(none)",
+    "",
+    "Tools I recently used:",
+    tools,
+    "",
+    "Event details:",
+    eventFacts(event) || "(no extra detail)"
+  ].join("\n");
+}
+function createNarrator(model, config, logger) {
+  let lastFinishedAt = 0;
+  return {
+    async summarize(event, ctx) {
+      const now = Date.now();
+      if (now - lastFinishedAt < config.minIntervalMs) return null;
+      const hasContext = ctx.assistantText.trim().length > 0 || ctx.recentTools.length > 0 || eventFacts(event).length > 0;
+      if (!hasContext) return null;
+      const ac = new AbortController();
+      const timer = setTimeout(() => ac.abort(), config.timeoutMs);
+      try {
+        const { text } = await generateText({
+          model,
+          system: SYSTEM_PROMPT,
+          temperature: 0.2,
+          prompt: buildContext(event, ctx),
+          abortSignal: ac.signal
+        });
+        const trimmed = text.trim();
+        if (trimmed.length === 0) return null;
+        lastFinishedAt = Date.now();
+        return trimmed;
+      } catch (err) {
+        if (logger) {
+          await logger.warn("narrator summary failed", {
+            error: err,
+            operation: "summarizing event for narration",
+            input: {
+              eventType: event.type,
+              assistantTextLen: ctx.assistantText.length,
+              recentToolsCount: ctx.recentTools.length
+            }
+          });
+        }
+        return null;
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+  };
+}
+
+// src/events/normalize.ts
+function objectRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim().length > 0) return value;
+  }
+  return void 0;
+}
+var TYPE_ALIASES = {
+  "permission.updated": "permission.asked",
+  // v1 SDK name
+  "session.next.tool.called": "tool.execute.before",
+  // v2 SDK
+  "session.next.tool.success": "tool.execute.after",
+  // v2 SDK
+  "session.next.tool.failed": "tool.execute.after"
+  // v2 SDK
+};
+function normalizeEvent(raw) {
+  const props = objectRecord(raw.properties);
+  const propType = typeof props.type === "string" ? props.type : void 0;
+  const canonicalType = TYPE_ALIASES[raw.type] ?? raw.type;
+  const merged = { ...raw, ...props, type: canonicalType };
+  if (canonicalType === "permission.asked" || canonicalType === "permission.replied") {
+    const meta = objectRecord(merged.metadata);
+    const toolName = firstString(
+      typeof merged.tool === "string" ? merged.tool : void 0,
+      merged.permission,
+      // v2 PermissionRequest.permission
+      propType,
+      // v1 Permission.type (rescued from properties)
+      meta.tool,
+      // older shape: permission metadata
+      merged.title
+      // last-resort v1 fallback (often long-form like "Run a shell command")
+    );
+    const next = { ...merged, tool: toolName };
+    if (canonicalType === "permission.replied") {
+      next.decision = firstString(merged.decision, merged.response, merged.reply, merged.result) ?? "responded";
+    }
+    return next;
+  }
+  if (canonicalType === "tool.execute.before" || canonicalType === "tool.execute.after") {
+    return {
+      ...merged,
+      tool: firstString(merged.tool, merged.name),
+      callID: firstString(merged.callID, merged.callId, merged.id)
+    };
+  }
+  if (canonicalType === "session.error") {
+    const err = objectRecord(merged.error);
+    const errData = objectRecord(err.data);
+    return {
+      ...merged,
+      // Real shape: properties.error.data.message. Fall back to a top-level
+      // `message` only because old/synthesized events sometimes use it.
+      message: firstString(merged.message, errData.message, err.message),
+      errorName: firstString(err.name, errData.name)
+    };
+  }
+  if (canonicalType === "file.edited") {
+    return {
+      ...merged,
+      file: firstString(merged.file, merged.path, merged.filePath)
+    };
+  }
+  if (canonicalType === "command.executed" || canonicalType === "tui.command.execute") {
+    return {
+      ...merged,
+      command: firstString(merged.command, merged.name, merged.id)
+    };
+  }
+  return merged;
+}
+
+// src/dispatcher.ts
+var SENTENCE_RE = /[\s\S]*?[.!?]+(?:["')\]]?)(?:\s+|$)/g;
+function createDispatcher(opts) {
+  const textWindow = opts.textWindow ?? 4e3;
+  const toolWindow = opts.toolWindow ?? 10;
+  const reasoningFlushChars = opts.reasoningFlushChars ?? 240;
+  let assistantText = "";
+  const recentTools = [];
+  const toolByCallId = /* @__PURE__ */ new Map();
+  const todoStatus = /* @__PURE__ */ new Map();
+  const partSeen = /* @__PURE__ */ new Map();
+  const reasoningBuffer = /* @__PURE__ */ new Map();
+  let deltaSequence = 0;
+  function appendText(t) {
+    assistantText = (assistantText + " " + t).slice(-textWindow);
+  }
+  function trackTool(tool) {
+    recentTools.push(tool);
+    while (recentTools.length > toolWindow) recentTools.shift();
+  }
+  function resetTurnState() {
+    assistantText = "";
+    recentTools.length = 0;
+    partSeen.clear();
+    reasoningBuffer.clear();
+    toolByCallId.clear();
+  }
+  async function fire(event) {
+    try {
+      const sr = await opts.handler.handle(event);
+      if (sr) opts.queue.push(sr);
+    } catch (err) {
+      if (opts.logger) {
+        await opts.logger.warn("handler failed", {
+          error: err,
+          operation: "dispatching opencode event",
+          input: { eventType: event.type }
+        });
+      }
+      opts.onError?.(err, event);
+    }
+  }
+  async function handleTodoUpdated(props) {
+    const todos = props.todos ?? [];
+    let transitionsToCompleted = 0;
+    for (const t of todos) {
+      const prev = todoStatus.get(t.id);
+      if (prev !== "completed" && t.status === "completed") {
+        transitionsToCompleted++;
+        await fire({ type: "todo.completed.item", content: t.content });
+      }
+      todoStatus.set(t.id, t.status);
+    }
+    if (todos.length > 0 && todos.every((t) => t.status === "completed") && transitionsToCompleted > 0) {
+      await fire({ type: "todo.completed.all", count: todos.length });
+    }
+    await fire({ type: "todo.updated", todos });
+  }
+  function computeDelta(partId, fullText) {
+    const prev = partSeen.get(partId) ?? 0;
+    if (fullText.length < prev) {
+      partSeen.set(partId, fullText.length);
+      return null;
+    }
+    if (fullText.length === prev) return null;
+    const delta = fullText.slice(prev);
+    partSeen.set(partId, fullText.length);
+    return delta;
+  }
+  async function handleTextPart(part) {
+    if (!part.id || typeof part.text !== "string") return;
+    const delta = computeDelta(part.id, part.text);
+    if (!delta) return;
+    appendText(delta);
+    await fire({
+      type: "message.text.delta",
+      text: delta,
+      partID: part.id,
+      dedupKey: `message.text.delta:${part.id}:${++deltaSequence}`
+    });
+  }
+  async function handleReasoningPart(part) {
+    if (!part.id || typeof part.text !== "string") return;
+    const delta = computeDelta(part.id, part.text);
+    if (!delta) return;
+    let buffered = (reasoningBuffer.get(part.id) ?? "") + delta;
+    const sentences = [];
+    let cursor = 0;
+    SENTENCE_RE.lastIndex = 0;
+    let m;
+    while ((m = SENTENCE_RE.exec(buffered)) !== null) {
+      sentences.push(m[0].trim());
+      cursor = SENTENCE_RE.lastIndex;
+    }
+    buffered = buffered.slice(cursor);
+    if (buffered.length >= reasoningFlushChars) {
+      sentences.push(buffered.trim());
+      buffered = "";
+    }
+    reasoningBuffer.set(part.id, buffered);
+    for (const sentence of sentences) {
+      if (!sentence) continue;
+      await fire({
+        type: "message.reasoning.delta",
+        text: sentence,
+        partID: part.id,
+        dedupKey: `message.reasoning.delta:${part.id}:${++deltaSequence}`
+      });
+    }
+  }
+  async function handleMessagePart(props) {
+    const part = props.part;
+    if (!part || typeof part !== "object") return;
+    if (part.type === "text") {
+      await handleTextPart(part);
+    } else if (part.type === "reasoning") {
+      await handleReasoningPart(part);
+    }
+  }
+  return {
+    async onEvent(event) {
+      const normalized = normalizeEvent(event);
+      if (normalized.type === "todo.updated") {
+        const todos = normalized.todos;
+        return handleTodoUpdated({ todos });
+      }
+      if (normalized.type === "message.part.updated") {
+        const part = normalized.part;
+        return handleMessagePart({ part });
+      }
+      if (normalized.type === "tool.execute.before") {
+        const tool = normalized.tool;
+        const callID = normalized.callID;
+        if (typeof tool === "string") {
+          trackTool(tool);
+          if (typeof callID === "string") toolByCallId.set(callID, tool);
+        }
+      } else if (normalized.type === "tool.execute.after") {
+        if (typeof normalized.tool !== "string") {
+          const callID2 = normalized.callID;
+          const remembered = callID2 ? toolByCallId.get(callID2) : void 0;
+          if (remembered) normalized.tool = remembered;
+        }
+        const callID = normalized.callID;
+        if (callID) toolByCallId.delete(callID);
+      }
+      try {
+        await fire(normalized);
+      } finally {
+        if (normalized.type === "session.idle" || normalized.type === "session.created") {
+          resetTurnState();
+        }
+      }
+    },
+    getContext() {
+      return { assistantText, recentTools: [...recentTools] };
+    }
+  };
+}
+
+// src/commands/index.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function createCommands(opts) {
+  function makeRequest(text, priority) {
+    return { id: randomUUID2(), priority, text, enqueuedAt: Date.now() };
+  }
+  return {
+    mute() {
+      opts.queue.mute();
+    },
+    unmute() {
+      opts.queue.unmute();
+    },
+    /** Toggle mute state. Returns the new muted state. */
+    toggle() {
+      if (opts.queue.isMuted()) {
+        opts.queue.unmute();
+      } else {
+        opts.queue.mute();
+      }
+      return opts.queue.isMuted();
+    },
+    /** Interrupt the current utterance (and drop the pending queue). */
+    stop() {
+      opts.queue.stop();
+    },
+    isMuted() {
+      return opts.queue.isMuted();
+    },
+    say(text) {
+      opts.queue.push(makeRequest(text, 2 /* NORMAL */));
+    },
+    test() {
+      opts.queue.push(
+        makeRequest(
+          "opencode voice test. If you hear this, audio is working.",
+          2 /* NORMAL */
+        )
+      );
+    },
+    status() {
+      return {
+        provider: opts.providerName,
+        voice: opts.voiceName,
+        muted: opts.queue.isMuted(),
+        queueSize: opts.queue.size()
+      };
+    }
+  };
+}
+
+// src/notify.ts
+var TOAST_MAX_LEN = 200;
+var TOAST_PREFIX = "opencode-speaker: ";
+var TOAST_DEFER_MS = 2500;
+var TOAST_DURATION_MS = 1e4;
+function buildMessage(summary) {
+  const raw = TOAST_PREFIX + summary;
+  if (raw.length <= TOAST_MAX_LEN) return raw;
+  return raw.slice(0, TOAST_MAX_LEN - 1) + "\u2026";
+}
+async function showToastSafe(client, message, variant, logger) {
+  const tui = client?.tui;
+  if (!tui || typeof tui.showToast !== "function") {
+    return;
+  }
+  try {
+    await tui.showToast({
+      body: { message, variant, duration: TOAST_DURATION_MS }
+    });
+  } catch (error) {
+    void logger.debug("toast failed", {
+      error,
+      operation: "showing toast",
+      input: { message, variant }
+    });
+  }
+}
+function tryShowToast(client, message, variant, logger) {
+  setTimeout(() => void showToastSafe(client, message, variant, logger), TOAST_DEFER_MS);
+}
+function createNotifier(client, logger) {
+  return {
+    fatal(summary, detail) {
+      void logger.error(summary, detail);
+      tryShowToast(client, buildMessage(summary), "error", logger);
+    },
+    warn(summary, detail) {
+      void logger.warn(summary, detail);
+      tryShowToast(client, buildMessage(summary), "warning", logger);
+    }
+  };
+}
+
+// src/ai-sdk/credentials.ts
+var ENV_VAR_BY_PROVIDER = {
+  openai: "OPENAI_API_KEY",
+  anthropic: "ANTHROPIC_API_KEY",
+  elevenlabs: "ELEVENLABS_API_KEY"
+};
+function requiredEnvVar(slug) {
+  const slash = slug.indexOf("/");
+  if (slash <= 0) return null;
+  const provider = slug.slice(0, slash);
+  return ENV_VAR_BY_PROVIDER[provider] ?? null;
+}
+function checkCredentials(check, env) {
+  const required = /* @__PURE__ */ new Set();
+  for (const slug of [check.narratorSlug, check.ttsSlug]) {
+    const v = requiredEnvVar(slug);
+    if (v) required.add(v);
+  }
+  const missing = [];
+  for (const name of required) {
+    const val = env[name];
+    if (val === void 0 || val.trim().length === 0) missing.push(name);
+  }
+  missing.sort();
+  return missing.length === 0 ? { ok: true } : { ok: false, missing };
+}
+
+// src/index.ts
+function formatSchemaErrors(errors) {
+  const parts = errors.map((e) => e.path ? `${e.path}: ${e.message}` : e.message);
+  return `invalid config \u2014 ${parts.join("; ")}`;
+}
+function oneLine(err) {
+  const s = err instanceof Error ? err.message : String(err);
+  return s.replace(/\s+/g, " ").trim();
+}
+var OpencodeSpeaker = async (ctx, options) => {
+  try {
+    return await initPlugin(ctx, options);
+  } catch (err) {
+    try {
+      const logger = createLogger(ctx.client, PLUGIN_NAME).child({ module: "init" });
+      const notifier = createNotifier(ctx.client, logger);
+      notifier.fatal("failed to initialize; plugin disabled", {
+        error: err,
+        operation: "initializing plugin"
+      });
+    } catch {
+    }
+    return {};
+  }
+};
+async function initPlugin(ctx, options) {
+  const logger = createLogger(ctx.client, PLUGIN_NAME);
+  const initLog = logger.child({ module: "init" });
+  const dispatchLog = logger.child({ module: "dispatcher" });
+  const queueLog = logger.child({ module: "queue" });
+  const narratorLog = logger.child({ module: "narrator" });
+  const audioLog = logger.child({ module: "audio" });
+  const ttsLog = logger.child({ module: "tts" });
+  const notifier = createNotifier(ctx.client, initLog);
+  const config = loadConfig(options, notifier);
+  if (!config) {
+    return {};
+  }
+  if (!config.enabled) {
+    await initLog.info(`${PLUGIN_NAME} disabled by config or env`, {
+      operation: "starting plugin"
+    });
+    return {};
+  }
+  const models = resolveModelsOrDisable(config, notifier);
+  if (!models) {
+    return {};
+  }
+  const { languageModel, resolvedSpeech } = models;
+  const credCheck = checkCredentials(
+    { narratorSlug: config.narrator.model, ttsSlug: config.tts.model },
+    process.env
+  );
+  if (!credCheck.ok) {
+    notifier.fatal(
+      `${credCheck.missing.join(", ")} not set; plugin disabled`,
+      {
+        operation: "checking provider credentials",
+        input: { missing: credCheck.missing }
+      }
+    );
+    return {};
+  }
+  const provider = createAiSdkProvider({
+    model: resolvedSpeech.model,
+    provider: resolvedSpeech.provider,
+    voice: config.tts.voice
+  });
+  const player = await initPlayer(audioLog);
+  const ttsConfig = config.tts;
+  async function speak(req, signal) {
+    if (!player) return;
+    const result = await provider.synthesize(
+      req.text,
+      {
+        voice: ttsConfig.voice,
+        rate: ttsConfig.rate
+      },
+      signal
+    );
+    await player.play(result.audio, result.contentType, signal);
+  }
+  const queue = new SpeechQueue({
+    speak,
+    staleMs: config.queue.staleMs,
+    now: () => Date.now(),
+    logger: queueLog,
+    onError: (err, req) => {
+      void queueLog.warn("speak failed", {
+        error: err,
+        operation: "speaking queued request",
+        input: { textPreview: req.text.slice(0, 80), priority: req.priority }
+      });
+    }
+  });
+  const narrator = createNarrator(languageModel, config.narrator, narratorLog);
+  const dispatcher = createDispatcher({
+    logger: dispatchLog,
+    handler: createHandlerRegistry({
+      events: config.events,
+      narrator,
+      getContext: () => dispatcher.getContext()
+    }),
+    queue,
+    onError: (err, e) => {
+      void dispatchLog.warn("handler error at boundary", {
+        error: err,
+        operation: "dispatcher onError boundary",
+        input: { eventType: e.type }
+      });
+    }
+  });
+  const commands = createCommands({
+    queue,
+    providerName: resolvedSpeech.provider,
+    voiceName: config.tts.voice
+  });
+  if (config.startMuted) commands.mute();
+  await initLog.info(`${PLUGIN_NAME} ready`, {
+    operation: "plugin ready",
+    input: { provider: resolvedSpeech.provider, voice: config.tts.voice }
+  });
+  if (config.greeting.trim().length > 0 && !config.startMuted) {
+    commands.say(config.greeting);
+  }
+  return {
+    event: async ({
+      event
+    }) => {
+      try {
+        await dispatcher.onEvent(event);
+      } catch (err) {
+        await dispatchLog.warn("event handler crashed", {
+          error: err,
+          operation: "dispatching opencode event",
+          input: { eventType: event.type }
+        });
+      }
+    }
+  };
+}
+function loadConfig(options, notifier) {
+  const parsed = parseConfig(options ?? {});
+  if (!parsed.ok) {
+    notifier.fatal(formatSchemaErrors(parsed.errors), {
+      operation: "parsing plugin config",
+      input: { errors: parsed.errors }
+    });
+    return null;
+  }
+  return parsed.config;
+}
+function resolveModelsOrDisable(config, notifier) {
+  try {
+    return {
+      languageModel: resolveLanguageModel(config.narrator.model),
+      resolvedSpeech: resolveSpeechModel(config.tts.model)
+    };
+  } catch (err) {
+    const summary = err instanceof ConfigError ? `invalid model slug \u2014 ${err.message}` : `failed to resolve models \u2014 ${oneLine(err)}`;
+    notifier.fatal(summary, {
+      error: err,
+      operation: "resolving model slugs",
+      input: { narrator: config.narrator.model, tts: config.tts.model }
+    });
+    return null;
+  }
+}
+async function initPlayer(audioLog) {
+  try {
+    const runner = await defaultRunner();
+    const player = createPlayer({ runner });
+    await player.init();
+    return player;
+  } catch (err) {
+    await audioLog.warn("Audio player unavailable; speech output disabled", {
+      error: err,
+      operation: "initializing audio player",
+      input: { platform: process.platform }
+    });
+    return null;
+  }
+}
+var index_default = OpencodeSpeaker;
+export {
+  OpencodeSpeaker,
+  index_default as default
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/index.ts", "../src/config.ts", "../src/ai-sdk/models.ts", "../src/events/catalog.ts", "../src/log.ts", "../src/queue/speech-queue.ts", "../src/tts/ai-sdk.ts", "../src/audio/player.ts", "../src/audio/runner.ts", "../src/handlers/index.ts", "../src/handlers/template.ts", "../src/handlers/narrator.ts", "../src/events/normalize.ts", "../src/dispatcher.ts", "../src/commands/index.ts", "../src/notify.ts", "../src/ai-sdk/credentials.ts"],
  "sourcesContent": ["import \"source-map-support/register.js\"\nimport { parseConfig, PLUGIN_NAME, type VoiceConfig } from \"./config.js\"\nimport { createLogger, type Logger } from \"./log.js\"\nimport { SpeechQueue } from \"./queue/speech-queue.js\"\nimport { type SpeechRequest } from \"./queue/types.js\"\nimport { createAiSdkProvider } from \"./tts/ai-sdk.js\"\nimport { createPlayer, type Player } from \"./audio/player.js\"\nimport { defaultRunner } from \"./audio/runner.js\"\nimport { createHandlerRegistry } from \"./handlers\"\nimport { createNarrator } from \"./handlers/narrator.js\"\nimport {\n  resolveLanguageModel,\n  resolveSpeechModel,\n  ConfigError,\n} from \"./ai-sdk/models.js\"\nimport { createDispatcher } from \"./dispatcher.js\"\nimport { createCommands } from \"./commands\"\nimport { createNotifier } from \"./notify.js\"\nimport { checkCredentials } from \"./ai-sdk/credentials.js\"\n\n// IMPORTANT: do not re-export anything that opencode's plugin loader might\n// mistake for a server plugin. The loader uses the v1 default-export contract\n// `{ id, server }` (see `default` below) \u2014 that path skips the legacy scan\n// that would otherwise iterate every module export. Putting public API\n// (registerProvider, types) here would put them in `Object.values(mod)` and\n// could break older loaders. They live in `./api.ts` instead.\n\ntype PluginCtx = {\n  client: {\n    app: { log: (...args: any[]) => Promise<unknown> }\n  }\n  directory: string\n  worktree?: string\n  project?: unknown\n  $: unknown\n}\n\ntype PluginOptions = Record<string, unknown> | undefined\ntype Notifier = ReturnType<typeof createNotifier>\n\nfunction formatSchemaErrors(errors: { path: string; message: string }[]): string {\n  const parts = errors.map((e) => (e.path ? `${e.path}: ${e.message}` : e.message))\n  return `invalid config \u2014 ${parts.join(\"; \")}`\n}\n\nfunction oneLine(err: unknown): string {\n  const s = err instanceof Error ? err.message : String(err)\n  return s.replace(/\\s+/g, \" \").trim()\n}\n\nexport const OpencodeSpeaker = async (ctx: PluginCtx, options?: PluginOptions) => {\n  try {\n    return await initPlugin(ctx, options)\n  } catch (err) {\n    // Last-line-of-defense: never let plugin failure crash opencode startup.\n    try {\n      const logger = createLogger(ctx.client as any, PLUGIN_NAME).child({ module: \"init\" })\n      const notifier = createNotifier(ctx.client as any, logger)\n      notifier.fatal(\"failed to initialize; plugin disabled\", {\n        error: err,\n        operation: \"initializing plugin\",\n      })\n    } catch {\n      /* logger/notifier itself failed; nothing we can safely do */\n    }\n    return {}\n  }\n}\n\nasync function initPlugin(ctx: PluginCtx, options?: PluginOptions) {\n  const logger = createLogger(ctx.client as any, PLUGIN_NAME)\n  const initLog     = logger.child({ module: \"init\" })\n  const dispatchLog = logger.child({ module: \"dispatcher\" })\n  const queueLog    = logger.child({ module: \"queue\" })\n  const narratorLog = logger.child({ module: \"narrator\" })\n  const audioLog    = logger.child({ module: \"audio\" })\n  const ttsLog      = logger.child({ module: \"tts\" })\n  const notifier = createNotifier(ctx.client as any, initLog)\n  // opencode passes per-plugin config as the second argument when the user\n  // declares the plugin in tuple form: [\"opencode-speaker\", { ...options }].\n  // We accept any user object and let parseConfig validate + apply defaults.\n  const config = loadConfig(options, notifier)\n  if (!config) {\n    return {}\n  }\n\n  if (!config.enabled) {\n    await initLog.info(`${PLUGIN_NAME} disabled by config or env`, {\n      operation: \"starting plugin\",\n    })\n    return {}\n  }\n\n  // 1. Resolve narrator + TTS models from config slugs.\n  const models = resolveModelsOrDisable(config, notifier)\n  if (!models) {\n    return {}\n  }\n  const { languageModel, resolvedSpeech } = models\n\n  const credCheck = checkCredentials(\n    { narratorSlug: config.narrator.model, ttsSlug: config.tts.model },\n    process.env,\n  )\n  if (!credCheck.ok) {\n    notifier.fatal(\n      `${credCheck.missing.join(\", \")} not set; plugin disabled`,\n      {\n        operation: \"checking provider credentials\",\n        input: { missing: credCheck.missing },\n      },\n    )\n    return {}\n  }\n\n  // 2. Build the AI SDK TTS provider.\n  const provider = createAiSdkProvider({\n    model: resolvedSpeech.model,\n    provider: resolvedSpeech.provider,\n    voice: config.tts.voice,\n  })\n\n  // 3. Set up audio player. The AI SDK provider returns raw audio bytes that\n  // we need to hand off to the OS's audio playback binary.\n  const player = await initPlayer(audioLog)\n\n  // 4. Build the speak function used by the queue.\n  const ttsConfig = config.tts\n  async function speak(req: SpeechRequest, signal: AbortSignal): Promise<void> {\n    if (!player) return\n    const result = await provider.synthesize(\n      req.text,\n      {\n        voice: ttsConfig.voice,\n        rate: ttsConfig.rate,\n      },\n      signal,\n    )\n    await player.play(result.audio, result.contentType, signal)\n  }\n\n  // 5. Wire queue.\n  const queue = new SpeechQueue({\n    speak,\n    staleMs: config.queue.staleMs,\n    now: () => Date.now(),\n    logger: queueLog,\n    onError: (err, req) => {\n      void queueLog.warn(\"speak failed\", {\n        error: err,\n        operation: \"speaking queued request\",\n        input: { textPreview: req.text.slice(0, 80), priority: req.priority },\n      })\n    },\n  })\n\n  // 6. Narrator + handler registry.\n  const narrator = createNarrator(languageModel, config.narrator, narratorLog)\n\n  const dispatcher = createDispatcher({\n    logger: dispatchLog,\n    handler: createHandlerRegistry({\n      events: config.events as any,\n      narrator,\n      getContext: () => dispatcher.getContext(),\n    }),\n    queue,\n    onError: (err, e) => {\n      void dispatchLog.warn(\"handler error at boundary\", {\n        error: err,\n        operation: \"dispatcher onError boundary\",\n        input: { eventType: e.type },\n      })\n    },\n  })\n\n  // 7. Commands + custom tool.\n  const commands = createCommands({\n    queue,\n    providerName: resolvedSpeech.provider,\n    voiceName: config.tts.voice,\n  })\n  if (config.startMuted) commands.mute()\n\n  await initLog.info(`${PLUGIN_NAME} ready`, {\n    operation: \"plugin ready\",\n    input: { provider: resolvedSpeech.provider, voice: config.tts.voice },\n  })\n\n  if (config.greeting.trim().length > 0 && !config.startMuted) {\n    commands.say(config.greeting)\n  }\n\n  return {\n    event: async ({\n      event,\n    }: {\n      event: { type: string; [k: string]: unknown }\n    }) => {\n      // The dispatcher is the single entry point: it knows how to unwrap\n      // OpenCode's `{ id, type, properties }` shape, fan out synthesized\n      // events (todo.completed.*, message.reasoning.delta, message.text.delta),\n      // and keep narration context fresh.\n      try {\n        await dispatcher.onEvent(event)\n      } catch (err) {\n        await dispatchLog.warn(\"event handler crashed\", {\n          error: err,\n          operation: \"dispatching opencode event\",\n          input: { eventType: event.type },\n        })\n      }\n    },\n  }\n}\n\nfunction loadConfig(options: PluginOptions, notifier: Notifier): VoiceConfig | null {\n  const parsed = parseConfig(options ?? {})\n\n  if (!parsed.ok) {\n    notifier.fatal(formatSchemaErrors(parsed.errors), {\n      operation: \"parsing plugin config\",\n      input: { errors: parsed.errors },\n    })\n    return null\n  }\n\n  return parsed.config\n}\n\nfunction resolveModelsOrDisable(config: VoiceConfig, notifier: Notifier) {\n  try {\n    return {\n      languageModel: resolveLanguageModel(config.narrator.model),\n      resolvedSpeech: resolveSpeechModel(config.tts.model),\n    }\n  } catch (err) {\n    const summary = err instanceof ConfigError\n      ? `invalid model slug \u2014 ${err.message}`\n      : `failed to resolve models \u2014 ${oneLine(err)}`\n    notifier.fatal(summary, {\n      error: err,\n      operation: \"resolving model slugs\",\n      input: { narrator: config.narrator.model, tts: config.tts.model },\n    })\n    return null\n  }\n}\n\nasync function initPlayer(audioLog: Logger): Promise<Player | null> {\n  try {\n    const runner = await defaultRunner()\n    const player = createPlayer({ runner })\n    await player.init()\n    return player\n  } catch (err) {\n    await audioLog.warn(\"Audio player unavailable; speech output disabled\", {\n      error: err,\n      operation: \"initializing audio player\",\n      input: { platform: process.platform },\n    })\n    return null\n  }\n}\n\n/**\n * Default export is the plugin function itself, matching the current\n * `@opencode-ai/plugin` contract (see ExamplePlugin / FolderWorkspacePlugin).\n *\n * History: this used to be `{ id, server: OpencodeSpeaker }` to satisfy an\n * older \"v1\" loader shape. Newer opencode releases reject that as\n * \"does not expose a server entrypoint\" \u2014 the loader expects the default\n * export to be the async plugin function directly.\n *\n * `index.ts` deliberately has no other exports beyond `OpencodeSpeaker` and\n * this default, so the loader's named-export scan (if any) does not invoke\n * a second plugin instance. Public API lives in `./api.ts`.\n */\nexport default OpencodeSpeaker\n", "import { z } from \"zod\"\nimport { SLUG_RE } from \"./ai-sdk/models.js\"\nimport { defaultEventsForVerbosity, type Verbosity } from \"./events/catalog.js\"\n\n/** Plugin identity. Used as the log scope, tmpdir prefix, and error labels. */\nexport const PLUGIN_NAME = \"opencode-speaker\"\n\n/** Default TTS model slug (used by schema + tests + demo scripts). */\nexport const DEFAULT_TTS_MODEL = \"openai/gpt-4o-mini-tts\"\n\n/** Default narrator (LLM) model slug. */\nexport const DEFAULT_NARRATOR_MODEL = \"openai/gpt-4.1-mini\"\n\n/** Default startup greeting (spoken once when the plugin is ready). */\nexport const DEFAULT_GREETING = \"Welcome to OpenCode Speaker!\"\n\n/** Environment variable name: when \"1\", disables the plugin entirely. */\nexport const ENV_DISABLED = \"OPENCODE_VOICE_DISABLED\"\n\n/** Environment variable name: when \"1\", starts the plugin muted. */\nexport const ENV_MUTE = \"OPENCODE_VOICE_MUTE\"\n\nconst PrioritySchema = z.enum([\"urgent\", \"normal\", \"chatty\"]).optional()\nconst ModeSchema = z.enum([\"template\", \"narrate\", \"verbatim\"])\nconst VerbositySchema = z.enum([\"minimal\", \"normal\", \"verbose\"])\n\nconst EventConfigSchema = z.object({\n  enabled: z.boolean().default(false),\n  mode: ModeSchema.default(\"template\"),\n  priority: PrioritySchema,\n})\n\nconst SLUG_MSG = `must be 'provider/model' (e.g. '${DEFAULT_TTS_MODEL}')`\n\nconst TTSSchema = z.object({\n  model: z.string().regex(SLUG_RE, `tts.model ${SLUG_MSG}`).default(DEFAULT_TTS_MODEL),\n  voice: z.string().optional(),\n  rate:  z.number().min(0.5).max(2.0).default(1.0),\n  pitch: z.number().min(0.5).max(2.0).default(1.0),\n}).default({})\n\nconst NarratorSchema = z.object({\n  model: z.string().regex(SLUG_RE, `narrator.model ${SLUG_MSG}`).default(DEFAULT_NARRATOR_MODEL),\n  timeoutMs:     z.number().int().positive().default(5000),\n  minIntervalMs: z.number().int().min(0).default(3000),\n}).default({})\n\nconst QueueSchema = z.object({\n  staleMs: z.number().int().min(0).default(8000),\n}).default({})\n\nconst EventsSchema = z.record(z.string(), EventConfigSchema).default({})\n\nconst VoiceConfigSchema = z.object({\n  enabled: z.boolean().default(true),\n  verbosity: VerbositySchema.default(\"normal\"),\n  startMuted: z.boolean().default(false),\n  greeting: z.string().default(DEFAULT_GREETING),\n  tts: TTSSchema,\n  narrator: NarratorSchema,\n  events: EventsSchema,\n  queue: QueueSchema,\n})\n\nexport type VoiceConfig = z.infer<typeof VoiceConfigSchema>\nexport type EventConfig = z.infer<typeof EventConfigSchema>\n\n// Event keys come in two flavors:\n//   1. Real OpenCode plugin events as documented at\n//      https://opencode.ai/docs/plugins/#events \u2014 these are dispatched by\n//      opencode itself and reach us via the `event` hook in src/index.ts.\n//   2. Plugin-internal synthesized events \u2014 fired by src/dispatcher.ts when\n//      it derives higher-level signals from raw events. These are NOT in the\n//      opencode docs but are valid configuration keys for this plugin.\n//      Currently synthesized:\n//        - \"todo.completed.item\" / \"todo.completed.all\" (from `todo.updated`)\n//        - \"message.text.delta\" / \"message.reasoning.delta\" (from per-sentence\n//          deltas of `message.part.updated` text and reasoning parts).\nfunction presetEvents(verbosity: Verbosity) {\n  return defaultEventsForVerbosity(verbosity)\n}\n\nexport const DEFAULT_CONFIG: VoiceConfig = VoiceConfigSchema.parse({\n  events: defaultEventsForVerbosity(\"normal\"),\n})\n\nexport type ParseResult =\n  | { ok: true; config: VoiceConfig }\n  | { ok: false; errors: { path: string; message: string }[] }\n\nexport function parseConfig(\n  raw: unknown,\n  env: Record<string, string | undefined> = process.env,\n): ParseResult {\n  const userObj = raw && typeof raw === \"object\" ? (raw as Record<string, unknown>) : {}\n\n  // Merge raw user input over defaults (event-level deep merge).\n  const userEvents =\n    userObj.events && typeof userObj.events === \"object\"\n      ? (userObj.events as Record<string, unknown>)\n      : {}\n  const rawVerbosity = userObj.verbosity\n  const verbosity = rawVerbosity === \"minimal\" || rawVerbosity === \"verbose\" || rawVerbosity === \"normal\"\n    ? rawVerbosity\n    : \"normal\"\n  const defaultsForVerbosity = presetEvents(verbosity)\n  const mergedEvents: Record<string, unknown> = { ...defaultsForVerbosity }\n  for (const [key, val] of Object.entries(userEvents)) {\n    const defaultEvent = defaultsForVerbosity[key] ?? {}\n    if (val && typeof val === \"object\" && !Array.isArray(val)) {\n      mergedEvents[key] = { ...defaultEvent, ...(val as Record<string, unknown>) }\n    } else {\n      mergedEvents[key] = val\n    }\n  }\n\n  const merged = { ...userObj, events: mergedEvents }\n  const parsed = VoiceConfigSchema.safeParse(merged)\n  if (!parsed.success) {\n    return {\n      ok: false,\n      errors: parsed.error.issues.map((i) => ({\n        path: i.path.join(\".\"),\n        message: i.message,\n      })),\n    }\n  }\n  const cfg = parsed.data\n\n  // Env overrides (the only ones we still need \u2014 API keys are AI SDK's job).\n  if (env[ENV_DISABLED] === \"1\") cfg.enabled = false\n  if (env[ENV_MUTE] === \"1\") cfg.startMuted = true\n\n  return { ok: true, config: cfg }\n}\n", "import { openai } from \"@ai-sdk/openai\"\nimport { anthropic } from \"@ai-sdk/anthropic\"\nimport { elevenlabs } from \"@ai-sdk/elevenlabs\"\nimport type { LanguageModel, SpeechModel } from \"ai\"\n\nexport class ConfigError extends Error {\n  constructor(message: string) {\n    super(message)\n    this.name = \"ConfigError\"\n  }\n}\n\n/**\n * Slug regex shared with `src/config.ts`. Exported so both the Zod schema\n * validation and the runtime resolver agree on what \"provider/model\" means.\n */\nexport const SLUG_RE = /^[a-z][a-z0-9-]*\\/[A-Za-z0-9._-]+$/\n\nfunction parseSlug(slug: string, field: string): [string, string] {\n  if (!SLUG_RE.test(slug)) {\n    throw new ConfigError(\n      `${field} must be 'provider/model' (e.g. 'openai/gpt-5'), got '${slug}'`,\n    )\n  }\n  const idx = slug.indexOf(\"/\")\n  return [slug.slice(0, idx), slug.slice(idx + 1)]\n}\n\nexport function resolveLanguageModel(slug: string): LanguageModel {\n  const [provider, modelId] = parseSlug(slug, \"narrator.model\")\n  switch (provider) {\n    case \"openai\":\n      return openai(modelId)\n    case \"anthropic\":\n      return anthropic(modelId)\n    default:\n      throw new ConfigError(\n        `Unknown narrator provider '${provider}' in '${slug}'. Supported: openai, anthropic`,\n      )\n  }\n}\n\nexport type ResolvedSpeech = { provider: \"openai\" | \"elevenlabs\"; model: SpeechModel }\n\nexport function resolveSpeechModel(slug: string): ResolvedSpeech {\n  const [provider, modelId] = parseSlug(slug, \"tts.model\")\n  switch (provider) {\n    case \"openai\":\n      return { provider: \"openai\", model: openai.speech(modelId) }\n    case \"elevenlabs\":\n      return { provider: \"elevenlabs\", model: elevenlabs.speech(modelId) }\n    default:\n      throw new ConfigError(\n        `Unknown TTS provider '${provider}' in '${slug}'. Supported: openai, elevenlabs`,\n      )\n  }\n}\n", "import { Priority } from \"../queue/types.js\"\n\nexport type EventMode = \"template\" | \"narrate\" | \"verbatim\"\nexport type EventPriorityName = \"urgent\" | \"normal\" | \"chatty\"\nexport type Verbosity = \"minimal\" | \"normal\" | \"verbose\"\n\nexport interface EventSpec {\n  mode: EventMode\n  priority?: EventPriorityName\n  queuePriority: Priority\n  defaultEnabled: Record<Verbosity, boolean>\n  synthetic?: true\n  narrationOccasion?: string\n}\n\nconst enabled = (normal: boolean, minimal = normal): Record<Verbosity, boolean> => ({\n  minimal,\n  normal,\n  verbose: normal,\n})\n\nexport const EVENT_SPECS = {\n  \"session.idle\": { mode: \"narrate\", queuePriority: Priority.NORMAL, defaultEnabled: enabled(true, true) },\n  \"session.error\": { mode: \"template\", priority: \"urgent\", queuePriority: Priority.URGENT, defaultEnabled: enabled(true, true) },\n  \"session.compacted\": { mode: \"template\", queuePriority: Priority.NORMAL, defaultEnabled: enabled(true, false) },\n  \"session.created\": { mode: \"template\", queuePriority: Priority.NORMAL, defaultEnabled: enabled(true, false) },\n  \"permission.asked\": { mode: \"template\", priority: \"urgent\", queuePriority: Priority.URGENT, defaultEnabled: enabled(true, true) },\n  \"permission.replied\": { mode: \"template\", queuePriority: Priority.NORMAL, defaultEnabled: enabled(true, false) },\n  \"tool.execute.before\": { mode: \"template\", priority: \"chatty\", queuePriority: Priority.CHATTY, defaultEnabled: enabled(true, false) },\n  \"tool.execute.after\": { mode: \"template\", priority: \"chatty\", queuePriority: Priority.CHATTY, defaultEnabled: enabled(true, false) },\n  \"file.edited\": { mode: \"template\", priority: \"chatty\", queuePriority: Priority.CHATTY, defaultEnabled: enabled(true, false) },\n  \"command.executed\": { mode: \"template\", queuePriority: Priority.NORMAL, defaultEnabled: enabled(true, false) },\n  \"message.updated\": { mode: \"verbatim\", priority: \"chatty\", queuePriority: Priority.CHATTY, defaultEnabled: enabled(false, false) },\n  \"message.reasoning.delta\": { mode: \"verbatim\", priority: \"chatty\", queuePriority: Priority.CHATTY, defaultEnabled: enabled(true, false), synthetic: true },\n  \"message.text.delta\": { mode: \"verbatim\", priority: \"chatty\", queuePriority: Priority.CHATTY, defaultEnabled: enabled(false, false), synthetic: true },\n  \"todo.completed.item\": { mode: \"template\", priority: \"chatty\", queuePriority: Priority.CHATTY, defaultEnabled: enabled(true, false), synthetic: true },\n  \"todo.completed.all\": { mode: \"narrate\", queuePriority: Priority.NORMAL, defaultEnabled: enabled(true, true), synthetic: true, narrationOccasion: \"The user has finished all todos.\" },\n} as const satisfies Record<string, EventSpec>\n\nexport type EventType = keyof typeof EVENT_SPECS\n\nexport function defaultEventsForVerbosity(verbosity: Verbosity) {\n  return Object.fromEntries(\n    (Object.entries(EVENT_SPECS) as Array<[string, EventSpec]>).map(([type, spec]) => [\n      type,\n      {\n        enabled: spec.defaultEnabled[verbosity],\n        mode: spec.mode,\n        ...(spec.priority ? { priority: spec.priority } : {}),\n      },\n    ]),\n  )\n}\n\nexport function queuePriorityForEvent(type: string): Priority {\n  return EVENT_SPECS[type as EventType]?.queuePriority ?? Priority.NORMAL\n}\n", "const SENSITIVE_KEYS = new Set([\n  \"apiKey\", \"api_key\", \"apikey\",\n  \"authorization\", \"Authorization\",\n  \"secret\", \"token\", \"password\",\n])\n\nexport function redact(value: unknown): unknown {\n  return redactInner(value, new WeakSet())\n}\n\nfunction redactInner(value: unknown, seen: WeakSet<object>): unknown {\n  if (value === null || typeof value !== \"object\") return value\n  if (seen.has(value as object)) return \"[Circular]\"\n  seen.add(value as object)\n  if (Array.isArray(value)) return value.map((v) => redactInner(v, seen))\n  const out: Record<string, unknown> = {}\n  for (const [k, v] of Object.entries(value)) {\n    out[k] = SENSITIVE_KEYS.has(k) ? \"***\" : redactInner(v, seen)\n  }\n  return out\n}\n\nconst MAX_FIELD_BYTES = 4096\n\nexport function truncatePayload(value: unknown): unknown {\n  return truncateInner(value, new WeakSet(), false)\n}\n\nfunction truncateInner(\n  value: unknown,\n  seen: WeakSet<object>,\n  insideErrorStack: boolean,\n): unknown {\n  if (typeof value === \"string\") {\n    if (insideErrorStack) return value\n    const bytes = Buffer.byteLength(value, \"utf8\")\n    if (bytes <= MAX_FIELD_BYTES) return value\n    const head = Buffer.from(value, \"utf8\").subarray(0, MAX_FIELD_BYTES).toString(\"utf8\")\n    return `${head}\u2026<truncated:${bytes - MAX_FIELD_BYTES} bytes>`\n  }\n  if (value === null || typeof value !== \"object\") return value\n  if (seen.has(value as object)) return value\n  seen.add(value as object)\n  if (Array.isArray(value)) return value.map((v) => truncateInner(v, seen, insideErrorStack))\n  const out: Record<string, unknown> = {}\n  for (const [k, v] of Object.entries(value)) {\n    const exempt = k === \"stack\"\n    out[k] = truncateInner(v, seen, exempt)\n  }\n  return out\n}\n\nexport type LogLevel = \"debug\" | \"info\" | \"warn\" | \"error\"\n\nexport interface SerializedError {\n  name: string\n  message: string\n  code?: string | number\n  stack?: string\n  file?: string\n  line?: number\n  column?: number\n  function?: string\n  cause?: SerializedError\n}\n\nexport interface LogContext {\n  error?: unknown\n  operation?: string\n  input?: unknown\n  [key: string]: unknown\n}\n\nexport interface Logger {\n  debug(msg: string, ctx?: LogContext | unknown): Promise<void>\n  info(msg: string, ctx?: LogContext | unknown): Promise<void>\n  warn(msg: string, ctx?: LogContext | unknown): Promise<void>\n  error(msg: string, ctx?: LogContext | unknown): Promise<void>\n  child(bindings: { module: string; [k: string]: unknown }): Logger\n}\n\nconst FRAME_RE = /^\\s*at (?:(.+?) \\()?(.+?):(\\d+):(\\d+)\\)?$/\n\nfunction isInternalFile(file: string): boolean {\n  return (\n    file.startsWith(\"node:\") ||\n    file.includes(\"/internal/\") ||\n    file.endsWith(\"/log.js\") ||\n    file.endsWith(\"/log.ts\")\n  )\n}\n\nfunction parseTopFrame(stack: string | undefined): {\n  file?: string\n  line?: number\n  column?: number\n  function?: string\n} {\n  if (!stack) return {}\n  const lines = stack.split(\"\\n\")\n  for (const raw of lines) {\n    const m = FRAME_RE.exec(raw)\n    if (!m) continue\n    const file = m[2]\n    if (isInternalFile(file)) continue\n    return {\n      function: m[1] || undefined,\n      file,\n      line: Number(m[3]),\n      column: Number(m[4]),\n    }\n  }\n  return {}\n}\n\nfunction nonErrorMessage(value: unknown): string {\n  try {\n    if (typeof value === \"string\") return value\n    if (typeof value === \"number\" || typeof value === \"boolean\") return String(value)\n    return JSON.stringify(value)\n  } catch {\n    return Object.prototype.toString.call(value)\n  }\n}\n\nexport function serializeError(err: unknown): SerializedError {\n  if (!(err instanceof Error)) {\n    return { name: \"NonError\", message: nonErrorMessage(err) }\n  }\n  try {\n    return serializeErrorDepth(err, 2)\n  } catch {\n    return { name: err.name ?? \"Error\", message: err.message ?? \"\" }\n  }\n}\n\nfunction serializeErrorDepth(err: Error, depth: number): SerializedError {\n  const stack = err.stack\n  const out: SerializedError = {\n    name: err.name,\n    message: err.message,\n    ...(stack ? { stack } : {}),\n    ...parseTopFrame(stack),\n  }\n  const code = (err as { code?: string | number }).code\n  if (code !== undefined) out.code = code\n  const cause = (err as { cause?: unknown }).cause\n  if (depth > 0 && cause instanceof Error) {\n    out.cause = serializeErrorDepth(cause, depth - 1)\n  }\n  return out\n}\n\ninterface OpencodeClient {\n  app: {\n    log: (req: {\n      body: { service: string; level: LogLevel; message: string; extra?: unknown }\n    }) => Promise<unknown>\n  }\n}\n\nexport function createLogger(client: OpencodeClient, service: string): Logger {\n  return makeLogger(client, service, undefined)\n}\n\nfunction makeLogger(\n  client: OpencodeClient,\n  service: string,\n  bindings: Record<string, unknown> | undefined,\n): Logger {\n  async function emit(\n    level: LogLevel,\n    message: string,\n    ctx?: LogContext | unknown,\n  ): Promise<void> {\n    try {\n      const body: {\n        service: string\n        level: LogLevel\n        message: string\n        extra?: unknown\n      } = { service, level, message }\n      const extra = buildExtra(ctx, bindings)\n      if (extra !== undefined) body.extra = extra\n      await client.app.log({ body })\n    } catch {\n      // Logger must never throw.\n    }\n  }\n  const logger: Logger = {\n    debug: (m, e) => emit(\"debug\", m, e),\n    info:  (m, e) => emit(\"info\",  m, e),\n    warn:  (m, e) => emit(\"warn\",  m, e),\n    error: (m, e) => emit(\"error\", m, e),\n    child(b) {\n      const merged = { ...(bindings ?? {}), ...b }\n      return makeLogger(client, service, merged)\n    },\n  }\n  return logger\n}\n\nfunction buildExtra(\n  ctx: LogContext | unknown,\n  bindings: Record<string, unknown> | undefined,\n): unknown {\n  try {\n    let normalized: Record<string, unknown> | undefined\n    if (ctx instanceof Error) {\n      normalized = { error: serializeError(ctx) }\n    } else if (ctx !== undefined && ctx !== null && typeof ctx === \"object\") {\n      const obj = ctx as Record<string, unknown>\n      normalized = { ...obj }\n      if (obj.error instanceof Error) {\n        normalized.error = serializeError(obj.error)\n      }\n    } else if (ctx !== undefined) {\n      normalized = { value: ctx }\n    }\n    if (bindings && Object.keys(bindings).length > 0) {\n      normalized = { ...(normalized ?? {}), bindings: { ...bindings } }\n    }\n    if (normalized === undefined) return undefined\n    return truncatePayload(redact(normalized))\n  } catch {\n    return bindings ? { bindings: { ...bindings } } : undefined\n  }\n}\n", "import { Priority, type SpeechRequest } from \"./types.js\"\nimport type { Logger } from \"../log.js\"\n\nexport type SpeakFn = (req: SpeechRequest, signal: AbortSignal) => Promise<void>\n\nexport interface SpeechQueueOptions {\n  speak: SpeakFn\n  staleMs: number\n  now: () => number\n  onError?: (err: unknown, req: SpeechRequest) => void\n  logger?: Logger\n}\n\nexport class SpeechQueue {\n  private queue: SpeechRequest[] = []\n  private current: { req: SpeechRequest; abort: AbortController } | null = null\n  private muted = false\n  private idleResolvers: Array<() => void> = []\n  private pumpRunning = false\n\n  constructor(private readonly opts: SpeechQueueOptions) {}\n\n  push(req: SpeechRequest): void {\n    if (this.muted) return\n\n    // Rule 2: interrupt if higher priority than current.\n    if (this.current && req.priority > this.current.req.priority) {\n      this.queue.unshift(req)\n      this.current.abort.abort()\n      return\n    }\n\n    // Rule 3: dedup by key against queued (not current) items.\n    if (req.dedupKey) {\n      const idx = this.queue.findIndex((q) => q.dedupKey === req.dedupKey)\n      if (idx >= 0) {\n        this.queue[idx] = req // newer wins\n        return\n      }\n    }\n\n    // Rule 4: insert by priority (stable FIFO within priority).\n    let i = 0\n    while (i < this.queue.length && this.queue[i].priority >= req.priority) i++\n    this.queue.splice(i, 0, req)\n\n    void this.pump()\n  }\n\n  mute(): void {\n    this.muted = true\n    this.queue = []\n    if (this.current) this.current.abort.abort()\n  }\n\n  unmute(): void {\n    this.muted = false\n  }\n\n  /**\n   * Interrupt the current utterance and drop the pending queue WITHOUT\n   * changing the muted state. Use this for \"stop speaking right now\" while\n   * leaving future events free to speak.\n   */\n  stop(): void {\n    this.queue = []\n    if (this.current) this.current.abort.abort()\n  }\n\n  isMuted(): boolean {\n    return this.muted\n  }\n\n  size(): number {\n    return this.queue.length + (this.current ? 1 : 0)\n  }\n\n  /** Resolves when queue is empty and nothing is speaking. */\n  async idle(): Promise<void> {\n    if (!this.current && this.queue.length === 0 && !this.pumpRunning) return\n    return new Promise<void>((resolve) => {\n      this.idleResolvers.push(resolve)\n    })\n  }\n\n  private async pump(): Promise<void> {\n    if (this.pumpRunning || this.current) return\n    this.pumpRunning = true\n    try {\n      while (this.queue.length > 0 && !this.muted) {\n        const next = this.queue.shift()!\n        // Rule 5: stale drop for non-urgent items.\n        if (\n          next.priority <= Priority.NORMAL &&\n          this.opts.now() - next.enqueuedAt > this.opts.staleMs\n        ) {\n          continue\n        }\n        const abort = new AbortController()\n        this.current = { req: next, abort }\n        try {\n          await this.opts.speak(next, abort.signal)\n        } catch (err) {\n          this.opts.onError?.(err, next)\n        } finally {\n          this.current = null\n        }\n      }\n    } finally {\n      this.pumpRunning = false\n      if (!this.current && this.queue.length === 0) {\n        const resolvers = this.idleResolvers\n        this.idleResolvers = []\n        for (const r of resolvers) r()\n      }\n    }\n  }\n}\n", "import { experimental_generateSpeech as generateSpeech, type SpeechModel } from \"ai\"\nimport type { TTSProvider, SynthesisOptions, SynthesisResult } from \"./provider.js\"\n\ninterface AiSdkProviderConfig {\n  model: SpeechModel\n  provider: \"openai\" | \"elevenlabs\"\n  voice?: string\n}\n\nexport function createAiSdkProvider(config: AiSdkProviderConfig): TTSProvider {\n  const { model, provider: providerName, voice: defaultVoice } = config\n\n  return {\n    name: providerName,\n\n    async synthesize(\n      text: string,\n      opts: SynthesisOptions,\n      signal: AbortSignal,\n    ): Promise<SynthesisResult> {\n      const voice =\n        opts.voice ??\n        defaultVoice ??\n        (providerName === \"openai\" ? \"alloy\" : undefined)\n\n      const result = await generateSpeech({\n        model,\n        text,\n        voice,\n        outputFormat: \"mp3\",\n        speed: opts.rate,\n        abortSignal: signal,\n      })\n      return {\n        audio: Buffer.from(result.audio.uint8Array),\n        contentType: result.audio.mediaType ?? \"audio/mpeg\",\n      }\n    },\n  }\n}\n", "import type { Runner } from \"./runner.js\"\nimport { PLUGIN_NAME } from \"../config.js\"\nimport { writeFile, mkdtemp, rm } from \"node:fs/promises\"\nimport { tmpdir } from \"node:os\"\nimport { join } from \"node:path\"\n\nexport interface PlayerOptions {\n  platform?: NodeJS.Platform\n  runner: Runner\n}\n\nexport interface Player {\n  init(): Promise<void>\n  play(\n    audio: Buffer | ReadableStream<Uint8Array>,\n    contentType: string,\n    signal: AbortSignal,\n  ): Promise<void>\n}\n\nconst LINUX_PLAYERS = [\"paplay\", \"aplay\", \"ffplay\"] as const\n\nexport function createPlayer(opts: PlayerOptions): Player {\n  const platform = opts.platform ?? process.platform\n  let binary: string | null = null\n\n  async function buffer(stream: Buffer | ReadableStream<Uint8Array>, signal: AbortSignal): Promise<Buffer> {\n    if (Buffer.isBuffer(stream)) return stream\n    const chunks: Uint8Array[] = []\n    const reader = stream.getReader()\n    try {\n      while (true) {\n        if (signal.aborted) throw new DOMException(\"aborted\", \"AbortError\")\n        const { done, value } = await reader.read()\n        if (done) break\n        if (value) chunks.push(value)\n      }\n    } finally {\n      if (signal.aborted) await reader.cancel().catch(() => undefined)\n    }\n    return Buffer.concat(chunks.map((c) => Buffer.from(c)))\n  }\n\n  async function writeTemp(buf: Buffer, contentType: string): Promise<{ dir: string; path: string }> {\n    const ext = contentType.includes(\"mpeg\")\n      ? \"mp3\"\n      : contentType.includes(\"wav\")\n        ? \"wav\"\n        : \"bin\"\n    const dir = await mkdtemp(join(tmpdir(), `${PLUGIN_NAME}-`))\n    const path = join(dir, `audio.${ext}`)\n    await writeFile(path, buf)\n    return { dir, path }\n  }\n\n  function powershellEncodedCommand(path: string): string {\n    const safePath = JSON.stringify(path.replace(/\\\\/g, \"/\"))\n    const script = [\n      \"Add-Type -AssemblyName presentationCore\",\n      \"$p = New-Object System.Windows.Media.MediaPlayer\",\n      `$p.Open([Uri]${safePath})`,\n      \"$p.Play()\",\n      \"Start-Sleep -Seconds 30\",\n    ].join(\"; \")\n    return Buffer.from(script, \"utf16le\").toString(\"base64\")\n  }\n\n  return {\n    async init() {\n      if (platform === \"darwin\") {\n        if (!(await opts.runner.has(\"afplay\"))) {\n          throw new Error(\"No audio player available (need `afplay`)\")\n        }\n        binary = \"afplay\"\n      } else if (platform === \"linux\") {\n        for (const b of LINUX_PLAYERS) {\n          if (await opts.runner.has(b)) {\n            binary = b\n            break\n          }\n        }\n        if (!binary) {\n          throw new Error(\n            \"No audio player available (need one of: paplay, aplay, ffplay)\",\n          )\n        }\n      } else if (platform === \"win32\") {\n        if (!(await opts.runner.has(\"powershell\"))) {\n          throw new Error(\"No audio player available (need `powershell`)\")\n        }\n        binary = \"powershell\"\n      } else {\n        throw new Error(`Unsupported platform for audio playback: ${platform}`)\n      }\n    },\n\n    async play(audio, contentType, signal) {\n      if (!binary) throw new Error(\"Audio player not initialized\")\n      if (signal.aborted) throw new DOMException(\"aborted\", \"AbortError\")\n      const buf = await buffer(audio, signal)\n      const tmp = await writeTemp(buf, contentType)\n      let cmd: string[]\n      if (binary === \"powershell\") {\n        cmd = [\n          \"powershell\",\n          \"-NoProfile\",\n          \"-EncodedCommand\",\n          powershellEncodedCommand(tmp.path),\n        ]\n      } else if (binary === \"ffplay\") {\n        cmd = [\"ffplay\", \"-autoexit\", \"-nodisp\", \"-loglevel\", \"quiet\", tmp.path]\n      } else {\n        cmd = [binary, tmp.path]\n      }\n      try {\n        const result = await opts.runner.run(cmd, signal)\n        if (result.exitCode !== 0) {\n          throw new Error(`audio playback failed with exit code ${result.exitCode}`)\n        }\n      } finally {\n        await rm(tmp.dir, { recursive: true, force: true })\n      }\n    },\n  }\n}\n", "/**\n * Shared `Runner` abstraction used by the audio player. A Runner knows how to:\n *   - probe the PATH for an executable\n *   - spawn a process with abort support\n *\n * The audio player uses this to invoke `afplay` / `paplay` / `aplay` /\n * `ffplay` / PowerShell to play the audio bytes returned by the TTS\n * provider. `src/index.ts` constructs one via `defaultRunner()` and hands\n * it to `createPlayer()`.\n */\n\nexport interface Runner {\n  has(binary: string): Promise<boolean>\n  run(cmd: string[], signal: AbortSignal): Promise<{ exitCode: number }>\n}\n\n/** Default runner: uses Node's child_process and PATH-based binary lookup. */\nexport async function defaultRunner(): Promise<Runner> {\n  const { spawn } = await import(\"node:child_process\")\n  const { access, constants } = await import(\"node:fs/promises\")\n  const { delimiter, sep } = await import(\"node:path\")\n\n  async function has(binary: string): Promise<boolean> {\n    const PATH = process.env.PATH ?? \"\"\n    const exts =\n      process.platform === \"win32\"\n        ? (process.env.PATHEXT ?? \".EXE;.CMD;.BAT\").split(\";\")\n        : [\"\"]\n    for (const dir of PATH.split(delimiter)) {\n      for (const ext of exts) {\n        try {\n          await access(`${dir}${sep}${binary}${ext}`, constants.X_OK)\n          return true\n        } catch {\n          /* keep searching */\n        }\n      }\n    }\n    return false\n  }\n\n  const ABORT_KILL_MS = 1000\n\n  async function run(cmd: string[], signal: AbortSignal): Promise<{ exitCode: number }> {\n    if (signal.aborted) throw new DOMException(\"aborted\", \"AbortError\")\n    return await new Promise((resolve, reject) => {\n      const child = spawn(cmd[0], cmd.slice(1), { stdio: \"ignore\" })\n      let killTimer: NodeJS.Timeout | undefined\n      const cleanup = () => {\n        signal.removeEventListener(\"abort\", onAbort)\n        if (killTimer) clearTimeout(killTimer)\n      }\n      const onAbort = () => {\n        child.kill(\"SIGTERM\")\n        killTimer = setTimeout(() => child.kill(\"SIGKILL\"), ABORT_KILL_MS)\n      }\n      signal.addEventListener(\"abort\", onAbort)\n      child.on(\"error\", (e) => {\n        cleanup()\n        reject(e)\n      })\n      child.on(\"exit\", (code) => {\n        cleanup()\n        if (signal.aborted) reject(new DOMException(\"aborted\", \"AbortError\"))\n        else if ((code ?? 0) !== 0) reject(new Error(`process exited with code ${code ?? 0}`))\n        else resolve({ exitCode: 0 })\n      })\n    })\n  }\n\n  return { has, run }\n}\n", "import { randomUUID } from \"node:crypto\"\nimport { Priority, type SpeechRequest } from \"../queue/types.js\"\nimport { renderTemplate, stripMarkdown, truncate } from \"./template.js\"\nimport type { Narrator, NarrationContext } from \"./narrator.js\"\nimport { queuePriorityForEvent } from \"../events/catalog.js\"\n\nexport interface EventConfig {\n  enabled: boolean\n  mode: \"template\" | \"narrate\" | \"verbatim\"\n  priority?: \"urgent\" | \"normal\" | \"chatty\"\n}\n\nexport interface HandlerRegistryOptions {\n  events: Record<string, EventConfig>\n  narrator: Narrator\n  getContext: () => NarrationContext\n}\n\nexport interface HandlerRegistry {\n  handle(event: { type: string; [k: string]: unknown }): Promise<SpeechRequest | null>\n}\n\ntype RenderMode = EventConfig[\"mode\"]\ntype RenderContext = Pick<HandlerRegistryOptions, \"narrator\" | \"getContext\">\ntype ModeRenderer = (\n  event: { type: string; [k: string]: unknown },\n  ctx: RenderContext,\n) => Promise<string | null> | string | null\n\nconst MODE_RENDERERS: Record<RenderMode, ModeRenderer> = {\n  template: (event) => renderTemplate(event),\n  narrate: async (event, ctx) => {\n    const text = await ctx.narrator.summarize(event, ctx.getContext())\n    return text ?? renderTemplate(event)\n  },\n  verbatim: (event) => truncate(stripMarkdown(String(event.text ?? \"\")), 300),\n}\n\nfunction priorityFromName(name?: string): Priority | null {\n  if (name === \"urgent\") return Priority.URGENT\n  if (name === \"normal\") return Priority.NORMAL\n  if (name === \"chatty\") return Priority.CHATTY\n  return null\n}\n\nexport function createHandlerRegistry(opts: HandlerRegistryOptions): HandlerRegistry {\n  return {\n    async handle(event) {\n      const cfg = opts.events[event.type]\n      if (!cfg || !cfg.enabled) return null\n\n      const text = await MODE_RENDERERS[cfg.mode](event, opts)\n      if (!text) return null\n\n      const priority =\n        priorityFromName(cfg.priority) ??\n        queuePriorityForEvent(event.type)\n      const overrideKey = (event as Record<string, unknown>).dedupKey\n      const dedupKey = typeof overrideKey === \"string\" ? overrideKey : event.type\n      return {\n        id: randomUUID(),\n        priority,\n        text,\n        dedupKey,\n        enqueuedAt: Date.now(),\n      }\n    },\n  }\n}\n", "export interface AnyEvent {\n  type: string\n  [key: string]: unknown\n}\n\nexport function truncate(s: string, max: number): string {\n  if (s.length <= max) return s\n  return s.slice(0, max) + \"\u2026\"\n}\n\nexport function stripMarkdown(text: string): string {\n  return text\n    .replace(/```[\\s\\S]*?```/g, \"\")          // fenced code\n    .replace(/`([^`]+)`/g, \"$1\")             // inline code\n    .replace(/\\*\\*([^*]+)\\*\\*/g, \"$1\")       // bold\n    .replace(/\\*([^*]+)\\*/g, \"$1\")           // italic\n    .replace(/__([^_]+)__/g, \"$1\")           // bold\n    .replace(/_([^_]+)_/g, \"$1\")             // italic\n    .replace(/!\\[[^\\]]*\\]\\([^)]*\\)/g, \"\")    // images\n    .replace(/\\[([^\\]]+)\\]\\([^)]*\\)/g, \"$1\") // links\n    .replace(/^#+\\s+/gm, \"\")                 // headings\n    .replace(/^\\s*[-*+]\\s+/gm, \"\")           // list bullets\n    .replace(/\\s+/g, \" \")\n    .trim()\n}\n\ntype Renderer = (e: AnyEvent) => string\n\nfunction basename(p: string): string {\n  const trimmed = p.replace(/[\\\\/]+$/, \"\")\n  const i = Math.max(trimmed.lastIndexOf(\"/\"), trimmed.lastIndexOf(\"\\\\\"))\n  return i >= 0 ? trimmed.slice(i + 1) : trimmed\n}\n\nfunction asString(v: unknown): string | undefined {\n  return typeof v === \"string\" && v.length > 0 ? v : undefined\n}\n\nconst templates: Record<string, Renderer> = {\n  // --- Real OpenCode events ---\n  \"session.idle\":         ()  => \"I'm idle now and waiting for your next instruction.\",\n  \"session.error\":        (e) =>\n    `I hit a session error: ${truncate(String(e.message ?? \"unknown\"), 200)}. Check the log for details.`,\n  \"session.compacted\":    ()  =>\n    \"I compacted the session, so older context is summarized and I have more room to continue.\",\n  \"session.created\":      () => \"I'm starting a new session and getting ready to work.\",\n  \"permission.asked\":     (e) =>\n    `I need your approval before I use ${asString(e.tool) ?? \"an operation\"}.`,\n  \"permission.replied\":   (e) => {\n    const raw = String(e.decision ?? \"responded\").toLowerCase()\n    const verb =\n      raw === \"allow\" || raw === \"approve\" || raw === \"accept\" || raw === \"yes\" ||\n      raw === \"once\" || raw === \"always\"\n        ? \"granted\"\n        : raw === \"deny\" || raw === \"reject\" || raw === \"no\"\n          ? \"denied\"\n          : raw\n    const tool = asString(e.tool) ?? \"the operation\"\n    if (verb === \"granted\") return `I got approval to use ${tool}.`\n    if (verb === \"denied\") return `I was denied permission to use ${tool}.`\n    if (verb === \"responded\") return `I got a response for ${tool}.`\n    return `I got a permission response for ${tool}: ${verb}.`\n  },\n  \"tool.execute.before\":  (e) => `I'm running ${asString(e.tool) ?? \"tool\"} now.`,\n  \"tool.execute.after\":   (e) => `I finished running ${asString(e.tool) ?? \"tool\"}.`,\n  \"file.edited\":          (e) => {\n    const raw = String(e.file ?? \"\")\n    return raw ? `I edited ${basename(raw)}.` : \"I edited a file.\"\n  },\n  \"command.executed\":     (e) => {\n    const name = String(e.command ?? \"\").trim()\n    return name ? `I ran ${name}.` : \"I ran a command.\"\n  },\n  // Note: `message.updated` carries `{ sessionID, info: Message }` \u2014 the\n  // message text lives in `info.parts`, not at the top level. Live narration\n  // is handled by the synthesized `message.text.delta` events derived from\n  // `message.part.updated`, so there is intentionally no template here.\n\n  // --- Synthesized by src/dispatcher.ts ---\n  \"message.text.delta\":      (e) => truncate(stripMarkdown(String(e.text ?? \"\")), 600),\n  \"message.reasoning.delta\": (e) => truncate(stripMarkdown(String(e.text ?? \"\")), 600),\n  \"todo.completed.all\":   (e) => {\n    const n = Number(e.count ?? 0)\n    return n > 0\n      ? `I've completed all ${n} todos. Nice work.`\n      : \"I've completed all todos. Nice work.\"\n  },\n  \"todo.completed.item\":  (e) =>\n    `I finished this task: ${truncate(stripMarkdown(String(e.content ?? \"\")), 80)}.`,\n}\n\nexport function renderTemplate(event: AnyEvent): string | null {\n  const fn = templates[event.type]\n  if (!fn) return null\n  const out = fn(event)\n  return out.length === 0 ? null : out\n}\n", "import { generateText, type LanguageModel } from \"ai\"\nimport { truncate } from \"./template.js\"\nimport type { Logger } from \"../log.js\"\nimport { EVENT_SPECS, type EventSpec, type EventType } from \"../events/catalog.js\"\n\nexport interface NarrationContext {\n  assistantText: string\n  recentTools: string[]\n}\n\nexport interface NarratorConfig {\n  timeoutMs: number\n  minIntervalMs: number\n}\n\nexport interface Narrator {\n  summarize(\n    event: { type: string; [k: string]: unknown },\n    ctx: NarrationContext,\n  ): Promise<string | null>\n}\n\n// Stable instructions. Kept separate from the per-event context so the model\n// treats the context as data (not instructions) and so this block can be\n// prompt-cached. Written in a single voice: the model *is* the agent.\nconst SYSTEM_PROMPT = [\n  \"You are the coding agent. Your words are read aloud by a text-to-speech engine while the\",\n  \"user looks away from the screen, so speak as yourself in natural spoken English.\",\n  \"\",\n  \"happened: what you attempted and changed, the outcome, and any blocker, error, or decision\",\n  \"that needs the user's attention. Add an obvious next step only if there is one.\",\n  \"\",\n  \"Style:\",\n  \"- First person \u2014 I, me, my. You did the work; never describe yourself in third person or as an AI.\",\n  \"- Plain prose only: no markdown, code blocks, quotes, bullet points, or headings.\",\n  \"- Refer to code by purpose (\\\"the auth module\\\", \\\"the new check\\\") rather than identifier.\",\n  \"  When a specific file name or the exact error message is the key fact, say it plainly.\",\n  \"- Avoid file paths, type names, and command flags unless one of them is the point.\",\n  \"- Only describe what the context below shows. Do not invent files, tools, or outcomes.\",\n  \"- No greetings, sign-offs, or restating these instructions.\",\n  \"\",\n  \"Example: \\\"I refactored the credentials loader and its tests pass. No blockers.\\\"\",\n].join(\"\\n\")\n\n// Normalized fields worth surfacing to the model. These names are produced by\n// src/events/normalize.ts, so they're reliable when present.\nconst FACT_FIELDS = [\"tool\", \"file\", \"command\", \"message\", \"errorName\", \"content\"] as const\n\nfunction eventFacts(event: { type: string; [k: string]: unknown }): string {\n  const lines: string[] = []\n  for (const key of FACT_FIELDS) {\n    const value = event[key]\n    if (typeof value === \"string\" && value.trim().length > 0) {\n      lines.push(`- ${key}: ${truncate(value, 200)}`)\n    }\n  }\n  if (typeof event.count === \"number\") lines.push(`- count: ${event.count}`)\n  return lines.join(\"\\n\")\n}\n\nfunction buildContext(\n  event: { type: string; [k: string]: unknown },\n  ctx: NarrationContext,\n): string {\n  // The dispatcher already bounds assistantText to its textWindow (4000), but\n  // the narrator can be called directly (tests, demo scripts), so cap here too.\n  const text = truncate(ctx.assistantText, 10000)\n  const tools =\n    ctx.recentTools.slice(-5).map((t) => `- ${t}`).join(\"\\n\") || \"(none)\"\n  const occasion =\n    (EVENT_SPECS[event.type as EventType] as EventSpec | undefined)?.narrationOccasion ??\n    \"I just finished a turn.\"\n  return [\n    occasion,\n    \"\",\n    \"What I produced recently:\",\n    text || \"(none)\",\n    \"\",\n    \"Tools I recently used:\",\n    tools,\n    \"\",\n    \"Event details:\",\n    eventFacts(event) || \"(no extra detail)\",\n  ].join(\"\\n\")\n}\n\nexport function createNarrator(\n  model: LanguageModel,\n  config: NarratorConfig,\n  logger?: Logger,\n): Narrator {\n  let lastFinishedAt = 0\n\n  return {\n    async summarize(event, ctx) {\n      const now = Date.now()\n      if (now - lastFinishedAt < config.minIntervalMs) return null\n\n      // Nothing concrete to summarize \u2014 skip the LLM call (and don't advance\n      // the throttle) so we never speak invented filler. The narrate renderer\n      // in handlers/index.ts falls back to the event template in this case.\n      const hasContext =\n        ctx.assistantText.trim().length > 0 ||\n        ctx.recentTools.length > 0 ||\n        eventFacts(event).length > 0\n      if (!hasContext) return null\n\n      const ac = new AbortController()\n      const timer = setTimeout(() => ac.abort(), config.timeoutMs)\n      try {\n        const { text } = await generateText({\n          model,\n          system: SYSTEM_PROMPT,\n          temperature: 0.2,\n          prompt: buildContext(event, ctx),\n          abortSignal: ac.signal,\n        })\n        const trimmed = text.trim()\n        if (trimmed.length === 0) return null\n        lastFinishedAt = Date.now()\n        return trimmed\n      } catch (err) {\n        if (logger) {\n          await logger.warn(\"narrator summary failed\", {\n            error: err,\n            operation: \"summarizing event for narration\",\n            input: {\n              eventType: event.type,\n              assistantTextLen: ctx.assistantText.length,\n              recentToolsCount: ctx.recentTools.length,\n            },\n          })\n        }\n        return null\n      } finally {\n        clearTimeout(timer)\n      }\n    },\n  }\n}\n", "export interface RawEvent {\n  type: string\n  properties?: unknown\n  [key: string]: unknown\n}\n\nexport type CanonicalEvent = { type: string; [key: string]: unknown }\n\nfunction objectRecord(value: unknown): Record<string, unknown> {\n  return value && typeof value === \"object\" && !Array.isArray(value)\n    ? value as Record<string, unknown>\n    : {}\n}\n\nfunction firstString(...values: unknown[]): string | undefined {\n  for (const value of values) {\n    if (typeof value === \"string\" && value.trim().length > 0) return value\n  }\n  return undefined\n}\n\n// OpenCode renamed/restructured a few events between SDK generations. We pin\n// the rest of the plugin to a small set of canonical names and let normalize\n// translate whatever the runtime currently emits into that vocabulary.\nconst TYPE_ALIASES: Record<string, string> = {\n  \"permission.updated\": \"permission.asked\",          // v1 SDK name\n  \"session.next.tool.called\": \"tool.execute.before\", // v2 SDK\n  \"session.next.tool.success\": \"tool.execute.after\", // v2 SDK\n  \"session.next.tool.failed\": \"tool.execute.after\",  // v2 SDK\n}\n\nexport function normalizeEvent(raw: RawEvent): CanonicalEvent {\n  const props = objectRecord(raw.properties)\n  // v1 `permission.updated` payload is a Permission, whose own `type` field\n  // (the action, e.g. \"bash\") collides with the event type when spread. Pull\n  // it out before the merge so we don't lose it.\n  const propType = typeof props.type === \"string\" ? props.type : undefined\n\n  const canonicalType = TYPE_ALIASES[raw.type] ?? raw.type\n  const merged: CanonicalEvent = { ...raw, ...props, type: canonicalType }\n\n  if (canonicalType === \"permission.asked\" || canonicalType === \"permission.replied\") {\n    const meta = objectRecord(merged.metadata)\n    // v2 PermissionRequest.tool is `{ messageID, callID }` \u2014 useless as a\n    // spoken name. The friendly action is in `permission` (v2), `metadata.tool`\n    // (older shape), `title` (v1 Permission), or `type` (v1 Permission, which\n    // we rescued into `propType` above).\n    const toolName = firstString(\n      typeof merged.tool === \"string\" ? merged.tool : undefined,\n      merged.permission, // v2 PermissionRequest.permission\n      propType,          // v1 Permission.type (rescued from properties)\n      meta.tool,         // older shape: permission metadata\n      merged.title,      // last-resort v1 fallback (often long-form like \"Run a shell command\")\n    )\n    const next: CanonicalEvent = { ...merged, tool: toolName }\n    if (canonicalType === \"permission.replied\") {\n      next.decision =\n        firstString(merged.decision, merged.response, merged.reply, merged.result) ?? \"responded\"\n    }\n    return next\n  }\n\n  if (canonicalType === \"tool.execute.before\" || canonicalType === \"tool.execute.after\") {\n    return {\n      ...merged,\n      tool: firstString(merged.tool, merged.name),\n      callID: firstString(merged.callID, merged.callId, merged.id),\n    }\n  }\n\n  if (canonicalType === \"session.error\") {\n    const err = objectRecord(merged.error)\n    const errData = objectRecord(err.data)\n    return {\n      ...merged,\n      // Real shape: properties.error.data.message. Fall back to a top-level\n      // `message` only because old/synthesized events sometimes use it.\n      message: firstString(merged.message, errData.message, err.message),\n      errorName: firstString(err.name, errData.name),\n    }\n  }\n\n  if (canonicalType === \"file.edited\") {\n    return {\n      ...merged,\n      file: firstString(merged.file, merged.path, merged.filePath),\n    }\n  }\n\n  if (canonicalType === \"command.executed\" || canonicalType === \"tui.command.execute\") {\n    return {\n      ...merged,\n      command: firstString(merged.command, merged.name, merged.id),\n    }\n  }\n\n  return merged\n}\n\nexport function commandNameFromEvent(raw: RawEvent): string | null {\n  const event = normalizeEvent(raw)\n  return typeof event.command === \"string\"\n    ? event.command.replace(/^\\/+/, \"\").toLowerCase()\n    : null\n}\n", "import type { SpeechRequest } from \"./queue/types.js\"\nimport type { HandlerRegistry } from \"./handlers/index.js\"\nimport type { NarrationContext } from \"./handlers/narrator.js\"\nimport type { Logger } from \"./log.js\"\nimport { normalizeEvent, type RawEvent } from \"./events/normalize.js\"\n\ninterface QueueIfc {\n  push(req: SpeechRequest): void\n}\n\nexport interface DispatcherOptions {\n  handler: HandlerRegistry\n  queue: QueueIfc\n  logger?: Logger\n  onError?: (err: unknown, event: { type: string }) => void\n  /** Max chars of recent assistant text to keep. */\n  textWindow?: number\n  /** Max recent tool calls to remember. */\n  toolWindow?: number\n  /** Max chars of reasoning buffer before forced flush when no sentence end is found. */\n  reasoningFlushChars?: number\n}\n\ninterface TodoSnapshot {\n  id: string\n  content: string\n  status: string\n}\n\ninterface PartLike {\n  id?: string\n  type?: string\n  text?: string\n  [k: string]: unknown\n}\n\nexport interface Dispatcher {\n  onEvent(event: RawEvent): Promise<void>\n  getContext(): NarrationContext\n}\n\n// Matches a sentence ending with . ! or ? optionally followed by a closing\n// quote/bracket and either whitespace or end-of-string. The lookahead-free\n// form keeps the regex compatible with older engines and easy to reason about.\nconst SENTENCE_RE = /[\\s\\S]*?[.!?]+(?:[\"')\\]]?)(?:\\s+|$)/g\n\nexport function createDispatcher(opts: DispatcherOptions): Dispatcher {\n  const textWindow = opts.textWindow ?? 4000\n  const toolWindow = opts.toolWindow ?? 10\n  const reasoningFlushChars = opts.reasoningFlushChars ?? 240\n\n  let assistantText = \"\"\n  const recentTools: string[] = []\n  // v2 `session.next.tool.success`/`.failed` only carry `callID`, not the\n  // tool name. We remember the callID -> tool mapping when the matching\n  // `tool.execute.before` (normalized from `session.next.tool.called`) fires\n  // so the after-event template can still say \"I finished running X.\"\n  const toolByCallId = new Map<string, string>()\n  const todoStatus = new Map<string, string>() // id -> last seen status\n\n  // For streaming message parts (text + reasoning): how much of each part's\n  // text we have already processed. Each `message.part.updated` carries the\n  // FULL current state of a part, so the delta is `part.text.slice(seenLen)`.\n  const partSeen = new Map<string, number>()\n  // For reasoning specifically, we buffer trailing text without a sentence\n  // boundary so we don't speak half-thoughts like \"Let me\" / \"think about\".\n  const reasoningBuffer = new Map<string, string>()\n  // Monotonic counter so each synthesized streaming delta has its own dedup\n  // key \u2014 otherwise successive reasoning deltas would collapse against each\n  // other in the speech queue and we'd lose content.\n  let deltaSequence = 0\n\n  function appendText(t: string) {\n    assistantText = (assistantText + \" \" + t).slice(-textWindow)\n  }\n\n  function trackTool(tool: string) {\n    recentTools.push(tool)\n    while (recentTools.length > toolWindow) recentTools.shift()\n  }\n\n  // A \"turn\" is one user prompt + the agent response that follows it, ended by\n  // session.idle. Without this reset, assistantText/recentTools accumulate\n  // across every turn in a session, so the narrator's end-of-turn summary\n  // would describe everything since the session began instead of just this\n  // turn. Must run AFTER session.idle's handler chain so the narrator still\n  // sees the full turn's context.\n  function resetTurnState() {\n    assistantText = \"\"\n    recentTools.length = 0\n    partSeen.clear()\n    reasoningBuffer.clear()\n    toolByCallId.clear()\n  }\n\n  async function fire(event: { type: string; [k: string]: unknown }): Promise<void> {\n    try {\n      const sr = await opts.handler.handle(event)\n      if (sr) opts.queue.push(sr)\n    } catch (err) {\n      if (opts.logger) {\n        await opts.logger.warn(\"handler failed\", {\n          error: err,\n          operation: \"dispatching opencode event\",\n          input: { eventType: event.type },\n        })\n      }\n      opts.onError?.(err, event)\n    }\n  }\n\n  async function handleTodoUpdated(props: { todos?: TodoSnapshot[] }): Promise<void> {\n    const todos = props.todos ?? []\n    let transitionsToCompleted = 0\n    for (const t of todos) {\n      const prev = todoStatus.get(t.id)\n      if (prev !== \"completed\" && t.status === \"completed\") {\n        transitionsToCompleted++\n        await fire({ type: \"todo.completed.item\", content: t.content })\n      }\n      todoStatus.set(t.id, t.status)\n    }\n    if (\n      todos.length > 0 &&\n      todos.every((t) => t.status === \"completed\") &&\n      transitionsToCompleted > 0\n    ) {\n      await fire({ type: \"todo.completed.all\", count: todos.length })\n    }\n    await fire({ type: \"todo.updated\", todos })\n  }\n\n  function computeDelta(partId: string, fullText: string): string | null {\n    const prev = partSeen.get(partId) ?? 0\n    // Defensive: text shouldn't shrink, but if a stream resets we re-anchor.\n    if (fullText.length < prev) {\n      partSeen.set(partId, fullText.length)\n      return null\n    }\n    if (fullText.length === prev) return null\n    const delta = fullText.slice(prev)\n    partSeen.set(partId, fullText.length)\n    return delta\n  }\n\n  async function handleTextPart(part: PartLike): Promise<void> {\n    if (!part.id || typeof part.text !== \"string\") return\n    const delta = computeDelta(part.id, part.text)\n    if (!delta) return\n    // Update assistant context for the narrator regardless of whether the\n    // user has enabled live text narration.\n    appendText(delta)\n    await fire({\n      type: \"message.text.delta\",\n      text: delta,\n      partID: part.id,\n      dedupKey: `message.text.delta:${part.id}:${++deltaSequence}`,\n    })\n  }\n\n  async function handleReasoningPart(part: PartLike): Promise<void> {\n    if (!part.id || typeof part.text !== \"string\") return\n    const delta = computeDelta(part.id, part.text)\n    if (!delta) return\n\n    let buffered = (reasoningBuffer.get(part.id) ?? \"\") + delta\n\n    const sentences: string[] = []\n    let cursor = 0\n    SENTENCE_RE.lastIndex = 0\n    let m: RegExpExecArray | null\n    while ((m = SENTENCE_RE.exec(buffered)) !== null) {\n      sentences.push(m[0].trim())\n      cursor = SENTENCE_RE.lastIndex\n    }\n    buffered = buffered.slice(cursor)\n\n    // If the trailing fragment grows large without a sentence end, force-flush\n    // it so very long reasoning blocks without punctuation still get heard.\n    if (buffered.length >= reasoningFlushChars) {\n      sentences.push(buffered.trim())\n      buffered = \"\"\n    }\n\n    reasoningBuffer.set(part.id, buffered)\n\n    for (const sentence of sentences) {\n      if (!sentence) continue\n      await fire({\n        type: \"message.reasoning.delta\",\n        text: sentence,\n        partID: part.id,\n        dedupKey: `message.reasoning.delta:${part.id}:${++deltaSequence}`,\n      })\n    }\n  }\n\n  async function handleMessagePart(props: { part?: PartLike }): Promise<void> {\n    const part = props.part\n    if (!part || typeof part !== \"object\") return\n    if (part.type === \"text\") {\n      await handleTextPart(part)\n    } else if (part.type === \"reasoning\") {\n      await handleReasoningPart(part)\n    }\n    // Other part types (tool, file, step-start, \u2026) are surfaced via their\n    // dedicated events; nothing further to forward here.\n  }\n\n  return {\n    async onEvent(event) {\n      const normalized = normalizeEvent(event)\n\n      if (normalized.type === \"todo.updated\") {\n        const todos = normalized.todos as TodoSnapshot[] | undefined\n        return handleTodoUpdated({ todos })\n      }\n\n      if (normalized.type === \"message.part.updated\") {\n        const part = normalized.part as PartLike | undefined\n        return handleMessagePart({ part })\n      }\n\n      if (normalized.type === \"tool.execute.before\") {\n        const tool = normalized.tool as string | undefined\n        const callID = normalized.callID as string | undefined\n        if (typeof tool === \"string\") {\n          trackTool(tool)\n          if (typeof callID === \"string\") toolByCallId.set(callID, tool)\n        }\n      } else if (normalized.type === \"tool.execute.after\") {\n        // v2 success/failed events lose the tool name \u2014 recover it from the\n        // matching `before` event so the template can say \"I finished X.\"\n        if (typeof normalized.tool !== \"string\") {\n          const callID = normalized.callID as string | undefined\n          const remembered = callID ? toolByCallId.get(callID) : undefined\n          if (remembered) normalized.tool = remembered\n        }\n        const callID = normalized.callID as string | undefined\n        if (callID) toolByCallId.delete(callID)\n      }\n\n      try {\n        await fire(normalized)\n      } finally {\n        if (\n          normalized.type === \"session.idle\" ||\n          normalized.type === \"session.created\"\n        ) {\n          resetTurnState()\n        }\n      }\n    },\n    getContext() {\n      return { assistantText, recentTools: [...recentTools] }\n    },\n  }\n}\n", "import { randomUUID } from \"node:crypto\"\nimport { Priority, type SpeechRequest } from \"../queue/types.js\"\n\nexport interface CommandsOptions {\n  queue: {\n    push(req: SpeechRequest): void\n    mute(): void\n    unmute(): void\n    stop(): void\n    size(): number\n    isMuted(): boolean\n  }\n  providerName: string\n  voiceName?: string\n}\n\nexport interface VoiceStatus {\n  provider: string\n  voice?: string\n  muted: boolean\n  queueSize: number\n}\n\nexport interface Commands {\n  mute(): void\n  unmute(): void\n  toggle(): boolean\n  stop(): void\n  say(text: string): void\n  test(): void\n  status(): VoiceStatus\n  isMuted(): boolean\n}\n\nexport function createCommands(opts: CommandsOptions): Commands {\n  function makeRequest(text: string, priority: Priority): SpeechRequest {\n    return { id: randomUUID(), priority, text, enqueuedAt: Date.now() }\n  }\n\n  return {\n    mute() {\n      opts.queue.mute()\n    },\n    unmute() {\n      opts.queue.unmute()\n    },\n    /** Toggle mute state. Returns the new muted state. */\n    toggle() {\n      if (opts.queue.isMuted()) {\n        opts.queue.unmute()\n      } else {\n        opts.queue.mute()\n      }\n      return opts.queue.isMuted()\n    },\n    /** Interrupt the current utterance (and drop the pending queue). */\n    stop() {\n      opts.queue.stop()\n    },\n    isMuted() {\n      return opts.queue.isMuted()\n    },\n    say(text: string) {\n      opts.queue.push(makeRequest(text, Priority.NORMAL))\n    },\n    test() {\n      opts.queue.push(\n        makeRequest(\n          \"opencode voice test. If you hear this, audio is working.\",\n          Priority.NORMAL,\n        ),\n      )\n    },\n    status(): VoiceStatus {\n      return {\n        provider: opts.providerName,\n        voice: opts.voiceName,\n        muted: opts.queue.isMuted(),\n        queueSize: opts.queue.size(),\n      }\n    },\n  }\n}\n", "import type { Logger } from \"./log.js\"\n\nconst TOAST_MAX_LEN = 200\nconst TOAST_PREFIX = \"opencode-speaker: \"\nconst TOAST_DEFER_MS = 2500\nconst TOAST_DURATION_MS = 10000\n\nexport type ToastVariant = \"error\" | \"warning\" | \"info\" | \"success\"\n\nexport interface NotifierClient {\n  tui?: {\n    showToast?: (req: {\n      body: {\n        message: string\n        variant: ToastVariant\n        duration?: number\n      }\n    }) => Promise<unknown>\n  }\n}\n\nexport interface Notifier {\n  fatal(summary: string, detail?: unknown): void\n  warn(summary: string, detail?: unknown): void\n}\n\ntype NotifyLogger = Pick<Logger, \"error\" | \"warn\" | \"info\" | \"debug\">\n\nfunction buildMessage(summary: string): string {\n  const raw = TOAST_PREFIX + summary\n  if (raw.length <= TOAST_MAX_LEN) return raw\n  return raw.slice(0, TOAST_MAX_LEN - 1) + \"\u2026\"\n}\n\nasync function showToastSafe(\n  client: NotifierClient | undefined,\n  message: string,\n  variant: ToastVariant,\n  logger: NotifyLogger,\n): Promise<void> {\n  // The SDK's showToast uses `this._client` internally. Calling it as a\n  // detached function loses `this` and throws TypeError. We call it as a\n  // method on `tui` to preserve the binding.\n  const tui = client?.tui\n  if (!tui || typeof tui.showToast !== \"function\") {\n    return\n  }\n  try {\n    await tui.showToast({\n      body: { message, variant, duration: TOAST_DURATION_MS },\n    })\n  } catch (error) {\n    void logger.debug(\"toast failed\", {\n      error,\n      operation: \"showing toast\",\n      input: { message, variant },\n    })\n  }\n}\n\nfunction tryShowToast(\n  client: NotifierClient | undefined,\n  message: string,\n  variant: ToastVariant,\n  logger: NotifyLogger,\n): void {\n  // Defer to let the TUI subscribe to the event stream first. The plugin's\n  // function may have already returned by the time this fires \u2014 that is fine,\n  // since the host keeps the plugin's JS runtime alive for the session.\n  setTimeout(() => void showToastSafe(client, message, variant, logger), TOAST_DEFER_MS)\n}\n\nexport function createNotifier(\n  client: NotifierClient | undefined,\n  logger: NotifyLogger,\n): Notifier {\n  return {\n    fatal(summary, detail) {\n      void logger.error(summary, detail)\n      tryShowToast(client, buildMessage(summary), \"error\", logger)\n    },\n    warn(summary, detail) {\n      void logger.warn(summary, detail)\n      tryShowToast(client, buildMessage(summary), \"warning\", logger)\n    },\n  }\n}\n", "const ENV_VAR_BY_PROVIDER: Record<string, string> = {\n  openai: \"OPENAI_API_KEY\",\n  anthropic: \"ANTHROPIC_API_KEY\",\n  elevenlabs: \"ELEVENLABS_API_KEY\",\n}\n\nexport function requiredEnvVar(slug: string): string | null {\n  const slash = slug.indexOf(\"/\")\n  if (slash <= 0) return null\n  const provider = slug.slice(0, slash)\n  return ENV_VAR_BY_PROVIDER[provider] ?? null\n}\n\nexport interface CredentialCheck {\n  narratorSlug: string\n  ttsSlug: string\n}\n\nexport type CredentialResult =\n  | { ok: true }\n  | { ok: false; missing: string[] }\n\nexport function checkCredentials(\n  check: CredentialCheck,\n  env: Record<string, string | undefined>,\n): CredentialResult {\n  const required = new Set<string>()\n  for (const slug of [check.narratorSlug, check.ttsSlug]) {\n    const v = requiredEnvVar(slug)\n    if (v) required.add(v)\n  }\n  const missing: string[] = []\n  for (const name of required) {\n    const val = env[name]\n    if (val === undefined || val.trim().length === 0) missing.push(name)\n  }\n  missing.sort()\n  return missing.length === 0 ? { ok: true } : { ok: false, missing }\n}\n"],
  "mappings": "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",
  "names": ["callID", "randomUUID", "randomUUID"]
}
