@bendyline/gezel-inference 0.0.0-stage → 0.1.0

package/dist/providers/apple-foundation-models/provider.js

@@ -0,0 +1,389 @@
+import { NATIVE_TOOL_LISTINGS, PROMPT_FOOTPRINT_POLICY, createAwakeTimeout, createLogger, decodeNativeResponse, decodeNativeToolArguments, narrowerNativeListing, nativeResponseSchema, nativeToolSpecs, resolvePromptFootprint, } from '@bendyline/gezel';
+import { computeToolBudgetChars } from '@bendyline/gezel/local-loop';
+import { ProviderQueue, runInQueue } from '../queue.js';
+import { StreamingSessionBase } from '../streaming-session.js';
+import { terminalToolClosingText } from '../terminal-tool-policy.js';
+import { createToolExecutor } from '../tool-executor.js';
+import { buildTurnUsage } from '../usage-builder.js';
+import { appleFmBinaryPath } from './binary.js';
+import { AppleFmError, AppleFmHelper } from './helper.js';
+export { appleFoundationModelsInstalled } from './binary.js';
+const log = createLogger('apple-fm');
+export const APPLE_FOUNDATION_MODEL_ID = 'apple-foundation-models';
+const TURN_BUDGET_MS = 300_000;
+const MAX_TOOL_CALLS = 12;
+const ACTION_LIMIT_TEXT = 'This turn reached its action limit. Completed actions are saved; send a message to continue.';
+const NO_TOOLS_NOTE = "\n\n## Tools available this turn\nNone: the tool list does not fit in this model's context. Answer in normal text.";
+function actionable(message) {
+    const error = new Error(message);
+    error.isActionable = true;
+    return error;
+}
+function isContextRefusal(error) {
+    return error instanceof AppleFmError && error.code === 'CONTEXT_LIMIT';
+}
+/** Key order is not stable across a native decoder's repeated calls. */
+function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableJson).join(',')}]`;
+    if (value && typeof value === 'object')
+        return `{${Object.keys(value)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`)
+            .join(',')}}`;
+    return JSON.stringify(value) ?? 'null';
+}
+/**
+ * Apple's on-device model (Apple Intelligence) on Apple silicon Macs running
+ * macOS 26+, through the `gezel-apple-fm` helper. The model is Apple's own:
+ * no download, no weights on disk, a small context window (4096 tokens before
+ * OS 27). It calls tools through Apple's native tool-calling API; each call
+ * comes back here and runs through the session's MCP bridge like any other
+ * provider's.
+ */
+export class AppleFoundationModelsProvider {
+    name = 'apple-foundation-models';
+    nativeTools = true;
+    supportsPriorMessages = true;
+    queue = new ProviderQueue({ concurrency: 1 });
+    helper;
+    platformSupported;
+    hello = null;
+    constructor(opts = {}) {
+        const platform = opts.platform ?? process.platform;
+        const arch = opts.arch ?? process.arch;
+        const binaryPath = opts.binaryPath ?? appleFmBinaryPath();
+        this.helper =
+            opts.helper ??
+                (platform === 'darwin' && arch === 'arm64' && binaryPath
+                    ? new AppleFmHelper({ binaryPath })
+                    : null);
+        this.platformSupported = platform === 'darwin' && arch === 'arm64';
+    }
+    async initialize() {
+        if (!this.platformSupported)
+            throw actionable('Apple on-device AI is only available on Apple silicon Macs.');
+        if (!this.helper)
+            throw actionable('Apple on-device AI is not installed with this build of Gezel (the gezel-apple-fm helper is missing).');
+        const hello = await this.helper.ready();
+        this.hello = hello;
+        if (!hello.available)
+            throw actionable(hello.reason ?? 'Apple on-device AI is unavailable on this Mac.');
+        log.info(`[apple-fm] ready: helper ${hello.version}, ${hello.os}, context ${hello.contextTokens} tokens`);
+    }
+    async shutdown() {
+        await this.helper?.shutdown();
+        this.hello = null;
+    }
+    getEffectiveModelId() {
+        return APPLE_FOUNDATION_MODEL_ID;
+    }
+    getContextWindow() {
+        return this.hello?.contextTokens;
+    }
+    async listModels() {
+        await this.initialize();
+        return [
+            {
+                id: APPLE_FOUNDATION_MODEL_ID,
+                name: 'Apple on-device model',
+                contextWindow: this.hello.contextTokens,
+                supportsTools: true,
+            },
+        ];
+    }
+    async createSession(opts) {
+        await this.initialize();
+        const bridges = await createToolExecutor(opts, '[apple-fm]');
+        const history = [];
+        for (const message of opts.priorMessages ?? []) {
+            // Apple's transcript only takes text turns here; earlier tool traffic
+            // is represented by the assistant text that followed it.
+            if (message.role === 'tool' || !message.content)
+                continue;
+            history.push({ role: message.role, content: message.content });
+        }
+        return new AppleFoundationSession({
+            helper: this.helper,
+            queue: this.queue,
+            bridges,
+            systemMessage: opts.systemMessage,
+            history,
+            contextTokens: this.hello.contextTokens,
+            startListing: PROMPT_FOOTPRINT_POLICY[resolvePromptFootprint({ contextWindow: this.hello.contextTokens })].nativeToolListing,
+            maxTokens: Math.min(this.hello.maxOutputTokens, opts.tuning?.sampling?.maxTokens ?? this.hello.maxOutputTokens),
+            // `response_format: json_schema` reaches here as tuning. Apple's guided
+            // generation enforces it; before, it was accepted and silently ignored.
+            ...(opts.tuning?.output?.jsonSchema !== undefined
+                ? { responseSchema: opts.tuning.output.jsonSchema }
+                : {}),
+            ...(opts.terminalToolPolicy ? { terminalToolPolicy: opts.terminalToolPolicy } : {}),
+        });
+    }
+}
+/** @internal Exported for unit tests. */
+export class AppleFoundationSession extends StreamingSessionBase {
+    deps;
+    model = APPLE_FOUNDATION_MODEL_ID;
+    numCtx;
+    systemMessage;
+    history;
+    /** Where this conversation last fitted; later turns start there. */
+    listing = 'full';
+    responseSchema;
+    finish = null;
+    constructor(deps) {
+        super();
+        this.deps = deps;
+        this.numCtx = deps.contextTokens;
+        this.systemMessage = deps.systemMessage;
+        this.history = [...deps.history];
+        this.listing = deps.startListing ?? 'full';
+        this.responseSchema =
+            deps.responseSchema === undefined ? undefined : nativeResponseSchema(deps.responseSchema);
+    }
+    /** Apple's own stop reason, and the 1,024-token cap it was held to. */
+    get lastTurnFinish() {
+        return this.finish;
+    }
+    setSystemMessage(message) {
+        this.systemMessage = message;
+    }
+    getRegisteredToolNames() {
+        return this.deps.bridges.isEmpty()
+            ? []
+            : this.deps.bridges.getOpenAITools().map((tool) => tool.name);
+    }
+    estimatePromptChars() {
+        return this.history.reduce((sum, m) => sum + m.content.length, this.systemMessage.length);
+    }
+    async sendAndWait(prompt, opts) {
+        return runInQueue(this.deps.queue, opts?.queue, () => this.sendAndWaitInner(prompt, opts));
+    }
+    async sendAndWaitInner(prompt, opts) {
+        const started = Date.now();
+        const timeout = createAwakeTimeout(opts?.timeoutMs ?? TURN_BUDGET_MS);
+        const signal = opts?.queue?.signal
+            ? AbortSignal.any([opts.queue.signal, timeout.signal])
+            : timeout.signal;
+        const inventory = this.deps.bridges.isEmpty()
+            ? []
+            : this.deps.bridges.getOpenAITools().map(({ name, description, parameters }) => ({
+                name,
+                description,
+                parameters,
+            }));
+        let history = [...this.history];
+        let listing = NATIVE_TOOL_LISTINGS.includes(this.listing)
+            ? this.listing
+            : 'full';
+        let droppedHistory = false;
+        let text = '';
+        let stopReason = 'stop';
+        this.finish = null;
+        let usage;
+        let calls = 0;
+        let ended = null;
+        const failures = new Map();
+        // Apple's model issues calls in parallel (it wrote a file in the same
+        // breath as reading its source). One at a time keeps each result in view.
+        let serial = Promise.resolve();
+        const runTool = async (name, rawArgs, tools) => {
+            if (signal.aborted)
+                return { output: '', endTurn: true };
+            if (ended !== null)
+                return { output: '', endTurn: true };
+            if (++calls > MAX_TOOL_CALLS) {
+                ended = ACTION_LIMIT_TEXT;
+                return { output: '', endTurn: true };
+            }
+            const spec = tools.find((tool) => tool.name === name);
+            let parsed;
+            try {
+                parsed = JSON.parse(rawArgs);
+            }
+            catch {
+                parsed = {};
+            }
+            const decoded = spec ? decodeNativeToolArguments(spec.parameters, parsed) : parsed;
+            const args = decoded && typeof decoded === 'object' && !Array.isArray(decoded)
+                ? decoded
+                : {};
+            let output;
+            let isError = false;
+            if (this.deps.bridges.hasTool(name)) {
+                try {
+                    const rich = await this.deps.bridges.callToolRich(name, args, {
+                        budgetChars: computeToolBudgetChars(this.deps.contextTokens, this.systemMessage.length + history.reduce((n, m) => n + m.content.length, 0)),
+                        numCtxTokens: this.deps.contextTokens,
+                    });
+                    output = rich.text;
+                    isError = rich.isError;
+                }
+                catch (err) {
+                    output = `ERROR: ${err instanceof Error ? err.message : String(err)}`;
+                    isError = true;
+                }
+            }
+            else {
+                output = `ERROR: tool ${name} is not available`;
+                isError = true;
+            }
+            if (isError) {
+                const key = `${name}\n${stableJson(args)}\n${output}`;
+                const count = (failures.get(key) ?? 0) + 1;
+                failures.set(key, count);
+                if (count >= 3) {
+                    ended = `Stopped: the same ${name} call failed three times (${output.slice(0, 200)}). Add detail or rephrase, then try again.`;
+                    return { output, endTurn: true };
+                }
+            }
+            else {
+                const closing = terminalToolClosingText(this.deps.terminalToolPolicy, name, args, output);
+                if (closing) {
+                    ended = closing;
+                    return { output, endTurn: true };
+                }
+            }
+            return { output };
+        };
+        try {
+            for (;;) {
+                const tools = nativeToolSpecs(inventory, listing);
+                const messages = [
+                    {
+                        role: 'system',
+                        content: `${this.systemMessage}${inventory.length && listing === 'none' ? NO_TOOLS_NOTE : ''}`,
+                    },
+                    ...history,
+                    { role: 'user', content: prompt },
+                ];
+                try {
+                    stopReason = await this.deps.helper.generate({
+                        messages,
+                        tools,
+                        maxTokens: this.deps.maxTokens,
+                        contextSize: this.deps.contextTokens,
+                        ...(this.responseSchema ? { schema: this.responseSchema } : {}),
+                    }, {
+                        onUsage: (value) => {
+                            usage = value;
+                        },
+                        onDelta: (chunk) => {
+                            text += chunk;
+                            // A guided reply is decoded whole once it finishes.
+                            if (!this.responseSchema)
+                                this.emitDelta(chunk);
+                        },
+                        onToolCall: (call) => {
+                            const next = serial.then(() => runTool(call.name, call.arguments, tools));
+                            serial = next.catch(() => { });
+                            return next;
+                        },
+                    }, signal);
+                    if (stopReason === 'cancelled' && timeout.signal.aborted && ended === null)
+                        throw new Error(`Apple on-device AI timed out after ${Math.round((opts?.timeoutMs ?? TURN_BUDGET_MS) / 1000)}s.`);
+                    await this.reportUsage(messages, tools, text, started, usage);
+                    break;
+                }
+                catch (error) {
+                    // The helper refuses an oversized prompt before generating anything,
+                    // so these retries cannot repeat an action.
+                    if (!isContextRefusal(error) || calls > 0 || text)
+                        throw error;
+                    const narrower = narrowerNativeListing(inventory, listing);
+                    if (narrower && narrower !== 'none') {
+                        listing = narrower;
+                        continue;
+                    }
+                    if (history.length > 0) {
+                        history = history.slice(Math.min(2, history.length));
+                        if (!droppedHistory) {
+                            droppedHistory = true;
+                            this.emitWarning("Earlier messages no longer fit Apple's on-device context; this reply sees only the most recent part of the conversation.");
+                        }
+                        continue;
+                    }
+                    if (narrower) {
+                        listing = narrower;
+                        continue;
+                    }
+                    throw actionable("This message is too long for Apple's on-device model. Shorten it or start a new conversation.");
+                }
+            }
+        }
+        finally {
+            timeout.dispose();
+        }
+        this.listing = listing;
+        if (this.responseSchema && ended === null) {
+            // Apple renders an unfinished guided reply as closed JSON with keys
+            // missing (a review stopped at `"category":"clar"}]`). Restoring nulls
+            // there would dress the half-written item up as complete, so a reply
+            // cut off at the cap is passed on as generated, marked `length`.
+            if (stopReason !== 'length')
+                text = this.decodeGuidedReply(text);
+            if (text)
+                this.emitDelta(text);
+        }
+        if (stopReason !== 'cancelled')
+            this.finish = { reason: stopReason, maxTokens: this.deps.maxTokens };
+        const reply = ended ?? text;
+        this.history.splice(0, this.history.length, ...history, { role: 'user', content: prompt });
+        if (reply)
+            this.history.push({ role: 'assistant', content: reply });
+        return reply;
+    }
+    /** The reply in the shape the app's schema asked for; text that is not JSON passes through. */
+    decodeGuidedReply(text) {
+        let value;
+        try {
+            value = JSON.parse(text);
+        }
+        catch {
+            return text;
+        }
+        return JSON.stringify(decodeNativeResponse(this.deps.responseSchema, this.responseSchema, value));
+    }
+    /** Input tokens are exact where the OS can count them (macOS 26.4+). */
+    async reportUsage(messages, tools, text, started, exact) {
+        if (exact) {
+            this.emitUsage(buildTurnUsage({
+                model: APPLE_FOUNDATION_MODEL_ID,
+                ...exact,
+                durationMs: Date.now() - started,
+                contextUtilization: {
+                    used: exact.inputTokens + exact.outputTokens,
+                    limit: this.deps.contextTokens,
+                },
+            }));
+            return;
+        }
+        let inputTokens = 0;
+        try {
+            inputTokens = await this.deps.helper.countTokens(messages, tools);
+        }
+        catch {
+            inputTokens = Math.ceil(messages.reduce((n, m) => n + m.content.length, 0) / 4);
+        }
+        this.emitUsage(buildTurnUsage({
+            model: APPLE_FOUNDATION_MODEL_ID,
+            inputTokens,
+            outputTokens: Math.ceil(text.length / 4),
+            durationMs: Date.now() - started,
+            contextUtilization: { used: inputTokens, limit: this.deps.contextTokens },
+        }));
+    }
+    providerState() {
+        return {};
+    }
+    async disconnect() {
+        this.clearHandlers();
+        try {
+            await this.deps.bridges.stop();
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}

package/dist/providers/apple-foundation-models/status.d.ts

@@ -0,0 +1,9 @@
+import { type AppleFoundationModelsStatus } from '@bendyline/gezel';
+import { AppleFmHelper } from './helper.js';
+/** Explicit diagnostic only: configuration reads never launch a subprocess. */
+export declare function appleFoundationModelsStatus(opts?: {
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    arch?: string;
+    createHelper?: (binaryPath: string) => Pick<AppleFmHelper, 'ready' | 'shutdown'>;
+}): Promise<AppleFoundationModelsStatus>;

package/dist/providers/apple-foundation-models/status.js

@@ -0,0 +1,49 @@
+import { acquireSuspendMonitor } from '@bendyline/gezel';
+import { appleFmBinaryPath, appleFoundationModelsInstalled } from './binary.js';
+import { AppleFmHelper } from './helper.js';
+/** Explicit diagnostic only: configuration reads never launch a subprocess. */
+export async function appleFoundationModelsStatus(opts = {}) {
+    const env = opts.env ?? process.env;
+    const platform = opts.platform ?? process.platform;
+    const arch = opts.arch ?? process.arch;
+    const supported = platform === 'darwin' && arch === 'arm64';
+    const installed = appleFoundationModelsInstalled(env, platform, arch);
+    if (!supported || !installed)
+        return {
+            supported,
+            installed,
+            available: false,
+            reason: supported
+                ? 'This Gezel installation does not include Apple on-device AI.'
+                : 'Apple on-device AI requires an Apple silicon Mac.',
+        };
+    const helper = opts.createHelper?.(appleFmBinaryPath(env)) ??
+        new AppleFmHelper({ binaryPath: appleFmBinaryPath(env) });
+    const release = acquireSuspendMonitor();
+    try {
+        const runtime = await helper.ready();
+        return {
+            supported,
+            installed,
+            available: runtime.available,
+            runtime,
+            ...(runtime.reason ? { reason: runtime.reason } : {}),
+        };
+    }
+    catch (error) {
+        return {
+            supported,
+            installed,
+            available: false,
+            reason: error instanceof Error ? error.message : String(error),
+        };
+    }
+    finally {
+        try {
+            await helper.shutdown();
+        }
+        finally {
+            release();
+        }
+    }
+}

package/dist/providers/audio/kokoro-frontend.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The desktop half of Kokoro's text frontend.
+ *
+ * Kokoro reads phoneme ids rather than text. `kokoro-js` will do that
+ * conversion itself, but only by calling `phonemizer`, which embeds eSpeak NG —
+ * GPL-3 code that cannot ship inside an MIT app on the app stores. So the
+ * daemon converts text here instead, using the shared `@bendyline/gezel/kokoro`
+ * frontend and the same dictionary the mobile voice pack carries, and hands
+ * `generate_from_ids` the token ids directly.
+ *
+ * The dictionaries are staged by `scripts/build-kokoro-lexicon.mjs` and
+ * gzipped; they are read once, on first synthesis, and then cached.
+ */
+/** Kokoro voice ids start with their language: `af_heart` is American, `bm_george` British. */
+export type KokoroLanguage = 'us' | 'gb';
+/** One inference: a phrase short enough for the model, with its token ids. */
+export interface KokoroUtterance {
+    /** Source text, used only for progress reporting. */
+    readonly text: string;
+    /** Phonemes handed to the tokenizer, kept for diagnostics. */
+    readonly phonemes: string;
+    /** Padded token ids for `generate_from_ids`. */
+    readonly tokens: readonly number[];
+}
+/** American voices are `a*`, British voices are `b*`; anything else reads as American. */
+export declare function kokoroLanguageForVoice(voiceId: string): KokoroLanguage;
+/**
+ * Find the staged dictionaries. `dist/kokoro-lexicon` is the packaged copy;
+ * the repo path is the development fallback, mirroring how the UI bundle and
+ * the handboek content are located.
+ */
+export declare function findKokoroLexiconDir(from?: string): string | undefined;
+export interface KokoroFrontendOptions {
+    /** Directory holding the gzipped dictionaries. Defaults to the staged copy. */
+    readonly lexiconDir?: string;
+}
+/** Loads and caches the dictionaries, and turns text into model-ready utterances. */
+export declare class KokoroFrontend {
+    private readonly lexiconDir;
+    private readonly loaded;
+    constructor(options?: KokoroFrontendOptions);
+    /** Read one dictionary, at most once per process. */
+    private lexicon;
+    /**
+     * Break text into utterances the model can speak, each already tokenized.
+     * Sentences stay whole where they fit, so the caller keeps streaming one
+     * sentence of audio at a time.
+     */
+    plan(text: string, voiceId: string): Promise<KokoroUtterance[]>;
+}

package/dist/providers/audio/kokoro-frontend.js

@@ -0,0 +1,113 @@
+/**
+ * The desktop half of Kokoro's text frontend.
+ *
+ * Kokoro reads phoneme ids rather than text. `kokoro-js` will do that
+ * conversion itself, but only by calling `phonemizer`, which embeds eSpeak NG —
+ * GPL-3 code that cannot ship inside an MIT app on the app stores. So the
+ * daemon converts text here instead, using the shared `@bendyline/gezel/kokoro`
+ * frontend and the same dictionary the mobile voice pack carries, and hands
+ * `generate_from_ids` the token ids directly.
+ *
+ * The dictionaries are staged by `scripts/build-kokoro-lexicon.mjs` and
+ * gzipped; they are read once, on first synthesis, and then cached.
+ */
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { gunzipSync } from 'node:zlib';
+import { parseKokoroLexicon, phonemizeForKokoro, splitForKokoro, tokenizeKokoroPhonemes, } from '@bendyline/gezel/kokoro';
+/** American voices are `a*`, British voices are `b*`; anything else reads as American. */
+export function kokoroLanguageForVoice(voiceId) {
+    return voiceId.startsWith('b') ? 'gb' : 'us';
+}
+const FILES = {
+    us: 'lexicon-us-en.txt.gz',
+    gb: 'lexicon-gb-en.txt.gz',
+};
+/**
+ * Find the staged dictionaries. `dist/kokoro-lexicon` is the packaged copy;
+ * the repo path is the development fallback, mirroring how the UI bundle and
+ * the handboek content are located.
+ */
+export function findKokoroLexiconDir(from = import.meta.url) {
+    // Walk up rather than assume a depth: the bundled layout under dist/ and the
+    // source layout under src/ nest differently, and both must resolve.
+    let directory = dirname(fileURLToPath(from));
+    for (let depth = 0; depth < 6; depth++) {
+        for (const candidate of [
+            join(directory, 'kokoro-lexicon'),
+            join(directory, 'assets', 'kokoro'),
+        ])
+            if (existsSync(join(candidate, FILES.us)))
+                return candidate;
+        const parent = resolve(directory, '..');
+        if (parent === directory)
+            break;
+        directory = parent;
+    }
+    return undefined;
+}
+/** Loads and caches the dictionaries, and turns text into model-ready utterances. */
+export class KokoroFrontend {
+    lexiconDir;
+    loaded = new Map();
+    constructor(options = {}) {
+        this.lexiconDir = options.lexiconDir ?? findKokoroLexiconDir();
+    }
+    /** Read one dictionary, at most once per process. */
+    lexicon(language) {
+        const cached = this.loaded.get(language);
+        if (cached)
+            return cached;
+        const directory = this.lexiconDir;
+        const pending = (async () => {
+            if (!directory)
+                throw new Error('Kokoro pronunciation dictionary is missing; rebuild the service ' +
+                    '(node scripts/build-kokoro-lexicon.mjs stages it).');
+            const file = join(directory, FILES[language]);
+            let packed;
+            try {
+                packed = await readFile(file);
+            }
+            catch (cause) {
+                // A bare ENOENT here reads as a bug; say what is missing and how to
+                // put it back, because a packaging slip is the likely cause.
+                throw new Error(`Kokoro pronunciation dictionary is missing at ${file}; rebuild the service (node scripts/build-kokoro-lexicon.mjs stages it).`, { cause });
+            }
+            return parseKokoroLexicon(gunzipSync(packed).toString('utf8'));
+        })();
+        // A failed read must not be cached as a permanent failure.
+        void pending.catch(() => this.loaded.delete(language));
+        this.loaded.set(language, pending);
+        return pending;
+    }
+    /**
+     * Break text into utterances the model can speak, each already tokenized.
+     * Sentences stay whole where they fit, so the caller keeps streaming one
+     * sentence of audio at a time.
+     */
+    async plan(text, voiceId) {
+        const lexicon = await this.lexicon(kokoroLanguageForVoice(voiceId));
+        const utterances = [];
+        // Split the source text first so progress still tracks readable units.
+        const sentences = text
+            .split(/(?<=[.!?…])\s+/)
+            .map((sentence) => sentence.trim())
+            .filter(Boolean);
+        for (const sentence of sentences.length ? sentences : [text.trim()].filter(Boolean)) {
+            const phonemes = phonemizeForKokoro(sentence, { lexicon });
+            if (!phonemes)
+                continue;
+            // A single very long sentence still has to fit the model's style table.
+            for (const piece of splitForKokoro(phonemes)) {
+                const { tokens } = tokenizeKokoroPhonemes(piece);
+                // Two pad frames and nothing else would be silence.
+                if (tokens.length <= 2)
+                    continue;
+                utterances.push({ text: sentence, phonemes: piece, tokens });
+            }
+        }
+        return utterances;
+    }
+}

package/dist/providers/audio/managed-speech-model.d.ts

@@ -0,0 +1,9 @@
+import { type SpeechAssetStore, type SpeechModelEntry } from '@bendyline/gezel/speech-models';
+import type { AudioModelPullEvent, InstalledAudioModelInfo } from './types.js';
+/** Inventory reads never download or publish an installation. */
+export declare function sharedSpeechModelInfo(assets: SpeechAssetStore, entry: SpeechModelEntry, root: string): Promise<InstalledAudioModelInfo | null>;
+/** Acquire this app's references and publish a Gezel-compatible manifest last. */
+export declare function ensureSpeechModel(assets: SpeechAssetStore, entry: SpeechModelEntry, root: string, download: boolean, onProgress?: (received: number, total: number) => void): Promise<boolean>;
+export declare function writeSpeechMetadata(directory: string, name: string, bytes: string): Promise<void>;
+/** Preserve byte-level progress while the shared installer coordinates another process. */
+export declare function speechPullEvents(id: string, work: (progress: (received: number, total: number) => void) => Promise<unknown>): AsyncIterable<AudioModelPullEvent>;