@lmk1010/speech-streaming-aliyun 0.0.0-stage → 0.2.2-rc.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/lib/index.js

@@ -0,0 +1,289 @@
+import { execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import z from "@deepseek-ai/schemastery";
+import { Channel } from "@lmk1010/speech-streaming";
+//#region lib/types/index.js
+/**
+* Aliyun Model Studio (DashScope) realtime recognition. One WebSocket is opened ahead of use and reused for every
+* turn (`run-task` … `finish-task`), so a press only pays for the task start, not the TLS and WebSocket handshake.
+*/
+const name = "speech-streaming-aliyun";
+const inject = ["speechStreaming"];
+const Config = z.object({
+	providerId: z.string().min(1).default("aliyun-realtime"),
+	model: z.string().min(1).default("paraformer-realtime-v2"),
+	host: z.string().default(""),
+	apiKey: z.string().default(""),
+	idleCloseMs: z.natural().default(12e4),
+	startTimeoutMs: z.natural().min(1e3).default(8e3)
+});
+function keychain(service) {
+	if (process.platform !== "darwin") return Promise.resolve("");
+	return new Promise((resolve) => {
+		execFile("security", [
+			"find-generic-password",
+			"-a",
+			"dshub",
+			"-s",
+			service,
+			"-w"
+		], (error, stdout) => {
+			resolve(error ? "" : stdout.trim());
+		});
+	});
+}
+const SocketWithHeaders = WebSocket;
+/** Reused WebSocket with one task at a time. */
+var Connection = class {
+	config;
+	credentials;
+	socket;
+	opening;
+	idle;
+	handler;
+	constructor(config, credentials) {
+		this.config = config;
+		this.credentials = credentials;
+	}
+	async get() {
+		clearTimeout(this.idle);
+		if (this.socket?.readyState === WebSocket.OPEN) return this.socket;
+		this.opening ??= (async () => {
+			const { host, key } = await this.credentials();
+			if (key === "") throw new Error("Aliyun API key is not configured");
+			const socket = new SocketWithHeaders(`wss://${host}/api-ws/v1/inference`, { headers: { Authorization: `bearer ${key}` } });
+			socket.binaryType = "arraybuffer";
+			await new Promise((resolve, reject) => {
+				const timer = setTimeout(() => {
+					reject(/* @__PURE__ */ new Error("Aliyun connection timed out"));
+					socket.close();
+				}, this.config.startTimeoutMs);
+				socket.onopen = () => {
+					clearTimeout(timer);
+					resolve();
+				};
+				socket.onerror = () => {
+					clearTimeout(timer);
+					reject(/* @__PURE__ */ new Error("Aliyun connection failed"));
+				};
+			});
+			socket.onmessage = (event) => {
+				const text = typeof event.data === "string" ? event.data : Buffer.from(event.data).toString();
+				try {
+					this.handler?.(JSON.parse(text));
+				} catch (error) {
+					this.handler?.({ header: {
+						event: "task-failed",
+						error_message: String(error)
+					} });
+				}
+			};
+			socket.onclose = () => {
+				if (this.socket === socket) this.socket = void 0;
+				this.handler?.({ header: {
+					event: "task-failed",
+					error_message: "connection closed"
+				} });
+			};
+			this.socket = socket;
+			return socket;
+		})().finally(() => {
+			this.opening = void 0;
+		});
+		return await this.opening;
+	}
+	listen(handler) {
+		this.handler = handler;
+	}
+	release() {
+		clearTimeout(this.idle);
+		this.idle = setTimeout(() => {
+			this.close();
+		}, this.config.idleCloseMs);
+	}
+	close() {
+		clearTimeout(this.idle);
+		this.socket?.close();
+		this.socket = void 0;
+	}
+};
+var AliyunRealtime = class {
+	config;
+	info;
+	connection;
+	busy = Promise.resolve();
+	constructor(config) {
+		this.config = config;
+		this.info = {
+			id: config.providerId,
+			name: `Aliyun ${config.model}`,
+			location: "cloud",
+			languages: [
+				"auto",
+				"zh",
+				"en"
+			]
+		};
+		this.connection = new Connection(config, async () => {
+			return {
+				host: config.host || await keychain("dshub.aliyun.host") || "dashscope.aliyuncs.com",
+				key: config.apiKey || process.env.DASHSCOPE_API_KEY || await keychain("dshub.aliyun.dashscope")
+			};
+		});
+	}
+	warm() {
+		this.connection.get().then(() => {
+			this.connection.release();
+		}, () => {});
+	}
+	async open(_options, signal) {
+		const previous = this.busy;
+		let done;
+		this.busy = new Promise((resolve) => {
+			done = resolve;
+		});
+		await previous;
+		const events = new Channel();
+		const taskId = randomUUID().replaceAll("-", "");
+		const finals = [];
+		let segment = 0, ended = false;
+		const finish = (error) => {
+			if (ended) return;
+			ended = true;
+			this.connection.listen(void 0);
+			this.connection.release();
+			if (error) events.fail(error);
+			else {
+				events.push({
+					type: "end",
+					text: finals.join(""),
+					audioSeconds: 0
+				});
+				events.close();
+			}
+			done();
+		};
+		let socket;
+		try {
+			socket = await this.connection.get();
+		} catch (error) {
+			finish(error);
+			throw error;
+		}
+		const started = Promise.withResolvers();
+		const timer = setTimeout(() => {
+			started.reject(/* @__PURE__ */ new Error("Aliyun task did not start"));
+		}, this.config.startTimeoutMs);
+		this.connection.listen((message) => {
+			switch (message.header?.event) {
+				case "task-started":
+					clearTimeout(timer);
+					started.resolve();
+					break;
+				case "result-generated": {
+					const sentence = message.payload?.output?.sentence;
+					if (!sentence?.text) break;
+					if (sentence.sentence_end) {
+						finals.push(sentence.text);
+						events.push({
+							type: "final",
+							segment,
+							text: sentence.text
+						});
+						segment++;
+					} else events.push({
+						type: "partial",
+						segment,
+						text: sentence.text
+					});
+					break;
+				}
+				case "task-finished":
+					finish();
+					break;
+				case "task-failed":
+					clearTimeout(timer);
+					started.reject(new Error(message.header.error_message ?? "Aliyun task failed"));
+					finish(new Error(message.header.error_message ?? "Aliyun task failed"));
+					break;
+				default: break;
+			}
+		});
+		socket.send(JSON.stringify({
+			header: {
+				action: "run-task",
+				task_id: taskId,
+				streaming: "duplex"
+			},
+			payload: {
+				task_group: "audio",
+				task: "asr",
+				function: "recognition",
+				model: this.config.model,
+				parameters: {
+					format: "pcm",
+					sample_rate: 16e3
+				},
+				input: {}
+			}
+		}));
+		const bytes = (pcm) => Uint8Array.from(new Uint8Array(pcm.buffer, pcm.byteOffset, pcm.byteLength));
+		const pending = [];
+		let ready = false, finishing = false;
+		const sendFinish = () => {
+			socket.send(JSON.stringify({
+				header: {
+					action: "finish-task",
+					task_id: taskId,
+					streaming: "duplex"
+				},
+				payload: { input: {} }
+			}));
+		};
+		started.promise.then(() => {
+			ready = true;
+			for (const chunk of pending) socket.send(chunk);
+			pending.length = 0;
+			if (finishing) sendFinish();
+		}, (error) => {
+			finish(error);
+		});
+		signal.addEventListener("abort", () => {
+			if (!ended) {
+				if (ready) sendFinish();
+				finish(/* @__PURE__ */ new Error("cancelled"));
+			}
+		}, { once: true });
+		return {
+			write: (pcm) => {
+				if (ready) socket.send(bytes(pcm));
+				else pending.push(bytes(pcm));
+			},
+			finish: () => {
+				finishing = true;
+				if (ready) sendFinish();
+			},
+			events
+		};
+	}
+	dispose() {
+		this.connection.close();
+	}
+};
+/**
+* Register the Aliyun realtime provider.
+* @param ctx - streaming registry owner.
+* @param config - model, host and credentials.
+*/
+function apply(ctx, config) {
+	const provider = new AliyunRealtime(config);
+	ctx.effect(() => {
+		const unregister = ctx.speechStreaming.register(provider);
+		return async () => {
+			provider.dispose();
+			await unregister();
+		};
+	});
+}
+//#endregion
+export { AliyunRealtime, Config, apply, inject, name };

package/lib/types/index.d.ts

@@ -0,0 +1,41 @@
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import { type SpeechProviderId, type StreamingProvider, type StreamingSession, type StreamOptions } from '@lmk1010/speech-streaming';
+export declare const name = "speech-streaming-aliyun";
+export declare const inject: string[];
+export interface Config {
+    providerId: string;
+    /** Realtime model: `paraformer-realtime-v2` or `fun-asr-realtime`. */
+    model: string;
+    /** API host; empty reads the Keychain item `dshub.aliyun.host`, then falls back to `dashscope.aliyuncs.com`. */
+    host: string;
+    /** API key; empty reads `DASHSCOPE_API_KEY`, then the macOS Keychain item `dshub.aliyun.dashscope`. */
+    apiKey: string;
+    /** Close the idle connection after this long. */
+    idleCloseMs: number;
+    /** Deadline for the connection and the task start. */
+    startTimeoutMs: number;
+}
+export declare const Config: z<Partial<Config>, Config>;
+export declare class AliyunRealtime implements StreamingProvider {
+    private readonly config;
+    readonly info: {
+        id: SpeechProviderId;
+        name: string;
+        location: "cloud";
+        languages: string[];
+    };
+    private readonly connection;
+    private busy;
+    constructor(config: Config);
+    warm(): void;
+    open(_options: StreamOptions, signal: AbortSignal): Promise<StreamingSession>;
+    dispose(): void;
+}
+/**
+ * Register the Aliyun realtime provider.
+ * @param ctx - streaming registry owner.
+ * @param config - model, host and credentials.
+ */
+export declare function apply(ctx: Context, config: Config): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/index.js

@@ -0,0 +1,205 @@
+/**
+ * Aliyun Model Studio (DashScope) realtime recognition. One WebSocket is opened ahead of use and reused for every
+ * turn (`run-task` … `finish-task`), so a press only pays for the task start, not the TLS and WebSocket handshake.
+ */
+import { execFile } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import z from '@deepseek-ai/schemastery';
+import { Channel } from '@lmk1010/speech-streaming';
+export const name = 'speech-streaming-aliyun';
+export const inject = ['speechStreaming'];
+export const Config = z.object({
+    providerId: z.string().min(1).default('aliyun-realtime'),
+    model: z.string().min(1).default('paraformer-realtime-v2'),
+    host: z.string().default(''),
+    apiKey: z.string().default(''),
+    idleCloseMs: z.natural().default(120_000),
+    startTimeoutMs: z.natural().min(1000).default(8000),
+});
+function keychain(service) {
+    if (process.platform !== 'darwin')
+        return Promise.resolve('');
+    return new Promise((resolve) => {
+        execFile('security', ['find-generic-password', '-a', 'dshub', '-s', service, '-w'], (error, stdout) => { resolve(error ? '' : stdout.trim()); });
+    });
+}
+const SocketWithHeaders = WebSocket;
+/** Reused WebSocket with one task at a time. */
+class Connection {
+    config;
+    credentials;
+    socket;
+    opening;
+    idle;
+    handler;
+    constructor(config, credentials) {
+        this.config = config;
+        this.credentials = credentials;
+    }
+    async get() {
+        clearTimeout(this.idle);
+        if (this.socket?.readyState === WebSocket.OPEN)
+            return this.socket;
+        this.opening ??= (async () => {
+            const { host, key } = await this.credentials();
+            if (key === '')
+                throw new Error('Aliyun API key is not configured');
+            const socket = new SocketWithHeaders(`wss://${host}/api-ws/v1/inference`, { headers: { Authorization: `bearer ${key}` } });
+            socket.binaryType = 'arraybuffer';
+            await new Promise((resolve, reject) => {
+                const timer = setTimeout(() => { reject(new Error('Aliyun connection timed out')); socket.close(); }, this.config.startTimeoutMs);
+                socket.onopen = () => { clearTimeout(timer); resolve(); };
+                socket.onerror = () => { clearTimeout(timer); reject(new Error('Aliyun connection failed')); };
+            });
+            socket.onmessage = (event) => {
+                const text = typeof event.data === 'string' ? event.data : Buffer.from(event.data).toString();
+                try {
+                    this.handler?.(JSON.parse(text));
+                }
+                catch (error) {
+                    this.handler?.({ header: { event: 'task-failed', error_message: String(error) } });
+                }
+            };
+            socket.onclose = () => { if (this.socket === socket)
+                this.socket = undefined; this.handler?.({ header: { event: 'task-failed', error_message: 'connection closed' } }); };
+            this.socket = socket;
+            return socket;
+        })().finally(() => { this.opening = undefined; });
+        return await this.opening;
+    }
+    listen(handler) { this.handler = handler; }
+    release() {
+        clearTimeout(this.idle);
+        this.idle = setTimeout(() => { this.close(); }, this.config.idleCloseMs);
+    }
+    close() { clearTimeout(this.idle); this.socket?.close(); this.socket = undefined; }
+}
+export class AliyunRealtime {
+    config;
+    info;
+    connection;
+    busy = Promise.resolve();
+    constructor(config) {
+        this.config = config;
+        this.info = { id: config.providerId, name: `Aliyun ${config.model}`, location: 'cloud', languages: ['auto', 'zh', 'en'] };
+        this.connection = new Connection(config, async () => {
+            // Read on every new connection (a few milliseconds), so a key saved, replaced or deleted in settings applies at once.
+            return {
+                host: config.host || await keychain('dshub.aliyun.host') || 'dashscope.aliyuncs.com',
+                key: config.apiKey || process.env.DASHSCOPE_API_KEY || await keychain('dshub.aliyun.dashscope'),
+            };
+        });
+    }
+    warm() { void this.connection.get().then(() => { this.connection.release(); }, () => { }); }
+    async open(_options, signal) {
+        // One task at a time on the shared connection.
+        const previous = this.busy;
+        let done;
+        this.busy = new Promise((resolve) => { done = resolve; });
+        await previous;
+        const events = new Channel();
+        const taskId = randomUUID().replaceAll('-', '');
+        const finals = [];
+        let segment = 0, ended = false;
+        const finish = (error) => {
+            if (ended)
+                return;
+            ended = true;
+            this.connection.listen(undefined);
+            this.connection.release();
+            if (error)
+                events.fail(error);
+            else {
+                events.push({ type: 'end', text: finals.join(''), audioSeconds: 0 });
+                events.close();
+            }
+            done();
+        };
+        let socket;
+        try {
+            socket = await this.connection.get();
+        }
+        catch (error) {
+            finish(error);
+            throw error;
+        }
+        const started = Promise.withResolvers();
+        const timer = setTimeout(() => { started.reject(new Error('Aliyun task did not start')); }, this.config.startTimeoutMs);
+        this.connection.listen((message) => {
+            switch (message.header?.event) {
+                case 'task-started':
+                    clearTimeout(timer);
+                    started.resolve();
+                    break;
+                case 'result-generated': {
+                    const sentence = message.payload?.output?.sentence;
+                    if (!sentence?.text)
+                        break;
+                    if (sentence.sentence_end) {
+                        finals.push(sentence.text);
+                        events.push({ type: 'final', segment, text: sentence.text });
+                        segment++;
+                    }
+                    else
+                        events.push({ type: 'partial', segment, text: sentence.text });
+                    break;
+                }
+                case 'task-finished':
+                    finish();
+                    break;
+                case 'task-failed':
+                    clearTimeout(timer);
+                    started.reject(new Error(message.header.error_message ?? 'Aliyun task failed'));
+                    finish(new Error(message.header.error_message ?? 'Aliyun task failed'));
+                    break;
+                default: break;
+            }
+        });
+        socket.send(JSON.stringify({ header: { action: 'run-task', task_id: taskId, streaming: 'duplex' },
+            payload: { task_group: 'audio', task: 'asr', function: 'recognition', model: this.config.model,
+                parameters: { format: 'pcm', sample_rate: 16000 }, input: {} } }));
+        // WebSocket.send needs bytes backed by an ordinary ArrayBuffer.
+        const bytes = (pcm) => Uint8Array.from(new Uint8Array(pcm.buffer, pcm.byteOffset, pcm.byteLength));
+        const pending = [];
+        let ready = false, finishing = false;
+        const sendFinish = () => {
+            socket.send(JSON.stringify({ header: { action: 'finish-task', task_id: taskId, streaming: 'duplex' }, payload: { input: {} } }));
+        };
+        void started.promise.then(() => {
+            ready = true;
+            for (const chunk of pending)
+                socket.send(chunk);
+            pending.length = 0;
+            if (finishing)
+                sendFinish();
+        }, (error) => { finish(error); });
+        signal.addEventListener('abort', () => { if (!ended) {
+            if (ready)
+                sendFinish();
+            finish(new Error('cancelled'));
+        } }, { once: true });
+        return {
+            write: (pcm) => { if (ready)
+                socket.send(bytes(pcm));
+            else
+                pending.push(bytes(pcm)); },
+            finish: () => { finishing = true; if (ready)
+                sendFinish(); },
+            events,
+        };
+    }
+    dispose() { this.connection.close(); }
+}
+/**
+ * Register the Aliyun realtime provider.
+ * @param ctx - streaming registry owner.
+ * @param config - model, host and credentials.
+ */
+export function apply(ctx, config) {
+    const provider = new AliyunRealtime(config);
+    ctx.effect(() => {
+        const unregister = ctx.speechStreaming.register(provider);
+        return async () => { provider.dispose(); await unregister(); };
+    });
+}
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,42 @@
 {
   "name": "@lmk1010/speech-streaming-aliyun",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "description": "Aliyun Model Studio realtime speech recognition (Paraformer / Fun-ASR) over a reused WebSocket",
+  "version": "0.2.2-rc.1",
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/types/**/*.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@deepseek-ai/schemastery": "~3.19.0"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "~4.1.0",
+    "@lmk1010/speech-streaming": "0.2.2-rc.1"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "~4.1.0",
+    "@lmk1010/speech-streaming": "0.2.2-rc.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lmk1010/dsh-airpods-space.git",
+    "directory": "packages/airpods/speech-streaming-aliyun"
+  },
+  "homepage": "https://github.com/lmk1010/dsh-airpods-space#readme"
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.