@fugood/buttress-server 2.25.0-beta.9 → 2.25.1-beta.0

package/lib/package.d.ts

@@ -0,0 +1,7 @@
+type PackageInfo = {
+    version: string;
+    name: string;
+    description?: string;
+};
+export declare const pkgInfo: () => PackageInfo;
+export {};

package/lib/routes/anthropic-messages.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Anthropic Messages API endpoints for ggml-llm/mlx-llm (EXPERIMENTAL)
+ * Provides /anthropic-messages/v1/messages and /anthropic-messages/v1/messages/count_tokens endpoints
+ *
+ * Implementation based on llama.cpp PR #17570 and follow-up fixes:
+ *   - https://github.com/ggml-org/llama.cpp/pull/17570 (initial Anthropic Messages support)
+ *   - https://github.com/ggml-org/llama.cpp/pull/18551 (signature_delta + persistent block state)
+ *   - https://github.com/ggml-org/llama.cpp/pull/20120 (preserve thinking blocks in conversion)
+ *
+ * Enable via TOML config: [anthropic_messages] enabled = true
+ *
+ * Note: This feature is experimental and may change in future versions.
+ */
+import type { EventStream, Config } from '../types';
+/**
+ * Stream an Anthropic Messages SSE response from the backend stream.
+ *
+ * Anthropic SSE event sequence:
+ *   message_start
+ *   [content_block_start (thinking)]   if reasoning observed
+ *     content_block_delta (thinking_delta) ...
+ *     content_block_delta (signature_delta)
+ *   content_block_stop
+ *   [content_block_start (text)]       if text observed
+ *     content_block_delta (text_delta) ...
+ *   content_block_stop
+ *   [content_block_start (tool_use)] * for each tool call
+ *     content_block_delta (input_json_delta) ...
+ *   content_block_stop
+ *   message_delta (stop_reason + usage)
+ *   message_stop
+ */
+export declare function streamAnthropicMessage(completionStream: ReadableStream<EventStream>, messageId: string, modelId: string): AsyncGenerator<{
+    readonly event: "content_block_start";
+    readonly data: string;
+} | {
+    readonly event: "content_block_delta";
+    readonly data: string;
+} | {
+    readonly event: "message_start";
+    readonly data: string;
+} | {
+    readonly event: "error";
+    readonly data: string;
+} | {
+    readonly event: "content_block_stop";
+    readonly data: string;
+} | {
+    readonly event: "message_delta";
+    readonly data: string;
+} | {
+    readonly event: "message_stop";
+    readonly data: string;
+}, void, unknown>;
+export default function factory({ global: globalConfig }: Config): import("../types").ButtressApp;

package/lib/routes/file.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("elysia").default<any, import("elysia").SingletonBase & {
+    store: import("../types").State;
+}, any, any, any, any, {
+    derive: any;
+    resolve: any;
+    schema: any;
+    standaloneSchema: any;
+    response: {} | {};
+}>;
+export default _default;

package/lib/routes/functions.check.d.ts

@@ -0,0 +1,13 @@
+/**
+ * End-to-end check for the local function endpoints.
+ *
+ * Boots a real server on an ephemeral port against a temporary functions
+ * directory, then exercises the HTTP list/call/SSE paths and a full MCP
+ * initialize → tools/list → tools/call round trip.
+ *
+ *   bun src/routes/functions.check.ts
+ *
+ * Not a jest test: it needs a real Elysia listener and the native transpiler,
+ * neither of which fits the root jest (jsdom + React Native preset) project.
+ */
+export {};

package/lib/routes/functions.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Local function endpoints (EXPERIMENTAL).
+ *
+ *   GET  /functions            list callable functions
+ *   POST /functions/:name      run one; add ?stream=1 for SSE progress.
+ *                              multipart bodies stage file fields inline and
+ *                              inject their server paths into the input
+ *   POST /functions/mcp        MCP (Streamable HTTP, stateless)
+ *   GET  /functions/files/*    download a file a function wrote (context.fileUrl)
+ *   POST /functions/upload     stage an input file for a function call
+ *
+ * Enable via TOML config: [functions] enabled = true, dir = "./functions"
+ */
+import type { FunctionsService } from '../functions';
+import type { Config } from '../types';
+export default function factory(config: Config, functions: FunctionsService): import("../types").ButtressApp;

