@mingxy/ocosay 1.0.35 → 1.1.0

package/dist/plugin.js

@@ -593,17 +593,17 @@ var require_howler = __commonJS({
           var duration = Math.max(0, (self._sprite[sprite][0] + self._sprite[sprite][1]) / 1e3 - seek);
           var timeout = duration * 1e3 / Math.abs(sound._rate);
           var start = self._sprite[sprite][0] / 1e3;
-          var stop2 = (self._sprite[sprite][0] + self._sprite[sprite][1]) / 1e3;
+          var stop3 = (self._sprite[sprite][0] + self._sprite[sprite][1]) / 1e3;
           sound._sprite = sprite;
           sound._ended = false;
           var setParams = function() {
             sound._paused = false;
             sound._seek = seek;
             sound._start = start;
-            sound._stop = stop2;
+            sound._stop = stop3;
             sound._loop = !!(sound._loop || self._sprite[sprite][2]);
           };
-          if (seek >= stop2) {
+          if (seek >= stop3) {
             self._ended(sound);
             return;
           }
@@ -3418,7 +3418,7 @@ var require_sonic_boom = __commonJS({
   "node_modules/sonic-boom/index.js"(exports, module) {
     "use strict";
     var fs3 = __require("fs");
-    var EventEmitter6 = __require("events");
+    var EventEmitter7 = __require("events");
     var inherits = __require("util").inherits;
     var path2 = __require("path");
     var sleep = require_atomic_sleep();
@@ -3655,7 +3655,7 @@ var require_sonic_boom = __commonJS({
       sonic._asyncDrainScheduled = false;
       sonic.emit("drain");
     }
-    inherits(SonicBoom, EventEmitter6);
+    inherits(SonicBoom, EventEmitter7);
     function mergeBuf(bufs, len) {
       if (bufs.length === 0) {
         return kEmptyBuffer;
@@ -4223,7 +4223,7 @@ var require_thread_stream = __commonJS({
   "node_modules/thread-stream/index.js"(exports, module) {
     "use strict";
     var { version } = require_package();
-    var { EventEmitter: EventEmitter6 } = __require("events");
+    var { EventEmitter: EventEmitter7 } = __require("events");
     var { Worker } = __require("worker_threads");
     var { join: join8 } = __require("path");
     var { pathToFileURL } = __require("url");
@@ -4258,7 +4258,7 @@ var require_thread_stream = __commonJS({
       }
       worker.terminate();
     });
-    function createWorker(stream, opts) {
+    function createWorker(stream2, opts) {
       const { filename, workerData } = opts;
       const bundlerOverrides = "__bundlerPathsOverrides" in globalThis ? globalThis.__bundlerPathsOverrides : {};
       const toExecute = bundlerOverrides["thread-stream-worker"] || join8(__dirname, "lib", "worker.js");
@@ -4267,8 +4267,8 @@ var require_thread_stream = __commonJS({
         trackUnmanagedFds: false,
         workerData: {
           filename: filename.indexOf("file://") === 0 ? filename : pathToFileURL(filename).href,
-          dataBuf: stream[kImpl].dataBuf,
-          stateBuf: stream[kImpl].stateBuf,
+          dataBuf: stream2[kImpl].dataBuf,
+          stateBuf: stream2[kImpl].stateBuf,
           workerData: {
             $context: {
               threadStreamVersion: version
@@ -4277,111 +4277,111 @@ var require_thread_stream = __commonJS({
           }
         }
       });
-      worker.stream = new FakeWeakRef(stream);
+      worker.stream = new FakeWeakRef(stream2);
       worker.on("message", onWorkerMessage);
       worker.on("exit", onWorkerExit);
-      registry.register(stream, worker);
+      registry.register(stream2, worker);
       return worker;
     }
-    function drain(stream) {
-      assert(!stream[kImpl].sync);
-      if (stream[kImpl].needDrain) {
-        stream[kImpl].needDrain = false;
-        stream.emit("drain");
+    function drain(stream2) {
+      assert(!stream2[kImpl].sync);
+      if (stream2[kImpl].needDrain) {
+        stream2[kImpl].needDrain = false;
+        stream2.emit("drain");
       }
     }
-    function nextFlush(stream) {
-      const writeIndex = Atomics.load(stream[kImpl].state, WRITE_INDEX);
-      let leftover = stream[kImpl].data.length - writeIndex;
+    function nextFlush(stream2) {
+      const writeIndex = Atomics.load(stream2[kImpl].state, WRITE_INDEX);
+      let leftover = stream2[kImpl].data.length - writeIndex;
       if (leftover > 0) {
-        if (stream[kImpl].buf.length === 0) {
-          stream[kImpl].flushing = false;
-          if (stream[kImpl].ending) {
-            end(stream);
-          } else if (stream[kImpl].needDrain) {
-            process.nextTick(drain, stream);
+        if (stream2[kImpl].buf.length === 0) {
+          stream2[kImpl].flushing = false;
+          if (stream2[kImpl].ending) {
+            end(stream2);
+          } else if (stream2[kImpl].needDrain) {
+            process.nextTick(drain, stream2);
           }
           return;
         }
-        let toWrite = stream[kImpl].buf.slice(0, leftover);
+        let toWrite = stream2[kImpl].buf.slice(0, leftover);
         let toWriteBytes = Buffer.byteLength(toWrite);
         if (toWriteBytes <= leftover) {
-          stream[kImpl].buf = stream[kImpl].buf.slice(leftover);
-          write(stream, toWrite, nextFlush.bind(null, stream));
+          stream2[kImpl].buf = stream2[kImpl].buf.slice(leftover);
+          write(stream2, toWrite, nextFlush.bind(null, stream2));
         } else {
-          stream.flush(() => {
-            if (stream.destroyed) {
+          stream2.flush(() => {
+            if (stream2.destroyed) {
               return;
             }
-            Atomics.store(stream[kImpl].state, READ_INDEX, 0);
-            Atomics.store(stream[kImpl].state, WRITE_INDEX, 0);
-            Atomics.notify(stream[kImpl].state, READ_INDEX);
-            while (toWriteBytes > stream[kImpl].data.length) {
+            Atomics.store(stream2[kImpl].state, READ_INDEX, 0);
+            Atomics.store(stream2[kImpl].state, WRITE_INDEX, 0);
+            Atomics.notify(stream2[kImpl].state, READ_INDEX);
+            while (toWriteBytes > stream2[kImpl].data.length) {
               leftover = leftover / 2;
-              toWrite = stream[kImpl].buf.slice(0, leftover);
+              toWrite = stream2[kImpl].buf.slice(0, leftover);
               toWriteBytes = Buffer.byteLength(toWrite);
             }
-            stream[kImpl].buf = stream[kImpl].buf.slice(leftover);
-            write(stream, toWrite, nextFlush.bind(null, stream));
+            stream2[kImpl].buf = stream2[kImpl].buf.slice(leftover);
+            write(stream2, toWrite, nextFlush.bind(null, stream2));
           });
         }
       } else if (leftover === 0) {
-        if (writeIndex === 0 && stream[kImpl].buf.length === 0) {
+        if (writeIndex === 0 && stream2[kImpl].buf.length === 0) {
           return;
         }
-        stream.flush(() => {
-          Atomics.store(stream[kImpl].state, READ_INDEX, 0);
-          Atomics.store(stream[kImpl].state, WRITE_INDEX, 0);
-          Atomics.notify(stream[kImpl].state, READ_INDEX);
-          nextFlush(stream);
+        stream2.flush(() => {
+          Atomics.store(stream2[kImpl].state, READ_INDEX, 0);
+          Atomics.store(stream2[kImpl].state, WRITE_INDEX, 0);
+          Atomics.notify(stream2[kImpl].state, READ_INDEX);
+          nextFlush(stream2);
         });
       } else {
-        destroy(stream, new Error("overwritten"));
+        destroy(stream2, new Error("overwritten"));
       }
     }
     function onWorkerMessage(msg) {
-      const stream = this.stream.deref();
-      if (stream === void 0) {
+      const stream2 = this.stream.deref();
+      if (stream2 === void 0) {
         this.exited = true;
         this.terminate();
         return;
       }
       switch (msg.code) {
         case "READY":
-          this.stream = new WeakRef2(stream);
-          stream.flush(() => {
-            stream[kImpl].ready = true;
-            stream.emit("ready");
+          this.stream = new WeakRef2(stream2);
+          stream2.flush(() => {
+            stream2[kImpl].ready = true;
+            stream2.emit("ready");
           });
           break;
         case "ERROR":
-          destroy(stream, msg.err);
+          destroy(stream2, msg.err);
           break;
         case "EVENT":
           if (Array.isArray(msg.args)) {
-            stream.emit(msg.name, ...msg.args);
+            stream2.emit(msg.name, ...msg.args);
           } else {
-            stream.emit(msg.name, msg.args);
+            stream2.emit(msg.name, msg.args);
           }
           break;
         case "WARNING":
           process.emitWarning(msg.err);
           break;
         default:
-          destroy(stream, new Error("this should not happen: " + msg.code));
+          destroy(stream2, new Error("this should not happen: " + msg.code));
       }
     }
     function onWorkerExit(code) {
-      const stream = this.stream.deref();
-      if (stream === void 0) {
+      const stream2 = this.stream.deref();
+      if (stream2 === void 0) {
         return;
       }
-      registry.unregister(stream);
-      stream.worker.exited = true;
-      stream.worker.off("exit", onWorkerExit);
-      destroy(stream, code !== 0 ? new Error("the worker thread exited") : null);
+      registry.unregister(stream2);
+      stream2.worker.exited = true;
+      stream2.worker.off("exit", onWorkerExit);
+      destroy(stream2, code !== 0 ? new Error("the worker thread exited") : null);
     }
-    var ThreadStream = class extends EventEmitter6 {
+    var ThreadStream = class extends EventEmitter7 {
       constructor(opts = {}) {
         super();
         if (opts.bufferSize < 4) {
@@ -4512,127 +4512,127 @@ var require_thread_stream = __commonJS({
         return this[kImpl].errored;
       }
     };
-    function error(stream, err) {
+    function error(stream2, err) {
       setImmediate(() => {
-        stream.emit("error", err);
+        stream2.emit("error", err);
       });
     }
-    function destroy(stream, err) {
-      if (stream[kImpl].destroyed) {
+    function destroy(stream2, err) {
+      if (stream2[kImpl].destroyed) {
         return;
       }
-      stream[kImpl].destroyed = true;
+      stream2[kImpl].destroyed = true;
       if (err) {
-        stream[kImpl].errored = err;
-        error(stream, err);
+        stream2[kImpl].errored = err;
+        error(stream2, err);
       }
-      if (!stream.worker.exited) {
-        stream.worker.terminate().catch(() => {
+      if (!stream2.worker.exited) {
+        stream2.worker.terminate().catch(() => {
         }).then(() => {
-          stream[kImpl].closed = true;
-          stream.emit("close");
+          stream2[kImpl].closed = true;
+          stream2.emit("close");
         });
       } else {
         setImmediate(() => {
-          stream[kImpl].closed = true;
-          stream.emit("close");
+          stream2[kImpl].closed = true;
+          stream2.emit("close");
         });
       }
     }
-    function write(stream, data, cb) {
-      const current = Atomics.load(stream[kImpl].state, WRITE_INDEX);
+    function write(stream2, data, cb) {
+      const current = Atomics.load(stream2[kImpl].state, WRITE_INDEX);
       const length = Buffer.byteLength(data);
-      stream[kImpl].data.write(data, current);
-      Atomics.store(stream[kImpl].state, WRITE_INDEX, current + length);
-      Atomics.notify(stream[kImpl].state, WRITE_INDEX);
+      stream2[kImpl].data.write(data, current);
+      Atomics.store(stream2[kImpl].state, WRITE_INDEX, current + length);
+      Atomics.notify(stream2[kImpl].state, WRITE_INDEX);
       cb();
       return true;
     }
-    function end(stream) {
-      if (stream[kImpl].ended || !stream[kImpl].ending || stream[kImpl].flushing) {
+    function end(stream2) {
+      if (stream2[kImpl].ended || !stream2[kImpl].ending || stream2[kImpl].flushing) {
         return;
       }
-      stream[kImpl].ended = true;
+      stream2[kImpl].ended = true;
       try {
-        stream.flushSync();
-        let readIndex = Atomics.load(stream[kImpl].state, READ_INDEX);
-        Atomics.store(stream[kImpl].state, WRITE_INDEX, -1);
-        Atomics.notify(stream[kImpl].state, WRITE_INDEX);
+        stream2.flushSync();
+        let readIndex = Atomics.load(stream2[kImpl].state, READ_INDEX);
+        Atomics.store(stream2[kImpl].state, WRITE_INDEX, -1);
+        Atomics.notify(stream2[kImpl].state, WRITE_INDEX);
         let spins = 0;
         while (readIndex !== -1) {
-          Atomics.wait(stream[kImpl].state, READ_INDEX, readIndex, 1e3);
-          readIndex = Atomics.load(stream[kImpl].state, READ_INDEX);
+          Atomics.wait(stream2[kImpl].state, READ_INDEX, readIndex, 1e3);
+          readIndex = Atomics.load(stream2[kImpl].state, READ_INDEX);
           if (readIndex === -2) {
-            destroy(stream, new Error("end() failed"));
+            destroy(stream2, new Error("end() failed"));
             return;
           }
           if (++spins === 10) {
-            destroy(stream, new Error("end() took too long (10s)"));
+            destroy(stream2, new Error("end() took too long (10s)"));
             return;
           }
         }
         process.nextTick(() => {
-          stream[kImpl].finished = true;
-          stream.emit("finish");
+          stream2[kImpl].finished = true;
+          stream2.emit("finish");
         });
       } catch (err) {
-        destroy(stream, err);
+        destroy(stream2, err);
       }
     }
-    function writeSync(stream) {
+    function writeSync(stream2) {
       const cb = () => {
-        if (stream[kImpl].ending) {
-          end(stream);
-        } else if (stream[kImpl].needDrain) {
-          process.nextTick(drain, stream);
+        if (stream2[kImpl].ending) {
+          end(stream2);
+        } else if (stream2[kImpl].needDrain) {
+          process.nextTick(drain, stream2);
         }
       };
-      stream[kImpl].flushing = false;
-      while (stream[kImpl].buf.length !== 0) {
-        const writeIndex = Atomics.load(stream[kImpl].state, WRITE_INDEX);
-        let leftover = stream[kImpl].data.length - writeIndex;
+      stream2[kImpl].flushing = false;
+      while (stream2[kImpl].buf.length !== 0) {
+        const writeIndex = Atomics.load(stream2[kImpl].state, WRITE_INDEX);
+        let leftover = stream2[kImpl].data.length - writeIndex;
         if (leftover === 0) {
-          flushSync(stream);
-          Atomics.store(stream[kImpl].state, READ_INDEX, 0);
-          Atomics.store(stream[kImpl].state, WRITE_INDEX, 0);
-          Atomics.notify(stream[kImpl].state, READ_INDEX);
+          flushSync(stream2);
+          Atomics.store(stream2[kImpl].state, READ_INDEX, 0);
+          Atomics.store(stream2[kImpl].state, WRITE_INDEX, 0);
+          Atomics.notify(stream2[kImpl].state, READ_INDEX);
           continue;
         } else if (leftover < 0) {
           throw new Error("overwritten");
         }
-        let toWrite = stream[kImpl].buf.slice(0, leftover);
+        let toWrite = stream2[kImpl].buf.slice(0, leftover);
         let toWriteBytes = Buffer.byteLength(toWrite);
         if (toWriteBytes <= leftover) {
-          stream[kImpl].buf = stream[kImpl].buf.slice(leftover);
-          write(stream, toWrite, cb);
+          stream2[kImpl].buf = stream2[kImpl].buf.slice(leftover);
+          write(stream2, toWrite, cb);
         } else {
-          flushSync(stream);
-          Atomics.store(stream[kImpl].state, READ_INDEX, 0);
-          Atomics.store(stream[kImpl].state, WRITE_INDEX, 0);
-          Atomics.notify(stream[kImpl].state, READ_INDEX);
-          while (toWriteBytes > stream[kImpl].buf.length) {
+          flushSync(stream2);
+          Atomics.store(stream2[kImpl].state, READ_INDEX, 0);
+          Atomics.store(stream2[kImpl].state, WRITE_INDEX, 0);
+          Atomics.notify(stream2[kImpl].state, READ_INDEX);
+          while (toWriteBytes > stream2[kImpl].buf.length) {
             leftover = leftover / 2;
-            toWrite = stream[kImpl].buf.slice(0, leftover);
+            toWrite = stream2[kImpl].buf.slice(0, leftover);
             toWriteBytes = Buffer.byteLength(toWrite);
           }
-          stream[kImpl].buf = stream[kImpl].buf.slice(leftover);
-          write(stream, toWrite, cb);
+          stream2[kImpl].buf = stream2[kImpl].buf.slice(leftover);
+          write(stream2, toWrite, cb);
         }
       }
     }
-    function flushSync(stream) {
-      if (stream[kImpl].flushing) {
+    function flushSync(stream2) {
+      if (stream2[kImpl].flushing) {
         throw new Error("unable to flush while flushing");
       }
-      const writeIndex = Atomics.load(stream[kImpl].state, WRITE_INDEX);
+      const writeIndex = Atomics.load(stream2[kImpl].state, WRITE_INDEX);
       let spins = 0;
       while (true) {
-        const readIndex = Atomics.load(stream[kImpl].state, READ_INDEX);
+        const readIndex = Atomics.load(stream2[kImpl].state, READ_INDEX);
         if (readIndex === -2) {
           throw Error("_flushSync failed");
         }
         if (readIndex !== writeIndex) {
-          Atomics.wait(stream[kImpl].state, READ_INDEX, readIndex, 1e3);
+          Atomics.wait(stream2[kImpl].state, READ_INDEX, readIndex, 1e3);
         } else {
           break;
         }
@@ -4657,11 +4657,11 @@ var require_transport = __commonJS({
     var sleep = require_atomic_sleep();
     var onExit = require_on_exit_leak_free();
     var ThreadStream = require_thread_stream();
-    function setupOnExit(stream) {
-      onExit.register(stream, autoEnd);
-      onExit.registerBeforeExit(stream, flush);
-      stream.on("close", function() {
-        onExit.unregister(stream);
+    function setupOnExit(stream2) {
+      onExit.register(stream2, autoEnd);
+      onExit.registerBeforeExit(stream2, flush);
+      stream2.on("close", function() {
+        onExit.unregister(stream2);
       });
     }
     function hasPreloadFlags() {
@@ -4754,44 +4754,44 @@ var require_transport = __commonJS({
         }
       }
       workerOpts = { ...workerOpts, name };
-      const stream = new ThreadStream({
+      const stream2 = new ThreadStream({
         filename,
         workerData,
         workerOpts,
         sync
       });
-      stream.on("ready", onReady);
-      stream.on("close", function() {
+      stream2.on("ready", onReady);
+      stream2.on("close", function() {
         process.removeListener("exit", onExit2);
       });
       process.on("exit", onExit2);
       function onReady() {
         process.removeListener("exit", onExit2);
-        stream.unref();
+        stream2.unref();
         if (workerOpts.autoEnd !== false) {
-          setupOnExit(stream);
+          setupOnExit(stream2);
         }
       }
       function onExit2() {
-        if (stream.closed) {
+        if (stream2.closed) {
           return;
         }
-        stream.flushSync();
+        stream2.flushSync();
         sleep(100);
-        stream.end();
+        stream2.end();
       }
-      return stream;
+      return stream2;
     }
-    function autoEnd(stream) {
-      stream.ref();
-      stream.flushSync();
-      stream.end();
-      stream.once("close", function() {
-        stream.unref();
+    function autoEnd(stream2) {
+      stream2.ref();
+      stream2.flushSync();
+      stream2.end();
+      stream2.once("close", function() {
+        stream2.unref();
       });
     }
-    function flush(stream) {
-      stream.flushSync();
+    function flush(stream2) {
+      stream2.flushSync();
     }
     function transport(fullOptions) {
       const { pipeline, targets, levels, dedupe, worker = {}, caller = getCallers(), sync = false } = fullOptions;
@@ -5049,15 +5049,15 @@ var require_tools = __commonJS({
         return data + propStr + msgStr + end;
       }
     }
-    function asChindings(instance, bindings) {
+    function asChindings(instance2, bindings) {
       let value;
-      let data = instance[chindingsSym];
-      const stringify2 = instance[stringifySym];
-      const stringifySafe = instance[stringifySafeSym];
-      const stringifiers = instance[stringifiersSym];
+      let data = instance2[chindingsSym];
+      const stringify2 = instance2[stringifySym];
+      const stringifySafe = instance2[stringifySafeSym];
+      const stringifiers = instance2[stringifiersSym];
       const wildcardStringifier = stringifiers[wildcardFirstSym];
-      const serializers = instance[serializersSym];
-      const formatter = instance[formattersSym].bindings;
+      const serializers = instance2[serializersSym];
+      const formatter = instance2[formattersSym].bindings;
       bindings = formatter(bindings);
       for (const key in bindings) {
         value = bindings[key];
@@ -5071,56 +5071,56 @@ var require_tools = __commonJS({
       }
       return data;
     }
-    function hasBeenTampered(stream) {
-      return stream.write !== stream.constructor.prototype.write;
+    function hasBeenTampered(stream2) {
+      return stream2.write !== stream2.constructor.prototype.write;
     }
     function buildSafeSonicBoom(opts) {
-      const stream = new SonicBoom(opts);
-      stream.on("error", filterBrokenPipe);
+      const stream2 = new SonicBoom(opts);
+      stream2.on("error", filterBrokenPipe);
       if (!opts.sync && isMainThread) {
-        onExit.register(stream, autoEnd);
-        stream.on("close", function() {
-          onExit.unregister(stream);
+        onExit.register(stream2, autoEnd);
+        stream2.on("close", function() {
+          onExit.unregister(stream2);
         });
       }
-      return stream;
+      return stream2;
       function filterBrokenPipe(err) {
         if (err.code === "EPIPE") {
-          stream.write = noop;
-          stream.end = noop;
-          stream.flushSync = noop;
-          stream.destroy = noop;
+          stream2.write = noop;
+          stream2.end = noop;
+          stream2.flushSync = noop;
+          stream2.destroy = noop;
           return;
         }
-        stream.removeListener("error", filterBrokenPipe);
-        stream.emit("error", err);
+        stream2.removeListener("error", filterBrokenPipe);
+        stream2.emit("error", err);
       }
     }
-    function autoEnd(stream, eventName) {
-      if (stream.destroyed) {
+    function autoEnd(stream2, eventName) {
+      if (stream2.destroyed) {
         return;
       }
       if (eventName === "beforeExit") {
-        stream.flush();
-        stream.on("drain", function() {
-          stream.end();
+        stream2.flush();
+        stream2.on("drain", function() {
+          stream2.end();
         });
       } else {
-        stream.flushSync();
+        stream2.flushSync();
       }
     }
     function createArgsNormalizer(defaultOptions) {
-      return function normalizeArgs(instance, caller, opts = {}, stream) {
+      return function normalizeArgs(instance2, caller, opts = {}, stream2) {
         if (typeof opts === "string") {
-          stream = buildSafeSonicBoom({ dest: opts });
+          stream2 = buildSafeSonicBoom({ dest: opts });
           opts = {};
-        } else if (typeof stream === "string") {
+        } else if (typeof stream2 === "string") {
           if (opts && opts.transport) {
             throw Error("only one of option.transport or stream can be specified");
           }
-          stream = buildSafeSonicBoom({ dest: stream });
+          stream2 = buildSafeSonicBoom({ dest: stream2 });
         } else if (opts instanceof SonicBoom || opts.writable || opts._writableState) {
-          stream = opts;
+          stream2 = opts;
           opts = {};
         } else if (opts.transport) {
           if (opts.transport instanceof SonicBoom || opts.transport.writable || opts.transport._writableState) {
@@ -5133,7 +5133,7 @@ var require_tools = __commonJS({
           if (opts.customLevels) {
             customLevels = opts.useOnlyCustomLevels ? opts.customLevels : Object.assign({}, opts.levels, opts.customLevels);
           }
-          stream = transport({ caller, ...opts.transport, levels: customLevels });
+          stream2 = transport({ caller, ...opts.transport, levels: customLevels });
         }
         opts = Object.assign({}, defaultOptions, opts);
         opts.serializers = Object.assign({}, defaultOptions.serializers, opts.serializers);
@@ -5144,14 +5144,14 @@ var require_tools = __commonJS({
         const { enabled, onChild } = opts;
         if (enabled === false) opts.level = "silent";
         if (!onChild) opts.onChild = noop;
-        if (!stream) {
+        if (!stream2) {
           if (!hasBeenTampered(process.stdout)) {
-            stream = buildSafeSonicBoom({ fd: process.stdout.fd || 1 });
+            stream2 = buildSafeSonicBoom({ fd: process.stdout.fd || 1 });
           } else {
-            stream = process.stdout;
+            stream2 = process.stdout;
           }
         }
-        return { opts, stream };
+        return { opts, stream: stream2 };
       };
     }
     function stringify(obj, stringifySafeFn) {
@@ -5238,11 +5238,11 @@ var require_levels = __commonJS({
       fatal: (hook) => {
         const logFatal = genLog(DEFAULT_LEVELS.fatal, hook);
         return function(...args) {
-          const stream = this[streamSym];
+          const stream2 = this[streamSym];
           logFatal.call(this, ...args);
-          if (typeof stream.flushSync === "function") {
+          if (typeof stream2.flushSync === "function") {
             try {
-              stream.flushSync();
+              stream2.flushSync();
             } catch (e) {
             }
           }
@@ -5262,16 +5262,16 @@ var require_levels = __commonJS({
       o[k] = '{"level":' + Number(k);
       return o;
     }, {});
-    function genLsCache(instance) {
-      const formatter = instance[formattersSym].level;
-      const { labels } = instance.levels;
+    function genLsCache(instance2) {
+      const formatter = instance2[formattersSym].level;
+      const { labels } = instance2.levels;
       const cache = {};
       for (const label in labels) {
         const level2 = formatter(labels[label], Number(label));
         cache[label] = JSON.stringify(level2).slice(0, -1);
       }
-      instance[lsCacheSym] = cache;
-      return instance;
+      instance2[lsCacheSym] = cache;
+      return instance2;
     }
     function isStandardLevel(level2, useOnlyCustomLevels) {
       if (useOnlyCustomLevels) {
@@ -5424,7 +5424,7 @@ var require_meta = __commonJS({
 var require_proto = __commonJS({
   "node_modules/pino/lib/proto.js"(exports, module) {
     "use strict";
-    var { EventEmitter: EventEmitter6 } = __require("node:events");
+    var { EventEmitter: EventEmitter7 } = __require("node:events");
     var {
       lsCacheSym,
       levelValSym,
@@ -5505,7 +5505,7 @@ var require_proto = __commonJS({
       [getLevelSym]: getLevel,
       [setLevelSym]: setLevel
     };
-    Object.setPrototypeOf(prototype, EventEmitter6.prototype);
+    Object.setPrototypeOf(prototype, EventEmitter7.prototype);
     module.exports = function() {
       return Object.create(prototype);
     };
@@ -5516,49 +5516,49 @@ var require_proto = __commonJS({
       }
       const serializers = this[serializersSym];
       const formatters = this[formattersSym];
-      const instance = Object.create(this);
+      const instance2 = Object.create(this);
       if (options == null) {
-        if (instance[formattersSym].bindings !== resetChildingsFormatter) {
-          instance[formattersSym] = buildFormatters(
+        if (instance2[formattersSym].bindings !== resetChildingsFormatter) {
+          instance2[formattersSym] = buildFormatters(
             formatters.level,
             resetChildingsFormatter,
             formatters.log
           );
         }
-        instance[chindingsSym] = asChindings(instance, bindings2);
+        instance2[chindingsSym] = asChindings(instance2, bindings2);
         if (this.onChild !== noop) {
-          this.onChild(instance);
+          this.onChild(instance2);
         }
-        return instance;
+        return instance2;
       }
       if (options.hasOwnProperty("serializers") === true) {
-        instance[serializersSym] = /* @__PURE__ */ Object.create(null);
+        instance2[serializersSym] = /* @__PURE__ */ Object.create(null);
         for (const k in serializers) {
-          instance[serializersSym][k] = serializers[k];
+          instance2[serializersSym][k] = serializers[k];
         }
         const parentSymbols = Object.getOwnPropertySymbols(serializers);
         for (var i = 0; i < parentSymbols.length; i++) {
           const ks = parentSymbols[i];
-          instance[serializersSym][ks] = serializers[ks];
+          instance2[serializersSym][ks] = serializers[ks];
         }
         for (const bk in options.serializers) {
-          instance[serializersSym][bk] = options.serializers[bk];
+          instance2[serializersSym][bk] = options.serializers[bk];
         }
         const bindingsSymbols = Object.getOwnPropertySymbols(options.serializers);
         for (var bi = 0; bi < bindingsSymbols.length; bi++) {
           const bks = bindingsSymbols[bi];
-          instance[serializersSym][bks] = options.serializers[bks];
+          instance2[serializersSym][bks] = options.serializers[bks];
         }
-      } else instance[serializersSym] = serializers;
+      } else instance2[serializersSym] = serializers;
       if (options.hasOwnProperty("formatters")) {
         const { level: level2, bindings: chindings, log } = options.formatters;
-        instance[formattersSym] = buildFormatters(
+        instance2[formattersSym] = buildFormatters(
           level2 || formatters.level,
           chindings || resetChildingsFormatter,
           log || formatters.log
         );
       } else {
-        instance[formattersSym] = buildFormatters(
+        instance2[formattersSym] = buildFormatters(
           formatters.level,
           resetChildingsFormatter,
           formatters.log
@@ -5566,27 +5566,27 @@ var require_proto = __commonJS({
       }
       if (options.hasOwnProperty("customLevels") === true) {
         assertNoLevelCollisions(this.levels, options.customLevels);
-        instance.levels = mappings(options.customLevels, instance[useOnlyCustomLevelsSym]);
-        genLsCache(instance);
+        instance2.levels = mappings(options.customLevels, instance2[useOnlyCustomLevelsSym]);
+        genLsCache(instance2);
       }
       if (typeof options.redact === "object" && options.redact !== null || Array.isArray(options.redact)) {
-        instance.redact = options.redact;
-        const stringifiers = redaction(instance.redact, stringify);
+        instance2.redact = options.redact;
+        const stringifiers = redaction(instance2.redact, stringify);
         const formatOpts = { stringify: stringifiers[redactFmtSym] };
-        instance[stringifySym] = stringify;
-        instance[stringifiersSym] = stringifiers;
-        instance[formatOptsSym] = formatOpts;
+        instance2[stringifySym] = stringify;
+        instance2[stringifiersSym] = stringifiers;
+        instance2[formatOptsSym] = formatOpts;
       }
       if (typeof options.msgPrefix === "string") {
-        instance[msgPrefixSym] = (this[msgPrefixSym] || "") + options.msgPrefix;
+        instance2[msgPrefixSym] = (this[msgPrefixSym] || "") + options.msgPrefix;
       }
-      instance[chindingsSym] = asChindings(instance, bindings2);
+      instance2[chindingsSym] = asChindings(instance2, bindings2);
       if (options.level !== void 0 && options.level !== this.level || options.hasOwnProperty("customLevels")) {
         const childLevel = options.level || this.level;
-        instance[setLevelSym](childLevel);
+        instance2[setLevelSym](childLevel);
       }
-      this.onChild(instance);
-      return instance;
+      this.onChild(instance2);
+      return instance2;
     }
     function bindings() {
       const chindings = this[chindingsSym];
@@ -5628,23 +5628,23 @@ var require_proto = __commonJS({
         obj = mixinMergeStrategy(obj, mixin(obj, num, this));
       }
       const s = this[asJsonSym](obj, msg, num, t);
-      const stream = this[streamSym];
-      if (stream[needsMetadataGsym] === true) {
-        stream.lastLevel = num;
-        stream.lastObj = obj;
-        stream.lastMsg = msg;
-        stream.lastTime = t.slice(this[timeSliceIndexSym]);
-        stream.lastLogger = this;
+      const stream2 = this[streamSym];
+      if (stream2[needsMetadataGsym] === true) {
+        stream2.lastLevel = num;
+        stream2.lastObj = obj;
+        stream2.lastMsg = msg;
+        stream2.lastTime = t.slice(this[timeSliceIndexSym]);
+        stream2.lastLogger = this;
       }
-      stream.write(streamWriteHook ? streamWriteHook(s) : s);
+      stream2.write(streamWriteHook ? streamWriteHook(s) : s);
     }
     function flush(cb) {
       if (cb != null && typeof cb !== "function") {
         throw Error("callback must be a function");
       }
-      const stream = this[streamSym];
-      if (typeof stream.flush === "function") {
-        stream.flush(cb || noop);
+      const stream2 = this[streamSym];
+      if (typeof stream2.flush === "function") {
+        stream2.flush(cb || noop);
       } else if (cb) cb();
     }
   }
@@ -6289,23 +6289,23 @@ var require_multistream = __commonJS({
         const level2 = this.lastLevel;
         const { streams: streams2 } = this;
         let recordedLevel = 0;
-        let stream;
+        let stream2;
         for (let i = initLoopVar(streams2.length, opts.dedupe); checkLoopVar(i, streams2.length, opts.dedupe); i = adjustLoopVar(i, opts.dedupe)) {
           dest = streams2[i];
           if (dest.level <= level2) {
             if (recordedLevel !== 0 && recordedLevel !== dest.level) {
               break;
             }
-            stream = dest.stream;
-            if (stream[metadata]) {
+            stream2 = dest.stream;
+            if (stream2[metadata]) {
               const { lastTime, lastMsg, lastObj, lastLogger } = this;
-              stream.lastLevel = level2;
-              stream.lastTime = lastTime;
-              stream.lastMsg = lastMsg;
-              stream.lastObj = lastObj;
-              stream.lastLogger = lastLogger;
+              stream2.lastLevel = level2;
+              stream2.lastTime = lastTime;
+              stream2.lastMsg = lastMsg;
+              stream2.lastObj = lastObj;
+              stream2.lastLogger = lastLogger;
             }
-            stream.write(data);
+            stream2.write(data);
             if (opts.dedupe) {
               recordedLevel = dest.level;
             }
@@ -6315,16 +6315,16 @@ var require_multistream = __commonJS({
         }
       }
       function emit(...args) {
-        for (const { stream } of this.streams) {
-          if (typeof stream.emit === "function") {
-            stream.emit(...args);
+        for (const { stream: stream2 } of this.streams) {
+          if (typeof stream2.emit === "function") {
+            stream2.emit(...args);
           }
         }
       }
       function flushSync() {
-        for (const { stream } of this.streams) {
-          if (typeof stream.flushSync === "function") {
-            stream.flushSync();
+        for (const { stream: stream2 } of this.streams) {
+          if (typeof stream2.flushSync === "function") {
+            stream2.flushSync();
           }
         }
       }
@@ -6370,11 +6370,11 @@ var require_multistream = __commonJS({
         return res;
       }
       function end() {
-        for (const { stream } of this.streams) {
-          if (typeof stream.flushSync === "function") {
-            stream.flushSync();
+        for (const { stream: stream2 } of this.streams) {
+          if (typeof stream2.flushSync === "function") {
+            stream2.flushSync();
           }
-          stream.end();
+          stream2.end();
         }
       }
       function clone(level2) {
@@ -6502,8 +6502,8 @@ var require_pino = __commonJS({
     var normalize = createArgsNormalizer(defaultOptions);
     var serializers = Object.assign(/* @__PURE__ */ Object.create(null), stdSerializers);
     function pino2(...args) {
-      const instance = {};
-      const { opts, stream } = normalize(instance, caller(), ...args);
+      const instance2 = {};
+      const { opts, stream: stream2 } = normalize(instance2, caller(), ...args);
       if (opts.level && typeof opts.level === "string" && DEFAULT_LEVELS[opts.level.toLowerCase()] !== void 0) opts.level = opts.level.toLowerCase();
       const {
         redact,
@@ -6566,16 +6566,16 @@ var require_pino = __commonJS({
       if (msgPrefix && typeof msgPrefix !== "string") throw Error(`Unknown msgPrefix type "${typeof msgPrefix}" - expected "string"`);
       assertDefaultLevelFound(level2, customLevels, useOnlyCustomLevels);
       const levels = mappings(customLevels, useOnlyCustomLevels);
-      if (typeof stream.emit === "function") {
-        stream.emit("message", { code: "PINO_CONFIG", config: { levels, messageKey, errorKey } });
+      if (typeof stream2.emit === "function") {
+        stream2.emit("message", { code: "PINO_CONFIG", config: { levels, messageKey, errorKey } });
       }
       assertLevelComparison(levelComparison);
       const levelCompFunc = genLevelComparison(levelComparison);
-      Object.assign(instance, {
+      Object.assign(instance2, {
         levels,
         [levelCompSym]: levelCompFunc,
         [useOnlyCustomLevelsSym]: useOnlyCustomLevels,
-        [streamSym]: stream,
+        [streamSym]: stream2,
         [timeSym]: time2,
         [timeSliceIndexSym]: timeSliceIndex,
         [stringifySym]: stringify,
@@ -6598,10 +6598,10 @@ var require_pino = __commonJS({
         onChild,
         [msgPrefixSym]: msgPrefix
       });
-      Object.setPrototypeOf(instance, proto());
-      genLsCache(instance);
-      instance[setLevelSym](level2);
-      return instance;
+      Object.setPrototypeOf(instance2, proto());
+      genLsCache(instance2);
+      instance2[setLevelSym](level2);
+      return instance2;
     }
     module.exports = pino2;
     module.exports.destination = (dest = process.stdout.fd) => {
@@ -6738,7 +6738,7 @@ import { EventEmitter } from "events";
 import fs from "fs";
 import { createWriteStream } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 
 // src/core/backends/naudiodon-backend.ts
 var UnsupportedError = class extends Error {
@@ -7389,12 +7389,43 @@ var HowlerBackend = class {
   }
 };
 
+// src/utils/logger.ts
+var import_pino = __toESM(require_pino(), 1);
+import { homedir } from "os";
+import { join as join4 } from "path";
+import { existsSync as existsSync4, mkdirSync } from "fs";
+var logDir = join4(homedir(), ".ocosay");
+var logFile = join4(logDir, "ocosay.log");
+if (!existsSync4(logDir)) {
+  try {
+    mkdirSync(logDir, { recursive: true });
+  } catch {
+  }
+}
+var streams = [
+  { stream: process.stdout }
+];
+try {
+  streams.push({ stream: import_pino.default.destination({ dest: logFile, mkdir: true }) });
+} catch {
+}
+var level = process.env.NODE_ENV !== "production" ? "debug" : process.env.OCOSAY_LOG_LEVEL || "info";
+var logger = (0, import_pino.default)(
+  {
+    level,
+    base: { service: "ocosay" },
+    timestamp: import_pino.default.stdTimeFunctions.isoTime
+  },
+  import_pino.default.multistream(streams)
+);
+
 // src/core/backends/index.ts
 function isNaudiodonAvailable() {
   try {
     __require.resolve("naudiodon");
     return true;
-  } catch (e) {
+  } catch (err) {
+    logger.debug({ err }, "naudiodon not available");
     return false;
   }
 }
@@ -7417,7 +7448,8 @@ function createBackend(type = "auto" /* AUTO */, options = {}) {
       if (naudiodon) {
         return new NaudiodonBackend(options);
       }
-    } catch (e) {
+    } catch (err) {
+      logger.warn({ err }, "failed to initialize naudiodon backend");
     }
   }
   switch (platform) {
@@ -7510,7 +7542,7 @@ var AudioPlayer = class extends EventEmitter {
     this._playing = true;
     this._paused = false;
     try {
-      const tempFile = join4(tmpdir4(), `ocosay-${Date.now()}.${format}`);
+      const tempFile = join5(tmpdir4(), `ocosay-${Date.now()}.${format}`);
       this.currentFile = tempFile;
       if (Buffer.isBuffer(audioData)) {
         fs.writeFileSync(tempFile, audioData);
@@ -7607,42 +7639,12 @@ var AudioPlayer = class extends EventEmitter {
   }
 };
 
-// src/utils/logger.ts
-var import_pino = __toESM(require_pino(), 1);
-import { homedir } from "os";
-import { join as join5 } from "path";
-import { existsSync as existsSync4, mkdirSync } from "fs";
-var logDir = join5(homedir(), ".ocosay");
-var logFile = join5(logDir, "ocosay.log");
-if (!existsSync4(logDir)) {
-  try {
-    mkdirSync(logDir, { recursive: true });
-  } catch {
-  }
-}
-var streams = [
-  { stream: process.stdout }
-];
-try {
-  streams.push({ stream: import_pino.default.destination({ dest: logFile, mkdir: true }) });
-} catch {
-}
-var level = process.env.NODE_ENV !== "production" ? "debug" : process.env.OCOSAY_LOG_LEVEL || "info";
-var logger = (0, import_pino.default)(
-  {
-    level,
-    base: { service: "ocosay" },
-    timestamp: import_pino.default.stdTimeFunctions.isoTime
-  },
-  import_pino.default.multistream(streams)
-);
-
 // src/core/speaker.ts
 function toast(options) {
-  const tui = global.__opencode_tui__;
-  if (tui?.showToast) {
+  const tui2 = global.__opencode_tui__;
+  if (tui2?.showToast) {
     try {
-      tui.showToast({
+      tui2.showToast({
         title: options.title,
         message: options.body,
         variant: options.type,
@@ -7733,6 +7735,7 @@ var Speaker = class extends EventEmitter2 {
       }
     } catch (error) {
       this.isSpeaking = false;
+      logger.error({ error }, "speak failed");
       const errorMessage = error instanceof Error ? error.message : "Unknown error";
       toast({
         title: "TTS playback error",
@@ -7809,50 +7812,512 @@ var Speaker = class extends EventEmitter2 {
     return provider.getCapabilities();
   }
   /**
-   * 获取所有已注册的 Provider
+   * 获取所有已注册的 Provider
+   */
+  getProviders() {
+    return listProviders();
+  }
+  /**
+   * 是否正在播放
+   */
+  isPlaying() {
+    return this.isSpeaking && !this.isPaused;
+  }
+  /**
+   * 是否暂停
+   */
+  isPausedState() {
+    return this.isPaused;
+  }
+};
+var defaultSpeaker;
+function getDefaultSpeaker() {
+  if (!defaultSpeaker) {
+    defaultSpeaker = new Speaker();
+  }
+  return defaultSpeaker;
+}
+async function speak(text, options) {
+  const speaker2 = getDefaultSpeaker();
+  return speaker2.speak(text, options);
+}
+async function stop() {
+  const speaker2 = getDefaultSpeaker();
+  return speaker2.stop();
+}
+function pause() {
+  const speaker2 = getDefaultSpeaker();
+  speaker2.pause();
+}
+function resume() {
+  const speaker2 = getDefaultSpeaker();
+  speaker2.resume();
+}
+async function listVoices(providerName) {
+  const speaker2 = getDefaultSpeaker();
+  return speaker2.listVoices(providerName);
+}
+
+// src/services/speaker-service.ts
+var SpeakerService = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.speaker = getDefaultSpeaker();
+  }
+  options;
+  speaker;
+  async speak(text, options) {
+    const timestamp = this.getTimestamp();
+    logger.info(`[Ocosay][${timestamp}][INFO][Speaker] \u5BF9\u5E94\u4E8B\u4EF6{\u64AD\u653E\u5F00\u59CB} - \u6587\u672C\u957F\u5EA6: ${text.length}`);
+    return this.speaker.speak(text, options);
+  }
+  pause() {
+    this.speaker.pause();
+  }
+  resume() {
+    this.speaker.resume();
+  }
+  async stop() {
+    return this.speaker.stop();
+  }
+  async listVoices(providerName) {
+    return this.speaker.listVoices(providerName);
+  }
+  getCapabilities(providerName) {
+    return this.speaker.getCapabilities(providerName);
+  }
+  getProviders() {
+    return this.speaker.getProviders();
+  }
+  isPlaying() {
+    return this.speaker.isPlaying();
+  }
+  isPausedState() {
+    return this.speaker.isPausedState();
+  }
+  async destroy() {
+    return this.speaker.destroy();
+  }
+  getTimestamp() {
+    const now = /* @__PURE__ */ new Date();
+    const pad = (n) => n.toString().padStart(2, "0");
+    return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())} ${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}`;
+  }
+};
+var defaultSpeakerService;
+function getDefaultSpeakerService() {
+  if (!defaultSpeakerService) {
+    defaultSpeakerService = new SpeakerService();
+  }
+  return defaultSpeakerService;
+}
+async function speak2(text, options) {
+  if (options) {
+    return speak(text, options);
+  }
+  return speak(text);
+}
+async function stop2() {
+  return stop();
+}
+function pause2() {
+  pause();
+}
+function resume2() {
+  resume();
+}
+async function listVoices2(providerName) {
+  return listVoices(providerName);
+}
+
+// src/services/streaming-service.ts
+import { EventEmitter as EventEmitter4 } from "events";
+
+// src/core/stream-player.ts
+import { EventEmitter as EventEmitter3 } from "events";
+var StreamPlayer = class extends EventEmitter3 {
+  backend = null;
+  _bytesWritten = 0;
+  _started = false;
+  _paused = false;
+  _stopped = false;
+  format = "mp3";
+  events;
+  constructor(options = {}) {
+    super();
+    this.format = options.format || "mp3";
+    this.events = options.events;
+    const backendType = options.backendType || "naudiodon" /* NAUDIODON */;
+    this.backend = createBackend(backendType, {
+      format: this.format,
+      events: {
+        onStart: () => {
+          this.events?.onStart?.();
+          this.emit("start");
+        },
+        onEnd: () => {
+          this.events?.onEnd?.();
+          this.emit("end");
+        },
+        onError: (error) => {
+          this.handleError(error);
+        },
+        onPause: () => {
+          this._paused = true;
+          this.events?.onPause?.();
+          this.emit("pause");
+        },
+        onResume: () => {
+          this._paused = false;
+          this.events?.onResume?.();
+          this.emit("resume");
+        },
+        onStop: () => {
+          this.events?.onStop?.();
+          this.emit("stop");
+        },
+        onProgress: (bytes) => {
+          this.events?.onProgress?.(bytes);
+          this.emit("progress", bytes);
+        }
+      }
+    });
+  }
+  /**
+   * 开始播放
+   * 初始化后端，准备接收音频数据
+   */
+  start() {
+    if (this._started) {
+      return;
+    }
+    if (!this.backend) {
+      this.handleError(new Error("Audio backend not initialized"));
+      return;
+    }
+    this.backend.start("");
+    this._started = true;
+    this._stopped = false;
+    this._paused = false;
+    this._bytesWritten = 0;
+  }
+  /**
+   * 写入音频数据块（边收边播）
+   * 如果尚未 start()，会自动调用
+   */
+  write(chunk) {
+    if (this._stopped) {
+      return;
+    }
+    if (!this._started) {
+      this.start();
+    }
+    if (this.backend) {
+      this.backend.write(chunk);
+      this._bytesWritten += chunk.length;
+      this.events?.onProgress?.(this._bytesWritten);
+      this.emit("progress", this._bytesWritten);
+    }
+  }
+  /**
+   * 结束写入
+   * 通知后端写入完成，但保持播放直到结束
+   */
+  end() {
+    if (this.backend) {
+      this.backend.end();
+    }
+  }
+  /**
+   * 停止播放
+   * 立即停止播放并释放资源
+   */
+  stop() {
+    this._stopped = true;
+    this._started = false;
+    this._paused = false;
+    if (this.backend) {
+      this.backend.stop();
+    }
+    this._bytesWritten = 0;
+    this.events?.onStop?.();
+    this.emit("stop");
+  }
+  /**
+   * 暂停播放
+   */
+  pause() {
+    if (!this._started || this._paused || this._stopped) {
+      return;
+    }
+    if (this.backend) {
+      this.backend.pause();
+    }
+  }
+  /**
+   * 恢复播放
+   */
+  resume() {
+    if (!this._paused || this._stopped) {
+      return;
+    }
+    if (this.backend) {
+      this.backend.resume();
+    }
+  }
+  /**
+   * 是否已启动
+   */
+  isStarted() {
+    return this._started;
+  }
+  /**
+   * 是否暂停
+   */
+  isPaused() {
+    return this._paused;
+  }
+  /**
+   * 是否已停止
+   */
+  isStopped() {
+    return this._stopped;
+  }
+  /**
+   * 获取已写入的字节数
+   */
+  getBytesWritten() {
+    return this._bytesWritten;
+  }
+  /**
+   * 处理错误
+   */
+  handleError(error) {
+    this.events?.onError?.(error);
+    this.emit("error", error);
+  }
+};
+
+// src/services/streaming-service.ts
+var StreamingService = class extends EventEmitter4 {
+  player = null;
+  providerName;
+  voice;
+  speed;
+  volume;
+  pitch;
+  backendType;
+  _isActive = false;
+  _bytesWritten = 0;
+  constructor(options = {}) {
+    super();
+    this.providerName = options.provider || "minimax";
+    this.voice = options.voice;
+    this.speed = options.speed;
+    this.volume = options.volume;
+    this.pitch = options.pitch;
+    this.backendType = options.backendType || "naudiodon" /* NAUDIODON */;
+  }
+  /**
+   * 获取时间戳
+   */
+  getTimestamp() {
+    const now = /* @__PURE__ */ new Date();
+    const pad = (n) => n.toString().padStart(2, "0");
+    return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())} ${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}`;
+  }
+  /**
+   * 初始化播放器
+   */
+  initPlayer() {
+    if (this.player) {
+      this.player.stop();
+      this.player = null;
+    }
+    const playerOptions = {
+      format: "mp3",
+      backendType: this.backendType,
+      events: {
+        onStart: () => {
+          const timestamp = this.getTimestamp();
+          logger.info(`[Ocosay][${timestamp}][INFO][Streaming] \u5BF9\u5E94\u4E8B\u4EF6{\u6D41\u5F0F\u64AD\u653E\u5F00\u59CB}`);
+          this.emit("start");
+        },
+        onEnd: () => {
+          const timestamp = this.getTimestamp();
+          logger.info(`[Ocosay][${timestamp}][INFO][Streaming] \u5BF9\u5E94\u4E8B\u4EF6{\u6D41\u5F0F\u64AD\u653E\u7ED3\u675F}`);
+          this._isActive = false;
+          this.emit("end");
+        },
+        onError: (error) => {
+          const timestamp = this.getTimestamp();
+          logger.error(`[Ocosay][${timestamp}][ERROR][Streaming] \u5BF9\u5E94\u4E8B\u4EF6{\u6D41\u5F0F\u64AD\u653E\u9519\u8BEF} - ${error.message}`);
+          this._isActive = false;
+          this.emit("error", error);
+        },
+        onProgress: (bytes) => {
+          this._bytesWritten = bytes;
+          this.emit("progress", bytes);
+        },
+        onPause: () => {
+          const timestamp = this.getTimestamp();
+          logger.info(`[Ocosay][${timestamp}][INFO][Streaming] \u5BF9\u5E94\u4E8B\u4EF6{\u6D41\u5F0F\u64AD\u653E\u6682\u505C}`);
+          this.emit("pause");
+        },
+        onResume: () => {
+          const timestamp = this.getTimestamp();
+          logger.info(`[Ocosay][${timestamp}][INFO][Streaming] \u5BF9\u5E94\u4E8B\u4EF6{\u6D41\u5F0F\u64AD\u653E\u6062\u590D}`);
+          this.emit("resume");
+        },
+        onStop: () => {
+          const timestamp = this.getTimestamp();
+          logger.info(`[Ocosay][${timestamp}][INFO][Streaming] \u5BF9\u5E94\u4E8B\u4EF6{\u6D41\u5F0F\u64AD\u653E\u505C\u6B62}`);
+          this._isActive = false;
+          this._bytesWritten = 0;
+          this.emit("stop");
+        }
+      }
+    };
+    this.player = new StreamPlayer(playerOptions);
+    return this.player;
+  }
+  /**
+   * 流式播放文本
+   * 边接收边播放（豆包模式）
+   */
+  async stream(text) {
+    if (!text || text.trim().length === 0) {
+      const timestamp2 = this.getTimestamp();
+      logger.warn(`[Ocosay][${timestamp2}][WARNING][Streaming] \u5BF9\u5E94\u4E8B\u4EF6{\u7A7A\u6587\u672C\u8DF3\u8FC7}`);
+      return;
+    }
+    const timestamp = this.getTimestamp();
+    logger.info(`[Ocosay][${timestamp}][INFO][Streaming] \u5BF9\u5E94\u4E8B\u4EF6{\u6D41\u5F0F\u64AD\u653E\u5F00\u59CB} - \u6587\u672C\u957F\u5EA6: ${text.length}`);
+    try {
+      const provider = getProvider(this.providerName);
+      if (!provider) {
+        throw new TTSError(
+          `Provider ${this.providerName} not found`,
+          "UNKNOWN" /* UNKNOWN */,
+          this.providerName
+        );
+      }
+      const player = this.initPlayer();
+      player.start();
+      this._isActive = true;
+      this._bytesWritten = 0;
+      const result = await provider.speak(text, {
+        voice: this.voice,
+        model: "stream",
+        speed: this.speed,
+        volume: this.volume,
+        pitch: this.pitch
+      });
+      await this.processAudioResult(result, player);
+    } catch (error) {
+      const ts = this.getTimestamp();
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      logger.error(`[Ocosay][${ts}][ERROR][Streaming] \u5BF9\u5E94\u4E8B\u4EF6{\u6D41\u5F0F\u64AD\u653E\u9519\u8BEF} - ${errorMsg}`);
+      this._isActive = false;
+      throw error;
+    }
+  }
+  /**
+   * 处理音频结果
+   */
+  async processAudioResult(result, player) {
+    if (result.isStream && result.audioData instanceof ReadableStream) {
+      await this.streamAudioChunks(result.audioData, player);
+    } else if (Buffer.isBuffer(result.audioData)) {
+      player.write(result.audioData);
+      player.end();
+    }
+  }
+  /**
+   * 流式处理音频chunk
+   */
+  async streamAudioChunks(stream2, player) {
+    const reader = stream2.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        if (value) {
+          const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
+          player.write(chunk);
+        }
+      }
+    } finally {
+      reader.releaseLock();
+      player.end();
+    }
+  }
+  /**
+   * 停止流式播放
+   */
+  stop() {
+    if (this.player) {
+      this.player.stop();
+    }
+    this._isActive = false;
+    this._bytesWritten = 0;
+  }
+  /**
+   * 暂停流式播放
+   */
+  pause() {
+    if (this.player) {
+      this.player.pause();
+    }
+  }
+  /**
+   * 恢复流式播放
+   */
+  resume() {
+    if (this.player) {
+      this.player.resume();
+    }
+  }
+  /**
+   * 获取流式播放状态
    */
-  getProviders() {
-    return listProviders();
+  getStatus() {
+    return {
+      isActive: this._isActive,
+      bytesWritten: this._bytesWritten,
+      state: this.player?.isStopped() ? "stopped" : this.player?.isPaused() ? "paused" : this._isActive ? "playing" : "idle"
+    };
   }
   /**
-   * 是否正在播放
+   * 是否处于活跃状态
    */
-  isPlaying() {
-    return this.isSpeaking && !this.isPaused;
+  isActive() {
+    return this._isActive;
   }
   /**
-   * 是否暂停
+   * 销毁服务
    */
-  isPausedState() {
-    return this.isPaused;
+  async destroy() {
+    if (this.player) {
+      this.player.stop();
+      this.player = null;
+    }
+    this._isActive = false;
+    this._bytesWritten = 0;
   }
 };
-var defaultSpeaker;
-function getDefaultSpeaker() {
-  if (!defaultSpeaker) {
-    defaultSpeaker = new Speaker();
+var defaultStreamingService;
+function getDefaultStreamingService() {
+  if (!defaultStreamingService) {
+    defaultStreamingService = new StreamingService();
   }
-  return defaultSpeaker;
-}
-async function speak(text, options) {
-  const speaker2 = getDefaultSpeaker();
-  return speaker2.speak(text, options);
-}
-async function stop() {
-  const speaker2 = getDefaultSpeaker();
-  return speaker2.stop();
-}
-function pause() {
-  const speaker2 = getDefaultSpeaker();
-  speaker2.pause();
-}
-function resume() {
-  const speaker2 = getDefaultSpeaker();
-  speaker2.resume();
+  return defaultStreamingService;
 }
-async function listVoices(providerName) {
-  const speaker2 = getDefaultSpeaker();
-  return speaker2.listVoices(providerName);
+async function stream(text, options) {
+  const service = options ? new StreamingService(options) : getDefaultStreamingService();
+  return service.stream(text);
 }
 
 // src/tools/tts.ts
@@ -7871,11 +8336,20 @@ function extractTextArg(args) {
       logger.warn("received text7 instead of text from OpenCode framework");
       return text7.trim();
     }
-    if (typeof text7 === "object" && "content" in text7) {
-      const content = text7.content;
-      if (typeof content === "string" && content.trim().length > 0) {
-        logger.warn("text7 is an object with content field");
-        return content.trim();
+    if (typeof text7 === "object") {
+      if ("split" in text7 && "content" in text7) {
+        const content = text7.content;
+        if (typeof content === "string" && content.trim().length > 0) {
+          logger.info("text7 split format detected");
+          return content.trim();
+        }
+      }
+      if ("content" in text7) {
+        const content = text7.content;
+        if (typeof content === "string" && content.trim().length > 0) {
+          logger.info("text7 content format detected");
+          return content.trim();
+        }
       }
     }
     logger.warn({ type: typeof text7 }, "text7 is not a valid string or object with content");
@@ -7902,29 +8376,29 @@ async function handleToolCall(toolName, args) {
         if (!text) {
           return { success: false, error: "No valid text found in args" };
         }
-        await speak(text);
+        await speak2(text);
         return { success: true, message: "Speech completed" };
       }
       case "tts_stop":
-        await stop();
+        await stop2();
         return { success: true, message: "Stopped" };
       case "tts_pause":
-        pause();
+        pause2();
         return { success: true, message: "Paused" };
       case "tts_resume":
-        resume();
+        resume2();
         return { success: true, message: "Resumed" };
       case "tts_list_voices": {
-        const voices = await listVoices(args?.provider);
+        const voices = await listVoices2(args?.provider);
         return { success: true, voices };
       }
       case "tts_list_providers": {
-        const speaker2 = getDefaultSpeaker();
+        const speaker2 = getDefaultSpeakerService();
         const providers2 = speaker2.getProviders();
         return { success: true, providers: providers2 };
       }
       case "tts_status": {
-        const s = getDefaultSpeaker();
+        const s = getDefaultSpeakerService();
         return {
           success: true,
           isPlaying: s.isPlaying(),
@@ -7946,14 +8420,14 @@ async function handleToolCall(toolName, args) {
             "tts_stream"
           );
         }
-        const streamReader2 = getStreamReader();
-        const synthesizer = getStreamingSynthesizer();
-        if (streamReader2 && synthesizer) {
-          streamReader2.start();
+        const streamingService = getDefaultStreamingService();
+        if (streamingService) {
           const textArg = extractTextArg(args);
           if (textArg && typeof textArg === "string" && textArg.trim().length > 0) {
             logger.info({ text: textArg.substring(0, 50) + "..." }, "synthesizing text");
-            synthesizer.synthesize(textArg);
+            stream(textArg).catch((error) => {
+              logger.error({ error }, "stream failed");
+            });
           }
           return { success: true, message: "Stream speak started" };
         }
@@ -7971,13 +8445,13 @@ async function handleToolCall(toolName, args) {
             "tts_stream"
           );
         }
-        const player = getStreamPlayer();
-        if (player) {
-          player.stop();
+        const streamingService = getDefaultStreamingService();
+        if (streamingService) {
+          streamingService.stop();
           return { success: true, message: "Stream stopped" };
         }
         throw new TTSError(
-          "Stream player not available",
+          "Stream service not available",
           "UNKNOWN" /* UNKNOWN */,
           "tts_stream"
         );
@@ -8105,34 +8579,39 @@ var MiniMaxProvider = class extends BaseTTSProvider {
         },
         responseType: "stream"
       });
-      const stream = response.data;
+      const stream2 = response.data;
       const audioChunks = [];
+      let lineBuffer = "";
       return new Promise((resolve, reject) => {
-        stream.on("data", (chunk) => {
-          try {
-            const lines = chunk.toString().split("\n");
-            for (const line of lines) {
-              if (line.startsWith("data:")) {
-                const data = JSON.parse(line.slice(5));
-                if (data.data?.audio) {
-                  audioChunks.push(Buffer.from(data.data.audio, "hex"));
-                }
-                if (data.data?.status === 2) {
-                  const fullAudio = Buffer.concat(audioChunks);
-                  resolve({
-                    audioData: fullAudio,
-                    format: this.audioFormat,
-                    isStream: true,
-                    duration: this.estimateDuration(fullAudio.length)
-                  });
-                }
+        stream2.on("data", (chunk) => {
+          lineBuffer += chunk.toString();
+          while (true) {
+            const lineEnd = lineBuffer.indexOf("\n");
+            if (lineEnd === -1) break;
+            const line = lineBuffer.slice(0, lineEnd).trim();
+            lineBuffer = lineBuffer.slice(lineEnd + 1);
+            if (!line || !line.startsWith("data:")) continue;
+            const jsonStr = line.slice(5).trim();
+            if (!jsonStr) continue;
+            try {
+              const data = JSON.parse(jsonStr);
+              if (data.audio) {
+                audioChunks.push(Buffer.from(data.audio, "hex"));
+              }
+              if (data.is_final === true) {
+                const fullAudio = Buffer.concat(audioChunks);
+                resolve({
+                  audioData: fullAudio,
+                  format: this.audioFormat,
+                  isStream: true,
+                  duration: this.estimateDuration(fullAudio.length)
+                });
               }
+            } catch (e) {
             }
-          } catch (e) {
-            audioChunks.push(chunk);
           }
         });
-        stream.on("error", (err) => {
+        stream2.on("error", (err) => {
           reject(new TTSError(
             "Stream error",
             "NETWORK" /* NETWORK */,
@@ -8140,7 +8619,19 @@ var MiniMaxProvider = class extends BaseTTSProvider {
             err
           ));
         });
-        stream.on("end", () => {
+        stream2.on("end", () => {
+          if (lineBuffer.trim() && lineBuffer.startsWith("data:")) {
+            const jsonStr = lineBuffer.slice(5).trim();
+            if (jsonStr) {
+              try {
+                const data = JSON.parse(jsonStr);
+                if (data.audio) {
+                  audioChunks.push(Buffer.from(data.audio, "hex"));
+                }
+              } catch (e) {
+              }
+            }
+          }
           if (audioChunks.length > 0) {
             const fullAudio = Buffer.concat(audioChunks);
             resolve({
@@ -8430,8 +8921,8 @@ var MINIMAX_VOICES = [
 ];
 
 // src/core/stream-reader.ts
-import { EventEmitter as EventEmitter3 } from "events";
-var StreamReader = class extends EventEmitter3 {
+import { EventEmitter as EventEmitter5 } from "events";
+var StreamReader = class extends EventEmitter5 {
   constructor(bufferSize = 30, bufferTimeout = 2e3) {
     super();
     this.bufferSize = bufferSize;
@@ -8595,8 +9086,8 @@ var StreamReader = class extends EventEmitter3 {
 };
 
 // src/core/streaming-synthesizer.ts
-import { EventEmitter as EventEmitter4 } from "events";
-var StreamingSynthesizer = class extends EventEmitter4 {
+import { EventEmitter as EventEmitter6 } from "events";
+var StreamingSynthesizer = class extends EventEmitter6 {
   constructor(options) {
     super();
     this.options = options;
@@ -8622,6 +9113,7 @@ var StreamingSynthesizer = class extends EventEmitter4 {
       await this.processAudioResult(result);
       this.emit("done");
     } catch (error) {
+      logger.error({ error }, "synthesize failed");
       const ttsError = error instanceof TTSError ? error : new TTSError(
         error instanceof Error ? error.message : "Synthesis failed",
         "UNKNOWN",
@@ -8644,8 +9136,8 @@ var StreamingSynthesizer = class extends EventEmitter4 {
   /**
    * 处理 ReadableStream，逐chunk emit
    */
-  async processReadableStream(stream) {
-    const reader = stream.getReader();
+  async processReadableStream(stream2) {
+    const reader = stream2.getReader();
     try {
       while (true) {
         const { done, value } = await reader.read();
@@ -8684,171 +9176,6 @@ var StreamingSynthesizer = class extends EventEmitter4 {
   }
 };
 
-// src/core/stream-player.ts
-import { EventEmitter as EventEmitter5 } from "events";
-var StreamPlayer = class extends EventEmitter5 {
-  backend = null;
-  _bytesWritten = 0;
-  _started = false;
-  _paused = false;
-  _stopped = false;
-  format = "mp3";
-  events;
-  constructor(options = {}) {
-    super();
-    this.format = options.format || "mp3";
-    this.events = options.events;
-    const backendType = options.backendType || "naudiodon" /* NAUDIODON */;
-    this.backend = createBackend(backendType, {
-      format: this.format,
-      events: {
-        onStart: () => {
-          this.events?.onStart?.();
-          this.emit("start");
-        },
-        onEnd: () => {
-          this.events?.onEnd?.();
-          this.emit("end");
-        },
-        onError: (error) => {
-          this.handleError(error);
-        },
-        onPause: () => {
-          this._paused = true;
-          this.events?.onPause?.();
-          this.emit("pause");
-        },
-        onResume: () => {
-          this._paused = false;
-          this.events?.onResume?.();
-          this.emit("resume");
-        },
-        onStop: () => {
-          this.events?.onStop?.();
-          this.emit("stop");
-        },
-        onProgress: (bytes) => {
-          this.events?.onProgress?.(bytes);
-          this.emit("progress", bytes);
-        }
-      }
-    });
-  }
-  /**
-   * 开始播放
-   * 初始化后端，准备接收音频数据
-   */
-  start() {
-    if (this._started) {
-      return;
-    }
-    if (!this.backend) {
-      this.handleError(new Error("Audio backend not initialized"));
-      return;
-    }
-    this.backend.start("");
-    this._started = true;
-    this._stopped = false;
-    this._paused = false;
-    this._bytesWritten = 0;
-  }
-  /**
-   * 写入音频数据块（边收边播）
-   * 如果尚未 start()，会自动调用
-   */
-  write(chunk) {
-    if (this._stopped) {
-      return;
-    }
-    if (!this._started) {
-      this.start();
-    }
-    if (this.backend) {
-      this.backend.write(chunk);
-      this._bytesWritten += chunk.length;
-      this.events?.onProgress?.(this._bytesWritten);
-      this.emit("progress", this._bytesWritten);
-    }
-  }
-  /**
-   * 结束写入
-   * 通知后端写入完成，但保持播放直到结束
-   */
-  end() {
-    if (this.backend) {
-      this.backend.end();
-    }
-  }
-  /**
-   * 停止播放
-   * 立即停止播放并释放资源
-   */
-  stop() {
-    this._stopped = true;
-    this._started = false;
-    this._paused = false;
-    if (this.backend) {
-      this.backend.stop();
-    }
-    this._bytesWritten = 0;
-    this.events?.onStop?.();
-    this.emit("stop");
-  }
-  /**
-   * 暂停播放
-   */
-  pause() {
-    if (!this._started || this._paused || this._stopped) {
-      return;
-    }
-    if (this.backend) {
-      this.backend.pause();
-    }
-  }
-  /**
-   * 恢复播放
-   */
-  resume() {
-    if (!this._paused || this._stopped) {
-      return;
-    }
-    if (this.backend) {
-      this.backend.resume();
-    }
-  }
-  /**
-   * 是否已启动
-   */
-  isStarted() {
-    return this._started;
-  }
-  /**
-   * 是否暂停
-   */
-  isPaused() {
-    return this._paused;
-  }
-  /**
-   * 是否已停止
-   */
-  isStopped() {
-    return this._stopped;
-  }
-  /**
-   * 获取已写入的字节数
-   */
-  getBytesWritten() {
-    return this._bytesWritten;
-  }
-  /**
-   * 处理错误
-   */
-  handleError(error) {
-    this.events?.onError?.(error);
-    this.emit("error", error);
-  }
-};
-
 // src/index.ts
 var speaker;
 var streamReader;
@@ -8982,15 +9309,6 @@ function getStreamStatus() {
     state: streamReader.getState()
   };
 }
-function getStreamReader() {
-  return streamReader;
-}
-function getStreamingSynthesizer() {
-  return streamingSynthesizer;
-}
-function getStreamPlayer() {
-  return streamPlayer;
-}
 
 // src/config.ts
 import * as fs2 from "fs";
@@ -9094,6 +9412,7 @@ function loadOrCreateConfig() {
     try {
       fs2.mkdirSync(configDir, { recursive: true });
     } catch (err) {
+      logger.error({ err }, "failed to create config directory");
       throw new Error(`[ocosay] \u65E0\u6CD5\u521B\u5EFA\u914D\u7F6E\u76EE\u5F55 ${configDir}: ${err}`);
     }
   }
@@ -9109,6 +9428,7 @@ function loadOrCreateConfig() {
         logger.warn({ err }, "failed to set config file permissions");
       }
     } catch (err) {
+      logger.error({ err }, "failed to write config file");
       throw new Error(`[ocosay] cannot write config file ${CONFIG_PATH}: ${err}`);
     }
     logger.info({ path: CONFIG_PATH }, "config file created");
@@ -9139,6 +9459,87 @@ function loadOrCreateConfig() {
   }
 }
 
+// src/services/notification-service.ts
+var instance;
+var tui = null;
+var initialized2 = false;
+var NotificationService = class _NotificationService {
+  constructor() {
+  }
+  static getInstance() {
+    if (!instance) {
+      instance = new _NotificationService();
+    }
+    return instance;
+  }
+  initialize(tuiInstance) {
+    if (initialized2) return;
+    tui = tuiInstance;
+    initialized2 = true;
+    logger.debug("NotificationService initialized");
+  }
+  isReady() {
+    return initialized2 && tui !== null;
+  }
+  showToast(message, type = "info") {
+    const title = this.getTitleForType(type);
+    if (tui?.showToast) {
+      try {
+        tui.showToast({
+          title,
+          message,
+          variant: type,
+          duration: type === "error" ? 8e3 : 5e3
+        });
+        return;
+      } catch (err) {
+        logger.warn({ err }, "tui.showToast failed");
+      }
+    }
+    this.fallbackLog(type, title, message);
+  }
+  success(message) {
+    this.showToast(message, "success");
+  }
+  error(message) {
+    this.showToast(message, "error");
+  }
+  warning(message) {
+    this.showToast(message, "warning");
+  }
+  info(message) {
+    this.showToast(message, "info");
+  }
+  getTitleForType(type) {
+    const titles = {
+      success: "Success",
+      error: "Error",
+      warning: "Warning",
+      info: "Info"
+    };
+    return titles[type];
+  }
+  fallbackLog(type, title, message) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    switch (type) {
+      case "error":
+        logger.error({ title, message, timestamp }, "Toast (fallback)");
+        break;
+      case "warning":
+        logger.warn({ title, message, timestamp }, "Toast (fallback)");
+        break;
+      default:
+        logger.info({ title, message, timestamp }, "Toast (fallback)");
+    }
+  }
+};
+function showToast(message, type = "info") {
+  NotificationService.getInstance().showToast(message, type);
+}
+function initializeNotificationService(tuiInstance) {
+  NotificationService.getInstance().initialize(tuiInstance);
+}
+
 // src/plugin.ts
 import { readFileSync as readFileSync2 } from "fs";
 import { fileURLToPath } from "url";
@@ -9286,24 +9687,12 @@ var server = (async (input, _options) => {
   }
   const opencodeTui = input.client?.tui;
   global.__opencode_tui__ = opencodeTui;
+  initializeNotificationService(opencodeTui);
   setTimeout(async () => {
-    if (!opencodeTui?.showToast) return;
     if (initError) {
-      await opencodeTui.showToast({
-        body: {
-          title: `Ocosay v${pluginVersion} Initialization Failed`,
-          message: "Initialization failed, please check config",
-          variant: "error"
-        }
-      });
+      showToast(`Ocosay v${pluginVersion} Initialization Failed: please check config`, "error");
     } else {
-      await opencodeTui.showToast({
-        body: {
-          title: `Ocosay v${pluginVersion} Plugin Loaded`,
-          message: `Auto-read: ${config.autoRead ? "ON" : "OFF"}`,
-          variant: "success"
-        }
-      });
+      showToast(`Ocosay v${pluginVersion} Plugin Loaded (Auto-read: ${config.autoRead ? "ON" : "OFF"})`, "success");
     }
   }, 7e3);
   return {
@@ -9338,15 +9727,7 @@ var server = (async (input, _options) => {
             });
             initError = null;
           } catch (err) {
-            if (opencodeTui?.showToast) {
-              await opencodeTui.showToast({
-                body: {
-                  title: `Ocosay v${pluginVersion} Initialization Failed`,
-                  message: "Initialization failed, please check config",
-                  variant: "error"
-                }
-              });
-            }
+            showToast(`Ocosay v${pluginVersion} Initialization Failed: please check config`, "error");
           }
         }
       }