speechflow 2.3.0 → 2.4.0

package/speechflow-cli/src/speechflow-util-llm.ts

@@ -7,6 +7,9 @@
 /*  standard dependencies  */
 import EventEmitter                  from "node:events"
 
+/*  internal dependencies  */
+import * as util                     from "./speechflow-util-misc"
+
 /*  external dependencies  */
 import OpenAI                        from "openai"
 import Anthropic                     from "@anthropic-ai/sdk"
@@ -28,6 +31,7 @@ export type LLMConfig = {
     temperature?:   number
     maxTokens?:     number
     cacheDir?:      string
+    thinking?:      boolean
 }
 export type LLMCompleteOptions = {
     system?:        string
@@ -61,6 +65,7 @@ export class LLM extends EventEmitter {
             temperature:   0.7,
             maxTokens:     1024,
             cacheDir:      "",
+            thinking:      false,
             ...config
         } as Required<LLMConfig>
 
@@ -252,7 +257,8 @@ export class LLM extends EventEmitter {
                 max_tokens:  this.config.maxTokens,
                 temperature: this.config.temperature,
                 system:      systemMessage?.content,
-                messages:    chatMessages as Anthropic.MessageParam[]
+                messages:    chatMessages as Anthropic.MessageParam[],
+                ...(!this.config.thinking ? { thinking: { type: "disabled" } } : {})
             }).catch((err) => {
                 throw new Error(`failed to perform Anthropic chat completion: ${err}`, { cause: err })
             })