package/lib/routes/generator-cache.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Warm-generator cache shared by the sessionless HTTP surfaces (compatibility
+ * routes and local functions).
+ *
+ * Generators are expensive to start (model load + context alloc), so entries
+ * are kept warm and reference-counted by in-flight requests: only idle entries
+ * (`activeRequests === 0`) are ever evicted, and the map doubles as an LRU
+ * because re-inserting on use moves a key to the end.
+ *
+ * Each caller creates its own cache instance (one per backend family) but the
+ * bookkeeping — in-flight de-duplication, retain/release, eviction — lives here.
+ */
+export type GeneratorCacheEntry = {
+    id: string;
+    type: string;
+    config: any;
+    repoId: string;
+    initialized: boolean;
+    activeRequests: number;
+};
+export type ResolvedGeneratorRequest = {
+    type: string;
+    /** Cache key and model identity for this request. */
+    repoId: string;
+    mergedConfig: any;
+};
+export type GeneratorCacheOptions = {
+    /** Warm entries kept alive; the oldest idle entries are finalized beyond it. */
+    max: number;
+    /** Pick the configured generator that serves `requestedModel`. */
+    resolve: (config: any, requestedModel?: string) => ResolvedGeneratorRequest;
+    /** Post-start preparation (typically `initContext`). */
+    prepare: (backend: any, entry: GeneratorCacheEntry) => Promise<void>;
+};
+export declare const createGeneratorCache: ({ max, resolve, prepare }: GeneratorCacheOptions) => {
+    getOrCreate: (backend: any, config: any, requestedModel: string | undefined, logPrefix: string) => Promise<GeneratorCacheEntry>;
+    release: (backend: any, entry: GeneratorCacheEntry | null | undefined, logPrefix: string) => Promise<void>;
+};
+/** Best-effort reader teardown: sources may already be closed or errored. */
+export declare function cancelReaderBestEffort(reader: {
+    cancel: () => Promise<unknown>;
+}): void;

package/lib/routes/index.d.ts

@@ -0,0 +1,6 @@
+export { default as infoFactory } from './info';
+export { default as file } from './file';
+export { default as status } from './status';
+export { default as openaiCompatFactory } from './openai-compat';
+export { default as anthropicMessagesFactory } from './anthropic-messages';
+export { default as functionsFactory } from './functions';

package/lib/routes/info.check.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/routes/info.d.ts

@@ -0,0 +1,4 @@
+import { type AnnounceSigner } from '../autodiscover/sign';
+import type { Config } from '../types';
+export default _default;
+declare function _default(config: Config, signer?: AnnounceSigner | null): import("../types").ButtressApp;

