@fonoster/community 0.0.0-stage → 0.30.0

package/dist/fake/index.js

@@ -0,0 +1,180 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FakeSttAdapter = exports.FakeTtsAdapter = void 0;
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const events_1 = require("events");
+const url_1 = require("url");
+const ws_1 = __importDefault(require("ws"));
+const speech_1 = require("../speech");
+// The fake adapters speak the fake provider protocol (mods/conformance/PROVIDERS.md). They are
+// built in, like every adapter, and enabled only in test mode.
+class FakeTtsAdapter {
+    constructor(options) {
+        this.options = options;
+    }
+    synthesize(request, signal) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const timeout = AbortSignal.timeout(this.options.timeoutMs);
+            const combined = anySignal([signal, timeout]);
+            let res;
+            try {
+                res = yield fetch(`${this.options.url}/v1/synthesize`, {
+                    method: "POST",
+                    headers: { "content-type": "application/json" },
+                    body: JSON.stringify(Object.assign(Object.assign({}, request), { format: { codec: "pcm16", rate: 16000 } })),
+                    signal: combined
+                });
+            }
+            catch (e) {
+                if (timeout.aborted)
+                    throw new speech_1.SpeechError("provider_timeout", `TTS did not answer within ${this.options.timeoutMs} ms`);
+                throw signal.aborted
+                    ? e
+                    : new speech_1.SpeechError("provider_unavailable", `TTS unreachable: ${e.message}`);
+            }
+            if (res.status === 400)
+                throw new speech_1.SpeechError("bad_message", "TTS rejected the request");
+            if (!res.ok || !res.body)
+                throw new speech_1.SpeechError("provider_unavailable", `TTS answered HTTP ${res.status}`);
+            const words = res.headers.get("x-fake-word-timings");
+            const body = res.body;
+            return {
+                words: words ? JSON.parse(words) : undefined,
+                audio: (function () {
+                    return __asyncGenerator(this, arguments, function* () {
+                        const reader = body.getReader();
+                        try {
+                            for (;;) {
+                                const { done, value } = yield __await(reader.read());
+                                if (done)
+                                    return yield __await(void 0);
+                                yield yield __await(Buffer.from(value));
+                            }
+                        }
+                        catch (e) {
+                            if (timeout.aborted)
+                                throw new speech_1.SpeechError("provider_timeout", "TTS stalled");
+                            if (!signal.aborted)
+                                throw new speech_1.SpeechError("provider_unavailable", e.message);
+                        }
+                    });
+                })()
+            };
+        });
+    }
+}
+exports.FakeTtsAdapter = FakeTtsAdapter;
+function anySignal(signals) {
+    const controller = new AbortController();
+    for (const s of signals) {
+        if (s.aborted) {
+            controller.abort();
+            break;
+        }
+        s.addEventListener("abort", () => controller.abort(), { once: true });
+    }
+    return controller.signal;
+}
+class FakeSttStream extends events_1.EventEmitter {
+    constructor(url, language, hints, model) {
+        super();
+        this.pending = [];
+        this.open = false;
+        const query = new url_1.URLSearchParams(Object.assign({ language, codec: "pcm16", rate: "16000" }, (model ? { model } : {})));
+        this.socket = new ws_1.default(`${url}/v1/listen?${query}`);
+        this.socket.on("open", () => {
+            this.open = true;
+            if (hints)
+                this.socket.send(JSON.stringify({ type: "config", hints }));
+            for (const p of this.pending)
+                this.socket.send(p);
+            this.pending = [];
+        });
+        this.socket.on("message", (raw) => {
+            const msg = JSON.parse(raw.toString());
+            if (msg.type === "transcript") {
+                const t = Object.assign({ text: msg.text, final: msg.final, language: msg.language, confidence: msg.confidence, startMs: msg.startMs, endMs: msg.endMs }, (msg.turn ? { turn: msg.turn } : {}));
+                this.emit("transcript", t);
+            }
+        });
+        this.socket.on("close", (code) => {
+            if (code === 1011)
+                this.emit("error", new speech_1.SpeechError("provider_unavailable", "STT closed the stream"));
+            if (code === 1008)
+                this.emit("error", new speech_1.SpeechError("bad_message", "STT rejected the stream"));
+        });
+        this.socket.on("error", (e) => this.emit("error", new speech_1.SpeechError("provider_unavailable", e.message)));
+    }
+    write(frame) {
+        this.send(frame);
+    }
+    update(options) {
+        this.send(JSON.stringify(Object.assign({ type: "config" }, options)));
+    }
+    close() {
+        this.removeAllListeners();
+        this.socket.removeAllListeners();
+        this.socket.on("error", () => undefined);
+        if (this.socket.readyState === ws_1.default.CONNECTING)
+            this.socket.terminate();
+        else
+            this.socket.close();
+    }
+    send(data) {
+        if (this.open && this.socket.readyState === ws_1.default.OPEN)
+            this.socket.send(data);
+        else if (!this.open)
+            this.pending.push(data);
+    }
+}
+class FakeSttAdapter {
+    constructor(options) {
+        this.options = options;
+    }
+    open(options) {
+        return new FakeSttStream(this.options.url, options.language, options.hints, options.model);
+    }
+}
+exports.FakeSttAdapter = FakeSttAdapter;

