@atomic-chat/core 0.5.1

package/dist/contracts/events.d.ts

@@ -0,0 +1,270 @@
+/**
+ * Event catalog. Every event the core emits is listed here with its payload. The app's
+ * `CoreEventBridge` maps these onto the legacy `@janhq/core` names (PLAN.md §3.5).
+ * Adding an event = add it here + add the relay mapping in the app, in the same PR pair.
+ */
+import type { DiffusionErrorEvent, DiffusionJobEvent, DiffusionVideoJobEvent, DiffusionVideoProgressEvent, DiffusionProgressEvent, DiffusionStateEvent } from './diffusion.js';
+import type { RemoteAccessStatus } from './remote-access.js';
+import type { LocalProviderId, RuntimeDeviceInfo, SessionInfo } from './session.js';
+export type DownloadKind = 'model' | 'backend' | 'draft' | 'cudart';
+/**
+ * What a download is doing while it has no bytes to report: reaching the server for the first time,
+ * or waiting out a backoff before trying again. The app's `DownloadStage`
+ * (`src-tauri/src/core/downloads/models.rs`), camelCase on the wire.
+ */
+export interface DownloadStage {
+    /** `connecting` for the first attempt, `retrying` for each one after. */
+    kind: 'connecting' | 'retrying';
+    attempt: number;
+    maxAttempts: number;
+}
+export interface CoreEvents {
+    'download:started': {
+        taskId: string;
+        modelId?: string;
+        kind: DownloadKind;
+    };
+    'download:progress': {
+        taskId: string;
+        modelId?: string;
+        transferred: number;
+        total: number;
+        percent: number;
+    };
+    /**
+     * A status change, never progress: it carries no byte counts on purpose, so a retry cannot rewind
+     * a progress bar. Its own event rather than a field of `download:progress`, whose payload the
+     * app's relay pins (ADR 2026-09-17-report-download-stages-as-their-own-event).
+     */
+    'download:stage': {
+        taskId: string;
+        stage: DownloadStage;
+    };
+    'download:error': {
+        taskId: string;
+        modelId?: string;
+        error: string;
+    };
+    'download:stopped': {
+        taskId: string;
+        modelId?: string;
+    };
+    'download:verified': {
+        taskId: string;
+        modelId?: string;
+    };
+    'model:validation-started': {
+        modelId: string;
+    };
+    'model:validation-failed': {
+        modelId: string;
+        error: string;
+    };
+    'model:imported': {
+        provider: LocalProviderId;
+        modelId: string;
+        modelPath: string;
+        mmprojPath?: string;
+    };
+    'backend:download-started': {
+        provider: LocalProviderId;
+        backend: string;
+        version: string;
+    };
+    'backend:download-finished': {
+        provider: LocalProviderId;
+        backend: string;
+        version?: string;
+        success: boolean;
+        error?: string;
+    };
+    'backend:manual-downloading': {
+        provider: LocalProviderId;
+        selection: string;
+    };
+    'backend:manual-failed': {
+        provider: LocalProviderId;
+        selection: string;
+        error: string;
+    };
+    'backend:better-detected': {
+        provider: LocalProviderId;
+        currentBackend: string;
+        recommendedBackend: string;
+        recommendedCategory: string;
+        version: string;
+        backendId: string;
+    };
+    'backend:runtime-reported': {
+        provider: LocalProviderId;
+        modelId: string;
+        configuredVersionBackend: string;
+        effectiveVersionBackend: string;
+        runtimeDevice: RuntimeDeviceInfo | null;
+        mismatch: boolean;
+    };
+    'backend:optimal-changed': {
+        provider: LocalProviderId;
+        revision: number;
+        optimal: unknown | null;
+    };
+    'settings:changed': {
+        provider: LocalProviderId | 'server' | 'cloud';
+        key: string;
+        value: unknown;
+    };
+    'session:started': SessionInfo & {
+        provider: LocalProviderId;
+    };
+    'session:died': {
+        provider: LocalProviderId;
+        pid: number;
+        model_id: string;
+        exit_code: number | null;
+        signal: string | null;
+        message: string;
+    };
+    'session:ctx-increased': {
+        provider: LocalProviderId;
+        modelId: string;
+        oldCtx: number;
+        newCtx: number;
+        reason: string;
+    };
+    'session:unloaded': {
+        provider: LocalProviderId;
+        model_id: string;
+        pid: number;
+    };
+    'server:started': {
+        host: string;
+        port: number;
+    };
+    'server:stopped': Record<string, never>;
+    'server:bind-failed': {
+        port: number;
+        error: string;
+    };
+    /**
+     * Every transition of the remote-access tunnel, and every change of the public server it depends
+     * on: the URL arrives seconds after the request that asked for it has answered.
+     */
+    'remote-access:status': RemoteAccessStatus;
+    /**
+     * Image generation, camelCase like the rest of that surface (the plugin's `atomic-diffusion://*`).
+     * `state` on every change of the engine install, the model or the output folder; `progress` per
+     * sampling step; `job` on every job transition; `error` for a failure nobody is awaiting.
+     */
+    'diffusion:state': DiffusionStateEvent;
+    'diffusion:progress': DiffusionProgressEvent;
+    'diffusion:job': DiffusionJobEvent;
+    'diffusion:error': DiffusionErrorEvent;
+    /** Video generation shares `state` and `error`; its jobs have their own two, so image consumers see no new shape. */
+    'diffusion:video-progress': DiffusionVideoProgressEvent;
+    'diffusion:video-job': DiffusionVideoJobEvent;
+    /**
+     * One request to the Local API Server, for the app's analytics window and its API screen
+     * (PLAN.md §2 decision 15). `started` and `progress` are sent only while the app's inspector is
+     * watching, because they carry the prompt preview; `finished` carries the analytics observation
+     * for every request that is product traffic, and the inspector's finish fields when it announced.
+     */
+    'api:request': ApiRequestEvent;
+    /** A process that owns engines the core does not published, refreshed or lost its registration. */
+    'external-sessions:changed': {
+        owner: string;
+        sessions: number;
+        reason: 'published' | 'expired' | 'unregistered';
+    };
+    /**
+     * The core needs a registered session's context grown and asks its owner. The owner answers on
+     * `POST /external-sessions/:owner/ctx/:request_id`; no answer within 60 s counts as declined.
+     */
+    'external-sessions:ctx-requested': {
+        request_id: string;
+        owner: string;
+        provider: string;
+        model_id: string;
+        trigger: string;
+    };
+    'core:log': {
+        level: 'debug' | 'info' | 'warn' | 'error';
+        msg: string;
+    };
+}
+/** What the app's `api_request_analytics.rs` aggregates (never content, only shape and outcome). */
+export interface ApiRequestObservation {
+    endpoint: string;
+    method: string;
+    model_id: string | null;
+    /** `llamacpp`, `llamacpp-upstream`, `mlx`, `remote`, or `unknown` before a backend was chosen. */
+    backend: string;
+    provider: string | null;
+    stream: boolean;
+    status: number;
+    /** Time to response headers. */
+    latency_ms: number;
+    is_anthropic_fallback: boolean;
+    error_kind: string | null;
+    upstream_status: number | null;
+    oom_detected: boolean;
+    ctx_overflow_detected: boolean;
+}
+/** The inspector's `request-started` fields. PRIVACY: `prompt_preview` is user content. */
+export interface ApiRequestStartedFields {
+    endpoint: string;
+    method: string;
+    model_id: string | null;
+    stream: boolean;
+    message_count: number | null;
+    prompt_preview: string | null;
+    prompt_chars: number | null;
+    has_non_text_parts: boolean;
+    client_max_tokens: number | null;
+}
+/** The inspector's `request-finished` fields. PRIVACY: `reply_preview` is model output. */
+export interface ApiRequestFinishFields {
+    status: number | null;
+    error_kind: string | null;
+    aborted: boolean;
+    headers_ms: number | null;
+    ttft_ms: number | null;
+    duration_ms: number | null;
+    prompt_tokens: number | null;
+    completion_tokens: number | null;
+    total_tokens: number | null;
+    tokens_estimated: boolean;
+    prompt_per_second: number | null;
+    predicted_per_second: number | null;
+    finish_reason: string | null;
+    reply_preview: string | null;
+    reply_chars: number | null;
+}
+export type ApiRequestEvent = ({
+    phase: 'started';
+    id: string;
+    seq: number;
+    started_at_ms: number;
+} & ApiRequestStartedFields) | {
+    phase: 'progress';
+    id: string;
+    seq: number;
+    ttft_ms: number | null;
+    completion_tokens: number | null;
+    reply_chars: number;
+    elapsed_ms: number;
+} | {
+    phase: 'finished';
+    id: string;
+    seq: number;
+    finished_at_ms: number;
+    observation: ApiRequestObservation | null;
+    finish: ApiRequestFinishFields | null;
+};
+export type CoreEventName = keyof CoreEvents;
+/** One serialised event record as it crosses the process boundary (SSE and stdout NDJSON). */
+export interface CoreEventRecord<K extends CoreEventName = CoreEventName> {
+    seq: number;
+    ts: number;
+    name: K;
+    payload: CoreEvents[K];
+}

