@kernel.chat/kbot 3.99.34 → 4.0.0

package/README.md

@@ -2,7 +2,7 @@
 
 <p align="center">
   <strong>kbot</strong><br>
-  Open-source terminal AI agent. 787+ tools. 35 agents. 20 providers. Dreams, learns, watches your system, controls your phone. $0 local.
+  Open-source terminal AI agent. 100+ specialist skills. 35 specialist agents. 20 providers. Dreams, learns, watches your system, controls your phone. $0 local.
 </p>
 
 <p align="center">
@@ -31,7 +31,8 @@ Most terminal AI agents lock you into one provider, one model, one way of workin
 - **Runs fully offline** — Embedded llama.cpp, Ollama, LM Studio, or Jan. $0, fully private.
 - **Learns your patterns** — Bayesian skill ratings + pattern extraction. Gets faster over time.
 - **35 specialist agents** — auto-routes your request to the right expert (coder, researcher, writer, guardian, quant, and 30 more). Run any agent manually: `kbot --agent <id> "<prompt>"`. List them: `kbot agents`.
-- **787+ tools** — files, bash, git, GitHub, web search, deploy, database, game dev, VFX, research, science, finance, security, music production, iPhone control, and more.
+- **100+ specialist skills** — files, bash, git, GitHub, web search, deploy, database, game dev, VFX, research, science, finance, security, music production, iPhone control, and more.
+- **v4.0 evidence-based curation** — went from 670 skills to ~100. Every kept skill has telemetry, agent reference, or test coverage. Everything else moved to plugins.
 - **Programmatic SDK** — use kbot as a library in your own apps.
 - **MCP server built in** — plug kbot into Claude Code, Cursor, VS Code, Zed, or Neovim as a tool provider.
 
@@ -165,8 +166,8 @@ Checks security, documentation, code quality, CI/CD, community health, and DevOp
 |---|---|---|---|---|---|
 | AI providers | 20 | 1 | 1 | 6 | 75+ |
 | Specialist agents | 35 | 0 | 0 | 0 | 0 |
-| Built-in tools | 787+ | ~20 | ~15 | ~10 | ~15 |
-| Science tools | 114 | 0 | 0 | 0 | 0 |
+| Built-in skills | 100+ | ~20 | ~15 | ~10 | ~15 |
+| Science skills | included | 0 | 0 | 0 | 0 |
 | Memory system | 7-tier bidirectional | File-based | No | No | No |
 | Dream engine | Yes ($0 local) | Cloud API | No | No | No |
 | Service watchdog | Yes | No | No | No | No |