package/lib/routes/llm-shared.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Shared helpers for LLM-backed sessionless routes (OpenAI / Anthropic
+ * compatibility endpoints and local functions).
+ *
+ * The generator cache is module-scoped so every caller reuses the same warm
+ * generator for a given model instead of duplicating contexts.
+ */
+import type { GeneratorCacheEntry } from './generator-cache';
+export type { GeneratorCacheEntry };
+export { cancelReaderBestEffort } from './generator-cache';
+export declare const LLM_TYPES: string[];
+/**
+ * Backend options every `messages`-shaped completion needs.
+ *
+ * Without `jinja` the backend never applies the model's own chat template and
+ * the reply degrades into raw-continuation output (`assistant\nassistant\n…`).
+ * `reasoning_format` splits a thinking model's `<think>` block out of `content`
+ * into `reasoning_content` instead of leaving it inline, and thinking stays off
+ * unless the caller asks for it.
+ */
+export declare const CHAT_COMPLETION_DEFAULTS: {
+    readonly jinja: true;
+    readonly add_generation_prompt: true;
+    readonly reasoning_format: 'auto';
+    readonly enable_thinking: false;
+};
+/**
+ * Get the LLM backend API for a generator type.
+ */
+export declare function getLlmBackend(backend: any, type: string): any;
+export declare function releaseGenerator(backend: any, entry: GeneratorCacheEntry | null | undefined, logPrefix?: string): Promise<void>;
+/**
+ * Get or create a cached generator for the requested model.
+ */
+export declare function getOrCreateGenerator(backend: any, config: any, requestedModel?: string, logPrefix?: string): Promise<GeneratorCacheEntry>;
+/**
+ * Extract token counts from a backend completion result event.
+ *
+ * The buttress backend reports counts under `timings.prompt_n`,
+ * `timings.cache_n`, and `timings.predicted_n` (with `tokens_evaluated`
+ * historically mirroring predicted_n on the result root). We tolerate
+ * the legacy `prompt_tokens`/`tokens_predicted` field names too in case
+ * a future backend variant promotes them to the root.
+ */
+export declare function extractTokenCounts(eventData: Record<string, any>): {
+    promptTokens: number;
+    cachedTokens: number;
+    completionTokens: number;
+};
+/**
+ * Extract token usage in OpenAI format from backend event data.
+ */
+export declare function extractUsage(eventData: Record<string, any>): {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+};

package/lib/routes/openai-compat.d.ts

@@ -0,0 +1,17 @@
+/**
+ * OpenAI-compatible API endpoints for ggml-llm (EXPERIMENTAL)
+ * Provides /oai-compat/v1/chat/completions and /oai-compat/v1/models endpoints
+ *
+ * Enable via TOML config: [openai_compat] enabled = true
+ *
+ * Note: This feature is experimental and may change in future versions.
+ */
+import type { EventStream, Config } from '../types';
+/**
+ * Stream an OpenAI-compatible chat completion (SSE) from the backend stream.
+ * Mirrors collectChatCompletion (the non-streaming path).
+ */
+export declare function streamChatCompletion(completionStream: ReadableStream<EventStream>, completionId: string, created: number, modelId: string, includeUsage: boolean): AsyncGenerator<{
+    readonly data: string;
+}, void, unknown>;
+export default function factory({ global: globalConfig }: Config): import("../types").ButtressApp;

package/lib/routes/status.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("elysia").default<any, import("elysia").SingletonBase & {
+    store: import("../types").State;
+}, any, any, any, any, any>;
+export default _default;

package/lib/routes/stt-shared.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Shared helpers for speech-to-text on the sessionless paths.
+ *
+ * Mirrors llm-shared: a module-scoped warm-generator cache, reference-counted
+ * by in-flight requests. Unlike the LLM path, an unmatched model is an error
+ * rather than a repo_id override — STT models are identified by repo *and*
+ * filename (several whisper builds live in one repo), so silently substituting
+ * one would load the wrong weights.
+ */
+import type { GeneratorCacheEntry } from './generator-cache';
+export declare const STT_TYPES: string[];
+/** Get the STT backend API for a generator type. */
+export declare function getSttBackend(backend: any, type: string): any;
+/** Model identity for an STT generator config: `repo_id` plus `filename`. */
+export declare function sttModelId(generatorConfig: any): string;
+export declare function getOrCreateSttGenerator(backend: any, config: any, requestedModel?: string, logPrefix?: string): Promise<GeneratorCacheEntry>;
+export declare function releaseSttGenerator(backend: any, entry: GeneratorCacheEntry | null | undefined, logPrefix?: string): Promise<void>;
+/**
+ * Normalize a transcription call result.
+ *
+ * `ggmlStt.transcribe` resolves a plain object while `onnxStt.transcribe`
+ * returns a ReadableStream of progress events — duck-typed here (never
+ * `instanceof`, which fails across vm realms) so both shapes collapse to the
+ * final result payload.
+ */
+export declare function resolveTranscription(value: any): Promise<any>;
+export type TranscribeRequest = {
+    model?: string;
+    audioPath?: string;
+    audioData?: Uint8Array | Buffer;
+    options?: Record<string, any>;
+};
+/**
+ * Run a transcription against a warm STT generator, releasing it afterwards.
+ */
+export declare function transcribeWith(backend: any, config: any, { model, audioPath, audioData, options }: TranscribeRequest, logPrefix?: string): Promise<any>;

