@fonoster/community 0.0.0-stage → 0.27.0

package/dist/openai/index.js

@@ -0,0 +1,154 @@
+"use strict";
+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.OpenAiCompatibleThink = exports.OPENAI_COMPATIBLE = void 0;
+exports.resolveThink = resolveThink;
+/**
+ * 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 util_1 = require("util");
+const llm_1 = require("../llm");
+// OpenAI-compatible Chat Completions (rework-autopilot A8), which covers OpenAI, Groq, Ollama and
+// the conformance fake LLM. Registered for those catalog adapters in ../adapters.ts.
+/** Adapters whose LLMs speak OpenAI-compatible Chat Completions, with their default endpoints. */
+exports.OPENAI_COMPATIBLE = {
+    openai: "https://api.openai.com",
+    groq: "https://api.groq.com/openai",
+    ollama: "http://localhost:11434",
+    fake: undefined
+};
+class OpenAiCompatibleThink {
+    constructor(provider, model, options) {
+        this.provider = provider;
+        this.model = model;
+        this.options = options;
+    }
+    stream(messages, tools, signal) {
+        return __asyncGenerator(this, arguments, function* stream_1() {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            const body = Object.assign(Object.assign({ model: this.model, stream: true, temperature: this.options.temperature, max_tokens: this.options.maxTokens, messages: messages.map(toOpenAi) }, (tools.length
+                ? { tools: tools.map((t) => ({ type: "function", function: t })) }
+                : {})), (this.options.jsonMode
+                ? { response_format: { type: "json_object" } }
+                : {}));
+            let res;
+            try {
+                res = yield __await(fetch(`${this.provider.baseUrl.replace(/\/$/, "")}/v1/chat/completions`, {
+                    method: "POST",
+                    headers: Object.assign({ "content-type": "application/json" }, (this.provider.apiKey
+                        ? { authorization: `Bearer ${this.provider.apiKey}` }
+                        : {})),
+                    body: JSON.stringify(body),
+                    signal
+                }));
+            }
+            catch (e) {
+                if (signal.aborted)
+                    throw e;
+                throw new llm_1.ThinkError("provider_unavailable", `language model unreachable: ${e.message}`);
+            }
+            if (res.status === 400 || res.status === 422)
+                throw new llm_1.ThinkError("bad_message", `language model rejected the request (HTTP ${res.status})`);
+            if (!res.ok || !res.body)
+                throw new llm_1.ThinkError("provider_unavailable", `language model answered HTTP ${res.status}`);
+            const calls = new Map();
+            const decoder = new util_1.TextDecoder();
+            let buffer = "";
+            const reader = res.body.getReader();
+            for (;;) {
+                let next;
+                try {
+                    next = yield __await(reader.read());
+                }
+                catch (e) {
+                    if (signal.aborted)
+                        throw e;
+                    throw new llm_1.ThinkError("provider_unavailable", `language model stream failed: ${e.message}`);
+                }
+                const { done, value } = next;
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                let newline;
+                while ((newline = buffer.indexOf("\n")) >= 0) {
+                    const line = buffer.slice(0, newline).trim();
+                    buffer = buffer.slice(newline + 1);
+                    if (!line.startsWith("data:"))
+                        continue;
+                    const data = line.slice(5).trim();
+                    if (data === "[DONE]")
+                        continue;
+                    const delta = (_c = (_b = (_a = JSON.parse(data).choices) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.delta) !== null && _c !== void 0 ? _c : {};
+                    if (delta.content)
+                        yield yield __await({ type: "text", text: delta.content });
+                    for (const tc of (_d = delta.tool_calls) !== null && _d !== void 0 ? _d : []) {
+                        const call = (_e = calls.get(tc.index)) !== null && _e !== void 0 ? _e : {
+                            id: (_f = tc.id) !== null && _f !== void 0 ? _f : `call_${tc.index}`,
+                            name: "",
+                            arguments: ""
+                        };
+                        if ((_g = tc.function) === null || _g === void 0 ? void 0 : _g.name)
+                            call.name = tc.function.name;
+                        if ((_h = tc.function) === null || _h === void 0 ? void 0 : _h.arguments)
+                            call.arguments += tc.function.arguments;
+                        calls.set(tc.index, call);
+                    }
+                }
+            }
+            if (calls.size)
+                yield yield __await({ type: "tool_calls", calls: [...calls.values()] });
+        });
+    }
+}
+exports.OpenAiCompatibleThink = OpenAiCompatibleThink;
+function toOpenAi(m) {
+    var _a;
+    if (m.role === "assistant" && ((_a = m.tool_calls) === null || _a === void 0 ? void 0 : _a.length)) {
+        return {
+            role: "assistant",
+            content: m.content || null,
+            tool_calls: m.tool_calls.map((c) => ({
+                id: c.id,
+                type: "function",
+                function: { name: c.name, arguments: c.arguments }
+            }))
+        };
+    }
+    return m;
+}
+/** Resolves a catalog id (`<provider>/<model>`) against configured providers. */
+function resolveThink(catalogId, providers, options) {
+    const slash = catalogId.indexOf("/");
+    const providerName = catalogId.slice(0, slash);
+    const provider = providers[providerName];
+    if (!provider)
+        throw new Error(`no language model provider "${providerName}" for ${catalogId}`);
+    return new OpenAiCompatibleThink(provider, catalogId.slice(slash + 1), options);
+}

package/dist/speech.d.ts

@@ -0,0 +1,77 @@
+/**
+ * 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 { EventEmitter } from "events";
+export type WordTiming = {
+    word: string;
+    startMs: number;
+    endMs: number;
+};
+/** Provider failures, named after the session error codes they become (VS17). */
+export declare class SpeechError extends Error {
+    readonly code: "provider_unavailable" | "provider_timeout" | "bad_message" | "internal";
+    constructor(code: "provider_unavailable" | "provider_timeout" | "bad_message" | "internal", message: string);
+}
+export type Synthesis = {
+    /** Internal-format audio (PCM16LE, 16 kHz) as it arrives. */
+    audio: AsyncIterable<Buffer>;
+    /** Word timings relative to the start of this audio, when the provider reports them. */
+    words?: WordTiming[];
+};
+export interface TtsAdapter {
+    synthesize(request: {
+        text: string;
+        voice: string;
+        language: string;
+    }, signal: AbortSignal): Promise<Synthesis>;
+}
+export type Transcript = {
+    text: string;
+    final: boolean;
+    language: string;
+    confidence: number;
+    startMs?: number;
+    endMs?: number;
+    /** Per-word timings when the recognizer reports them (catalog feature `word-timings`). */
+    words?: WordTiming[];
+    /**
+     * Turn signals from a turn-aware recognizer (catalog feature `turn-detection`): its own
+     * end-of-thought estimate and whether it declared the end of the turn. Absent otherwise.
+     */
+    turn?: {
+        eot?: number;
+        endOfTurn?: boolean;
+    };
+};
+/** One streaming recognition session. Emits "transcript" (Transcript) and "error" (SpeechError). */
+export interface SttStream extends EventEmitter {
+    write(frame: Buffer): void;
+    update(options: {
+        language?: string;
+        hints?: string[];
+    }): void;
+    close(): void;
+}
+export interface SttAdapter {
+    /** `model` is the provider's own model name (catalog id `<provider>/<model>`). */
+    open(options: {
+        language: string;
+        hints?: string[];
+        model?: string;
+    }): SttStream;
+}

package/dist/speech.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpeechError = void 0;
+/** Provider failures, named after the session error codes they become (VS17). */
+class SpeechError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+exports.SpeechError = SpeechError;

package/dist/types.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 "./llm";
+export * from "./speech";

package/dist/types.js

@@ -0,0 +1,37 @@
+"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.
+ */
+// The shared adapter interfaces: speech (STT, TTS) and language models (LLM).
+__exportStar(require("./llm"), exports);
+__exportStar(require("./speech"), exports);

package/package.json

@@ -1,6 +1,81 @@
 {
   "name": "@fonoster/community",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.27.0",
+  "description": "Vendor adapters (STT, TTS, LLM) behind shared interfaces, one subpath per vendor",
+  "author": "Pedro Sanders <psanders@fonoster.com>",
+  "homepage": "https://github.com/fonoster/fonoster#readme",
+  "license": "MIT",
+  "main": "dist/index",
+  "types": "dist/index",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "default": "./dist/types.js"
+    },
+    "./deepgram": {
+      "types": "./dist/deepgram/index.d.ts",
+      "default": "./dist/deepgram/index.js"
+    },
+    "./elevenlabs": {
+      "types": "./dist/elevenlabs/index.d.ts",
+      "default": "./dist/elevenlabs/index.js"
+    },
+    "./openai": {
+      "types": "./dist/openai/index.d.ts",
+      "default": "./dist/openai/index.js"
+    },
+    "./fake": {
+      "types": "./dist/fake/index.d.ts",
+      "default": "./dist/fake/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "typesVersions": {
+    "*": {
+      "types": [
+        "dist/types.d.ts"
+      ],
+      "deepgram": [
+        "dist/deepgram/index.d.ts"
+      ],
+      "elevenlabs": [
+        "dist/elevenlabs/index.d.ts"
+      ],
+      "openai": [
+        "dist/openai/index.d.ts"
+      ],
+      "fake": [
+        "dist/fake/index.d.ts"
+      ]
+    }
+  },
+  "directories": {
+    "src": "src",
+    "test": "test"
+  },
+  "scripts": {
+    "prebuild": "rimraf ./dist tsconfig.tsbuildinfo",
+    "build": "tsc -b tsconfig.json",
+    "clean": "rimraf ./dist node_modules tsconfig.tsbuildinfo"
+  },
+  "dependencies": {
+    "ws": "^8.18.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fonoster/fonoster.git"
+  },
+  "bugs": {
+    "url": "https://github.com/fonoster/fonoster/issues"
+  }
+}

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.