@mingxy/ocosay 1.0.35 → 1.1.1

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;
@@ -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(instance, 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) {
             }
           }
@@ -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);
     };
@@ -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();
     }
   }
@@ -6287,25 +6287,25 @@ var require_multistream = __commonJS({
       function write(data) {
         let dest;
         const level2 = this.lastLevel;
-        const { streams: streams2 } = this;
+        const { streams } = this;
         let recordedLevel = 0;
-        let stream;
-        for (let i = initLoopVar(streams2.length, opts.dedupe); checkLoopVar(i, streams2.length, opts.dedupe); i = adjustLoopVar(i, opts.dedupe)) {
-          dest = streams2[i];
+        let stream2;
+        for (let i = initLoopVar(streams.length, opts.dedupe); checkLoopVar(i, streams.length, opts.dedupe); i = adjustLoopVar(i, opts.dedupe)) {
+          dest = streams[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();
           }
         }
       }
@@ -6337,7 +6337,7 @@ var require_multistream = __commonJS({
         if (!isStream) {
           throw Error("stream object needs to implement either StreamEntry or DestinationStream interface");
         }
-        const { streams: streams2, streamLevels: streamLevels2 } = this;
+        const { streams, streamLevels: streamLevels2 } = this;
         let level2;
         if (typeof dest.levelVal === "number") {
           level2 = dest.levelVal;
@@ -6354,33 +6354,33 @@ var require_multistream = __commonJS({
           levelVal: void 0,
           id: ++res.lastId
         };
-        streams2.unshift(dest_);
-        streams2.sort(compareByLevel);
-        this.minLevel = streams2[0].level;
+        streams.unshift(dest_);
+        streams.sort(compareByLevel);
+        this.minLevel = streams[0].level;
         return res;
       }
       function remove(id2) {
-        const { streams: streams2 } = this;
-        const index = streams2.findIndex((s) => s.id === id2);
+        const { streams } = this;
+        const index = streams.findIndex((s) => s.id === id2);
         if (index >= 0) {
-          streams2.splice(index, 1);
-          streams2.sort(compareByLevel);
-          this.minLevel = streams2.length > 0 ? streams2[0].level : -1;
+          streams.splice(index, 1);
+          streams.sort(compareByLevel);
+          this.minLevel = streams.length > 0 ? streams[0].level : -1;
         }
         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) {
-        const streams2 = new Array(this.streams.length);
-        for (let i = 0; i < streams2.length; i++) {
-          streams2[i] = {
+        const streams = new Array(this.streams.length);
+        for (let i = 0; i < streams.length; i++) {
+          streams[i] = {
             level: level2,
             stream: this.streams[i].stream
           };
@@ -6390,7 +6390,7 @@ var require_multistream = __commonJS({
           add,
           remove,
           minLevel: level2,
-          streams: streams2,
+          streams,
           clone,
           emit,
           flushSync,
@@ -6503,7 +6503,7 @@ var require_pino = __commonJS({
     var serializers = Object.assign(/* @__PURE__ */ Object.create(null), stdSerializers);
     function pino2(...args) {
       const instance = {};
-      const { opts, stream } = normalize(instance, caller(), ...args);
+      const { opts, stream: stream2 } = normalize(instance, caller(), ...args);
       if (opts.level && typeof opts.level === "string" && DEFAULT_LEVELS[opts.level.toLowerCase()] !== void 0) opts.level = opts.level.toLowerCase();
       const {
         redact,
@@ -6566,8 +6566,8 @@ 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);
@@ -6575,7 +6575,7 @@ var require_pino = __commonJS({
         levels,
         [levelCompSym]: levelCompFunc,
         [useOnlyCustomLevelsSym]: useOnlyCustomLevels,
-        [streamSym]: stream,
+        [streamSym]: stream2,
         [timeSym]: time2,
         [timeSliceIndexSym]: timeSliceIndex,
         [stringifySym]: stringify,
@@ -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,74 @@ var HowlerBackend = class {
   }
 };
 
+// src/utils/logger.ts
+var import_pino = __toESM(require_pino(), 1);
+import { Transform } from "stream";
+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 level = process.env.NODE_ENV !== "production" ? "debug" : process.env.OCOSAY_LOG_LEVEL || "info";
+var formatLog = (log) => {
+  const time = log.time ? new Date(log.time).toISOString().replace("T", " ").replace("Z", "") : "";
+  const levelStr = log.level === 30 ? "INFO" : log.level === 40 ? "WARNING" : log.level === 50 ? "ERROR" : "DEBUG";
+  const module = log.module || "App";
+  const msg = log.msg || "";
+  return `[Ocosay][${time}][${levelStr}][${module}] \u5BF9\u5E94\u4E8B\u4EF6{${msg}}
+`;
+};
+var createFormatStream = () => new Transform({
+  transform(chunk, _encoding, callback) {
+    try {
+      const log = JSON.parse(chunk.toString());
+      this.push(formatLog(log));
+    } catch {
+      this.push(chunk);
+    }
+    callback();
+  }
+});
+var stdoutStream = createFormatStream();
+stdoutStream.pipe(process.stdout);
+var fileStream = null;
+try {
+  const fileDest = import_pino.default.destination({ dest: logFile, mkdir: true });
+  fileStream = createFormatStream();
+  fileStream.pipe(fileDest);
+} catch {
+}
+var logger = (0, import_pino.default)(
+  {
+    level,
+    base: { service: "ocosay" },
+    timestamp: import_pino.default.stdTimeFunctions.isoTime,
+    formatters: {
+      level: (label) => ({ level: label })
+    }
+  },
+  import_pino.default.multistream([
+    { stream: stdoutStream },
+    ...fileStream ? [{ stream: fileStream }] : []
+  ])
+);
+function createModuleLogger(module) {
+  return logger.child({ module });
+}
+
 // 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 +7479,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 +7573,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,52 +7670,81 @@ 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) {
+// src/core/notification.ts
+var logger2 = createModuleLogger("NotificationService");
+var NotificationService = class {
+  tui = null;
+  pendingToasts = [];
+  retryTimer;
+  setTui(tui) {
+    this.tui = tui;
+    logger2.debug("tui reference set");
+    this.flushPending();
+  }
+  showToast(options) {
+    const { title, message, variant = "info", duration = 5e3 } = options;
+    if (!this.tui) {
+      logger2.debug({ title }, "tui not ready, queueing toast");
+      this.pendingToasts.push(options);
+      this.scheduleRetry();
+      return false;
+    }
     try {
-      tui.showToast({
-        title: options.title,
-        message: options.body,
-        variant: options.type,
-        duration: 3e3
+      this.tui.showToast({
+        body: {
+          title,
+          message,
+          variant,
+          duration
+        }
       });
+      logger2.debug({ title, variant }, "toast shown");
+      return true;
     } catch (err) {
-      logger.warn({ err }, "toast call failed");
+      logger2.warn({ err, title }, "toast call failed, queueing for retry");
+      this.pendingToasts.push(options);
+      this.scheduleRetry();
+      return false;
     }
   }
-}
+  scheduleRetry() {
+    if (this.retryTimer) return;
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = void 0;
+      this.flushPending();
+    }, 2e3);
+  }
+  flushPending() {
+    if (this.pendingToasts.length === 0 || !this.tui) return;
+    logger2.info({ count: this.pendingToasts.length }, "flushing pending toasts");
+    const pending = [...this.pendingToasts];
+    this.pendingToasts = [];
+    for (const toast of pending) {
+      try {
+        this.showToast(toast);
+      } catch (err) {
+        this.pendingToasts.push(toast);
+        logger2.warn({ err }, "showToast threw unexpected error, re-queued");
+      }
+    }
+  }
+  success(title, message, duration) {
+    return this.showToast({ title, message, variant: "success", duration });
+  }
+  error(title, message, duration) {
+    return this.showToast({ title, message, variant: "error", duration });
+  }
+  info(title, message, duration) {
+    return this.showToast({ title, message, variant: "info", duration });
+  }
+  warning(title, message, duration) {
+    return this.showToast({ title, message, variant: "warning", duration });
+  }
+};
+var notificationService = new NotificationService();
+
+// src/core/speaker.ts
+var logger3 = createModuleLogger("Speaker");
 var Speaker = class extends EventEmitter2 {
   constructor(options = {}) {
     super();
@@ -7662,11 +7754,10 @@ var Speaker = class extends EventEmitter2 {
       onEnd: () => {
         this.isSpeaking = false;
         this.emit("end", this.currentText);
-        toast({
-          title: "TTS playback success",
-          body: "Audio generated and playing",
-          type: "info"
-        });
+        notificationService.info(
+          "TTS playback success",
+          "Audio generated and playing"
+        );
       },
       onError: (error) => this.emit("error", error),
       onPause: () => {
@@ -7729,16 +7820,16 @@ var Speaker = class extends EventEmitter2 {
       });
       if (this.player) {
         await this.player.play(result.audioData, result.format);
-        logger.info({ textLength: text.length, model: options.model }, "TTS playback completed");
+        logger3.info({ textLength: text.length, model: options.model }, "TTS playback completed");
       }
     } catch (error) {
       this.isSpeaking = false;
+      logger3.error({ error }, "speak failed");
       const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      toast({
-        title: "TTS playback error",
-        body: errorMessage,
-        type: "error"
-      });
+      notificationService.error(
+        "TTS playback error",
+        errorMessage
+      );
       if (error instanceof TTSError) {
         this.emit("error", error);
         throw error;
@@ -7801,61 +7892,524 @@ var Speaker = class extends EventEmitter2 {
     return provider.listVoices();
   }
   /**
-   * 获取 Provider 能力
+   * 获取 Provider 能力
+   */
+  getCapabilities(providerName) {
+    const name = providerName || this.options.defaultProvider || "minimax";
+    const provider = getProvider(name);
+    return provider.getCapabilities();
+  }
+  /**
+   * 获取所有已注册的 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();
+    }
+  }
+  /**
+   * 恢复流式播放
    */
-  getCapabilities(providerName) {
-    const name = providerName || this.options.defaultProvider || "minimax";
-    const provider = getProvider(name);
-    return provider.getCapabilities();
+  resume() {
+    if (this.player) {
+      this.player.resume();
+    }
   }
   /**
-   * 获取所有已注册的 Provider
+   * 获取流式播放状态
    */
-  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();
+  return defaultStreamingService;
 }
-function resume() {
-  const speaker2 = getDefaultSpeaker();
-  speaker2.resume();
-}
-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
+var logger4 = createModuleLogger("TTS");
 function extractTextArg(args) {
   if (!args || typeof args !== "object") {
     return void 0;
@@ -7868,17 +8422,26 @@ function extractTextArg(args) {
   const text7 = argObj.text7;
   if (text7 != null) {
     if (typeof text7 === "string" && text7.trim().length > 0) {
-      logger.warn("received text7 instead of text from OpenCode framework");
+      logger4.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) {
+          logger4.info("text7 split format detected");
+          return content.trim();
+        }
+      }
+      if ("content" in text7) {
+        const content = text7.content;
+        if (typeof content === "string" && content.trim().length > 0) {
+          logger4.info("text7 content format detected");
+          return content.trim();
+        }
       }
     }
-    logger.warn({ type: typeof text7 }, "text7 is not a valid string or object with content");
+    logger4.warn({ type: typeof text7 }, "text7 is not a valid string or object with content");
     return void 0;
   }
   for (const key of Object.keys(argObj)) {
@@ -7890,7 +8453,7 @@ function extractTextArg(args) {
     }
   }
   if (text !== void 0) {
-    logger.warn({ type: typeof text }, "text arg is not a valid string");
+    logger4.warn({ type: typeof text }, "text arg is not a valid string");
   }
   return void 0;
 }
@@ -7902,29 +8465,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 +8509,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);
+            logger4.info({ text: textArg.substring(0, 50) + "..." }, "synthesizing text");
+            stream(textArg).catch((error) => {
+              logger4.error({ error }, "stream failed");
+            });
           }
           return { success: true, message: "Stream speak started" };
         }
@@ -7971,13 +8534,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 +8668,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 +8708,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 +9010,9 @@ 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 logger5 = createModuleLogger("StreamReader");
+var StreamReader = class extends EventEmitter5 {
   constructor(bufferSize = 30, bufferTimeout = 2e3) {
     super();
     this.bufferSize = bufferSize;
@@ -8457,7 +9038,7 @@ var StreamReader = class extends EventEmitter3 {
   }
   handleDelta(sessionID, messageID, partID, delta) {
     if (typeof delta !== "string") {
-      logger.warn({ delta }, "handleDelta received non-string delta, skipping");
+      logger5.warn({ delta }, "handleDelta received non-string delta, skipping");
       return;
     }
     if (this.state === "idle" /* IDLE */) {
@@ -8466,11 +9047,11 @@ var StreamReader = class extends EventEmitter3 {
       this.messageID = messageID;
       this.partID = partID;
       this.emit("streamStart");
-      logger.debug({ sessionID, messageID, partID }, "Stream started");
+      logger5.debug({ sessionID, messageID, partID }, "Stream started");
     }
     this.buffer += delta;
     this.resetTimeout();
-    logger.debug({ deltaLength: delta.length, bufferLength: this.buffer.length }, "Delta received");
+    logger5.debug({ deltaLength: delta.length, bufferLength: this.buffer.length }, "Delta received");
     if (this.shouldFlush()) {
       this.flushBuffer();
     }
@@ -8595,8 +9176,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 +9203,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 +9226,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 +9266,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,20 +9399,12 @@ 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";
 import * as path from "path";
 import * as os from "os";
+var logger6 = createModuleLogger("Config");
 var DEFAULT_CONFIG = {
   enabled: true,
   autoPlay: false,
@@ -9094,11 +9503,12 @@ function loadOrCreateConfig() {
     try {
       fs2.mkdirSync(configDir, { recursive: true });
     } catch (err) {
+      logger6.error({ err }, "failed to create config directory");
       throw new Error(`[ocosay] \u65E0\u6CD5\u521B\u5EFA\u914D\u7F6E\u76EE\u5F55 ${configDir}: ${err}`);
     }
   }
   if (!fs2.existsSync(CONFIG_PATH)) {
-    logger.info("config file not found, creating default config");
+    logger6.info("config file not found, creating default config");
     const defaultConfig = generateDefaultConfig();
     const configContent = JSON.stringify(defaultConfig, null, 2);
     try {
@@ -9106,13 +9516,14 @@ function loadOrCreateConfig() {
       try {
         fs2.chmodSync(CONFIG_PATH, 384);
       } catch (err) {
-        logger.warn({ err }, "failed to set config file permissions");
+        logger6.warn({ err }, "failed to set config file permissions");
       }
     } catch (err) {
+      logger6.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");
-    logger.info("please edit config file to add API Key and Base URL");
+    logger6.info({ path: CONFIG_PATH }, "config file created");
+    logger6.info("please edit config file to add API Key and Base URL");
     return defaultConfig;
   }
   try {
@@ -9134,7 +9545,7 @@ function loadOrCreateConfig() {
       }
     };
   } catch (error) {
-    logger.error({ error }, "config file read failed, using default config");
+    logger6.error({ error }, "config file read failed, using default config");
     return generateDefaultConfig();
   }
 }
@@ -9143,6 +9554,7 @@ function loadOrCreateConfig() {
 import { readFileSync as readFileSync2 } from "fs";
 import { fileURLToPath } from "url";
 import { dirname as dirname2, join as join7 } from "path";
+var logger7 = createModuleLogger("Plugin");
 var __filename = fileURLToPath(import.meta.url);
 var __dirname2 = dirname2(__filename);
 var id = "ocosay";
@@ -9282,30 +9694,26 @@ var server = (async (input, _options) => {
     });
   } catch (err) {
     initError = err instanceof Error ? err : new Error(String(err));
-    logger.error({ error: initError }, "initialization failed");
+    logger7.error({ error: initError }, "initialization failed");
   }
   const opencodeTui = input.client?.tui;
   global.__opencode_tui__ = opencodeTui;
-  setTimeout(async () => {
-    if (!opencodeTui?.showToast) return;
+  notificationService.setTui(opencodeTui);
+  setTimeout(() => {
     if (initError) {
-      await opencodeTui.showToast({
-        body: {
-          title: `Ocosay v${pluginVersion} Initialization Failed`,
-          message: "Initialization failed, please check config",
-          variant: "error"
-        }
-      });
+      notificationService.error(
+        `Ocosay v${pluginVersion} Init Failed`,
+        "Please check your config file",
+        8e3
+      );
     } else {
-      await opencodeTui.showToast({
-        body: {
-          title: `Ocosay v${pluginVersion} Plugin Loaded`,
-          message: `Auto-read: ${config.autoRead ? "ON" : "OFF"}`,
-          variant: "success"
-        }
-      });
+      notificationService.success(
+        `Ocosay v${pluginVersion} Ready`,
+        `Auto-read: ${config.autoRead ? "ON" : "OFF"}`,
+        5e3
+      );
     }
-  }, 7e3);
+  }, 1500);
   return {
     tool: {
       tts_speak: ttsSpeakTool,
@@ -9338,15 +9746,11 @@ 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"
-                }
-              });
-            }
+            notificationService.error(
+              `Ocosay v${pluginVersion} Init Failed`,
+              "Initialization failed, please check config",
+              8e3
+            );
           }
         }
       }