package/lib/routes/tts-shared.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Shared helpers for text-to-speech on the sessionless paths.
+ *
+ * Mirrors stt-shared: a module-scoped warm-generator cache, reference-counted
+ * by in-flight requests. Like the STT path, an unmatched model is an error
+ * rather than a substitution — synthesizing with the wrong voice is a silent
+ * failure the caller cannot detect.
+ */
+import type { GeneratorCacheEntry } from './generator-cache';
+export declare const TTS_TYPES: string[];
+/** Get the TTS backend API for a generator type (only onnx-tts today). */
+export declare function getTtsBackend(backend: any, _type: string): any;
+/** Model identity for a TTS generator config: `repo_id` plus `filename`. */
+export declare function ttsModelId(generatorConfig: any): string;
+export declare function getOrCreateTtsGenerator(backend: any, config: any, requestedModel?: string, logPrefix?: string): Promise<GeneratorCacheEntry>;
+export declare function releaseTtsGenerator(backend: any, entry: GeneratorCacheEntry | null | undefined, logPrefix?: string): Promise<void>;
+export type SynthesizeRequest = {
+    model?: string;
+    text: string;
+    /** Passed to the backend verbatim; `options.speaker` picks a registered voice. */
+    options?: Record<string, any>;
+};
+export type SynthesizeBackendResult = {
+    cachedId: string;
+    /**
+     * Path into the TTS output cache. The cache owns this file and may evict it
+     * — callers that need the audio beyond the immediate request must copy it.
+     */
+    cachedFile: string;
+    sampling_rate: number;
+    channels: number;
+};
+/**
+ * Run a synthesis against a warm TTS generator, releasing it afterwards.
+ */
+export declare function synthesizeWith(backend: any, config: any, { model, text, options }: SynthesizeRequest, logPrefix?: string): Promise<SynthesizeBackendResult>;

package/lib/services/common.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import type { ServiceContext } from '../types';
+export declare const schemas: {
+    getCapabilities: z.ZodTuple<[z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        type: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        config: z.ZodOptional<z.ZodAny>;
+        currentClientCapabilities: z.ZodOptional<z.ZodAny>;
+        options: z.ZodOptional<z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        config?: any;
+        currentClientCapabilities?: any;
+        options?: any;
+    }, {
+        type?: string | undefined;
+        config?: any;
+        currentClientCapabilities?: any;
+        options?: any;
+    }>>>], null>;
+    startGenerator: z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodAny>], null>;
+    finalizeGenerator: z.ZodTuple<[z.ZodString], null>;
+};
+export interface Service {
+    getCapabilities: (ctx: ServiceContext, ...args: z.infer<typeof schemas.getCapabilities>) => Promise<any>;
+    startGenerator: (ctx: ServiceContext, ...args: z.infer<typeof schemas.startGenerator>) => Promise<any>;
+    finalizeGenerator: (ctx: ServiceContext, ...args: z.infer<typeof schemas.finalizeGenerator>) => Promise<any>;
+}
+declare const _default: Service;
+export default _default;