package/dist/contracts/events.js

@@ -0,0 +1,7 @@
+/**
+ * Event catalog. Every event the core emits is listed here with its payload. The app's
+ * `CoreEventBridge` maps these onto the legacy `@janhq/core` names (PLAN.md §3.5).
+ * Adding an event = add it here + add the relay mapping in the app, in the same PR pair.
+ */
+export {};
+//# sourceMappingURL=events.js.map

package/dist/contracts/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","sourceRoot":"","sources":["../../src/contracts/events.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/contracts/hardware.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Hardware facts a host injects into the core (`PUT /hardware/override`, PLAN.md §2 decision 10).
+ *
+ * The core probes hardware with shell tools, which is not enough for an NVIDIA driver's exact
+ * version or a GPU's compute capability — the numbers the CUDA tier is chosen from. The desktop app
+ * measures them with NVML/Vulkan; a headless host measures them with `nvidia-smi` and friends. Both
+ * hand the core the same shape, and the core prefers it over its own probe.
+ *
+ * Browser-safe: types only, shared with every host and client.
+ */
+/**
+ * The slice of the hardware probe's `GpuInfo` the backend selectors read. `hardware/` must produce
+ * at least these fields (its full `GpuInfo` is a superset). Rust `backend.rs::GpuInfo` requires only
+ * `driver_version`; everything else is `#[serde(default)]`.
+ */
+export interface GpuProbeInfo {
+    driver_version?: string;
+    /** `"NVIDIA" | "AMD" | "Intel" | "Unknown (vendor_id: N)"` as `tauri-plugin-hardware` spells it. */
+    vendor?: string | null;
+    /** MiB. */
+    total_memory?: number;
+    nvidia_info?: {
+        /** NVML `"major.minor"`, e.g. `"7.5"`; empty when NVML did not report it. */
+        compute_capability?: string;
+    } | null;
+    vulkan_info?: {
+        api_version?: string;
+        /** PCI device id — the only gfx signal on Windows. */
+        device_id?: number | null;
+        /** `"DiscreteGpu" | "IntegratedGpu" | …` */
+        device_type?: string;
+    } | null;
+}
+/** The override in force, as the snapshot reports it. */
+export interface HardwareOverride {
+    /** What the host's enumeration found. Replaces the core's probe wholesale. */
+    gpus: GpuProbeInfo[];
+    /** CPU instruction-set flags (`avx`, `avx2`, `avx512`), lowercase as the feature check expects. */
+    cpu_extensions?: string[];
+    /** `linux` | `windows` | `macos` — the host's own idea of the OS, for cross-checking. */
+    os_type?: string;
+    /** Who injected it, for the log and for the snapshot. */
+    source?: string;
+    /** Milliseconds since the epoch, from the core's clock. */
+    received_at: number;
+}
+/** The body of `PUT /hardware/override`, validated by the core before it is applied. */
+export interface HardwareOverrideInput {
+    gpus?: unknown;
+    cpu_extensions?: unknown;
+    os_type?: unknown;
+    source?: unknown;
+}