@@ -281,7 +287,8 @@ export class LLM extends EventEmitter {
                 config: {
                     maxOutputTokens: this.config.maxTokens,
                     temperature:     this.config.temperature,
-                    ...(systemInstruction ? { systemInstruction } : {})
+                    ...(systemInstruction ? { systemInstruction } : {}),
+                    ...(!this.config.thinking ? { thinkingConfig: { thinkingBudget: 0 } } : {})
                 }
             }).catch((err) => {
                 throw new Error(`failed to perform Google chat completion: ${err}`, { cause: err })
@@ -300,6 +307,7 @@ export class LLM extends EventEmitter {
                 model:      this.config.model,
                 messages,
                 keep_alive: "10m",
+                think:      this.config.thinking,
                 options: {
                     num_predict: this.config.maxTokens,
                     temperature: this.config.temperature
@@ -353,8 +361,16 @@ export class LLM extends EventEmitter {
             this.ollama?.abort()
             this.ollama = null
         }
-        else if (this.config.provider === "transformers") {
-            this.transformer?.dispose()
+        else if (this.config.provider === "transformers" && this.transformer !== null) {
+            const ac = new AbortController()
+            await Promise.race([
+                this.transformer.dispose(),
+                util.timeout(5000, "transformer dispose timeout", ac.signal)
+            ]).finally(() => {
+                ac.abort()
+            }).catch((error) => {
+                this.log("warning", `error during transformer cleanup: ${error}`)
+            })
             this.transformer = null
         }
         this.initialized = false

package/speechflow-cli/src/speechflow-util-misc.ts

@@ -46,35 +46,52 @@ export const deepClone = (value: any): any => {
 }
 
 /*  sleep: wait a duration of time and then resolve  */
-export function sleep (durationMs: number, signal?: AbortSignal) {
+export function sleep (durationMs: number, signal?: AbortSignal): Promise<void> {
     return new Promise<void>((resolve) => {
-        const ac = new AbortController()
-        const timer = setTimeout(() => {
-            ac.abort()
+        const ac: AbortController | undefined =
+            signal !== undefined ? new AbortController() : undefined
+        let timer: ReturnType<typeof setTimeout> | null = setTimeout(() => {
+            timer = null
+            if (signal !== undefined)
+                ac!.abort()
             resolve()
         }, durationMs)
         timer.unref()
-        if (signal !== undefined)
-            signal.addEventListener("abort", () => {
-                clearTimeout(timer)
+        if (signal !== undefined) {
+            if (signal.aborted)
                 resolve()
-            }, { once: true, signal: ac.signal })
+            else
+                signal.addEventListener("abort", () => {
+                    if (timer !== null)
+                        clearTimeout(timer)
+                    resolve()
+                }, { once: true, signal: ac!.signal })
+        }
     })
 }
 
 /*  timeout: wait a duration of time and then reject  */
-export function timeout (durationMs: number, info = "timeout", signal?: AbortSignal) {
+export function timeout (durationMs: number, info = "timeout", signal?: AbortSignal): Promise<never> {
     return new Promise<never>((resolve, reject) => {
-        const ac = new AbortController()
-        const timer = setTimeout(() => {
-            ac.abort()
+        const ac: AbortController | undefined =
+            signal !== undefined ? new AbortController() : undefined
+        let timer: ReturnType<typeof setTimeout> | null = setTimeout(() => {
+            timer = null
+            if (signal !== undefined)
+                ac!.abort()
             reject(new Error(info))
         }, durationMs)
         timer.unref()
-        if (signal !== undefined)
-            signal.addEventListener("abort", () => {
-                clearTimeout(timer)
+        if (signal !== undefined) {
+            if (signal.aborted)
                 resolve(undefined as never)
-            }, { once: true, signal: ac.signal })
+            else
+                signal.addEventListener("abort", () => {
+                    if (timer !== null)
+                        clearTimeout(timer)
+                    resolve(undefined as never)
+                }, { once: true, signal: ac!.signal })
+        }
     })
 }
+

package/speechflow-cli/src/speechflow-util-queue.ts

@@ -48,6 +48,15 @@ export class QueuePointer<T extends QueueElement> extends EventEmitter {
     silent (silence: boolean) {
         this.silence = silence
     }
+    silently<R> (fn: () => R): R {
+        this.silence = true
+        try {
+            return fn()
+        }
+        finally {
+            this.silence = false
+        }
+    }
 
     /*  notify about operation  */
     notify (event: string, info: any) {
@@ -171,12 +180,14 @@ export class QueuePointer<T extends QueueElement> extends EventEmitter {
     }
     insert (element: T) {
         this.queue.elements.splice(this.index, 0, element)
+        this.queue.adjustPointers(this, this.index, "insert")
         this.queue.notify("write", { start: this.index, end: this.index, op: "insert" })
     }
     delete () {
         if (this.index >= this.queue.elements.length)
             throw new Error("cannot delete after last element")
         this.queue.elements.splice(this.index, 1)
+        this.queue.adjustPointers(this, this.index, "delete")
         this.queue.notify("write", { start: this.index, end: this.index, op: "delete" })
     }
 }
@@ -193,6 +204,15 @@ export class Queue<T extends QueueElement> extends EventEmitter {
     silent (silence: boolean) {
         this.silence = silence
     }
+    silently<R> (fn: () => R): R {
+        this.silence = true
+        try {
+            return fn()
+        }
+        finally {
+            this.silence = false
+        }
+    }
     notify (event: string, info: any) {
         if (!this.silence)
             this.emit(event, info)
@@ -207,6 +227,24 @@ export class Queue<T extends QueueElement> extends EventEmitter {
             throw new Error("pointer does not exist")
         this.pointers.delete(name)
     }
+
+    /*  adjust all sibling pointer positions (after insert/delete splice)
+        NOTICE: for insert, pointers AT the index are shifted forward to preserve
+        their pointer-to-element binding; for delete, pointers AT the index are
+        intentionally NOT adjusted, causing them to silently advance to the next
+        element (which shifted into the deleted position).  */
+    adjustPointers (exclude: QueuePointer<T>, index: number, op: "insert" | "delete"): void {
+        for (const pointer of this.pointers.values()) {
+            if (pointer === exclude)
+                continue
+            const pos = pointer.position()
+            if (op === "insert" && pos >= index)
+                pointer.position(pos + 1)
+            else if (op === "delete" && pos > index)
+                pointer.position(pos - 1)
+        }
+    }
+
     trim (): void {
         /*  determine minimum pointer position  */
         let min = this.elements.length
@@ -227,6 +265,11 @@ export class Queue<T extends QueueElement> extends EventEmitter {
             this.notify("write", { start: 0, end: min, op: "trim" })
         }
     }
+    clear (): void {
+        this.elements.length = 0
+        for (const pointer of this.pointers.values())
+            pointer.position(0)
+    }
 }
 
 /*  meta store  */

package/speechflow-cli/src/speechflow.ts

@@ -7,5 +7,6 @@
 
 /*  pass-through control to the main module  */
 import Main from "./speechflow-main"
+
 Main.main()