@bendyline/gezel-inference 0.0.0-stage → 1.0.0

package/dist/providers/audio/whisper-cpp.js

@@ -0,0 +1,420 @@
+/**
+ * WhisperCppProvider — talks to a local `whisper-server` binary over
+ * HTTP. The server speaks `POST /inference` with a multipart form
+ * upload (`file=@audio.wav`) plus optional `language`, `prompt`,
+ * `temperature`, `response_format`. We always request `json` so we
+ * get `{ text, segments, language }` back in one parse.
+ *
+ * Lifecycle of the binary itself is the supervisor's concern — this
+ * provider just calls `ensureRunning()` before each transcription and
+ * marks activity afterwards, identical to how
+ * `StableDiffusionCppProvider` delegates to `NativeEngineSupervisor`.
+ *
+ * Model management mirrors sd-cpp: weights live under
+ * `<modelsRoot>/<id>/<filename>` alongside a `manifest.json`. The
+ * narration MVP hard-codes a small catalog of Whisper GGML
+ * conversions hosted on Hugging Face under `ggerganov/whisper.cpp`
+ * (see `WHISPER_MODEL_CATALOG`); a future revision can route through
+ * the proper catalog system instead.
+ */
+import { createHash } from 'node:crypto';
+import { createReadStream } from 'node:fs';
+import { mkdir, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { SPEECH_MODEL_CATALOG, SpeechAssetStore, catalogEntry, } from '@bendyline/gezel/speech-models';
+import { FormData } from 'undici';
+import { resolveModelDirectory } from '../../models/model-id.js';
+import { MODEL_HASH_READ_BUFFER_BYTES, assertModelStorePathSafe, findModelRoot, hashModelPayloadFiles, listOverlayModelIds, makeSharedModelReadable, modelExistsOnlyReadOnly, readOnlyModelError, verifyReadOnlyModelPayload, } from '../../models/storage-roots.js';
+import { downloadWithRetry } from '../../utils/download-with-retry.js';
+import { ensureSpeechModel, sharedSpeechModelInfo, speechPullEvents, } from './managed-speech-model.js';
+const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000;
+/**
+ * Whisper GGML conversions on Hugging Face. Sizes are approximate —
+ * the actual bytes are verified by sha256 at pull time. SHA values
+ * below are the published Hugging Face values; bumping a model means
+ * editing both the URL/sha together.
+ *
+ * Why hard-code instead of going through `@bendyline/gezel-catalog`:
+ * the audio MVP's three models don't justify the catalog manifest
+ * round-trip (registering a new `audio-stt-model` kind, plumbing it
+ * through `CatalogService`, etc.). When TTS / STT grow more variants,
+ * promote this list into the catalog same way image-models are.
+ */
+export const WHISPER_MODEL_CATALOG = SPEECH_MODEL_CATALOG.filter((entry) => entry.kind === 'stt').map((entry) => ({
+    id: entry.id,
+    name: entry.label,
+    description: entry.description,
+    approxSizeBytes: entry.files[0].size,
+    downloadUrl: entry.files[0].url,
+    sha256: entry.files[0].sha256,
+    filename: entry.files[0].name,
+}));
+export class WhisperCppProvider {
+    name = 'whisper-cpp';
+    baseUrl;
+    modelsRoot;
+    assets;
+    storageRoots;
+    timeoutMs;
+    fetchImpl;
+    supervisor;
+    configured;
+    constructor(opts) {
+        this.baseUrl = opts.baseUrl.replace(/\/+$/, '');
+        this.modelsRoot = opts.modelsRoot;
+        if (opts.assets)
+            this.assets = new SpeechAssetStore({ ...opts.assets, fetchImpl: opts.fetchImpl });
+        this.storageRoots = opts.storageRoots ?? {
+            writableRoot: opts.modelsRoot,
+            readOnlyRoots: [],
+        };
+        this.timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        this.fetchImpl = opts.fetchImpl ?? fetch;
+        this.supervisor = opts.supervisor;
+        this.configured = opts.configured ?? true;
+    }
+    async transcribe(input) {
+        return this.supervisor
+            ? this.supervisor.withRequest(() => this.transcribeInner(input))
+            : this.transcribeInner(input);
+    }
+    async transcribeInner(input) {
+        const started = Date.now();
+        let baseUrl = this.baseUrl;
+        if (this.supervisor) {
+            const launch = await this.supervisor.ensureRunning();
+            baseUrl = launch.baseUrl.replace(/\/+$/, '');
+        }
+        let bytes;
+        let mime;
+        let filename;
+        if ('path' in input.audio) {
+            bytes = await readFile(input.audio.path);
+            filename = basename(input.audio.path);
+            mime = guessMime(filename);
+        }
+        else {
+            bytes = input.audio.data;
+            mime = input.audio.mimeType || 'audio/wav';
+            filename = inlineAudioFilename(mime);
+        }
+        // `patientFetch()` is the npm `undici` fetch, not Node's bundled global
+        // fetch. Its BodyInit brand-check does not recognize Node's global
+        // FormData and serializes it as the literal string "[object FormData]".
+        // Build the form with the matching undici implementation so whisper.cpp
+        // receives a real multipart `file` field.
+        const form = new FormData();
+        form.set('file', new Blob([new Uint8Array(bytes)], { type: mime }), filename);
+        form.set('response_format', 'json');
+        if (input.language)
+            form.set('language', input.language);
+        if (input.model)
+            form.set('model', input.model);
+        if (input.prompt)
+            form.set('prompt', input.prompt);
+        const ctrl = new AbortController();
+        const timer = setTimeout(() => ctrl.abort(), this.timeoutMs);
+        let res;
+        try {
+            res = await this.fetchImpl(`${baseUrl}/inference`, {
+                method: 'POST',
+                body: form,
+                signal: ctrl.signal,
+            });
+        }
+        catch (err) {
+            if (ctrl.signal.aborted) {
+                throw new Error(`whisper-server did not respond within ${this.timeoutMs / 1000}s`);
+            }
+            throw new Error(`whisper-server unreachable at ${baseUrl}. Is the audio engine enabled in Settings? (${err instanceof Error ? err.message : String(err)})`);
+        }
+        finally {
+            clearTimeout(timer);
+            this.supervisor?.markUsed();
+        }
+        if (!res.ok) {
+            const text = await res.text().catch(() => '');
+            throw new Error(`whisper-server returned ${res.status} ${res.statusText}: ${text.slice(0, 300)}`);
+        }
+        const payload = (await res.json());
+        const text = normalizeWhisperTranscript(payload.text ?? '');
+        const out = {
+            text,
+            durationMs: Date.now() - started,
+        };
+        // Echo the model that actually ran: the explicit request, else the
+        // documented fallback (first installed model), resolved HERE so the
+        // fallback rule lives in one place and consumers can stamp provenance.
+        const model = input.model ?? (await this.listInstalledModels().catch(() => []))[0]?.id;
+        if (model)
+            out.model = model;
+        if (payload.language)
+            out.language = payload.language;
+        if (Array.isArray(payload.segments) && payload.segments.length > 0) {
+            out.segments = payload.segments
+                .filter((s) => typeof s.start === 'number' && typeof s.end === 'number' && typeof s.text === 'string')
+                .map((s) => ({ start: s.start, end: s.end, text: s.text.trim() }));
+        }
+        return out;
+    }
+    async listInstalledModels() {
+        const entries = await listOverlayModelIds(this.storageRoots);
+        const out = [];
+        for (const id of entries) {
+            try {
+                const root = await findModelRoot(this.storageRoots, id);
+                if (!root)
+                    continue;
+                const raw = await readFile(join(root, id, 'manifest.json'), 'utf8');
+                const parsed = JSON.parse(raw);
+                if (!parsed.id || !parsed.name || !parsed.installedAt)
+                    continue;
+                if (!(await verifyReadOnlyModelPayload(this.storageRoots, root, id, parsed.fileSha256))) {
+                    continue;
+                }
+                out.push({
+                    id: parsed.id,
+                    name: parsed.name,
+                    approxSizeBytes: parsed.approxSizeBytes ?? 0,
+                    installedAt: parsed.installedAt,
+                });
+            }
+            catch {
+                /* skip malformed entries */
+            }
+        }
+        if (this.assets)
+            for (const entry of SPEECH_MODEL_CATALOG.filter((entry) => entry.kind === 'stt')) {
+                if (out.some((model) => model.id === entry.id))
+                    continue;
+                const info = await sharedSpeechModelInfo(this.assets, entry, this.modelsRoot);
+                if (info)
+                    out.push(info);
+            }
+        out.sort((a, b) => a.name.localeCompare(b.name));
+        return out;
+    }
+    async *pullModel(id, spec) {
+        const pinned = catalogEntry(id);
+        if (this.assets &&
+            pinned?.kind === 'stt' &&
+            spec.files.length === 1 &&
+            spec.files[0]?.sha256.toLowerCase() === pinned.files[0]?.sha256) {
+            yield* speechPullEvents(id, async (progress) => {
+                await ensureSpeechModel(this.assets, pinned, this.modelsRoot, true, progress);
+                await makeSharedModelReadable(join(this.modelsRoot, id));
+            });
+            return;
+        }
+        const itemDir = join(this.modelsRoot, id);
+        await mkdir(this.modelsRoot, { recursive: true });
+        await assertModelStorePathSafe(this.modelsRoot, itemDir);
+        await mkdir(itemDir, { recursive: true });
+        await assertModelStorePathSafe(this.modelsRoot, itemDir);
+        const totalAllBytes = spec.files.reduce((n, f) => n + f.approxSizeBytes, 0);
+        let writtenAll = 0;
+        for (const file of spec.files) {
+            const filename = filenameForRole(file.role, file.downloadUrl);
+            const destPath = join(itemDir, filename);
+            const result = yield* downloadWithSha256(this.fetchImpl, {
+                url: file.downloadUrl,
+                destPath,
+                expectedSha256: file.sha256,
+                approxSizeBytes: file.approxSizeBytes,
+                writtenSoFar: writtenAll,
+                totalAllBytes,
+            });
+            if (result.kind === 'error') {
+                yield { type: 'error', error: `${file.role}: ${result.error}` };
+                yield { type: 'done', id };
+                return;
+            }
+            writtenAll = result.writtenAll;
+        }
+        const fileSha256 = await hashModelPayloadFiles(itemDir);
+        await writeFile(join(itemDir, 'manifest.json'), JSON.stringify({
+            id,
+            name: spec.name,
+            approxSizeBytes: totalAllBytes,
+            files: spec.files.map((f) => ({
+                role: f.role,
+                filename: filenameForRole(f.role, f.downloadUrl),
+                sha256: f.sha256.toLowerCase(),
+            })),
+            fileSha256,
+            installedAt: new Date().toISOString(),
+        }, null, 2), 'utf8');
+        await makeSharedModelReadable(itemDir);
+        yield { type: 'progress', bytesWritten: writtenAll, totalBytes: totalAllBytes };
+        yield { type: 'done', id };
+    }
+    async deleteModel(id) {
+        const itemDir = resolveModelDirectory(this.modelsRoot, id);
+        if (await modelExistsOnlyReadOnly(this.storageRoots, id)) {
+            throw readOnlyModelError(id);
+        }
+        await rm(itemDir, { recursive: true, force: true });
+        const pinned = catalogEntry(id);
+        if (this.assets && pinned)
+            for (const file of pinned.files)
+                await this.assets.collect(file);
+    }
+    async health() {
+        if (!this.configured) {
+            return {
+                status: 'not-configured',
+                baseUrl: this.baseUrl,
+                error: 'whisper.cpp engine is not wired up. Build the binary or pull a model from Settings → Audio.',
+            };
+        }
+        const installed = await this.listInstalledModels();
+        if (installed.length === 0) {
+            return {
+                status: 'no-model',
+                baseUrl: this.baseUrl,
+                error: 'No STT model is available locally. Download one from Settings → Audio.',
+            };
+        }
+        if (this.supervisor) {
+            // Engine is configured + has a model; the supervisor will lazy-start
+            // on the next transcribe. Don't probe eagerly — same reasoning as
+            // sd-cpp's health(): a Settings open shouldn't pay a cold-start.
+            return { status: 'ok', baseUrl: this.baseUrl };
+        }
+        return await probeReachable(this.fetchImpl, this.baseUrl);
+    }
+    async shutdown() {
+        await this.supervisor?.stop();
+    }
+}
+/** whisper.cpp emits this sentinel for valid audio containing no speech. */
+export function normalizeWhisperTranscript(value) {
+    const text = value.trim();
+    return /^\[\s*BLANK_AUDIO\s*\]$/i.test(text) ? '' : text;
+}
+/** MediaRecorder MIME values often carry codec parameters; filenames cannot. */
+export function inlineAudioFilename(mimeType) {
+    const subtype = mimeType.split(';', 1)[0]?.split('/', 2)[1]?.trim().toLowerCase();
+    const extension = subtype?.replace(/[^a-z0-9.+_-]/g, '') || 'wav';
+    return `audio.${extension}`;
+}
+/**
+ * Resolve the on-disk filename for a downloaded file. Whisper today
+ * is a single-file pull (`weights`), so `filenameForRole` mostly just
+ * returns the URL's basename. Defined as a helper so Kokoro / future
+ * multi-file pulls (e.g. `voice:af_heart`) can reuse the convention.
+ */
+function filenameForRole(role, url) {
+    const base = extractFilename(url);
+    if (role === 'weights')
+        return base;
+    // Voice files etc. — keep the role in the filename so the manifest
+    // and disk layout are self-describing.
+    const dot = base.lastIndexOf('.');
+    const ext = dot > 0 ? base.slice(dot) : '';
+    const safeRole = role.replace(/[^a-zA-Z0-9._-]+/g, '_');
+    return `${safeRole}${ext}`;
+}
+function extractFilename(url) {
+    try {
+        const u = new URL(url);
+        const last = u.pathname.split('/').filter(Boolean).pop();
+        return last && last.length > 0 ? last : 'weights.bin';
+    }
+    catch {
+        return 'weights.bin';
+    }
+}
+function guessMime(filename) {
+    const lower = filename.toLowerCase();
+    if (lower.endsWith('.wav'))
+        return 'audio/wav';
+    if (lower.endsWith('.mp3'))
+        return 'audio/mpeg';
+    if (lower.endsWith('.m4a') || lower.endsWith('.mp4'))
+        return 'audio/mp4';
+    if (lower.endsWith('.ogg') || lower.endsWith('.oga'))
+        return 'audio/ogg';
+    if (lower.endsWith('.flac'))
+        return 'audio/flac';
+    if (lower.endsWith('.webm'))
+        return 'audio/webm';
+    return 'application/octet-stream';
+}
+async function probeReachable(fetchImpl, baseUrl) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), 2000);
+    try {
+        const res = await fetchImpl(`${baseUrl}/`, { method: 'GET', signal: ctrl.signal });
+        void res.body?.cancel?.().catch(() => { });
+        return { status: 'ok', baseUrl };
+    }
+    catch (err) {
+        return {
+            status: 'unreachable',
+            baseUrl,
+            error: ctrl.signal.aborted
+                ? `whisper-server did not respond within 2s at ${baseUrl}`
+                : err instanceof Error
+                    ? err.message
+                    : String(err),
+        };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * Stream a URL to disk with sha256 verification, yielding cumulative
+ * progress events. Shared with KokoroProvider via a sibling import —
+ * exported so we don't duplicate the logic.
+ */
+export async function* downloadWithSha256(fetchImpl, opts) {
+    const { url, destPath, expectedSha256, totalAllBytes } = opts;
+    let writtenAll = opts.writtenSoFar;
+    const tmpPath = `${destPath}.partial`;
+    const download = downloadWithRetry({
+        url,
+        destPath,
+        approxSizeBytes: opts.approxSizeBytes,
+        fetchImpl,
+    });
+    let writtenThisFile = 0;
+    while (true) {
+        const next = await download.next();
+        if (next.done) {
+            if (next.value.kind === 'aborted')
+                return { kind: 'error', error: 'download aborted' };
+            if (next.value.kind === 'error')
+                return { kind: 'error', error: next.value.error };
+            writtenThisFile = next.value.bytesWritten;
+            writtenAll = opts.writtenSoFar + writtenThisFile;
+            break;
+        }
+        if (next.value.type === 'progress') {
+            writtenThisFile = next.value.bytesWritten;
+            writtenAll = opts.writtenSoFar + writtenThisFile;
+            yield { type: 'progress', bytesWritten: writtenAll, totalBytes: totalAllBytes };
+        }
+    }
+    const hasher = createHash('sha256');
+    await new Promise((resolve, reject) => {
+        // Big read buffer so the hash doesn't starve in the busy daemon event
+        // loop. See MODEL_HASH_READ_BUFFER_BYTES.
+        const stream = createReadStream(tmpPath, { highWaterMark: MODEL_HASH_READ_BUFFER_BYTES });
+        stream.on('data', (chunk) => hasher.update(chunk));
+        stream.on('end', resolve);
+        stream.on('error', reject);
+    });
+    const actual = hasher.digest('hex');
+    if (actual !== expectedSha256.toLowerCase()) {
+        await rm(tmpPath, { force: true });
+        return {
+            kind: 'error',
+            error: `sha256 mismatch: expected ${expectedSha256}, got ${actual}`,
+        };
+    }
+    await rm(destPath, { force: true });
+    await rename(tmpPath, destPath);
+    return { kind: 'ok', writtenAll, actualSize: writtenThisFile };
+}

package/dist/providers/audio-persister-contract.d.ts

@@ -0,0 +1,13 @@
+export interface ToolAudioPersister {
+    persist(audios: ReadonlyArray<{
+        base64: string;
+        mimeType: string;
+        durationSeconds?: number;
+        voice?: string;
+    }>): Promise<Array<{
+        path: string;
+        mimeType: string;
+        durationSeconds?: number;
+        voice?: string;
+    }>>;
+}

package/dist/providers/audio-persister-contract.js

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

package/dist/providers/catalog-model-config.d.ts

@@ -0,0 +1,63 @@
+import type { CatalogService } from '@bendyline/gezel-catalog';
+/**
+ * Translate a possibly-tag-shaped model id to its canonical catalog
+ * id. The chat manager stores `record.model` as whatever string the
+ * caller passed — which is often the Ollama tag (`gemma4:26b`,
+ * `qwen3.6:latest`) rather than the catalog id (`gemma4-26b`,
+ * `qwen3.6`). All downstream lookups (parameter size, profile
+ * resolution) need the catalog id; without this translation they
+ * miss and fall through to tier defaults, which silently disables
+ * every per-model behavior the manifest declared.
+ *
+ * Resolution order:
+ *   1. Direct id lookup — `catalog.get('chat-model', modelId)` hits
+ *      when the caller passed the canonical id (e.g. `gemma4-26b`).
+ *   2. Tag-aware fallback — list every chat-model entry and find
+ *      one whose `ollama.tag` matches the requested string (or its
+ *      `:latest`-stripped form). Worth the O(n) walk because the
+ *      catalog list is small (~12 entries) and the result of step 1
+ *      determines whether the per-model behaviors fire at all.
+ *
+ * Returns `undefined` when neither path resolves — caller falls back
+ * to the original modelId string for downstream logic. Best-effort:
+ * any thrown error from the catalog returns undefined silently.
+ */
+export declare function resolveCatalogIdFromModelId(catalog: CatalogService, modelId: string | undefined): Promise<string | undefined>;
+/**
+ * Catalog-driven `--reasoning-budget N` lookup. Returns the integer
+ * the supervisor passes to `llama-server`, or undefined to leave the
+ * default unrestricted (-1). The rule itself is shared with the phone's
+ * native chat layer: see `catalogReasoningBudget`.
+ */
+export declare function resolveCatalogReasoningBudget(catalog: CatalogService, catalogId: string | undefined): Promise<number | undefined>;
+/**
+ * The catalog manifest's per-model llama.cpp engine-launch defaults
+ * (`tuning.engine.llamaCpp`), if any. Mirrors
+ * {@link resolveCatalogReasoningBudget}: engine flags are a model-LOAD
+ * concern (argv), so we read them straight off the manifest rather than
+ * the per-request tuning resolver. Returns undefined on any miss — the
+ * launcher then falls through to global `config.llamaCpp*` + server
+ * defaults.
+ */
+export declare function resolveCatalogLlamaCppEngineConfig(catalog: CatalogService, catalogId: string | undefined): Promise<{
+    nGpuLayers?: number | undefined;
+    cpuMoe?: boolean | undefined;
+    nCpuMoe?: number | undefined;
+    nCpuFfn?: number | undefined;
+    loadMode?: "none" | "auto" | "mmap" | "mlock" | "mmap+mlock" | "dio" | undefined;
+    lazyMode?: "on" | "off" | "auto" | undefined;
+    cacheReuse?: number | undefined;
+    swaFull?: boolean | undefined;
+    flashAttn?: "on" | "off" | "auto" | undefined;
+    ubatchSize?: number | undefined;
+    contextSize?: number | undefined;
+    chatTemplate?: string | undefined;
+    threads?: number | undefined;
+    batchSize?: number | undefined;
+    spec?: {
+        type?: "none" | "draft-mtp" | "draft-eagle3" | "draft-dflash" | "draft-simple" | "ngram-mod" | "ngram-simple" | "ngram-map-k" | "ngram-map-k4v" | "ngram-cache" | undefined;
+        mtp?: boolean | undefined;
+        draftModelId?: string | undefined;
+        nMax?: number | undefined;
+    } | undefined;
+} | undefined>;

package/dist/providers/catalog-model-config.js

@@ -0,0 +1,95 @@
+import { catalogReasoningBudget, normalizeChatModelCatalogId } from '@bendyline/gezel';
+/**
+ * Translate a possibly-tag-shaped model id to its canonical catalog
+ * id. The chat manager stores `record.model` as whatever string the
+ * caller passed — which is often the Ollama tag (`gemma4:26b`,
+ * `qwen3.6:latest`) rather than the catalog id (`gemma4-26b`,
+ * `qwen3.6`). All downstream lookups (parameter size, profile
+ * resolution) need the catalog id; without this translation they
+ * miss and fall through to tier defaults, which silently disables
+ * every per-model behavior the manifest declared.
+ *
+ * Resolution order:
+ *   1. Direct id lookup — `catalog.get('chat-model', modelId)` hits
+ *      when the caller passed the canonical id (e.g. `gemma4-26b`).
+ *   2. Tag-aware fallback — list every chat-model entry and find
+ *      one whose `ollama.tag` matches the requested string (or its
+ *      `:latest`-stripped form). Worth the O(n) walk because the
+ *      catalog list is small (~12 entries) and the result of step 1
+ *      determines whether the per-model behaviors fire at all.
+ *
+ * Returns `undefined` when neither path resolves — caller falls back
+ * to the original modelId string for downstream logic. Best-effort:
+ * any thrown error from the catalog returns undefined silently.
+ */
+export async function resolveCatalogIdFromModelId(catalog, modelId) {
+    if (!modelId)
+        return undefined;
+    const normalized = normalizeChatModelCatalogId(modelId);
+    try {
+        const direct = await catalog.get('chat-model', normalized ?? modelId);
+        if (direct && direct.manifest.kind === 'chat-model')
+            return direct.manifest.id;
+    }
+    catch {
+        // Fall through to the tag-aware path.
+    }
+    try {
+        const baseTag = modelId.replace(/:latest$/, '');
+        const items = await catalog.list('chat-model');
+        for (const item of items) {
+            if (item.manifest.kind !== 'chat-model')
+                continue;
+            const tag = item.manifest.ollama?.tag;
+            if (tag === modelId || tag === baseTag)
+                return item.manifest.id;
+        }
+    }
+    catch {
+        // Fall through.
+    }
+    return undefined;
+}
+/**
+ * Catalog-driven `--reasoning-budget N` lookup. Returns the integer
+ * the supervisor passes to `llama-server`, or undefined to leave the
+ * default unrestricted (-1). The rule itself is shared with the phone's
+ * native chat layer: see `catalogReasoningBudget`.
+ */
+export async function resolveCatalogReasoningBudget(catalog, catalogId) {
+    if (!catalogId)
+        return undefined;
+    try {
+        const resolvedCatalogId = (await resolveCatalogIdFromModelId(catalog, catalogId)) ?? catalogId;
+        const detail = await catalog.get('chat-model', resolvedCatalogId);
+        if (!detail || detail.manifest.kind !== 'chat-model')
+            return undefined;
+        return catalogReasoningBudget(detail.manifest.tuning);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The catalog manifest's per-model llama.cpp engine-launch defaults
+ * (`tuning.engine.llamaCpp`), if any. Mirrors
+ * {@link resolveCatalogReasoningBudget}: engine flags are a model-LOAD
+ * concern (argv), so we read them straight off the manifest rather than
+ * the per-request tuning resolver. Returns undefined on any miss — the
+ * launcher then falls through to global `config.llamaCpp*` + server
+ * defaults.
+ */
+export async function resolveCatalogLlamaCppEngineConfig(catalog, catalogId) {
+    if (!catalogId)
+        return undefined;
+    try {
+        const resolvedCatalogId = (await resolveCatalogIdFromModelId(catalog, catalogId)) ?? catalogId;
+        const detail = await catalog.get('chat-model', resolvedCatalogId);
+        if (!detail || detail.manifest.kind !== 'chat-model')
+            return undefined;
+        return detail.manifest.tuning?.engine?.llamaCpp;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/providers/code-block-salvage.d.ts

@@ -0,0 +1 @@
+export * from '@bendyline/gezel/local-loop';

package/dist/providers/code-block-salvage.js

@@ -0,0 +1,2 @@
+// Moved to core so the portable runtime runs the same loop; see core/src/local-loop.
+export * from '@bendyline/gezel/local-loop';

package/dist/providers/codex-cli/reasoning.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Reasoning values accepted by current Codex CLI builds. Individual models
+ * expose a subset of these through their model metadata (for example,
+ * the Luna models stop at `max`, while Astra, Sol and Terra also expose `ultra`).
+ */
+export declare const CODEX_REASONING_EFFORTS: readonly ["minimal", "low", "medium", "high", "xhigh", "max", "ultra"];
+export type CodexReasoningEffort = (typeof CODEX_REASONING_EFFORTS)[number];
+export declare function isCodexReasoningEffort(value: string | undefined): value is CodexReasoningEffort;

package/dist/providers/codex-cli/reasoning.js

@@ -0,0 +1,17 @@
+/**
+ * Reasoning values accepted by current Codex CLI builds. Individual models
+ * expose a subset of these through their model metadata (for example,
+ * the Luna models stop at `max`, while Astra, Sol and Terra also expose `ultra`).
+ */
+export const CODEX_REASONING_EFFORTS = [
+    'minimal',
+    'low',
+    'medium',
+    'high',
+    'xhigh',
+    'max',
+    'ultra',
+];
+export function isCodexReasoningEffort(value) {
+    return CODEX_REASONING_EFFORTS.some((effort) => effort === value);
+}

package/dist/providers/complete-tool-call.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Is a whole textual tool call already present in streamed output?
+ *
+ * Read where a turn can act on exactly ONE call
+ * (`SessionOpts.singleToolCallTurn`): once that call is complete nothing
+ * else the model writes can be used, so the provider stops the stream.
+ * Wild-caught (qwen3.8-27b MLX Meester, 2026-09-23): after its
+ * `invoke_craftbook` call the model wrote the call again, then
+ * `</function>` 1300+ times until max_tokens.
+ *
+ * The outermost wrapper decides. A Hermes call is not complete at
+ * `</function>` while its `<tool_call>` is still open — the salvage pass
+ * reads the closed envelope, and stopping between the two closers would
+ * hand it a truncated one.
+ */
+export declare function hasCompleteToolCallMarkup(text: string): boolean;

package/dist/providers/complete-tool-call.js

@@ -0,0 +1,25 @@
+/**
+ * Is a whole textual tool call already present in streamed output?
+ *
+ * Read where a turn can act on exactly ONE call
+ * (`SessionOpts.singleToolCallTurn`): once that call is complete nothing
+ * else the model writes can be used, so the provider stops the stream.
+ * Wild-caught (qwen3.8-27b MLX Meester, 2026-09-23): after its
+ * `invoke_craftbook` call the model wrote the call again, then
+ * `</function>` 1300+ times until max_tokens.
+ *
+ * The outermost wrapper decides. A Hermes call is not complete at
+ * `</function>` while its `<tool_call>` is still open — the salvage pass
+ * reads the closed envelope, and stopping between the two closers would
+ * hand it a truncated one.
+ */
+export function hasCompleteToolCallMarkup(text) {
+    if (text.includes('<tool_call>'))
+        return /<tool_call>[\s\S]*?<\/tool_call>/.test(text);
+    if (text.includes('<function_calls>')) {
+        return /<function_calls>[\s\S]*?<\/function_calls>/.test(text);
+    }
+    if (text.includes('<function='))
+        return /<function=[^>\s]+>[\s\S]*?<\/function>/.test(text);
+    return /<invoke\s+name="[^"]+"\s*>[\s\S]*?<\/invoke>/.test(text);
+}

package/dist/providers/constrained-turn.d.ts

@@ -0,0 +1 @@
+export * from '@bendyline/gezel/local-loop';