package/lib/services/create-llm-service.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { ReadableStream } from 'node:stream/web';
+import type { ServiceContext, EventStream, Expand } from '../types';
+export declare const schemas: {
+    initContext: z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodAny>], null>;
+    completion: z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodAny>], null>;
+    tokenize: z.ZodTuple<[z.ZodString, z.ZodAny], null>;
+    detokenize: z.ZodTuple<[z.ZodString, z.ZodAny], null>;
+    applyChatTemplate: z.ZodTuple<[z.ZodString, z.ZodAny], null>;
+    releaseContext: z.ZodTuple<[z.ZodString], null>;
+};
+export interface Service {
+    initContext: (ctx: ServiceContext, ...args: z.infer<typeof schemas.initContext>) => ReadableStream<Expand<EventStream>>;
+    completion: (ctx: ServiceContext, ...args: z.infer<typeof schemas.completion>) => Promise<ReadableStream<Expand<EventStream>>>;
+    tokenize: (ctx: ServiceContext, ...args: z.infer<typeof schemas.tokenize>) => Promise<any>;
+    detokenize: (ctx: ServiceContext, ...args: z.infer<typeof schemas.detokenize>) => Promise<any>;
+    applyChatTemplate: (ctx: ServiceContext, ...args: z.infer<typeof schemas.applyChatTemplate>) => Promise<any>;
+    releaseContext: (ctx: ServiceContext, ...args: z.infer<typeof schemas.releaseContext>) => Promise<any>;
+}
+type GetBackend = (backend: any) => any;
+export declare function createInitContext(getBackend: GetBackend): ({ backend, session }: ServiceContext, id: any, property: any) => ReadableStream<EventStream>;
+export declare function createReleaseContext(getBackend: GetBackend, label: string): ({ backend, session }: ServiceContext, id: any, force: any) => Promise<any>;
+export default function createLlmService(getBackend: GetBackend, label: string): Service;
+export {};

package/lib/services/create-onnx-init-context.d.ts

@@ -0,0 +1,10 @@
+import { ReadableStream } from 'node:stream/web';
+import type { EventStream, ServiceContext } from '../types';
+type InitContextBackend = {
+    initContext: (id: string, property: Record<string, unknown> & {
+        onProgress: (progress: number) => void;
+    }) => Promise<unknown>;
+};
+type GetBackend = (backend: ServiceContext['backend']) => InitContextBackend;
+export default function createOnnxInitContext(getBackend: GetBackend): ({ backend }: ServiceContext, id: string, property: Record<string, unknown> | undefined) => ReadableStream<EventStream>;
+export {};

package/lib/services/ggml-llm.d.ts

@@ -0,0 +1,5 @@
+import { schemas, type Service } from './create-llm-service';
+export { schemas };
+export type { Service };
+declare const _default: Service;
+export default _default;

package/lib/services/ggml-stt.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import type { ServiceContext, EventStream, Expand } from '../types';
+export declare const schemas: {
+    initContext: z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodAny>], null>;
+    transcribe: z.ZodTuple<[z.ZodString, z.ZodString, z.ZodOptional<z.ZodAny>], null>;
+    transcribeData: z.ZodTuple<[z.ZodString, z.ZodUnion<[z.ZodType<Buffer<ArrayBufferLike>, z.ZodTypeDef, Buffer<ArrayBufferLike>>, z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>]>, z.ZodOptional<z.ZodAny>], null>;
+    releaseContext: z.ZodTuple<[z.ZodString], null>;
+};
+export interface Service {
+    initContext: (ctx: ServiceContext, ...args: z.infer<typeof schemas.initContext>) => ReadableStream<Expand<EventStream>>;
+    transcribe: (ctx: ServiceContext, ...args: z.infer<typeof schemas.transcribe>) => Promise<any>;
+    transcribeData: (ctx: ServiceContext, ...args: z.infer<typeof schemas.transcribeData>) => Promise<any>;
+    releaseContext: (ctx: ServiceContext, ...args: z.infer<typeof schemas.releaseContext>) => Promise<any>;
+}
+declare const _default: {
+    initContext: ({ backend, session }: ServiceContext, id: any, property: any) => import("stream/web").ReadableStream<EventStream>;
+    transcribe({ backend, session }: {
+        backend: any;
+        session: any;
+    }, id: any, audioPath: any, options: any): Promise<any>;
+    transcribeData({ backend }: {
+        backend: any;
+    }, id: any, audioData: any, options: any): Promise<any>;
+    releaseContext: ({ backend, session }: ServiceContext, id: any, force: any) => Promise<any>;
+};
+export default _default;

