@fugood/buttress-server 2.25.0-beta.63 → 2.25.0-beta.70

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/index.d.ts

@@ -0,0 +1,5 @@
+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';

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,54 @@
+/**
+ * Shared helpers for LLM-backed compatibility routes (OpenAI / Anthropic).
+ *
+ * The generator cache is module-scoped so different compatibility routes
+ * (e.g. /oai-compat and /anthropic-messages) reuse the same warm generator
+ * for a given model instead of duplicating contexts.
+ */
+export declare const LLM_TYPES: string[];
+export type GeneratorCacheEntry = {
+    id: string;
+    type: string;
+    config: any;
+    repoId: string;
+    initialized: boolean;
+    activeRequests: number;
+};
+export declare function cancelReaderBestEffort(reader: {
+    cancel: () => Promise<unknown>;
+}): void;
+export declare function releaseGenerator(backend: any, entry: GeneratorCacheEntry | null | undefined, logPrefix?: string): Promise<void>;
+/**
+ * Get the LLM backend API for a generator type.
+ */
+export declare function getLlmBackend(backend: any, type: string): any;
+/**
+ * Get or create a cached generator for the requested model.
+ *
+ * If `requestedModel` matches a configured generator's `model.repo_id`,
+ * that config is used; otherwise the first LLM generator is selected and
+ * its repo_id is overridden with 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/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/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 { 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 { 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;

package/lib/types.d.ts

@@ -0,0 +1,158 @@
+import type { Elysia, SingletonBase } from 'elysia';
+import type { ReadableStream } from 'node:stream/web';
+import type { Backend } from './index';
+export type HumanReadableUnit = number | string;
+type NormalizeKeys = 'max_body_size' | 'session_timeout' | 'max_size_bytes';
+export type DeepNormalize<T> = T extends object ? {
+    [K in keyof T]: K extends NormalizeKeys ? number : DeepNormalize<T[K]>;
+} : T;
+export type HumanReadableServerConfig = {
+    id?: string;
+    name?: string;
+    port?: number;
+    log_level?: 'debug' | 'info' | 'warn' | 'error';
+    max_body_size?: HumanReadableUnit;
+    session_timeout?: HumanReadableUnit;
+    temp_file_dir?: string;
+};
+export type SessionCacheConfig = {
+    enabled?: boolean;
+    max_size_bytes?: HumanReadableUnit;
+    max_entries?: number;
+};
+export type RuntimeConfig = {
+    cache_dir?: string;
+    huggingface_token?: string;
+    session_cache?: SessionCacheConfig;
+} & Record<string, any>;
+export type GeneratorType = 'ggml-llm' | 'ggml-stt' | 'mlx-llm' | 'onnx-stt' | 'onnx-tts';
+export type GeneratorConfig = {
+    type: GeneratorType;
+} & Record<string, any>;
+export type GlobalConfig = {
+    runtime?: RuntimeConfig;
+    openai_compat?: {
+        enabled?: boolean;
+        cors_allowed_origins?: string | string[];
+    };
+    anthropic_messages?: {
+        enabled?: boolean;
+        cors_allowed_origins?: string | string[];
+    };
+} & Record<string, any>;
+export type AutodiscoverConfig = {
+    udp: {
+        port?: number;
+        announcements: {
+            enabled: boolean;
+            interval?: number;
+        };
+        requests: {
+            enabled: boolean;
+            responseDelay?: number;
+        };
+    };
+    http: {
+        enabled: boolean;
+        path?: string;
+        cors?: boolean;
+    };
+    mdns?: {
+        enabled: boolean;
+    };
+};
+export type HumanReadableConfig = {
+    autodiscover?: AutodiscoverConfig | boolean;
+    server?: HumanReadableServerConfig;
+    generators?: GeneratorConfig[];
+} & GlobalConfig;
+export type ServerConfig = {
+    id: string;
+    name: string;
+    port: number;
+    log_level?: 'debug' | 'info' | 'warn' | 'error';
+    max_body_size: number;
+    session_timeout: number;
+    temp_file_dir: string;
+};
+export type Config = {
+    autodiscover: AutodiscoverConfig | null;
+    server: ServerConfig;
+    global: GlobalConfig;
+    generators: GeneratorConfig[];
+};
+export type GeneratorInfo = {
+    type: GeneratorType;
+    /** Performance score 0–100 from buttress-hardware-guardrails. */
+    score?: number;
+    /** Whether the host has an accelerator (GPU/Metal/etc) for this backend. */
+    hasGpu?: boolean;
+    /** Usable memory in bytes for this backend (GPU when present, else CPU). */
+    usableBytes?: number;
+} & Record<string, any>;
+export type ServerInfo = {
+    id: string;
+    name: string;
+    version: string;
+    address: string;
+    addresses?: string[];
+    port: number;
+    url: string;
+    generators: GeneratorInfo[];
+    authentication: {
+        required: boolean;
+        type: string;
+        /** Issuer key id (when type === 'workspace-jwt'). */
+        kid?: string;
+        /** True when buttress is paired with a workspace. */
+        bound?: boolean;
+    };
+    /** Workspace identity (only present when paired). */
+    workspace?: {
+        id: string;
+        name?: string;
+    };
+};
+export type EventStream = {
+    event: string;
+    data: any;
+};
+export type StreamReaderEntry = {
+    reader: ReadableStreamDefaultReader<EventStream>;
+    peerId: string;
+};
+export type Session = {
+    streams: Map<string, ReadableStream<EventStream>>;
+    streamReaders: Map<string, StreamReaderEntry>;
+    generators: Set<string>;
+    fileManager: import('./utils/SessionFileManager').SessionFileManager;
+    initializedContexts: Set<string>;
+    timeout: ReturnType<typeof setTimeout> | null;
+    identity?: import('./utils/buttressAuth').VerifiedIdentity | null;
+    ready?: Promise<boolean>;
+    currentPeerId?: string | null;
+};
+export type State = {
+    serverInfo: ServerInfo;
+    backend: Backend;
+    config: Config;
+    sessions: Map<string, Session>;
+    workspaceState: import('./utils/workspaceState').WorkspaceState;
+};
+type ButtressSingleton = SingletonBase & {
+    store: State;
+};
+export type ButtressApp = Elysia<any, ButtressSingleton, any, any, any, any, any>;
+export type MethodReturnType = string | object | number | boolean | null | ReadableStream<EventStream>;
+export type ServiceContext = State & {
+    peerId: string;
+    session: Session;
+};
+export type ServiceMethodHandler<InputType = any, OutputType = any> = (ctx: ServiceContext, property: InputType) => OutputType | Promise<OutputType>;
+export interface ServiceHandler {
+    [method: string]: ServiceMethodHandler;
+}
+export type Expand<T> = T extends object ? {
+    [K in keyof T]: Expand<T[K]>;
+} : T;
+export {};

