@kernel.chat/kbot 3.99.34 → 3.99.35

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/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

package/dist/providers/llada.js

@@ -0,0 +1,197 @@
+// LLaDA2.0-Uni provider client
+//
+// LLaDA2.0-Uni (Inclusion AI, ArXiv:2604.20796, 2026-04-22) is a unified
+// discrete-diffusion LLM that does multimodal *understanding* AND text-to-image
+// generation in a single MoE model. It pairs a SigLIP-VQ semantic tokenizer
+// with a diffusion decoder for high-fidelity 8-step image inference.
+//
+// Local serving status (as of 2026-04-25):
+//   The official repo (https://github.com/inclusionAI/LLaDA2.0-Uni) currently
+//   ships only Python inference scripts (`scripts/t2i_generate.py`,
+//   `scripts/mmu_understand.py`, `scripts/image_edit.py`) using the HF
+//   transformers loader. SGLang serving is on the README's TODO list but not
+//   yet released. Most users will wrap the Python entrypoints behind a small
+//   OpenAI-compatible FastAPI shim, or wait for the SGLang adapter.
+//
+// SPEC: refine when LLaDA's API stabilizes — currently assumes OpenAI-compatible
+// shape on http://localhost:8000 (the conventional vllm / TGI / SGLang layout).
+// All endpoints below are speculative until the upstream serving surface lands.
+const DEFAULT_BASE_URL = process.env.KBOT_LLADA_URL || 'http://localhost:8000';
+const DEFAULT_MODEL = 'llada2.0-uni';
+/** Typed client for a LLaDA2.0-Uni HTTP server (OpenAI-compatible shape). */
+export class LLaDAClient {
+    baseUrl;
+    apiKey;
+    timeoutMs;
+    fetchImpl;
+    constructor(opts = {}) {
+        this.baseUrl = (opts.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, '');
+        this.apiKey = opts.apiKey;
+        this.timeoutMs = opts.timeoutMs ?? 60_000;
+        // Bind so `this` in node's global fetch stays right.
+        this.fetchImpl = opts.fetchImpl ?? ((...a) => fetch(...a));
+    }
+    /** Build standard headers — Authorization only attached when an apiKey is set. */
+    headers() {
+        const h = { 'Content-Type': 'application/json' };
+        if (this.apiKey)
+            h.Authorization = `Bearer ${this.apiKey}`;
+        return h;
+    }
+    async post(path, body) {
+        const url = `${this.baseUrl}${path}`;
+        const ctrl = new AbortController();
+        const timer = setTimeout(() => ctrl.abort(), this.timeoutMs);
+        try {
+            const res = await this.fetchImpl(url, {
+                method: 'POST',
+                headers: this.headers(),
+                body: JSON.stringify(body),
+                signal: ctrl.signal,
+            });
+            if (!res.ok) {
+                const txt = await res.text().catch(() => '');
+                throw new Error(`LLaDA ${path} failed: ${res.status} ${res.statusText} ${txt}`.trim());
+            }
+            return (await res.json());
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    /** Quick health probe. Resolves true when the server responds with 2xx. */
+    async isReachable() {
+        try {
+            const ctrl = new AbortController();
+            const timer = setTimeout(() => ctrl.abort(), 2000);
+            try {
+                // SPEC: refine when LLaDA's API stabilizes — try /v1/models, fall back to /health.
+                const res = await this.fetchImpl(`${this.baseUrl}/v1/models`, {
+                    method: 'GET',
+                    signal: ctrl.signal,
+                });
+                if (res.ok)
+                    return true;
+                const res2 = await this.fetchImpl(`${this.baseUrl}/health`, {
+                    method: 'GET',
+                    signal: ctrl.signal,
+                });
+                return res2.ok;
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Text chat — OpenAI-compatible POST /v1/chat/completions.
+     * SPEC: refine when LLaDA's API stabilizes — currently assumes OpenAI-compatible shape.
+     */
+    async chat(req) {
+        const body = {
+            model: req.model || DEFAULT_MODEL,
+            messages: req.messages,
+            temperature: req.temperature ?? 0.7,
+        };
+        if (req.maxTokens !== undefined)
+            body.max_tokens = req.maxTokens;
+        if (req.thinkingSteps !== undefined) {
+            // LLaDA exposes `mode: "thinking"` + `thinking_steps` in its native API.
+            // We pass them as extra fields; servers that don't recognize them ignore.
+            body.mode = 'thinking';
+            body.thinking_steps = req.thinkingSteps;
+        }
+        const data = await this.post('/v1/chat/completions', body);
+        const text = data.choices?.[0]?.message?.content ?? '';
+        if (!text)
+            throw new Error('LLaDA chat returned no content');
+        const thinking = data.choices?.[0]?.message?.thinking ?? data.thinking;
+        return { text, thinking, raw: data };
+    }
+    /**
+     * 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.
+     */
+    async generateImage(req) {
+        const size = req.size || '1024x1024';
+        const [w, h] = parseSize(size);
+        const body = {
+            model: DEFAULT_MODEL,
+            prompt: req.prompt,
+            size,
+            n: 1,
+            // LLaDA-native fields (ignored by stricter OpenAI servers):
+            image_w: w,
+            image_h: h,
+            steps: req.steps ?? 8,
+            cfg_scale: req.cfgScale ?? 2.0,
+        };
+        if (req.thinking) {
+            body.mode = 'thinking';
+            body.thinking_steps = 32;
+        }
+        if (req.refImage) {
+            // SPEC: LLaDA uses `image_tokens` for editing. The likely server shim accepts
+            // either `input_image` (URL/data URL) or `image` and tokenizes server-side.
+            body.input_image = req.refImage;
+            body.image = req.refImage;
+        }
+        const data = await this.post('/v1/images/generations', body);
+        const item = data.data?.[0];
+        if (!item)
+            throw new Error('LLaDA image returned no data');
+        let url = item.url;
+        if (!url && item.b64_json)
+            url = `data:image/png;base64,${item.b64_json}`;
+        if (!url)
+            throw new Error('LLaDA image returned neither url nor b64_json');
+        const thinking = item.thinking ?? data.thinking;
+        return { url, thinking, raw: data };
+    }
+    /**
+     * Multimodal understanding: chat with an image attached.
+     * SPEC: refine when LLaDA's API stabilizes — uses OpenAI-vision content blocks.
+     */
+    async understand(req) {
+        if (!req.imageUrl && !req.imageData) {
+            throw new Error('LLaDA.understand requires imageUrl or imageData');
+        }
+        const imageUrl = req.imageUrl
+            ? req.imageUrl
+            : req.imageData.startsWith('data:')
+                ? req.imageData
+                : `data:image/png;base64,${req.imageData}`;
+        const messages = [
+            {
+                role: 'user',
+                content: [
+                    { type: 'text', text: req.prompt },
+                    { type: 'image_url', image_url: { url: imageUrl } },
+                ],
+            },
+        ];
+        const out = await this.chat({
+            model: req.model,
+            messages,
+            maxTokens: req.maxTokens ?? 1024,
+            temperature: 0.2,
+        });
+        return { text: out.text, raw: out.raw };
+    }
+}
+function parseSize(size) {
+    const m = /^(\d+)\s*x\s*(\d+)$/i.exec(size.trim());
+    if (!m)
+        return [1024, 1024];
+    return [Number(m[1]), Number(m[2])];
+}
+/** Convenience factory mirroring the rest of kbot's local-provider style. */
+export function createLLaDAClient(opts = {}) {
+    return new LLaDAClient(opts);
+}
+//# sourceMappingURL=llada.js.map

package/dist/tools/image-thoughtful.d.ts

@@ -8,14 +8,14 @@ export declare const imageThoughtfulInputSchema: z.ZodObject<{
     reference_image_url: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     prompt: string;
-    aspect_ratio: "1:1" | "16:9" | "9:16" | "4:3" | "3:4";
     thinking_steps: number;
+    aspect_ratio: "1:1" | "16:9" | "9:16" | "4:3" | "3:4";
     style_hints?: string | undefined;
     reference_image_url?: string | undefined;
 }, {
     prompt: string;
-    aspect_ratio?: "1:1" | "16:9" | "9:16" | "4:3" | "3:4" | undefined;
     thinking_steps?: number | undefined;
+    aspect_ratio?: "1:1" | "16:9" | "9:16" | "4:3" | "3:4" | undefined;
     style_hints?: string | undefined;
     reference_image_url?: string | undefined;
 }>;

package/dist/tools/llada-image.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import type { ToolDefinition } from './index.js';
+import { LLaDAClient } from '../providers/llada.js';
+export declare const lladaImageInputSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    aspect_ratio: z.ZodDefault<z.ZodOptional<z.ZodEnum<["1:1", "16:9", "9:16", "4:3", "3:4"]>>>;
+    thinking_steps: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    style_hints: z.ZodOptional<z.ZodString>;
+    reference_image_url: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    prompt: string;
+    thinking_steps: number;
+    aspect_ratio: "1:1" | "16:9" | "9:16" | "4:3" | "3:4";
+    style_hints?: string | undefined;
+    reference_image_url?: string | undefined;
+}, {
+    prompt: string;
+    thinking_steps?: number | undefined;
+    aspect_ratio?: "1:1" | "16:9" | "9:16" | "4:3" | "3:4" | undefined;
+    style_hints?: string | undefined;
+    reference_image_url?: string | undefined;
+}>;
+export type LLaDAImageInput = z.infer<typeof lladaImageInputSchema>;
+export interface LLaDAImageThoughtfulOutput {
+    url: string;
+    plan: string;
+    refinements: string[];
+    final_prompt: string;
+    /** Optional reasoning trace surfaced by LLaDA's `thinking` mode. */
+    thinking?: string;
+}
+export interface RunLLaDAImageOptions {
+    /** Inject a client (for tests). Defaults to a fresh LLaDAClient(). */
+    client?: LLaDAClient;
+}
+export declare function runLLaDAImageThoughtful(rawInput: unknown, opts?: RunLLaDAImageOptions): Promise<LLaDAImageThoughtfulOutput>;
+export declare const lladaImageTool: ToolDefinition;
+//# sourceMappingURL=llada-image.d.ts.map

package/dist/tools/llada-image.js

@@ -0,0 +1,171 @@
+// kbot Local Image Thoughtful Tool — LLaDA2.0-Uni route
+//
+// Mirrors `image-thoughtful.ts` (which uses OpenAI gpt-image-2) but routes
+// every call — plan, refine, generate — through a local LLaDA2.0-Uni server.
+// LLaDA is a *unified* discrete-diffusion model: the same model that does
+// chat reasoning also does the final image generation, so this tool is the
+// $0 / no-API-key path to thoughtful image gen.
+//
+// SPEC: refine when LLaDA's API stabilizes — currently assumes OpenAI-compatible
+// shape on http://localhost:8000. See `src/providers/llada.ts` for details.
+import { z } from 'zod';
+import { LLaDAClient } from '../providers/llada.js';
+// ─────────────────────────────────────────────────────────────────────────
+// Schema (kept in lockstep with image-thoughtful.ts)
+// ─────────────────────────────────────────────────────────────────────────
+const AspectRatio = z.enum(['1:1', '16:9', '9:16', '4:3', '3:4']);
+export const lladaImageInputSchema = z.object({
+    prompt: z.string().min(1, 'prompt is required'),
+    aspect_ratio: AspectRatio.optional().default('1:1'),
+    thinking_steps: z.number().int().min(1).max(5).optional().default(3),
+    style_hints: z.string().optional(),
+    reference_image_url: z.string().url().optional(),
+});
+// LLaDA's image_h/image_w map cleanly off these aspect-ratio sizes.
+const SIZE_MAP = {
+    '1:1': '1024x1024',
+    '16:9': '1792x1024',
+    '9:16': '1024x1792',
+    '4:3': '1408x1056',
+    '3:4': '1056x1408',
+};
+// ─────────────────────────────────────────────────────────────────────────
+// Prompts (intentionally identical wording to image-thoughtful for parity)
+// ─────────────────────────────────────────────────────────────────────────
+function planSystemPrompt() {
+    return [
+        'You are an expert art director planning an image before generation.',
+        'Return a JSON object with keys: composition, palette, key_elements, mood, lighting, style.',
+        'Keep each value to one or two sentences. Be concrete and visual.',
+    ].join(' ');
+}
+function critiqueSystemPrompt() {
+    return [
+        'You are a critic refining an image plan. Read the prompt and the current plan,',
+        'identify the single weakest element, and return an improved JSON plan with the',
+        'same keys (composition, palette, key_elements, mood, lighting, style).',
+        'Do not restate the brief — produce the next iteration of the plan only.',
+    ].join(' ');
+}
+function finalPromptSystemPrompt() {
+    return [
+        'You compose the final image-generation prompt. Combine the brief, plan, and any',
+        'style hints into a single cohesive paragraph (no JSON, no headings, no lists).',
+        'Lead with subject and composition, then palette, lighting, mood, and style.',
+    ].join(' ');
+}
+function buildPlanUserText(input) {
+    return [
+        `Brief: ${input.prompt}`,
+        `Aspect ratio: ${input.aspect_ratio}`,
+        input.style_hints ? `Style hints: ${input.style_hints}` : null,
+        input.reference_image_url ? `Reference image URL: ${input.reference_image_url}` : null,
+    ]
+        .filter(Boolean)
+        .join('\n');
+}
+export async function runLLaDAImageThoughtful(rawInput, opts = {}) {
+    const input = lladaImageInputSchema.parse(rawInput);
+    const client = opts.client ?? new LLaDAClient();
+    // 1. Plan
+    const planResp = await client.chat({
+        messages: [
+            { role: 'system', content: planSystemPrompt() },
+            { role: 'user', content: buildPlanUserText(input) },
+        ],
+        temperature: 0.5,
+    });
+    const plan = planResp.text;
+    // 2. Refine — thinking_steps - 1 critique passes (1 = no refinement)
+    const refinements = [];
+    let currentPlan = plan;
+    for (let i = 1; i < input.thinking_steps; i++) {
+        const next = await client.chat({
+            messages: [
+                { role: 'system', content: critiqueSystemPrompt() },
+                {
+                    role: 'user',
+                    content: `Brief: ${input.prompt}\nCurrent plan: ${currentPlan}`,
+                },
+            ],
+            temperature: 0.5,
+        });
+        refinements.push(next.text);
+        currentPlan = next.text;
+    }
+    // 3. Compose final prompt
+    const finalResp = await client.chat({
+        messages: [
+            { role: 'system', content: finalPromptSystemPrompt() },
+            {
+                role: 'user',
+                content: [
+                    `Brief: ${input.prompt}`,
+                    input.style_hints ? `Style hints: ${input.style_hints}` : '',
+                    `Plan: ${currentPlan}`,
+                ]
+                    .filter(Boolean)
+                    .join('\n\n'),
+            },
+        ],
+        temperature: 0.4,
+    });
+    const finalPromptText = finalResp.text;
+    // 4. Generate (LLaDA-native call — same model, diffusion decoder).
+    const img = await client.generateImage({
+        prompt: finalPromptText,
+        size: SIZE_MAP[input.aspect_ratio],
+        refImage: input.reference_image_url,
+    });
+    return {
+        url: img.url,
+        plan,
+        refinements,
+        final_prompt: finalPromptText,
+        thinking: img.thinking,
+    };
+}
+// ─────────────────────────────────────────────────────────────────────────
+// Tool definition
+// ─────────────────────────────────────────────────────────────────────────
+export const lladaImageTool = {
+    name: 'local_image_thoughtful',
+    description: 'Local plan/refine/generate image tool routed through a LLaDA2.0-Uni server (default http://localhost:8000). The same unified diffusion LLM does both the planning and the final image generation, so no OpenAI key is required. Returns the image URL plus the full reasoning trail.',
+    tier: 'free',
+    parameters: {
+        prompt: {
+            type: 'string',
+            description: 'What to draw — the brief.',
+            required: true,
+        },
+        aspect_ratio: {
+            type: 'string',
+            description: 'One of "1:1", "16:9", "9:16", "4:3", "3:4". Default "1:1".',
+            default: '1:1',
+        },
+        thinking_steps: {
+            type: 'number',
+            description: 'How many plan iterations to run (1..5). Default 3. 1 skips refinement.',
+            default: 3,
+        },
+        style_hints: {
+            type: 'string',
+            description: 'Optional style guidance ("oil painting", "ukiyo-e", "isometric vector").',
+        },
+        reference_image_url: {
+            type: 'string',
+            description: 'Optional URL of a reference image. Forwarded to LLaDA as the editing source (input_image).',
+        },
+    },
+    async execute(args) {
+        try {
+            const out = await runLLaDAImageThoughtful(args);
+            return JSON.stringify(out, null, 2);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return `Error: ${message}`;
+        }
+    },
+};
+//# sourceMappingURL=llada-image.js.map

package/dist/tools/swarm-2026-04.js

@@ -3,6 +3,7 @@
 // lazy registry picks them up alongside everything else.
 import { registerTool } from './index.js';
 import { imageThoughtfulTool } from './image-thoughtful.js';
+import { lladaImageTool } from './llada-image.js';
 import { channelSendTool, channelReceiveTool } from './channel-tools.js';
 import { fileLibraryAddTool, fileLibraryListTool, fileLibrarySearchTool, fileLibraryGetTool, } from './file-library-tools.js';
 import { workspaceAgentTools } from './workspace-agent-tools.js';
@@ -72,6 +73,7 @@ function adaptSecurityTool(t) {
 }
 export function registerSwarm2026Tools() {
     registerTool(imageThoughtfulTool);
+    registerTool(lladaImageTool);
     registerTool(channelSendTool);
     registerTool(channelReceiveTool);
     registerTool(fileLibraryAddTool);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kernel.chat/kbot",
-  "version": "3.99.34",
+  "version": "3.99.35",
   "description": "Open-source terminal AI agent. 787+ tools, 35 agents, 20 providers. Dreams, learns, watches your system. Controls your phone. Fully local, fully sovereign. MIT.",
   "type": "module",
   "repository": {