package/dist/http.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Synthesis } from "./speech";
+/**
+ * Shared HTTP plumbing for streaming TTS vendors: timeouts, error mapping, body streaming.
+ * `timeoutMs` bounds the wait for the response and for each next chunk, not the whole body: the
+ * body is read at playback pace, so a reply longer than `timeoutMs` must not count as a stall
+ * (FN-B6: long replies were cut off with "Deepgram stalled").
+ */
+export declare function streamingPost(url: string, init: {
+    headers: Record<string, string>;
+    body: string;
+}, signal: AbortSignal, timeoutMs: number, vendor: string): Promise<Synthesis["audio"]>;

package/dist/http.js

@@ -0,0 +1,128 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamingPost = streamingPost;
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const speech_1 = require("./speech");
+/**
+ * Shared HTTP plumbing for streaming TTS vendors: timeouts, error mapping, body streaming.
+ * `timeoutMs` bounds the wait for the response and for each next chunk, not the whole body: the
+ * body is read at playback pace, so a reply longer than `timeoutMs` must not count as a stall
+ * (FN-B6: long replies were cut off with "Deepgram stalled").
+ */
+function streamingPost(url, init, signal, timeoutMs, vendor) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const controller = new AbortController();
+        const abort = () => controller.abort();
+        signal.addEventListener("abort", abort, { once: true });
+        const timeout = { aborted: false };
+        let timer;
+        const arm = () => {
+            timer = setTimeout(() => {
+                timeout.aborted = true;
+                controller.abort();
+            }, timeoutMs);
+        };
+        const disarm = () => clearTimeout(timer);
+        arm();
+        let res;
+        try {
+            res = yield fetch(url, {
+                method: "POST",
+                headers: init.headers,
+                body: init.body,
+                signal: controller.signal
+            });
+        }
+        catch (e) {
+            disarm();
+            if (timeout.aborted)
+                throw new speech_1.SpeechError("provider_timeout", `${vendor} did not answer within ${timeoutMs} ms`);
+            if (signal.aborted)
+                throw e;
+            throw new speech_1.SpeechError("provider_unavailable", `${vendor} unreachable: ${e.message}`);
+        }
+        disarm();
+        if (res.status === 400 || res.status === 422) {
+            throw new speech_1.SpeechError("bad_message", `${vendor} rejected the request (HTTP ${res.status}): ${(yield res.text()).slice(0, 200)}`);
+        }
+        if (!res.ok || !res.body)
+            throw new speech_1.SpeechError("provider_unavailable", `${vendor} answered HTTP ${res.status}`);
+        const body = res.body;
+        return (function () {
+            return __asyncGenerator(this, arguments, function* () {
+                const reader = body.getReader();
+                // Vendors may split samples across chunks; keep byte pairs together.
+                let odd;
+                try {
+                    for (;;) {
+                        arm();
+                        const { done, value } = yield __await(reader.read());
+                        disarm();
+                        if (done)
+                            return yield __await(void 0);
+                        let chunk = Buffer.from(value);
+                        if (odd) {
+                            chunk = Buffer.concat([odd, chunk]);
+                            odd = undefined;
+                        }
+                        if (chunk.length % 2) {
+                            odd = chunk.subarray(chunk.length - 1);
+                            chunk = chunk.subarray(0, chunk.length - 1);
+                        }
+                        if (chunk.length)
+                            yield yield __await(chunk);
+                    }
+                }
+                catch (e) {
+                    if (timeout.aborted)
+                        throw new speech_1.SpeechError("provider_timeout", `${vendor} stalled`);
+                    if (!signal.aborted)
+                        throw new speech_1.SpeechError("provider_unavailable", e.message);
+                }
+                finally {
+                    disarm();
+                    signal.removeEventListener("abort", abort);
+                }
+            });
+        })();
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from "./adapters";
+export * from "./types";