package/dist/contracts/hardware.js

@@ -0,0 +1,12 @@
+/**
+ * Hardware facts a host injects into the core (`PUT /hardware/override`, PLAN.md §2 decision 10).
+ *
+ * The core probes hardware with shell tools, which is not enough for an NVIDIA driver's exact
+ * version or a GPU's compute capability — the numbers the CUDA tier is chosen from. The desktop app
+ * measures them with NVML/Vulkan; a headless host measures them with `nvidia-smi` and friends. Both
+ * hand the core the same shape, and the core prefers it over its own probe.
+ *
+ * Browser-safe: types only, shared with every host and client.
+ */
+export {};
+//# sourceMappingURL=hardware.js.map

package/dist/contracts/hardware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hardware.js","sourceRoot":"","sources":["../../src/contracts/hardware.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG"}

package/dist/contracts/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Browser-safe contracts shared with the Atomic Chat app. No `node:*` imports allowed here.
+ */
+export * from './errors.js';
+export * from './session.js';
+export * from './model-yml.js';
+export * from './settings.js';
+export * from './events.js';
+export * from './control-api.js';
+export * from './remote-access.js';
+export * from './diffusion.js';
+export * from './hardware.js';

package/dist/contracts/index.js

@@ -0,0 +1,13 @@
+/**
+ * Browser-safe contracts shared with the Atomic Chat app. No `node:*` imports allowed here.
+ */
+export * from './errors.js';
+export * from './session.js';
+export * from './model-yml.js';
+export * from './settings.js';
+export * from './events.js';
+export * from './control-api.js';
+export * from './remote-access.js';
+export * from './diffusion.js';
+export * from './hardware.js';
+//# sourceMappingURL=index.js.map