package/lib/services/index.d.ts

@@ -0,0 +1,39 @@
+import type { ServiceContext } from '../types';
+import type { Service as CommonService } from './common';
+import type { Service as GgmlLlmService } from './ggml-llm';
+import type { Service as GgmlSttService } from './ggml-stt';
+import type { Service as MlxLlmService } from './mlx-llm';
+import type { Service as OnnxSttService } from './onnx-stt';
+import type { Service as OnnxTtsService } from './onnx-tts';
+declare const services: {
+    common: CommonService;
+    ggmlLlm: GgmlLlmService;
+    ggmlStt: {
+        initContext: ({ backend, session }: ServiceContext, id: any, property: any) => import("stream/web").ReadableStream<import("../types").EventStream>;
+        transcribe({ backend, session }: {
+            backend: any;
+            session: any;
+        }, id: any, audioPath: any, options: any): Promise<any>;
+        transcribeData({ backend }: {
+            backend: any;
+        }, id: any, audioData: any, options: any): Promise<any>;
+        releaseContext: ({ backend, session }: ServiceContext, id: any, force: any) => Promise<any>;
+    };
+    mlxLlm: GgmlLlmService;
+    onnxStt: OnnxSttService;
+    onnxTts: OnnxTtsService;
+};
+export declare const schemas: Record<string, Record<string, any>>;
+export type StripContext<T> = T extends (ctx: ServiceContext, ...args: infer P) => infer R ? (...args: P) => R : T;
+export type ClientService<S> = {
+    [K in keyof S]: StripContext<S[K]>;
+};
+export type Services = {
+    common: ClientService<CommonService>;
+    ggmlLlm: ClientService<GgmlLlmService>;
+    ggmlStt: ClientService<GgmlSttService>;
+    mlxLlm: ClientService<MlxLlmService>;
+    onnxStt: ClientService<OnnxSttService>;
+    onnxTts: ClientService<OnnxTtsService>;
+};
+export default services;

package/lib/services/mlx-llm.d.ts

@@ -0,0 +1,5 @@
+import { schemas, type Service } from './create-llm-service';
+export { schemas };
+export type { Service };
+declare const _default: Service;
+export default _default;

package/lib/services/onnx-stt.d.ts