package/lib/utils/SessionFileManager.d.ts

@@ -0,0 +1,16 @@
+import type { ReadableStream as NodeReadableStream } from 'node:stream/web';
+type UploadData = Buffer | ArrayBuffer | ReadableStream | NodeReadableStream;
+export declare class SessionFileManager {
+    sessionId: string;
+    private sessionDir;
+    private registry;
+    constructor(sessionId: string, tempDir: string);
+    register(filename: string, realPath: string, opts?: {
+        owned?: boolean;
+        ttl?: number;
+    }): void;
+    resolve(filename: string): string | null;
+    storeUpload(originalName: string, data: UploadData): Promise<string>;
+    destroy(): Promise<void>;
+}
+export {};

package/lib/utils/buttressAuth.d.ts

@@ -0,0 +1,25 @@
+import type { WorkspaceBinding } from './workspaceState';
+export declare const ACCESS_TOKEN_KIND = "ba";
+export interface AccessTokenClaims {
+    k: typeof ACCESS_TOKEN_KIND;
+    w_id: string;
+    st: 'ws' | 'dev';
+    sid: string;
+    jti?: string;
+    iat?: number;
+    exp: number;
+}
+export interface VerifiedIdentity {
+    workspaceId: string;
+    subjectType: 'ws' | 'dev';
+    subjectId: string;
+    jti?: string;
+    exp: number;
+}
+/**
+ * Extract a buttress access token from a request. Prefers the Authorization
+ * Bearer header; falls back to ?access_token / ?token query params for clients
+ * (browser WebSocket, RN file transfer) that can't set headers.
+ */
+export declare const extractAccessTokenFromRequest: (headers: Record<string, string | undefined> | undefined, query: Record<string, unknown> | undefined) => string | null;
+export declare const verifyAccessToken: (token: string | null, binding: WorkspaceBinding | null) => Promise<VerifiedIdentity | null>;

package/lib/utils/config.d.ts

@@ -0,0 +1,21 @@
+import type { Config, AutodiscoverConfig, HumanReadableConfig } from '../types';
+import type { Backend } from '../index';
+export declare const deepMerge: (target?: Record<string, any>, source?: Record<string, any>) => Record<string, any>;
+export declare const normalizeConfigInput: (input: any) => null | Record<string, any>;
+export declare const mergeGeneratorConfig: (base: any, override: any) => Record<string, any>;
+export declare const resolveDefaultConfig: (defaultConfigs: Config, backend: Backend, type: string, modelId: string | null) => Record<string, any> | null;
+/**
+ * Normalize autodiscover config input.
+ * - undefined/false → null (disabled)
+ * - true → default config
+ * - object → merge with defaults
+ */
+export declare const normalizeAutodiscoverConfig: (input: AutodiscoverConfig | boolean | undefined) => AutodiscoverConfig | null;
+export declare const resolveSupportedGenerators: (config: Config, defaultTypes: string[]) => {
+    type: string;
+}[];
+/**
+ * Process raw user config (HumanReadableConfig) into Config.
+ * Handles: device defaults, value normalization (bytes/ms), structure splitting.
+ */
+export declare const processConfig: (input: HumanReadableConfig | null) => Config;

package/lib/utils/httpAuthGuard.d.ts

@@ -0,0 +1 @@
+export declare const buttressAuthGuard: any;