package/dist/contracts/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/contracts/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA;AAC5B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,eAAe,CAAA;AAC7B,cAAc,aAAa,CAAA;AAC3B,cAAc,kBAAkB,CAAA;AAChC,cAAc,oBAAoB,CAAA;AAClC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,eAAe,CAAA"}

package/dist/contracts/model-yml.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `<data>/llamacpp/models/<id>/model.yml` — the file that defines a model. Shared with the app;
+ * see PLAN.md §8.1. Canonical shape: guest-js/types.ts:142-171 (+ `capabilities` from cli/mod.rs).
+ */
+export type ImportedModelSource = 'ollama' | 'lmstudio' | 'unsloth' | 'local' | 'huggingface-cache' | 'gpt4all' | 'jan' | 'msty' | 'llamacpp-cache';
+export interface ModelYml {
+    /** Relative to the data folder, or absolute. Required. */
+    model_path: string;
+    mmproj_path?: string;
+    name: string;
+    size_bytes: number;
+    /** Non-sharded models only. */
+    model_sha256?: string;
+    model_size_bytes?: number;
+    mmproj_sha256?: string;
+    mmproj_size_bytes?: number;
+    embedding?: boolean;
+    projector_vision?: boolean;
+    projector_audio?: boolean;
+    /** Data-folder-relative Gemma 4 MTP head. */
+    mtp_draft_path?: string;
+    /** Data-folder-relative DFlash draft. */
+    dflash_draft_path?: string;
+    source?: ImportedModelSource;
+    capabilities?: string[];
+}
+/** Key order the app's serde_yaml writer produces; `writeModelYml` must emit keys in this order. */
+export declare const MODEL_YML_KEY_ORDER: readonly (keyof ModelYml)[];

package/dist/contracts/model-yml.js

@@ -0,0 +1,23 @@
+/**
+ * `<data>/llamacpp/models/<id>/model.yml` — the file that defines a model. Shared with the app;
+ * see PLAN.md §8.1. Canonical shape: guest-js/types.ts:142-171 (+ `capabilities` from cli/mod.rs).
+ */
+/** Key order the app's serde_yaml writer produces; `writeModelYml` must emit keys in this order. */
+export const MODEL_YML_KEY_ORDER = [
+    'model_path',
+    'mmproj_path',
+    'name',
+    'size_bytes',
+    'model_sha256',
+    'model_size_bytes',
+    'mmproj_sha256',
+    'mmproj_size_bytes',
+    'embedding',
+    'projector_vision',
+    'projector_audio',
+    'mtp_draft_path',
+    'dflash_draft_path',
+    'source',
+    'capabilities',
+];
+//# sourceMappingURL=model-yml.js.map

package/dist/contracts/model-yml.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-yml.js","sourceRoot":"","sources":["../../src/contracts/model-yml.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAmCH,oGAAoG;AACpG,MAAM,CAAC,MAAM,mBAAmB,GAAgC;IAC9D,YAAY;IACZ,aAAa;IACb,MAAM;IACN,YAAY;IACZ,cAAc;IACd,kBAAkB;IAClB,eAAe;IACf,mBAAmB;IACnB,WAAW;IACX,kBAAkB;IAClB,iBAAiB;IACjB,gBAAgB;IAChB,mBAAmB;IACnB,QAAQ;IACR,cAAc;CACf,CAAA"}