package/dist/index.js

@@ -0,0 +1,39 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// @fonoster/community: the vendor adapters, one subpath per vendor
+// (@fonoster/community/deepgram, /elevenlabs, /openai, /fake). The root exports the shared
+// interfaces and the adapter table keyed by catalog adapter id.
+__exportStar(require("./adapters"), exports);
+__exportStar(require("./types"), exports);

package/dist/llm.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export type ToolCall = {
+    id: string;
+    name: string;
+    arguments: string;
+};
+export type ChatMessage = {
+    role: "system" | "user";
+    content: string;
+} | {
+    role: "assistant";
+    content: string;
+    tool_calls?: ToolCall[];
+} | {
+    role: "tool";
+    tool_call_id: string;
+    content: string;
+};
+export type ThinkChunk = {
+    type: "text";
+    text: string;
+} | {
+    type: "tool_calls";
+    calls: ToolCall[];
+};
+export type ToolSpec = {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+};
+export interface Think {
+    stream(messages: ChatMessage[], tools: ToolSpec[], signal: AbortSignal): AsyncIterable<ThinkChunk>;
+}
+export type ThinkProvider = {
+    baseUrl: string;
+    apiKey?: string;
+};
+/**
+ * A language model vendor failed, named like the session error codes (registry "vendor errors
+ * map to provider_unavailable", task 1.5): unreachable or 401/403/429/5xx → provider_unavailable,
+ * 400/422 → bad_message. An abort is not a provider error and is rethrown as it is.
+ */
+export declare class ThinkError extends Error {
+    readonly code: "provider_unavailable" | "provider_timeout" | "bad_message";
+    constructor(code: "provider_unavailable" | "provider_timeout" | "bad_message", message: string);
+}

package/dist/llm.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// The LLM adapter interface (rework-autopilot A8: the Think plug): a streaming language model
+// behind one interface. Implementations live in one subpath per vendor (openai covers
+// OpenAI, Groq, Ollama and the conformance fake LLM).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThinkError = void 0;
+/**
+ * A language model vendor failed, named like the session error codes (registry "vendor errors
+ * map to provider_unavailable", task 1.5): unreachable or 401/403/429/5xx → provider_unavailable,
+ * 400/422 → bad_message. An abort is not a provider error and is rethrown as it is.
+ */
+class ThinkError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "ThinkError";
+    }
+}
+exports.ThinkError = ThinkError;

package/dist/openai/index.d.ts

@@ -0,0 +1,20 @@
+import { ChatMessage, Think, ThinkChunk, ThinkProvider, ToolSpec } from "../llm";
+/** Adapters whose LLMs speak OpenAI-compatible Chat Completions, with their default endpoints. */
+export declare const OPENAI_COMPATIBLE: Record<string, string | undefined>;
+export declare class OpenAiCompatibleThink implements Think {
+    private readonly provider;
+    private readonly model;
+    private readonly options;
+    constructor(provider: ThinkProvider, model: string, options: {
+        temperature: number;
+        maxTokens: number;
+        /** Ask for a JSON object reply (catalog feature `json-mode`). */
+        jsonMode?: boolean;
+    });
+    stream(messages: ChatMessage[], tools: ToolSpec[], signal: AbortSignal): AsyncIterable<ThinkChunk>;
+}
+/** Resolves a catalog id (`<provider>/<model>`) against configured providers. */
+export declare function resolveThink(catalogId: string, providers: Record<string, ThinkProvider>, options: {
+    temperature: number;
+    maxTokens: number;
+}): Think;