@@ -0,0 +1,77 @@
+import { z } from 'zod';
+import type { ReadableStream } from 'node:stream/web';
+import type { ServiceContext, EventStream, Expand } from '../types';
+export declare const schemas: {
+    initContext: z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>], null>;
+    transcribe: z.ZodTuple<[z.ZodString, z.ZodObject<{
+        audio: z.ZodString;
+        options: z.ZodOptional<z.ZodObject<{
+            language: z.ZodOptional<z.ZodString>;
+            task: z.ZodOptional<z.ZodString>;
+            return_timestamps: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodLiteral<"word">]>>;
+            chunk_length_s: z.ZodOptional<z.ZodNumber>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            language: z.ZodOptional<z.ZodString>;
+            task: z.ZodOptional<z.ZodString>;
+            return_timestamps: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodLiteral<"word">]>>;
+            chunk_length_s: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            language: z.ZodOptional<z.ZodString>;
+            task: z.ZodOptional<z.ZodString>;
+            return_timestamps: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodLiteral<"word">]>>;
+            chunk_length_s: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, "strip", z.ZodTypeAny, {
+        audio: string;
+        options?: z.objectOutputType<{
+            language: z.ZodOptional<z.ZodString>;
+            task: z.ZodOptional<z.ZodString>;
+            return_timestamps: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodLiteral<"word">]>>;
+            chunk_length_s: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    }, {
+        audio: string;
+        options?: z.objectInputType<{
+            language: z.ZodOptional<z.ZodString>;
+            task: z.ZodOptional<z.ZodString>;
+            return_timestamps: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodLiteral<"word">]>>;
+            chunk_length_s: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    }>], null>;
+    transcribeData: z.ZodTuple<[z.ZodString, z.ZodUnion<[z.ZodType<Buffer<ArrayBufferLike>, z.ZodTypeDef, Buffer<ArrayBufferLike>>, z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>]>, z.ZodOptional<z.ZodObject<{
+        language: z.ZodOptional<z.ZodString>;
+        task: z.ZodOptional<z.ZodString>;
+        return_timestamps: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodLiteral<"word">]>>;
+        chunk_length_s: z.ZodOptional<z.ZodNumber>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        language: z.ZodOptional<z.ZodString>;
+        task: z.ZodOptional<z.ZodString>;
+        return_timestamps: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodLiteral<"word">]>>;
+        chunk_length_s: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        language: z.ZodOptional<z.ZodString>;
+        task: z.ZodOptional<z.ZodString>;
+        return_timestamps: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodLiteral<"word">]>>;
+        chunk_length_s: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">>>], null>;
+    releaseContext: z.ZodTuple<[z.ZodString], null>;
+};
+export interface TranscribeResult {
+    text: string;
+    chunks?: {
+        text: string;
+        timestamp?: [number, number | null];
+    }[];
+    segments?: unknown[];
+}
+export interface Service {
+    initContext: (ctx: ServiceContext, ...args: z.infer<typeof schemas.initContext>) => ReadableStream<Expand<EventStream>>;
+    transcribe: (ctx: ServiceContext, ...args: z.infer<typeof schemas.transcribe>) => ReadableStream<Expand<EventStream>>;
+    transcribeData: (ctx: ServiceContext, ...args: z.infer<typeof schemas.transcribeData>) => Promise<TranscribeResult>;
+    releaseContext: (ctx: ServiceContext, ...args: z.infer<typeof schemas.releaseContext>) => Promise<{
+        released: boolean;
+        alreadyReleased?: boolean;
+    }>;
+}
+declare const _default: Service;
+export default _default;

package/lib/services/onnx-tts.d.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import type { ReadableStream } from 'node:stream/web';
+import type { ServiceContext, EventStream, Expand } from '../types';
+export declare const schemas: {
+    initContext: z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>], null>;
+    addSpeaker: z.ZodTuple<[z.ZodString, z.ZodUnion<[z.ZodType<Float32Array<ArrayBuffer>, z.ZodTypeDef, Float32Array<ArrayBuffer>>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>], null>;
+    synthesize: z.ZodTuple<[z.ZodString, z.ZodObject<{
+        text: z.ZodString;
+        options: z.ZodOptional<z.ZodObject<{
+            speaker: z.ZodOptional<z.ZodString>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            speaker: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            speaker: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, "strip", z.ZodTypeAny, {
+        text: string;
+        options?: z.objectOutputType<{
+            speaker: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    }, {
+        text: string;
+        options?: z.objectInputType<{
+            speaker: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    }>], null>;
+    releaseContext: z.ZodTuple<[z.ZodString], null>;
+};
+export interface AddSpeakerResult {
+    speakerId: string;
+    type: 'embed' | 'config';
+}
+export interface SynthesizeResult {
+    filename: string;
+    sampling_rate: number;
+    channels: number;
+}
+export interface Service {
+    initContext: (ctx: ServiceContext, ...args: z.infer<typeof schemas.initContext>) => ReadableStream<Expand<EventStream>>;
+    addSpeaker: (ctx: ServiceContext, ...args: z.infer<typeof schemas.addSpeaker>) => Promise<AddSpeakerResult>;
+    synthesize: (ctx: ServiceContext, ...args: z.infer<typeof schemas.synthesize>) => Promise<SynthesizeResult>;
+    releaseContext: (ctx: ServiceContext, ...args: z.infer<typeof schemas.releaseContext>) => Promise<{
+        released: boolean;
+        alreadyReleased?: boolean;
+    }>;
+}
+declare const _default: Service;
+export default _default;