package/dist/contracts/remote-access.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Remote access: the status of the Cloudflare quick tunnel in front of the Local API Server.
+ *
+ * camelCase on the wire, verbatim from the app (`web-app/src/types/remoteAccess.ts`, and the Rust
+ * `RemoteAccessStatus` of `src-tauri/src/core/server/remote_access/mod.rs` on the image-generation
+ * line), because the settings page renders this payload as it arrives.
+ *
+ * PRIVACY: the tunnel URL identifies the user's machine. It lives in memory only and is never
+ * logged or persisted; it is new on every start anyway.
+ */
+export type RemoteAccessState = 'off' | 'starting' | 'online' | 'stopping' | 'error';
+/** Machine-readable failure codes; the frontend owns the wording. */
+export type RemoteAccessFailure = 
+/** The bundled binary is missing or could not be started. */
+'cloudflared_unavailable'
+/** cloudflared never printed a tunnel URL (no route to Cloudflare's API). */
+ | 'no_url'
+/** A URL was minted but no edge connection registered, on either transport. */
+ | 'not_registered'
+/** The tunnel registered, but its URL never answered as this server. */
+ | 'not_reachable'
+/** A tunnel that was online ended by itself. */
+ | 'exited'
+/** The process could not be confirmed dead. Only Stop is offered until it is. */
+ | 'stop_failed';
+/** A tunnel needs something to point at. */
+export type RemoteAccessBlockReason = 'server_stopped';
+export interface RemoteAccessStatus {
+    state: RemoteAccessState;
+    /** Origin only (`https://<words>.trycloudflare.com`), and only while online. */
+    url: string | null;
+    error: RemoteAccessFailure | null;
+    blockReason: RemoteAccessBlockReason | null;
+    canStart: boolean;
+    canStop: boolean;
+    /**
+     * Whether the *running* server was started with an API key. The frontend compares it with the
+     * key in its settings to offer "restart to apply".
+     */
+    serverHasApiKey: boolean;
+}
+/** Why a start was refused; travels as `details` of the 409, which is what the app's parser reads. */
+export type RemoteAccessRefusal = 'server_stopped' | 'operation_in_progress' | 'stop_failed';

package/dist/contracts/remote-access.js

@@ -0,0 +1,12 @@
+/**
+ * Remote access: the status of the Cloudflare quick tunnel in front of the Local API Server.
+ *
+ * camelCase on the wire, verbatim from the app (`web-app/src/types/remoteAccess.ts`, and the Rust
+ * `RemoteAccessStatus` of `src-tauri/src/core/server/remote_access/mod.rs` on the image-generation
+ * line), because the settings page renders this payload as it arrives.
+ *
+ * PRIVACY: the tunnel URL identifies the user's machine. It lives in memory only and is never
+ * logged or persisted; it is new on every start anyway.
+ */
+export {};
+//# sourceMappingURL=remote-access.js.map

package/dist/contracts/remote-access.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-access.js","sourceRoot":"","sources":["../../src/contracts/remote-access.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG"}

package/dist/contracts/session.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Session shapes returned by `load()` and read by the app's `model-factory.ts` (port + api_key)
+ * and by the Rust agent (`core_sessions` mirror). Byte-identical with
+ * src-tauri/plugins/tauri-plugin-llamacpp-upstream/guest-js/types.ts:122-132 and state.rs:9-23.
+ */
+export type LocalProviderId = 'llamacpp-upstream' | 'llamacpp' | 'mlx' | 'foundation-models';
+export interface RuntimeDeviceInfo {
+    /** Backends in load order, deduped, e.g. ["CUDA", "CPU"]. */
+    loaded_backends: string[];
+    /** "CUDA0" | "Vulkan0" | "Metal" | "CPU" | "" */
+    primary_device: string;
+    gpu_layers_offloaded: number | null;
+    total_layers: number | null;
+    gpu_buffer_bytes: number | null;
+    cuda_runtime_missing: boolean;
+    device_init_error: string | null;
+}
+export interface SessionInfo {
+    pid: number;
+    port: number;
+    model_id: string;
+    model_path: string;
+    is_embedding: boolean;
+    /** Bearer token the session expects; "" for MLX. */
+    api_key: string;
+    mmproj_path?: string | null;
+    runtime_device?: RuntimeDeviceInfo | null;
+}
+export interface UnloadResult {
+    success: boolean;
+    error?: string;
+}
+/** One line of `llama-server --list-devices`, memory in MiB (Rust `DeviceInfo`). */
+export interface DeviceInfo {
+    id: string;
+    name: string;
+    mem: number;
+    free: number;
+}

package/dist/contracts/session.js

@@ -0,0 +1,7 @@
+/**
+ * Session shapes returned by `load()` and read by the app's `model-factory.ts` (port + api_key)
+ * and by the Rust agent (`core_sessions` mirror). Byte-identical with
+ * src-tauri/plugins/tauri-plugin-llamacpp-upstream/guest-js/types.ts:122-132 and state.rs:9-23.
+ */
+export {};
+//# sourceMappingURL=session.js.map