@@ -228,7 +229,9 @@ kbot auto-routes to the right agent for each task. Or pick one with `--agent <na
 | **Domain** | infrastructure, quant, investigator, oracle, chronist, sage, communicator, adapter |
 | **Presets** | claude-code, cursor, copilot, creative, developer |
 
-## 686+ Tools
+## 100+ Specialist Skills
+
+As of v4.0, kbot ships ~100 curated skills (down from 670 — every kept skill has telemetry, agent reference, or test coverage). The rest are available as plugins.
 
 | Category | Examples |
 |----------|---------|
@@ -320,7 +323,7 @@ graph TD
     D -->|Multi-step| F[Autonomous Planner]
     E --> G[Provider API + Tool Loop]
     F --> G
-    G --> H{686+ Tools}
+    G --> H{100+ Skills}
     H --> I[File ops, bash, git, GitHub, search, deploy, DB, game dev...]
     G --> J[Learning Engine]
     J --> K[Patterns + Solutions + User Profile]

package/dist/agent-protocol.js

@@ -391,6 +391,7 @@ export function getTrustReport() {
 export function registerAgentProtocolTools() {
     registerTool({
         name: 'agent_handoff',
+        deprecated: true,
         description: 'Create a handoff to transfer work to another agent. Includes context, artifacts, and priority. The receiving agent can accept or reject. Use this when a task is better suited for a different specialist.',
         parameters: {
             from: { type: 'string', description: 'Agent ID initiating the handoff', required: true },
@@ -430,6 +431,7 @@ export function registerAgentProtocolTools() {
     });
     registerTool({
         name: 'blackboard_write',
+        deprecated: true,
         description: 'Write to the shared agent blackboard (working memory). Any agent can write facts, hypotheses, decisions, artifacts, or questions. Other agents can read these to coordinate without direct communication.',
         parameters: {
             key: { type: 'string', description: 'Key to write (e.g., "architecture_decision", "security_finding")', required: true },
@@ -464,6 +466,7 @@ export function registerAgentProtocolTools() {
     });
     registerTool({
         name: 'blackboard_read',
+        deprecated: true,
         description: 'Read from the shared agent blackboard. Query a specific key or list all entries filtered by type. Use this to see what other agents have written and coordinate work.',
         parameters: {
             key: { type: 'string', description: 'Specific key to read. If omitted, returns all entries.' },
@@ -504,6 +507,7 @@ export function registerAgentProtocolTools() {
     });
     registerTool({
         name: 'agent_propose',
+        deprecated: true,
         description: 'Propose an approach for multi-agent negotiation. Other agents can vote agree/disagree/abstain. Use resolve to determine the outcome. Ties are broken by trust scores.',
         parameters: {
             action: { type: 'string', description: 'Action: propose, vote, resolve, or status', required: true },
@@ -589,6 +593,7 @@ export function registerAgentProtocolTools() {
     });
     registerTool({
         name: 'agent_trust',
+        deprecated: true,
         description: 'Check or update trust scores for agents. Trust is asymmetric: success adds 0.05, failure subtracts 0.10. Scores persist across sessions in ~/.kbot/trust.json.',
         parameters: {
             action: { type: 'string', description: 'Action: check, update, best, or report', required: true },

package/dist/auth.d.ts

@@ -1,6 +1,6 @@
 declare const KBOT_DIR: string;
 declare const CONFIG_PATH: string;
-export type ByokProvider = 'anthropic' | 'openai' | 'google' | 'mistral' | 'xai' | 'deepseek' | 'groq' | 'together' | 'fireworks' | 'perplexity' | 'cohere' | 'nvidia' | 'sambanova' | 'cerebras' | 'openrouter' | 'lmstudio' | 'jan' | 'ollama' | 'kbot-local' | 'embedded';
+export type ByokProvider = 'anthropic' | 'openai' | 'google' | 'mistral' | 'xai' | 'deepseek' | 'groq' | 'together' | 'fireworks' | 'perplexity' | 'cohere' | 'nvidia' | 'sambanova' | 'cerebras' | 'openrouter' | 'lmstudio' | 'jan' | 'ollama' | 'kbot-local' | 'llada' | 'embedded';
 export interface ProviderConfig {
     name: string;
     apiUrl: string;

package/dist/auth.js

@@ -18,6 +18,7 @@ const OLLAMA_HOST = process.env.OLLAMA_HOST || 'http://localhost:11434';
 const LMSTUDIO_HOST = process.env.LMSTUDIO_HOST || 'http://localhost:1234';
 const JAN_HOST = process.env.JAN_HOST || 'http://localhost:1337';
 const KBOT_LOCAL_HOST = process.env.KBOT_LOCAL_HOST || 'http://127.0.0.1:18789';
+const LLADA_HOST = process.env.KBOT_LLADA_URL || 'http://localhost:8000';
 export const PROVIDERS = {
     anthropic: {
         name: 'Anthropic (Claude)',
@@ -241,6 +242,23 @@ export const PROVIDERS = {
         outputCost: 0,
         authHeader: 'bearer',
     },
+    llada: {
+        // LLaDA2.0-Uni — Inclusion AI unified discrete-diffusion multimodal LLM.
+        // Local, $0 path to image generation + multimodal understanding.
+        // SPEC: refine when LLaDA's API stabilizes — currently assumes an
+        // OpenAI-compatible server at $KBOT_LLADA_URL (default http://localhost:8000).
+        // The upstream repo (github.com/inclusionAI/LLaDA2.0-Uni) ships Python
+        // inference scripts today; SGLang serving is on their TODO list.
+        name: 'LLaDA2.0-Uni (Local)',
+        apiUrl: `${LLADA_HOST}/v1/chat/completions`,
+        apiStyle: 'openai',
+        defaultModel: 'llada2.0-uni',
+        fastModel: 'llada2.0-uni',
+        inputCost: 0,
+        outputCost: 0,
+        authHeader: 'bearer', // Auth is ignored when no key is set; local servers usually don't require one.
+        models: ['llada2.0-uni'],
+    },
     embedded: {
         name: 'Embedded (llama.cpp)',
         apiUrl: 'embedded://local', // Not a real URL — inference runs in-process
@@ -381,11 +399,11 @@ const ENV_KEYS = [
 ];
 /** Check if a provider is local (runs on this machine, may still need a token) */
 export function isLocalProvider(provider) {
-    return provider === 'ollama' || provider === 'kbot-local' || provider === 'lmstudio' || provider === 'jan' || provider === 'embedded';
+    return provider === 'ollama' || provider === 'kbot-local' || provider === 'lmstudio' || provider === 'jan' || provider === 'embedded' || provider === 'llada';
 }
 /** Check if a provider needs no API key at all */
 export function isKeylessProvider(provider) {
-    return provider === 'ollama' || provider === 'lmstudio' || provider === 'jan' || provider === 'embedded';
+    return provider === 'ollama' || provider === 'lmstudio' || provider === 'jan' || provider === 'embedded' || provider === 'llada';
 }
 /** Check if BYOK mode is enabled (via env var or config) */
 export function isByokEnabled() {

package/dist/cli.js

@@ -102,7 +102,7 @@ async function main() {
         console.log(`  ${chalk.cyan('https://github.com/isaacsight/kernel/issues')}  ${chalk.dim('Bug reports')}`);
         console.log(`  ${chalk.cyan('support@kernel.chat')}  ${chalk.dim('Email (AI-assisted replies)')}`);
         console.log();
-        console.log(`  ${chalk.dim('35 specialist agents · 787+ tools · 20 providers · MIT licensed')}`);
+        console.log(`  ${chalk.dim('35 specialist agents · 100+ skills · 20 providers · MIT licensed')}`);
         console.log();
         process.exit(0);
     });
@@ -582,10 +582,10 @@ async function main() {
     // ── Discovery Agent ──
     const discoveryCmd = program
         .command('discovery')
-        .description('Autonomous outreach agent — finds conversations, drafts responses, posts for you');
+        .description('Background outreach agent — finds conversations, drafts responses, posts for you');
     discoveryCmd
         .command('start')
-        .description('Start the discovery loop — scans HN, GitHub, Reddit and posts autonomously')
+        .description('Start the discovery loop — scans HN, GitHub, Reddit and posts in the background')
         .option('--dry-run', 'Find and draft but don\'t post')
         .option('--interval <minutes>', 'Poll interval in minutes', '60')
         .option('--model <model>', 'Ollama model for analysis', 'qwen2.5-coder:32b')
@@ -4202,7 +4202,7 @@ async function main() {
             const models = await listOllamaModels();
             if (models.length > 0)
                 printInfo(`${models.length} models available. Using: ${ollamaModel || PROVIDERS.ollama.defaultModel}`);
-            printInfo('670+ tools ready. Type your prompt or press Enter for interactive mode.');
+            printInfo('100+ skills ready. Type your prompt or press Enter for interactive mode.');
         }
         else {
             printError(`Cannot reach Ollama at ${ollamaHost}. Is it running?`);
@@ -4696,7 +4696,7 @@ async function byokFlow() {
     console.log();
     printSuccess(`BYOK mode enabled — ${providerConfig.name}`);
     printInfo('You pay the provider directly. No message limits. No restrictions.');
-    printInfo('All 362 tools + 35 agents + learning system = yours.');
+    printInfo('All 100+ skills + 35 specialist agents + learning system = yours.');
     console.log();
     printSuccess('Ready. Run `kbot` to start.');
 }
@@ -4996,7 +4996,7 @@ async function startRepl(agentOpts, context, tier, byokActive = false, localActi
         const suggestions = await detectProjectSuggestions();
         console.log();
         console.log(chalk.dim('  ┌─────────────────────────────────────────────────┐'));
-        console.log(chalk.dim('  │') + chalk.bold('  35 agents. 362 tools. Just say what you need.  ') + chalk.dim(' │'));
+        console.log(chalk.dim('  │') + chalk.bold('  35 agents. 100+ skills. Just say what you need.  ') + chalk.dim(' │'));
         console.log(chalk.dim('  │                                                 │'));
         if (suggestions.length > 0) {
             for (const s of suggestions.slice(0, 4)) {

package/dist/plugin-sdk.d.ts

@@ -35,6 +35,17 @@ export interface PluginConfig {
     enabled: string[];
     disabled: string[];
 }
+export interface LoadPluginsOptions {
+    /** Override the plugin directory (used by tests). Defaults to ~/.kbot/plugins. */
+    pluginsDir?: string;
+    /** Override the integrity manifest path. Defaults to ~/.kbot/plugins.json. */
+    manifestPath?: string;
+    /**
+     * Override the integrity-disabled flag. Defaults to reading
+     * `process.env.KBOT_PLUGIN_INTEGRITY === 'off'`.
+     */
+    integrityDisabled?: boolean;
+}
 export interface SDKPluginManifest {
     name: string;
     version: string;
@@ -53,8 +64,18 @@ export interface SDKPluginManifest {
 /**
  * Load all installed and enabled SDK plugins.
  * Called at startup after the legacy plugins.ts loadPlugins() runs.
- */
-export declare function loadPlugins(verbose?: boolean): Promise<SDKPluginManifest[]>;
+ *
+ * Integrity contract (mirrors plugins.ts):
+ *   - Reads the same manifest at `~/.kbot/plugins.json` (override via
+ *     `KBOT_PLUGIN_MANIFEST` or `opts.manifestPath`).
+ *   - If the manifest exists, only plugins whose `name` appears in
+ *     `result.verified` are imported. Drift → throws `IntegrityError`.
+ *   - If the manifest is missing, falls back to back-compat behaviour: all
+ *     discovered, enabled plugins are imported (with a yellow info note).
+ *   - `KBOT_PLUGIN_INTEGRITY=off` skips verification entirely with a loud
+ *     yellow warning.
+ */
+export declare function loadPlugins(verbose?: boolean, opts?: LoadPluginsOptions): Promise<SDKPluginManifest[]>;
 /**
  * Scaffold a new plugin with a full project structure.
  * Creates ~/.kbot/plugins/<name>/ with index.ts and package.json.

package/dist/plugin-sdk.js

@@ -21,11 +21,32 @@ import { join, basename, resolve } from 'node:path';
 import { homedir } from 'node:os';
 import { pathToFileURL } from 'node:url';
 import { execSync } from 'node:child_process';
+import chalk from 'chalk';
 import { registerTool } from './tools/index.js';
+import { IntegrityError, verifyAllPlugins, enforce, } from './plugins-integrity.js';
 // ── Constants ────────────────────────────────────────────────────────────
 const KBOT_DIR = join(homedir(), '.kbot');
 const PLUGINS_DIR = join(KBOT_DIR, 'plugins');
+// NOTE: PLUGINS_CONFIG (per-plugin enable/disable list) shares the path
+// `~/.kbot/plugins.json` with the integrity manifest used by plugins.ts. This
+// is a pre-existing collision in the SDK loader — the enable/disable JSON has
+// shape `{ enabled, disabled }`, while the integrity manifest has shape
+// `{ schemaVersion, plugins }`. In practice users running with the integrity
+// manifest must override the SDK config path, or the integrity manifest path,
+// via `KBOT_PLUGIN_MANIFEST`. The fix is out of scope for the integrity
+// wiring; flagged here so we do not mask the collision in tests.
 const PLUGINS_CONFIG = join(KBOT_DIR, 'plugins.json');
+/**
+ * Default integrity manifest path. Mirrors plugins.ts so a single manifest
+ * covers both drop-in `.js` plugins (handled by plugins.ts) and SDK-style
+ * directory plugins (handled here). The integrity manifest's `path` field is
+ * resolved relative to `~/.kbot/plugins/`, so:
+ *   - `hello.js`            → simple drop-in plugin
+ *   - `my-tool/index.js`    → SDK-style packaged plugin
+ * are both expressible in one manifest. Override via `KBOT_PLUGIN_MANIFEST`
+ * or the `manifestPath` option to `loadPlugins`.
+ */
+const DEFAULT_MANIFEST_PATH = join(homedir(), '.kbot', 'plugins.json');
 // ── State ────────────────────────────────────────────────────────────────
 const loadedSDKPlugins = new Map();
 const registeredCommands = new Map();
@@ -219,19 +240,22 @@ function registerPluginHooks(plugin) {
 /**
  * Discover local plugins in ~/.kbot/plugins/<name>/ directories.
  * Each directory should contain an index.ts or index.js file.
+ *
+ * Pass `pluginsDir` to scan a custom location (used by tests). Defaults to
+ * the module-level `PLUGINS_DIR` (`~/.kbot/plugins`).
  */
-function discoverLocalPlugins() {
-    ensureDir(PLUGINS_DIR);
+function discoverLocalPlugins(pluginsDir = PLUGINS_DIR) {
+    ensureDir(pluginsDir);
     const results = [];
     let entries;
     try {
-        entries = readdirSync(PLUGINS_DIR);
+        entries = readdirSync(pluginsDir);
     }
     catch {
         return results;
     }
     for (const entry of entries) {
-        const dirPath = join(PLUGINS_DIR, entry);
+        const dirPath = join(pluginsDir, entry);
         try {
             const stat = statSync(dirPath);
             if (!stat.isDirectory())
@@ -328,16 +352,91 @@ function discoverNpmPlugins() {
     }
     return results;
 }
+// ── Integrity Gate ───────────────────────────────────────────────────────
+/**
+ * Run the integrity manifest gate before loading any SDK plugin module.
+ *
+ * Mirrors `plugins.ts`'s `runIntegrityGate` so the two loaders enforce the
+ * same fail-closed contract against the same manifest at `~/.kbot/plugins.json`.
+ *
+ * Behaviour:
+ *   - If KBOT_PLUGIN_INTEGRITY=off (or `integrityDisabled === true`):
+ *     emit a yellow warning and return `null` (verification skipped, all
+ *     discovered plugins are eligible to load).
+ *   - If the manifest file does not exist: emit a yellow info note and
+ *     return `null` (back-compat — manifest is optional today).
+ *   - If the manifest exists and verifies: return the `VerifyAllResult` so
+ *     the caller can restrict loads to `result.verified`.
+ *   - If the manifest exists and any plugin fails: throw `IntegrityError`
+ *     (loader refuses to import any SDK plugin this session).
+ */
+async function runIntegrityGate(manifestPath, pluginsDir, integrityDisabled) {
+    if (integrityDisabled) {
+        console.error(chalk.yellow(`  ⚠ KBOT_PLUGIN_INTEGRITY=off — skipping integrity check for SDK plugins (NOT FOR PRODUCTION). ` +
+            `Plugins under ${pluginsDir} will load without hash checking.`));
+        return null;
+    }
+    if (!existsSync(manifestPath)) {
+        console.error(chalk.yellow(`  ⚠ no plugin manifest at ${manifestPath} — plugin SDK loaded without integrity verification. ` +
+            `Create one to pin plugins by SHA-256 (see PLUGINS_INTEGRITY.md).`));
+        return null;
+    }
+    try {
+        const result = await verifyAllPlugins(manifestPath, pluginsDir);
+        if (result.failed.length > 0) {
+            const lines = result.failed
+                .map((f) => `    - ${f.name}: ${f.reason}`)
+                .join('\n');
+            console.error(chalk.red(`  ✗ Plugin integrity check failed for ${result.failed.length} SDK plugin(s):\n${lines}\n` +
+                `    Manifest: ${manifestPath}\n` +
+                `    To refresh hashes, recompute SHA-256 for each plugin entry and update the manifest. ` +
+                `Set KBOT_PLUGIN_INTEGRITY=off ONLY for local dev; never in production.`));
+            enforce(result); // throws IntegrityError
+        }
+        return result;
+    }
+    catch (err) {
+        if (err instanceof IntegrityError)
+            throw err;
+        // loadManifest threw (malformed JSON, schema violation, etc.) — fail closed.
+        console.error(chalk.red(`  ✗ Failed to load plugin integrity manifest at ${manifestPath}: ${err.message}`));
+        throw err;
+    }
+}
 // ── Public API ───────────────────────────────────────────────────────────
 /**
  * Load all installed and enabled SDK plugins.
  * Called at startup after the legacy plugins.ts loadPlugins() runs.
+ *
+ * Integrity contract (mirrors plugins.ts):
+ *   - Reads the same manifest at `~/.kbot/plugins.json` (override via
+ *     `KBOT_PLUGIN_MANIFEST` or `opts.manifestPath`).
+ *   - If the manifest exists, only plugins whose `name` appears in
+ *     `result.verified` are imported. Drift → throws `IntegrityError`.
+ *   - If the manifest is missing, falls back to back-compat behaviour: all
+ *     discovered, enabled plugins are imported (with a yellow info note).
+ *   - `KBOT_PLUGIN_INTEGRITY=off` skips verification entirely with a loud
+ *     yellow warning.
  */
-export async function loadPlugins(verbose = false) {
+export async function loadPlugins(verbose = false, opts = {}) {
+    const pluginsDir = opts.pluginsDir ?? PLUGINS_DIR;
+    const manifestPath = opts.manifestPath ?? process.env.KBOT_PLUGIN_MANIFEST ?? DEFAULT_MANIFEST_PATH;
+    const integrityDisabled = opts.integrityDisabled ?? process.env.KBOT_PLUGIN_INTEGRITY === 'off';
     const manifests = [];
-    // Discover from both sources
-    const localPlugins = discoverLocalPlugins();
-    const npmPlugins = discoverNpmPlugins();
+    // Integrity gate — runs BEFORE any SDK plugin file is imported. Throws
+    // IntegrityError on drift unless KBOT_PLUGIN_INTEGRITY=off.
+    const integrity = await runIntegrityGate(manifestPath, pluginsDir, integrityDisabled);
+    // When a manifest verified successfully, restrict loads to verified names.
+    // When the manifest is missing or integrity is disabled, allow every file.
+    const verifiedNames = integrity
+        ? new Set(integrity.verified)
+        : null;
+    // Discover from both sources. NPM plugins live in global node_modules and
+    // are not (yet) covered by the integrity manifest's relative-path scheme;
+    // when integrity is enforced, only local plugins listed in the manifest
+    // load. NPM plugins are skipped entirely under enforcement.
+    const localPlugins = discoverLocalPlugins(pluginsDir);
+    const npmPlugins = verifiedNames ? [] : discoverNpmPlugins();
     const allDiscovered = [
         ...localPlugins.map(p => ({ ...p, source: 'local' })),
         ...npmPlugins.map(p => ({ ...p, source: 'npm' })),
@@ -361,6 +460,17 @@ export async function loadPlugins(verbose = false) {
             manifests.push(manifest);
             continue;
         }
+        // When manifest verification ran, only load plugins whose name appears in
+        // the verified set. Discovered plugins not declared in the manifest are
+        // skipped (they could not have passed verification).
+        if (verifiedNames && !verifiedNames.has(name)) {
+            if (verbose) {
+                console.error(chalk.yellow(`  ⚠ [SDK] Skipping ${name} — not declared in plugin manifest`));
+            }
+            manifest.error = 'not declared in plugin integrity manifest';
+            manifests.push(manifest);
+            continue;
+        }
         try {
             const plugin = await importPlugin(entryPath);
             manifest.version = plugin.version;

package/dist/plugins.js

@@ -107,7 +107,21 @@ export async function loadPlugins(verbose = false, opts = {}) {
     const verifiedNames = integrity
         ? new Set(integrity.verified)
         : null;
-    const files = readdirSync(pluginsDir).filter(f => PLUGIN_EXTENSIONS.some(ext => f.endsWith(ext)));
+    // Top-level plugin files
+    const topLevel = readdirSync(pluginsDir).filter(f => PLUGIN_EXTENSIONS.some(ext => f.endsWith(ext)));
+    // Forged subdirectory (created by forge.ts at runtime). v3.99.31 and earlier
+    // persisted forged tools here without the loader scanning for them; fixed in v4.0.
+    let forgedFiles = [];
+    try {
+        const forgedDir = join(pluginsDir, 'forged');
+        forgedFiles = readdirSync(forgedDir)
+            .filter(f => PLUGIN_EXTENSIONS.some(ext => f.endsWith(ext)))
+            .map(f => `forged/${f}`);
+    }
+    catch {
+        // forged/ doesn't exist — nothing to load
+    }
+    const files = [...topLevel, ...forgedFiles];
     if (files.length === 0)
         return [];
     for (const file of files) {

package/dist/providers/llada.d.ts

@@ -0,0 +1,98 @@
+export interface LLaDAClientOptions {
+    baseUrl?: string;
+    apiKey?: string;
+    /** Default request timeout in ms. */
+    timeoutMs?: number;
+    /** Optional fetch override (used by tests). */
+    fetchImpl?: typeof fetch;
+}
+export interface LLaDAChatMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string | Array<{
+        type: 'text';
+        text: string;
+    } | {
+        type: 'image_url';
+        image_url: {
+            url: string;
+        };
+    }>;
+}
+export interface LLaDAChatRequest {
+    messages: LLaDAChatMessage[];
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    /** Optional thinking budget — LLaDA supports `mode: "thinking"` with `thinking_steps`. */
+    thinkingSteps?: number;
+}
+export interface LLaDAChatResponse {
+    text: string;
+    /** When `thinkingSteps` is set, LLaDA returns the reasoning trace. */
+    thinking?: string;
+    raw?: unknown;
+}
+export interface LLaDAImageRequest {
+    prompt: string;
+    /** Either "1024x1024" / "WxH" — converted to image_h/image_w server-side. */
+    size?: string;
+    /** Optional reference image (URL or base64 data URL) for image editing. */
+    refImage?: string;
+    /** Diffusion sampling steps (LLaDA defaults to 8 with the turbo decoder). */
+    steps?: number;
+    cfgScale?: number;
+    /** Enable LLaDA's interleaved thinking-then-generate mode. */
+    thinking?: boolean;
+}
+export interface LLaDAImageResponse {
+    /** A URL or `data:image/png;base64,...` payload. */
+    url: string;
+    /** Reasoning trace, only present when `thinking: true`. */
+    thinking?: string;
+    raw?: unknown;
+}
+export interface LLaDAUnderstandRequest {
+    prompt: string;
+    /** Pass exactly one of imageUrl or imageData (base64). */
+    imageUrl?: string;
+    imageData?: string;
+    model?: string;
+    maxTokens?: number;
+}
+export interface LLaDAUnderstandResponse {
+    text: string;
+    raw?: unknown;
+}
+/** Typed client for a LLaDA2.0-Uni HTTP server (OpenAI-compatible shape). */
+export declare class LLaDAClient {
+    readonly baseUrl: string;
+    readonly apiKey: string | undefined;
+    private readonly timeoutMs;
+    private readonly fetchImpl;
+    constructor(opts?: LLaDAClientOptions);
+    /** Build standard headers — Authorization only attached when an apiKey is set. */
+    private headers;
+    private post;
+    /** Quick health probe. Resolves true when the server responds with 2xx. */
+    isReachable(): Promise<boolean>;
+    /**
+     * Text chat — OpenAI-compatible POST /v1/chat/completions.
+     * SPEC: refine when LLaDA's API stabilizes — currently assumes OpenAI-compatible shape.
+     */
+    chat(req: LLaDAChatRequest): Promise<LLaDAChatResponse>;
+    /**
+     * Image generation. The native LLaDA call is `model.generate_image(...)`;
+     * we expose it via a POST /v1/images/generations shim that accepts the
+     * extra LLaDA-specific knobs (`steps`, `cfg_scale`, `thinking`).
+     * SPEC: refine when LLaDA's API stabilizes — assumes OpenAI-compatible shape.
+     */
+    generateImage(req: LLaDAImageRequest): Promise<LLaDAImageResponse>;
+    /**
+     * Multimodal understanding: chat with an image attached.
+     * SPEC: refine when LLaDA's API stabilizes — uses OpenAI-vision content blocks.
+     */
+    understand(req: LLaDAUnderstandRequest): Promise<LLaDAUnderstandResponse>;
+}
+/** Convenience factory mirroring the rest of kbot's local-provider style. */
+export declare function createLLaDAClient(opts?: LLaDAClientOptions): LLaDAClient;
+//# sourceMappingURL=llada.d.ts.map