package/dist/contracts/session.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.js","sourceRoot":"","sources":["../../src/contracts/session.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/contracts/settings.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Provider settings as the core stores them (canonical keys). The app's extension `settings.json`
+ * descriptors are copied into `src/settings/schema/*.json`; this file only carries the value types.
+ * Source: guest-js/types.ts:151-222 (LlamacppConfig), extensions/<ext>/settings.json.
+ */
+import type { LocalProviderId } from './session.js';
+export type FlashAttn = 'auto' | 'on' | 'off';
+export type SplitMode = 'none' | 'layer' | 'row';
+export type CacheType = 'f32' | 'f16' | 'bf16' | 'q8_0' | 'q4_0' | 'q4_1' | 'iq4_nl' | 'q5_0' | 'q5_1' | 'turbo2' | 'turbo3' | 'turbo4';
+/**
+ * Full llama-server load configuration: engine settings merged with per-model overrides.
+ * Mirrors Rust `LlamacppConfig` field-for-field (`dflash_block_size` is an engine setting that the
+ * load plan turns into `dflash_n_max`; it is not part of this struct).
+ */
+export interface LlamacppConfig {
+    /** `<version>/<backend>`, e.g. `b10405/macos-arm64`. */
+    version_backend: string;
+    auto_unload: boolean;
+    timeout: number;
+    llamacpp_env: string;
+    extra_args: string;
+    reasoning_preserve: boolean;
+    mtp: boolean;
+    mtp_draft_path: string;
+    dflash: boolean;
+    dflash_draft_path: string;
+    dflash_spec_supported: boolean;
+    dflash_n_max: number;
+    concurrent_mode: boolean;
+    concurrent_slots: number;
+    expose_metrics: boolean;
+    parallel: number;
+    cont_batching: boolean;
+    fit: boolean;
+    fit_target: string;
+    fit_ctx: string;
+    threads: number;
+    threads_batch: number;
+    ctx_shift: boolean;
+    ctx_size: number;
+    n_gpu_layers: number;
+    n_predict: number;
+    batch_size: number;
+    ubatch_size: number;
+    device: string;
+    /** Free-form in Rust; `SplitMode` documents the known values. */
+    split_mode: SplitMode | string;
+    main_gpu: number;
+    /** Free-form in Rust; unknown values are not emitted. */
+    flash_attn: FlashAttn | string;
+    no_mmap: boolean;
+    mlock: boolean;
+    no_kv_offload: boolean;
+    cache_type_k: CacheType | string;
+    cache_type_v: CacheType | string;
+    defrag_thold: number;
+    rope_scaling: string;
+    rope_scale: number;
+    rope_freq_base: number;
+    rope_freq_scale: number;
+    chat_template: string;
+    offload_mmproj: boolean;
+    cpu_moe: boolean;
+    n_cpu_moe: number;
+    override_tensor_buffer_t: string;
+}
+export type MlxDraftKind = 'dflash' | 'mtp' | 'eagle3';
+export type MlxKvQuantScheme = 'off' | 'uniform' | 'turboquant';
+export interface MlxConfig {
+    version_backend: string;
+    ctx_size: number;
+    auto_unload: boolean;
+    timeout: number;
+    draft_model_path: string;
+    draft_kind: MlxDraftKind | '';
+    block_size: number;
+    kv_quant_scheme: MlxKvQuantScheme;
+    kv_bits: number;
+}
+export interface FoundationModelsConfig {
+    timeout: number;
+}
+export type ProviderSettings<P extends LocalProviderId> = P extends 'mlx' ? MlxConfig : P extends 'foundation-models' ? FoundationModelsConfig : LlamacppConfig;
+/** UI descriptor of one setting (mirrors the app's SettingComponentProps). */
+export interface SettingDescriptor {
+    key: string;
+    title: string;
+    description: string;
+    controllerType: 'checkbox' | 'input' | 'dropdown' | 'slider';
+    controllerProps: Record<string, unknown> & {
+        value: unknown;
+    };
+    recommended?: unknown;
+}
+export interface ServerSettings {
+    host: string;
+    port: number;
+    prefix: string;
+    api_key: string;
+    trusted_hosts: string[];
+    cors_enabled: boolean;
+    proxy_timeout_ms: number;
+    enable_on_startup: boolean;
+    verbose_logs: boolean;
+}
+export declare const DEFAULT_SERVER_SETTINGS: ServerSettings;