@nodetool-ai/websocket 0.7.0-rc.22 → 0.8.1

package/dist/unified-websocket-runner.js

@@ -1,3840 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { tmpdir } from "node:os";
-import { pathToFileURL } from "node:url";
-import { getSecret } from "@nodetool-ai/models";
-import { getSetting } from "./settings-registry.js";
-import { pack, unpack } from "msgpackr";
-import { createLogger, getDefaultAssetsPath, buildAssetUrl } from "@nodetool-ai/config";
-import { resolveContentUrls, resolveContentForProvider } from "./resolve-media-urls.js";
-import { Graph, WorkflowRunner } from "@nodetool-ai/kernel";
-import { Asset, Job, Message, ModelObserver, Prediction, Thread, Workflow } from "@nodetool-ai/models";
-import { FileStorageAdapter, ProcessingContext as RuntimeProcessingContext, executeComfy } from "@nodetool-ai/runtime";
-import { Tool } from "@nodetool-ai/agents";
-const log = createLogger("nodetool.websocket.runner");
-const DATA_URI_PATTERN = /data:([^;,]+)?;base64,[A-Za-z0-9+/=\r\n]+/gi;
-const MAX_ERROR_TEXT_LENGTH = 4000;
-/**
- * Return `true` when the given http(s) URL appears to point at a public
- * destination (not a loopback, link-local, or RFC1918 private address).
- *
- * Used before `fetch`ing URLs supplied by chat clients to resolve source
- * images — without this gate, an authenticated user could coerce the server
- * into reading internal services via `http://169.254.169.254/...`,
- * `http://localhost:6379/...`, etc. The check is conservative: unparseable
- * URLs and literal IP addresses in private ranges are refused. DNS-based
- * bypass is still possible, so this is a defense-in-depth measure and not a
- * full SSRF mitigation; intended for complementing network-level egress
- * filtering.
- */
-function isSafeExternalUrl(url) {
-    let parsed;
-    try {
-        parsed = new URL(url);
-    }
-    catch {
-        return false;
-    }
-    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-        return false;
-    }
-    // Normalise IPv6 hostnames: WHATWG URL may return them with or without
-    // surrounding brackets depending on the runtime.
-    const host = parsed.hostname.toLowerCase().replace(/^\[|\]$/g, "");
-    if (!host)
-        return false;
-    if (host === "localhost" ||
-        host === "ip6-localhost" ||
-        host === "ip6-loopback" ||
-        host.endsWith(".localhost") ||
-        host.endsWith(".local") ||
-        host.endsWith(".internal")) {
-        return false;
-    }
-    // IPv4 literal check
-    const ipv4 = host.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
-    if (ipv4) {
-        const [a, b] = ipv4.slice(1).map((n) => parseInt(n, 10));
-        // 0.0.0.0/8, 10.0.0.0/8, 127.0.0.0/8, 169.254.0.0/16,
-        // 172.16.0.0/12, 192.168.0.0/16, 100.64.0.0/10 (CGNAT)
-        if (a === 0 || a === 10 || a === 127)
-            return false;
-        if (a === 169 && b === 254)
-            return false;
-        if (a === 172 && b >= 16 && b <= 31)
-            return false;
-        if (a === 192 && b === 168)
-            return false;
-        if (a === 100 && b >= 64 && b <= 127)
-            return false;
-    }
-    // IPv6 literal — refuse loopback / ULA / link-local / unspecified ranges.
-    if (host.includes(":")) {
-        if (host === "::" || host === "::1")
-            return false;
-        if (host.startsWith("fc") || host.startsWith("fd"))
-            return false; // ULA fc00::/7
-        if (host.startsWith("fe80:"))
-            return false; // link-local
-    }
-    return true;
-}
-function sanitizeLargeText(text, maxLength = MAX_ERROR_TEXT_LENGTH) {
-    const sanitized = text.replace(DATA_URI_PATTERN, (match, mimeType) => {
-        const mime = typeof mimeType === "string" && mimeType !== "" ? mimeType : "data";
-        return `[${mime} base64 omitted, ${match.length} chars]`;
-    });
-    if (sanitized.length <= maxLength) {
-        return sanitized;
-    }
-    const truncatedChars = sanitized.length - maxLength;
-    return `${sanitized.slice(0, maxLength)}... (truncated ${truncatedChars} chars)`;
-}
-function sanitizeErrorValue(value, seen = new WeakSet()) {
-    if (typeof value === "string") {
-        return sanitizeLargeText(value);
-    }
-    if (value instanceof Error) {
-        return sanitizeLargeText(value.message);
-    }
-    if (Array.isArray(value)) {
-        return value.map((item) => sanitizeErrorValue(item, seen));
-    }
-    if (value && typeof value === "object") {
-        if (seen.has(value)) {
-            return "[circular]";
-        }
-        seen.add(value);
-        const result = {};
-        for (const [key, nested] of Object.entries(value)) {
-            result[key] = sanitizeErrorValue(nested, seen);
-        }
-        return result;
-    }
-    return value;
-}
-function formatSanitizedError(error) {
-    if (typeof error === "string") {
-        return sanitizeLargeText(error);
-    }
-    if (error instanceof Error) {
-        return sanitizeLargeText(error.message);
-    }
-    const sanitized = sanitizeErrorValue(error);
-    if (typeof sanitized === "string") {
-        return sanitized;
-    }
-    try {
-        return sanitizeLargeText(JSON.stringify(sanitized));
-    }
-    catch {
-        return sanitizeLargeText(String(error));
-    }
-}
-function getAssetStoragePath() {
-    return getDefaultAssetsPath();
-}
-// ---------------------------------------------------------------------------
-// Auto-save assets — persists generated media as Asset records
-// ---------------------------------------------------------------------------
-const ASSET_MEDIA_TYPES = new Set(["image", "audio", "video"]);
-const ASSET_TYPE_MIME = {
-    image: "image/png",
-    audio: "audio/wav",
-    video: "video/mp4"
-};
-const ASSET_TYPE_EXT = {
-    image: "png",
-    audio: "wav",
-    video: "mp4"
-};
-function isAssetLikeValue(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return false;
-    const v = value;
-    return (typeof v.type === "string" &&
-        ASSET_MEDIA_TYPES.has(v.type) &&
-        ("data" in v || "uri" in v));
-}
-function decodeAssetBytes(data) {
-    if (data === null || data === undefined)
-        return null;
-    if (data instanceof Uint8Array)
-        return data;
-    if (Buffer.isBuffer(data))
-        return new Uint8Array(data);
-    if (Array.isArray(data) && data.every((v) => Number.isInteger(v))) {
-        return new Uint8Array(data);
-    }
-    if (typeof data === "string") {
-        return Uint8Array.from(Buffer.from(data, "base64"));
-    }
-    return null;
-}
-async function readBytesFromUri(uri) {
-    if (!uri)
-        return null;
-    try {
-        if (uri.startsWith("file://")) {
-            const { readFile } = await import("node:fs/promises");
-            const { fileURLToPath } = await import("node:url");
-            return new Uint8Array(await readFile(fileURLToPath(uri)));
-        }
-        if (uri.startsWith("data:")) {
-            const commaIdx = uri.indexOf(",");
-            if (commaIdx < 0)
-                return null;
-            return Uint8Array.from(Buffer.from(uri.slice(commaIdx + 1), "base64"));
-        }
-        if (uri.startsWith("http://") || uri.startsWith("https://")) {
-            const resp = await fetch(uri);
-            if (!resp.ok)
-                return null;
-            return new Uint8Array(await resp.arrayBuffer());
-        }
-    }
-    catch {
-        // Failed to read bytes — non-fatal
-    }
-    return null;
-}
-/**
- * Recursively find asset-like values in a result object and persist them as
- * Asset records in the database + on disk.
- *
- * Mutates the result in-place: sets `asset_id` and updates `uri` to
- * `asset://{id}.{ext}`.
- */
-async function autoSaveAssets(result, opts) {
-    const { join } = await import("node:path");
-    const { writeFile, mkdir } = await import("node:fs/promises");
-    const queue = [];
-    // Collect all asset-like values from the result (may be nested)
-    function collect(value) {
-        if (value === null || value === undefined)
-            return;
-        if (Array.isArray(value)) {
-            for (const item of value)
-                collect(item);
-            return;
-        }
-        if (isAssetLikeValue(value)) {
-            queue.push(value);
-            return;
-        }
-        if (typeof value === "object") {
-            for (const v of Object.values(value)) {
-                collect(v);
-            }
-        }
-    }
-    collect(result);
-    for (const assetValue of queue) {
-        // Skip if already saved
-        if (assetValue.asset_id)
-            continue;
-        const assetType = String(assetValue.type);
-        // Get bytes from inline data or URI
-        let bytes = decodeAssetBytes(assetValue.data);
-        if (!bytes && typeof assetValue.uri === "string") {
-            bytes = await readBytesFromUri(assetValue.uri);
-        }
-        if (!bytes)
-            continue;
-        // Determine mime/ext, preferring explicit content_type
-        const explicitMime = assetValue.mime_type ?? assetValue.content_type;
-        const contentType = typeof explicitMime === "string" && explicitMime
-            ? explicitMime
-            : (ASSET_TYPE_MIME[assetType] ?? "application/octet-stream");
-        const ext = ASSET_TYPE_EXT[assetType] ?? "bin";
-        // Create Asset record
-        const asset = new Asset({
-            user_id: opts.userId,
-            workflow_id: opts.workflowId ?? null,
-            node_id: opts.nodeId,
-            job_id: opts.jobId,
-            name: `${assetType}_${opts.nodeId.slice(0, 8)}`,
-            content_type: contentType,
-            parent_id: null
-        });
-        const fileName = `${asset.id}.${ext}`;
-        try {
-            await mkdir(opts.storagePath, { recursive: true });
-            await writeFile(join(opts.storagePath, fileName), bytes);
-            asset.size = bytes.length;
-            await asset.save();
-            // Mutate the result value in-place
-            assetValue.asset_id = asset.id;
-            assetValue.uri = `asset://${fileName}`;
-        }
-        catch (err) {
-            log.warn("Auto-save asset failed", {
-                nodeId: opts.nodeId,
-                error: String(err)
-            });
-        }
-    }
-}
-/**
- * Returns true if every node in the graph has a type starting with "comfy.".
- */
-function isComfyGraph(graph) {
-    return (graph.nodes.length > 0 &&
-        graph.nodes.every((n) => typeof n.type === "string" && n.type.startsWith("comfy.")));
-}
-/**
- * Converts a NodeTool graph (with comfy.* nodes) into a ComfyUI API prompt dict.
- */
-function graphToComfyPrompt(graph) {
-    const prompt = {};
-    for (const node of graph.nodes) {
-        const id = String(node.id);
-        const classType = node.type.replace(/^comfy\./, "");
-        const props = node.properties ??
-            node.data ??
-            {};
-        const inputs = {};
-        for (const [key, value] of Object.entries(props)) {
-            if (key.startsWith("_") || key === "workflow_id")
-                continue;
-            // MsgPack may decode large integers as BigInt; ComfyUI expects plain numbers
-            inputs[key] = typeof value === "bigint" ? Number(value) : value;
-        }
-        prompt[id] = { class_type: classType, inputs };
-    }
-    // Wire edges: set inputs to [sourceId, slotIndex]
-    for (const edge of graph.edges) {
-        const sourceId = String(edge.source);
-        const targetId = String(edge.target);
-        const sourceHandle = edge.sourceHandle;
-        const targetHandle = edge.targetHandle;
-        if (!prompt[targetId])
-            continue;
-        // Determine output slot index from source handle name.
-        // Handles may be "output_0", "output_1", etc. (generic indexed format)
-        // or named like "MODEL", "CLIP", "VAE" (resolved via _comfy_metadata).
-        let slotIndex = 0;
-        const outputMatch = /^output_(\d+)$/.exec(sourceHandle);
-        if (outputMatch) {
-            slotIndex = parseInt(outputMatch[1], 10);
-        }
-        else {
-            const sourceNode = graph.nodes.find((n) => String(n.id) === sourceId);
-            if (sourceNode) {
-                const nodeProps = sourceNode.properties ??
-                    sourceNode.data ??
-                    {};
-                const meta = (nodeProps._comfy_metadata ??
-                    sourceNode._comfy_metadata);
-                if (meta?.outputs) {
-                    const idx = meta.outputs.indexOf(sourceHandle);
-                    if (idx >= 0)
-                        slotIndex = idx;
-                }
-            }
-        }
-        prompt[targetId].inputs[targetHandle] = [sourceId, slotIndex];
-    }
-    return prompt;
-}
-function createRuntimeContext(opts) {
-    const storagePath = getAssetStoragePath();
-    const storage = new FileStorageAdapter(storagePath);
-    const ctx = new RuntimeProcessingContext({
-        ...opts,
-        secretResolver: getSecret,
-        storage,
-        tempUrlResolver: (fileUri) => {
-            // Convert file:///path/to/storage/temp/uuid.png → public asset URL.
-            // When ASSET_DOMAIN / TEMP_DOMAIN are configured the result uses those
-            // domains; otherwise it falls back to /api/storage/temp/uuid.png.
-            const prefix = pathToFileURL(storagePath).toString();
-            if (fileUri.startsWith(prefix)) {
-                return buildAssetUrl(fileUri.slice(prefix.length + 1));
-            }
-            return fileUri;
-        }
-    });
-    const MIME_TO_EXT = {
-        "image/jpeg": "jpg", "image/png": "png", "image/gif": "gif",
-        "image/webp": "webp", "image/bmp": "bmp", "image/svg+xml": "svg",
-        "audio/mpeg": "mp3", "audio/mp3": "mp3", "audio/wav": "wav",
-        "audio/ogg": "ogg", "video/mp4": "mp4", "video/webm": "webm",
-        "application/pdf": "pdf", "text/plain": "txt", "text/html": "html",
-        "model/gltf-binary": "glb"
-    };
-    ctx.setModelInterfaces({
-        createAsset: async (args) => {
-            const { join } = await import("node:path");
-            const { writeFile, mkdir } = await import("node:fs/promises");
-            const asset = new Asset({
-                user_id: args.userId,
-                workflow_id: args.workflowId ?? null,
-                node_id: args.nodeId ?? null,
-                job_id: args.jobId ?? null,
-                name: args.name,
-                content_type: args.contentType,
-                parent_id: args.parentId ?? null
-            });
-            if (args.content) {
-                const ext = MIME_TO_EXT[args.contentType] ?? "bin";
-                const fileName = `${asset.id}.${ext}`;
-                await mkdir(storagePath, { recursive: true });
-                await writeFile(join(storagePath, fileName), args.content);
-                asset.size = args.content.length;
-            }
-            await asset.save();
-            return asset;
-        }
-    });
-    return ctx;
-}
-/**
- * Default system prompt for regular chat — matches Python's REGULAR_SYSTEM_PROMPT.
- */
-const REGULAR_SYSTEM_PROMPT = `You are a helpful assistant.
-
-# IMAGE TOOLS
-When using image tools, you will get an image url as result.
-ALWAYS EMBED THE IMAGE AS MARKDOWN IMAGE TAG.
-
-# File types
-References to documents, images, videos or audio files are objects with following structure:
-- type: either document, image, video, audio
-- uri: either local "file:///path/to/file" or "http://"
-`;
-class ToolBridge {
-    waiters = new Map();
-    createWaiter(toolCallId, timeoutMs = 300_000) {
-        return new Promise((resolve, reject) => {
-            let timer = null;
-            const cleanup = () => {
-                if (timer)
-                    clearTimeout(timer);
-                this.waiters.delete(toolCallId);
-            };
-            const wrappedResolve = (value) => {
-                cleanup();
-                resolve(value);
-            };
-            const wrappedReject = (reason) => {
-                cleanup();
-                reject(reason);
-            };
-            this.waiters.set(toolCallId, {
-                resolve: wrappedResolve,
-                reject: wrappedReject
-            });
-            if (timeoutMs > 0) {
-                timer = setTimeout(() => {
-                    if (this.waiters.has(toolCallId)) {
-                        wrappedReject(new Error(`Tool call ${toolCallId} timed out after ${timeoutMs}ms`));
-                    }
-                }, timeoutMs);
-            }
-        });
-    }
-    resolveResult(toolCallId, payload) {
-        const waiter = this.waiters.get(toolCallId);
-        if (!waiter)
-            return;
-        waiter.resolve(payload);
-    }
-    cancelAll() {
-        const error = new Error("All pending tool calls cancelled");
-        for (const waiter of this.waiters.values()) {
-            waiter.reject(error);
-        }
-        this.waiters.clear();
-    }
-}
-/**
- * Proxy tool that forwards execution to the frontend via ToolBridge.
- * Mirrors Python's UIToolProxy from messaging/ui_tool_proxy.py.
- */
-class UIToolProxy extends Tool {
-    name;
-    description;
-    inputSchema;
-    bridge;
-    sendMsg;
-    constructor(manifest, bridge, sendMsg) {
-        super();
-        this.name = typeof manifest.name === "string" ? manifest.name : "";
-        this.description =
-            typeof manifest.description === "string"
-                ? manifest.description
-                : "UI tool";
-        this.inputSchema =
-            typeof manifest.parameters === "object" && manifest.parameters !== null
-                ? manifest.parameters
-                : {};
-        this.bridge = bridge;
-        this.sendMsg = sendMsg;
-    }
-    async process(_context, params) {
-        const toolCallId = randomUUID();
-        await this.sendMsg({
-            type: "tool_call",
-            tool_call_id: toolCallId,
-            name: this.name,
-            args: params
-        });
-        try {
-            const payload = await this.bridge.createWaiter(toolCallId, 60_000);
-            if (payload.ok) {
-                return payload.result ?? {};
-            }
-            return {
-                error: `Frontend tool execution failed: ${payload.error ?? "Unknown error"}`
-            };
-        }
-        catch (err) {
-            return { error: err instanceof Error ? err.message : String(err) };
-        }
-    }
-    userMessage(_params) {
-        return `Executing frontend tool: ${this.name}`;
-    }
-}
-export class UnifiedWebSocketRunner {
-    websocket = null;
-    mode = "binary";
-    userId;
-    authToken;
-    defaultModel;
-    defaultProvider;
-    resolveExecutor;
-    resolveNodeType;
-    resolveProvider;
-    resolveTools;
-    getSystemStats;
-    workspaceResolver;
-    beforeRunJob;
-    getNodeMetadata;
-    validateNode;
-    nodeRegistry;
-    configuredProvidersCache = new Map();
-    sendLock = Promise.resolve();
-    activeJobs = new Map();
-    currentTask = null;
-    heartbeatTimer = null;
-    statsTimer = null;
-    chatRequestSeq = 0;
-    clientToolsManifest = {};
-    toolBridge = new ToolBridge();
-    observerRegistered = false;
-    logError(context, error) {
-        log.error(context, formatSanitizedError(error));
-    }
-    /**
-     * Extract text from message content that may be a string or array of content items.
-     * Mirrors Python's _extract_query_text / _extract_objective / _extract_text_content.
-     */
-    extractTextContent(content, fallback = "") {
-        if (typeof content === "string")
-            return content;
-        if (Array.isArray(content)) {
-            const texts = content
-                .filter((c) => c.type === "text" && typeof c.text === "string")
-                .map((c) => c.text);
-            return texts.length > 0 ? texts.join(" ") : fallback;
-        }
-        return fallback;
-    }
-    /**
-     * Run one final LLM call to present structured agent results as readable
-     * markdown. Falls back to formatted JSON if the call fails.
-     */
-    async presentStructuredResults(provider, model, objective, resultsJson, threadId) {
-        const messages = [
-            {
-                role: "user",
-                content: `You completed the following task:\n"${objective}"\n\nHere are the structured results:\n\`\`\`json\n${resultsJson}\n\`\`\`\n\nPresent these results to the user in clear, well-formatted markdown. Be concise — do not repeat the raw JSON. Focus on readability.`
-            }
-        ];
-        try {
-            let content = "";
-            for await (const item of provider.generateMessagesTraced({
-                messages,
-                model
-            })) {
-                if ("type" in item && item.type === "chunk") {
-                    const chunk = item;
-                    content += chunk.content ?? "";
-                    // Stream chunks to client so the user sees the response forming
-                    await this.sendMessage({
-                        type: "chunk",
-                        content: chunk.content ?? "",
-                        done: false,
-                        thread_id: threadId
-                    });
-                }
-            }
-            return content || resultsJson;
-        }
-        catch (err) {
-            log.warn("Failed to present structured results via LLM, using JSON fallback", {
-                error: err instanceof Error ? err.message : String(err)
-            });
-            return resultsJson;
-        }
-    }
-    inferOutputType(value) {
-        if (value === null || value === undefined)
-            return "any";
-        if (typeof value === "string")
-            return "str";
-        if (typeof value === "number")
-            return Number.isInteger(value) ? "int" : "float";
-        if (typeof value === "boolean")
-            return "bool";
-        if (Array.isArray(value))
-            return "list";
-        if (value && typeof value === "object")
-            return "dict";
-        return "any";
-    }
-    resolveOutputNodeForKey(active, outputKey) {
-        let fallback = null;
-        for (const raw of active.graph.nodes) {
-            const node = raw;
-            const id = typeof node.id === "string" ? node.id : null;
-            if (!id)
-                continue;
-            const name = typeof node.name === "string" ? node.name : id;
-            const type = typeof node.type === "string" ? node.type : "";
-            if (name === outputKey || id === outputKey)
-                return { id, name };
-            if (type === "nodetool.output.Output" && !fallback)
-                fallback = { id, name };
-        }
-        return fallback;
-    }
-    async sendOutputUpdates(active, outputs) {
-        for (const [outputKey, values] of Object.entries(outputs)) {
-            const nodeRef = this.resolveOutputNodeForKey(active, outputKey) ?? {
-                id: outputKey,
-                name: outputKey
-            };
-            const seq = Array.isArray(values) ? values : [];
-            for (const rawValue of seq) {
-                const value = await active.context.normalizeOutputValue(rawValue);
-                await this.sendMessage({
-                    type: "output_update",
-                    node_id: nodeRef.id,
-                    node_name: nodeRef.name,
-                    output_name: "output",
-                    value,
-                    output_type: this.inferOutputType(value),
-                    metadata: {},
-                    workflow_id: active.workflowId,
-                    job_id: active.jobId
-                });
-            }
-        }
-    }
-    constructor(options) {
-        this.userId = options.userId ?? null;
-        this.authToken = options.authToken ?? null;
-        this.defaultModel = options.defaultModel ?? "gpt-oss:20b";
-        this.defaultProvider = options.defaultProvider ?? "ollama";
-        this.resolveExecutor = options.resolveExecutor;
-        this.resolveNodeType = options.resolveNodeType;
-        this.resolveProvider = options.resolveProvider;
-        this.resolveTools = options.resolveTools;
-        this.workspaceResolver = options.workspaceResolver;
-        this.beforeRunJob = options.beforeRunJob;
-        this.getNodeMetadata = options.getNodeMetadata;
-        this.validateNode = options.validateNode;
-        this.nodeRegistry = options.nodeRegistry;
-        this.getSystemStats =
-            options.getSystemStats ??
-                (() => ({
-                    timestamp: Date.now(),
-                    process_uptime_sec: process.uptime(),
-                    memory: process.memoryUsage()
-                }));
-    }
-    async connect(websocket, userId, authToken) {
-        if (userId)
-            this.userId = userId;
-        if (authToken)
-            this.authToken = authToken;
-        this.userId = this.userId ?? "1";
-        await websocket.accept();
-        this.websocket = websocket;
-        log.info("Client connected", { userId: this.userId });
-        this.startHeartbeat();
-        // Only broadcast system stats in development — unnecessary overhead in production
-        if (process.env.NODE_ENV !== "production") {
-            this.startStatsBroadcast();
-        }
-        this.registerObserver();
-    }
-    async disconnect() {
-        log.info("Client disconnected");
-        this.stopHeartbeat();
-        this.stopStatsBroadcast();
-        this.unregisterObserver();
-        this.toolBridge.cancelAll();
-        this.currentTask = null;
-        for (const [jobId, job] of this.activeJobs) {
-            if (job.comfyHandle) {
-                job.comfyHandle.cancel();
-            }
-            else if (job.runner) {
-                job.runner.cancel();
-            }
-            this.activeJobs.delete(jobId);
-        }
-        if (this.websocket) {
-            try {
-                await this.websocket.close();
-            }
-            catch (error) {
-                this.logError("disconnect websocket.close failed", error);
-            }
-        }
-        this.websocket = null;
-    }
-    serializeForJson(value) {
-        if (value instanceof Uint8Array)
-            return Array.from(value);
-        if (value instanceof Date)
-            return value.toISOString();
-        if (Array.isArray(value))
-            return value.map((v) => this.serializeForJson(v));
-        if (value && typeof value === "object") {
-            const out = {};
-            for (const [k, v] of Object.entries(value)) {
-                out[k] = this.serializeForJson(v);
-            }
-            return out;
-        }
-        return value;
-    }
-    async sendMessage(message) {
-        if (!this.websocket)
-            return;
-        if (this.websocket.clientState === "disconnected" ||
-            this.websocket.applicationState === "disconnected") {
-            return;
-        }
-        // Resolve storage keys in content to browser-accessible URLs before
-        // sending over the wire.  This keeps DB storage URL-agnostic while
-        // delivering ready-to-use URLs to the client.
-        if (Array.isArray(message.content)) {
-            message = {
-                ...message,
-                content: resolveContentUrls(message.content)
-            };
-        }
-        const payload = this.mode === "text"
-            ? this.serializeForJson(message)
-            : message;
-        const prev = this.sendLock;
-        let release;
-        this.sendLock = new Promise((resolve) => {
-            release = resolve;
-        });
-        await prev;
-        try {
-            if (this.mode === "binary") {
-                await this.websocket.sendBytes(pack(payload));
-            }
-            else {
-                await this.websocket.sendText(JSON.stringify(payload));
-            }
-        }
-        finally {
-            release();
-        }
-    }
-    async receiveMessage() {
-        if (!this.websocket) {
-            throw new Error("WebSocket is not connected");
-        }
-        const message = await this.websocket.receive();
-        if (message.type === "websocket.disconnect")
-            return null;
-        if (message.bytes) {
-            return unpack(message.bytes);
-        }
-        if (message.text) {
-            return JSON.parse(message.text);
-        }
-        return null;
-    }
-    /**
-     * Normalize a raw graph so that the kernel's NodeDescriptor contract is met.
-     * The web-UI / Python serialisation stores node properties under `data`;
-     * the kernel expects them under `properties`.
-     */
-    normalizeGraph(graph) {
-        const nodes = graph.nodes.map((n) => {
-            if (n.properties === undefined && n.data !== undefined) {
-                const { data, ...rest } = n;
-                return { ...rest, properties: data };
-            }
-            return n;
-        });
-        const edges = graph.edges.map((edge) => {
-            const rawEdgeType = edge.edge_type ?? edge.type;
-            const edge_type = rawEdgeType === "control" ? "control" : "data";
-            const { type, ...rest } = edge;
-            return { ...rest, edge_type };
-        });
-        return { nodes, edges };
-    }
-    async hydrateGraph(graph) {
-        const normalized = this.normalizeGraph(graph);
-        if (!this.resolveNodeType) {
-            return normalized;
-        }
-        const hydrated = await Graph.loadFromDict(normalized, {
-            resolver: this.resolveNodeType
-        });
-        return {
-            nodes: [...hydrated.nodes],
-            edges: [...hydrated.edges]
-        };
-    }
-    getRawGraph(req) {
-        if (req.graph) {
-            return this.normalizeGraph(req.graph);
-        }
-        if (req.workflow_id && this.userId) {
-            const userId = this.userId;
-            const workflowId = req.workflow_id;
-            return (async () => {
-                const workflow = await Workflow.find(userId, workflowId);
-                if (!workflow)
-                    throw new Error(`Workflow not found: ${workflowId}`);
-                return this.normalizeGraph(workflow.graph);
-            })();
-        }
-        throw new Error("workflow_id or graph is required");
-    }
-    /**
-     * Surface a clean terminal job_update when pre-run setup fails (typically
-     * because the Python bridge could not start). Without this the error would
-     * bubble up to handleCommand and be sent as a generic `invalid_command`
-     * envelope, which the UI does not associate with the job — the workflow
-     * appears to spin forever instead of failing.
-     */
-    async emitBeforeRunFailure(jobId, workflowId, err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        this.logError("beforeRunJob failed", err);
-        await this.sendMessage({
-            type: "job_update",
-            status: "failed",
-            job_id: jobId,
-            workflow_id: workflowId,
-            error: errorMessage
-        });
-        try {
-            const job = (await Job.get(jobId));
-            if (job) {
-                job.markFailed(errorMessage);
-                await job.save();
-            }
-        }
-        catch (persistErr) {
-            this.logError("beforeRunJob failure persistence failed", persistErr);
-        }
-    }
-    async runJob(req) {
-        const userId = req.user_id ?? this.userId ?? "1";
-        const workflowId = req.workflow_id ?? null;
-        const jobId = req.job_id ?? randomUUID();
-        // Get the normalized (but not hydrated) graph first so we can check
-        // for comfy nodes before hydration strips unregistered node types.
-        const rawGraph = await this.getRawGraph(req);
-        // Route ComfyUI workflows to the dedicated comfy executor
-        if (isComfyGraph(rawGraph)) {
-            if (this.beforeRunJob) {
-                try {
-                    await this.beforeRunJob(rawGraph);
-                }
-                catch (err) {
-                    await this.emitBeforeRunFailure(jobId, workflowId, err);
-                    return;
-                }
-            }
-            await this.runComfyJob(jobId, workflowId, userId, rawGraph, req.settings ?? {});
-            return;
-        }
-        // Hydrate non-comfy graphs (resolves node types from the registry)
-        const graph = await this.hydrateGraph(rawGraph);
-        if (this.beforeRunJob) {
-            try {
-                await this.beforeRunJob(graph);
-            }
-            catch (err) {
-                await this.emitBeforeRunFailure(jobId, workflowId, err);
-                return;
-            }
-        }
-        const workspaceDir = workflowId && this.workspaceResolver
-            ? await this.workspaceResolver(workflowId, userId)
-            : null;
-        const context = createRuntimeContext({
-            jobId,
-            workflowId,
-            userId,
-            workspaceDir,
-            assetOutputMode: this.mode === "text" ? "data_uri" : "temp_url"
-        });
-        // Expose executor/node-type resolution on the context so that
-        // sub-workflow nodes (WorkflowNode) can create child runners.
-        context.setResolveExecutor((node) => this.resolveExecutor(node));
-        if (this.resolveNodeType) {
-            const resolverObj = typeof this.resolveNodeType === "function"
-                ? { resolveNodeType: this.resolveNodeType }
-                : this.resolveNodeType;
-            context.setResolveNodeType((nodeType) => resolverObj.resolveNodeType(nodeType));
-        }
-        const runner = new WorkflowRunner(jobId, {
-            resolveExecutor: (node) => this.resolveExecutor(node),
-            executionContext: context,
-            validateNode: this.validateNode
-        });
-        const active = {
-            jobId,
-            workflowId,
-            context,
-            runner,
-            graph,
-            finished: false,
-            status: "running"
-        };
-        this.activeJobs.set(jobId, active);
-        log.info("Job started", { jobId, workflowId });
-        try {
-            const existing = await Job.get(jobId);
-            if (!existing) {
-                await Job.create({
-                    id: jobId,
-                    workflow_id: workflowId ?? "",
-                    user_id: userId,
-                    status: "running",
-                    params: req.params ?? {},
-                    graph
-                });
-            }
-        }
-        catch (error) {
-            this.logError("runJob persistence failed", error);
-            // Persistence is best-effort in TS runtime mode.
-        }
-        const executePromise = runner.run({
-            job_id: jobId,
-            workflow_id: workflowId ?? undefined,
-            params: req.params ?? {}
-        }, graph);
-        active.streamTask = this.streamJobMessages(active, executePromise);
-    }
-    /**
-     * Execute a ComfyUI workflow via the comfy executor (local or RunPod).
-     */
-    async runComfyJob(jobId, workflowId, _userId, graph, _settings) {
-        const active = {
-            jobId,
-            workflowId,
-            context: null,
-            runner: null,
-            graph,
-            finished: false,
-            status: "running"
-        };
-        this.activeJobs.set(jobId, active);
-        // Build node metadata lookup for status messages
-        const nodeLookup = new Map();
-        for (const node of graph.nodes) {
-            const id = String(node.id);
-            const type = node.type ?? "comfy.unknown";
-            const props = (node.properties ?? node.data ?? {});
-            const name = props.title ?? type;
-            nodeLookup.set(id, { name, type });
-        }
-        const getNode = (id) => nodeLookup.get(id) ?? { name: `Node ${id}`, type: "comfy.unknown" };
-        try {
-            await this.sendMessage({
-                type: "job_update",
-                status: "running",
-                job_id: jobId,
-                workflow_id: workflowId
-            });
-            const prompt = graphToComfyPrompt(graph);
-            const host = await getSetting("COMFYUI_ADDR");
-            if (!host) {
-                throw new Error("COMFYUI_ADDR is not configured. Set it in Settings.");
-            }
-            // Track active node so we can mark it completed when the next one starts
-            let activeNodeId = null;
-            const completeNode = (nodeId) => {
-                const n = getNode(nodeId);
-                void this.sendMessage({
-                    type: "node_update",
-                    node_id: nodeId,
-                    node_name: n.name,
-                    node_type: n.type,
-                    status: "completed",
-                    workflow_id: workflowId
-                });
-            };
-            const onProgress = (event) => {
-                switch (event.type) {
-                    case "executing": {
-                        // When a new node starts, the previous one is implicitly done
-                        if (activeNodeId && activeNodeId !== event.node) {
-                            completeNode(activeNodeId);
-                            activeNodeId = null;
-                        }
-                        if (event.node) {
-                            activeNodeId = event.node;
-                            const n = getNode(event.node);
-                            void this.sendMessage({
-                                type: "node_update",
-                                node_id: event.node,
-                                node_name: n.name,
-                                node_type: n.type,
-                                status: "running",
-                                workflow_id: workflowId
-                            });
-                        }
-                        else {
-                            // null node = execution finished, complete any lingering active node
-                            if (activeNodeId) {
-                                completeNode(activeNodeId);
-                                activeNodeId = null;
-                            }
-                        }
-                        break;
-                    }
-                    case "progress":
-                        if (event.node) {
-                            void this.sendMessage({
-                                type: "node_progress",
-                                node_id: event.node,
-                                progress: event.progress ?? 0,
-                                total: event.total ?? 1,
-                                workflow_id: workflowId
-                            });
-                        }
-                        break;
-                    case "executed":
-                        if (event.node) {
-                            // Explicit completion with output — mark done and clear active
-                            if (activeNodeId === event.node)
-                                activeNodeId = null;
-                            const n = getNode(event.node);
-                            void this.sendMessage({
-                                type: "node_update",
-                                node_id: event.node,
-                                node_name: n.name,
-                                node_type: n.type,
-                                status: "completed",
-                                result: event.output ?? null,
-                                workflow_id: workflowId
-                            });
-                        }
-                        break;
-                    case "execution_cached":
-                        if (event.cached_nodes) {
-                            for (const nodeId of event.cached_nodes) {
-                                completeNode(nodeId);
-                            }
-                        }
-                        break;
-                    case "execution_error":
-                        if (event.node) {
-                            activeNodeId = null;
-                            const n = getNode(event.node);
-                            void this.sendMessage({
-                                type: "node_update",
-                                node_id: event.node,
-                                node_name: n.name,
-                                node_type: n.type,
-                                status: "error",
-                                error: event.error ?? "Execution error",
-                                workflow_id: workflowId
-                            });
-                        }
-                        break;
-                }
-            };
-            const handle = executeComfy(prompt, host, onProgress);
-            active.comfyHandle = handle;
-            const result = await handle.result;
-            if (result.status === "completed") {
-                if (result.images && result.images.length > 0) {
-                    await this.sendMessage({
-                        type: "output_update",
-                        job_id: jobId,
-                        workflow_id: workflowId,
-                        result: { images: result.images }
-                    });
-                }
-                active.status = "completed";
-                active.finished = true;
-                await this.sendMessage({
-                    type: "job_update",
-                    status: "completed",
-                    job_id: jobId,
-                    workflow_id: workflowId
-                });
-            }
-            else {
-                throw new Error(result.error ?? "ComfyUI execution failed");
-            }
-        }
-        catch (err) {
-            active.status = "failed";
-            active.finished = true;
-            active.error = err instanceof Error ? err.message : String(err);
-            log.error("ComfyUI job failed", { jobId, error: active.error });
-            await this.sendMessage({
-                type: "job_update",
-                status: "failed",
-                job_id: jobId,
-                workflow_id: workflowId,
-                error: active.error
-            });
-        }
-        finally {
-            this.activeJobs.delete(jobId);
-        }
-    }
-    async streamJobMessages(active, executePromise) {
-        let terminalSeen = false;
-        let terminalWithResultSeen = false;
-        let outputUpdateSeen = false;
-        let finalOutputs = {};
-        await this.sendMessage({
-            type: "job_update",
-            status: "running",
-            job_id: active.jobId,
-            workflow_id: active.workflowId
-        });
-        void executePromise
-            .then((result) => {
-            active.status = result.status;
-            active.error = result.error;
-            finalOutputs = result.outputs ?? {};
-        })
-            .catch((err) => {
-            this.logError("job execution failed", err);
-            active.status = "failed";
-            active.error = formatSanitizedError(err);
-        })
-            .finally(() => {
-            active.finished = true;
-        });
-        while (!active.finished || active.context.hasMessages()) {
-            while (active.context.hasMessages()) {
-                const msg = active.context.popMessage();
-                if (!msg)
-                    break;
-                const outbound = {
-                    ...msg,
-                    job_id: msg.job_id ?? active.jobId,
-                    workflow_id: msg.workflow_id ??
-                        active.workflowId
-                };
-                if (outbound.error !== undefined) {
-                    outbound.error = formatSanitizedError(outbound.error);
-                }
-                if (outbound.type === "notification" &&
-                    typeof outbound.content === "string") {
-                    outbound.content = sanitizeLargeText(outbound.content);
-                }
-                if (outbound.type === "node_update" && outbound.status === "error") {
-                    log.error("Node error", {
-                        jobId: active.jobId,
-                        nodeId: outbound.node_id,
-                        error: outbound.error
-                    });
-                }
-                else if (outbound.type === "job_update" &&
-                    outbound.status === "failed") {
-                    log.error("Job failed", {
-                        jobId: active.jobId,
-                        error: outbound.error
-                    });
-                }
-                // Skip messages for constant/input nodes — they produce trivial
-                // outputs that don't need to be relayed to the frontend.
-                if (outbound.type === "output_update" ||
-                    outbound.type === "node_update") {
-                    const nodeId = String(outbound.node_id ?? "");
-                    const graphNodes = active.graph.nodes ?? [];
-                    const node = graphNodes.find((n) => n.id === nodeId);
-                    const nodeType = typeof node?.type === "string" ? node.type : "";
-                    // Skip constant and input nodes entirely
-                    if (nodeType.startsWith("nodetool.constant.") ||
-                        nodeType.startsWith("nodetool.input.")) {
-                        continue;
-                    }
-                    // Only relay output_update for Output-type nodes
-                    if (outbound.type === "output_update") {
-                        if (!nodeType.includes("Output"))
-                            continue;
-                        outputUpdateSeen = true;
-                    }
-                    // Auto-save generated assets before normalization strips inline data
-                    if (outbound.type === "node_update" &&
-                        outbound.status === "completed" &&
-                        outbound.result != null &&
-                        this.getNodeMetadata) {
-                        const meta = this.getNodeMetadata(nodeType);
-                        if (meta?.auto_save_asset) {
-                            try {
-                                await autoSaveAssets(outbound.result, {
-                                    userId: this.userId ?? "1",
-                                    workflowId: active.workflowId,
-                                    jobId: active.jobId,
-                                    nodeId: String(outbound.node_id ?? ""),
-                                    storagePath: getAssetStoragePath()
-                                });
-                            }
-                            catch (err) {
-                                log.warn("autoSaveAssets error", { error: String(err) });
-                            }
-                        }
-                    }
-                    // Materialize binary assets to temp URLs before sending over WebSocket
-                    if (outbound.type === "node_update" && outbound.result != null) {
-                        outbound.result = await active.context.normalizeOutputValue(outbound.result);
-                    }
-                    if (outbound.type === "output_update" && outbound.value != null) {
-                        outbound.value = await active.context.normalizeOutputValue(outbound.value);
-                    }
-                }
-                await this.sendMessage(outbound);
-                if (outbound.type === "job_update") {
-                    const status = String(outbound.status ?? "");
-                    if (["completed", "failed", "cancelled", "error", "suspended"].includes(status)) {
-                        terminalSeen = true;
-                        if (outbound.result !== undefined) {
-                            terminalWithResultSeen = true;
-                        }
-                    }
-                }
-            }
-            if (!active.finished) {
-                await new Promise((resolve) => setTimeout(resolve, 10));
-            }
-        }
-        if (!outputUpdateSeen && Object.keys(finalOutputs).length > 0) {
-            await this.sendOutputUpdates(active, finalOutputs);
-        }
-        log.info("Job completed", { jobId: active.jobId, status: active.status });
-        if (!terminalSeen ||
-            (!terminalWithResultSeen && Object.keys(finalOutputs).length > 0)) {
-            await this.sendMessage({
-                type: "job_update",
-                status: active.status,
-                job_id: active.jobId,
-                workflow_id: active.workflowId,
-                error: active.error,
-                result: { outputs: finalOutputs }
-            });
-        }
-        // Persist final job status
-        try {
-            const job = (await Job.get(active.jobId));
-            if (job) {
-                if (active.status === "completed") {
-                    job.markCompleted();
-                }
-                else if (active.status === "failed") {
-                    job.markFailed(active.error ?? "Unknown error");
-                }
-                else if (active.status === "cancelled") {
-                    job.markCancelled();
-                }
-                await job.save();
-            }
-        }
-        catch (error) {
-            this.logError("job persistence (final status) failed", error);
-        }
-        this.activeJobs.delete(active.jobId);
-    }
-    async reconnectJob(jobId, workflowId) {
-        const active = this.activeJobs.get(jobId);
-        if (!active) {
-            throw new Error(`Job ${jobId} not found`);
-        }
-        await this.sendMessage({
-            type: "job_update",
-            status: active.status,
-            job_id: jobId,
-            workflow_id: workflowId ?? active.workflowId
-        });
-        for (const status of Object.values(active.context.getNodeStatuses())) {
-            await this.sendMessage({
-                ...status,
-                job_id: jobId,
-                workflow_id: workflowId ?? active.workflowId
-            });
-        }
-        for (const status of Object.values(active.context.getEdgeStatuses())) {
-            await this.sendMessage({
-                ...status,
-                job_id: jobId,
-                workflow_id: workflowId ?? active.workflowId
-            });
-        }
-    }
-    async resumeJob(jobId, workflowId) {
-        await this.reconnectJob(jobId, workflowId);
-    }
-    async cancelJob(jobId, workflowId) {
-        if (!jobId) {
-            return { error: "No job_id provided" };
-        }
-        const active = this.activeJobs.get(jobId);
-        if (!active) {
-            return {
-                error: "Job not found or already completed",
-                job_id: jobId,
-                workflow_id: workflowId ?? ""
-            };
-        }
-        if (active.comfyHandle) {
-            active.comfyHandle.cancel();
-        }
-        else if (active.runner) {
-            active.runner.cancel();
-        }
-        active.status = "cancelled";
-        // Do NOT set active.finished = true here. Let the runner's cancellation
-        // propagate through executePromise's .finally() callback so that
-        // streamJobMessages can drain remaining messages and persist job state.
-        return {
-            message: "Job cancellation requested",
-            job_id: jobId,
-            workflow_id: workflowId ?? active.workflowId ?? ""
-        };
-    }
-    getStatus(jobId) {
-        if (jobId) {
-            const active = this.activeJobs.get(jobId);
-            if (!active) {
-                return { status: "not_found", job_id: jobId };
-            }
-            return {
-                status: active.status,
-                job_id: active.jobId,
-                workflow_id: active.workflowId
-            };
-        }
-        return {
-            active_jobs: Array.from(this.activeJobs.values()).map((job) => ({
-                job_id: job.jobId,
-                workflow_id: job.workflowId,
-                status: job.status
-            }))
-        };
-    }
-    async clearModels() {
-        return {
-            message: "Model clearing is managed by provider implementations in TS runtime"
-        };
-    }
-    async ensureThreadExists(threadId) {
-        const userId = this.userId ?? "1";
-        if (!threadId) {
-            const thread = await Thread.create({ user_id: userId, title: "" });
-            return thread.id;
-        }
-        const existing = await Thread.find(userId, threadId);
-        if (existing)
-            return existing.id;
-        const thread = await Thread.create({
-            id: threadId,
-            user_id: userId,
-            title: ""
-        });
-        return thread.id;
-    }
-    dbMessageToProviderMessage(m) {
-        const role = m.role;
-        // Filter out non-standard roles (e.g. "agent_execution") that providers can't handle
-        if (!role || !["user", "assistant", "system", "tool"].includes(role)) {
-            return null;
-        }
-        const rawContent = Array.isArray(m.content)
-            ? resolveContentForProvider(m.content)
-            : m.content;
-        return {
-            role,
-            content: rawContent ?? "",
-            toolCallId: typeof m.tool_call_id === "string" ? m.tool_call_id : null,
-            toolCalls: Array.isArray(m.tool_calls)
-                ? m.tool_calls
-                : null,
-            threadId: m.thread_id
-        };
-    }
-    /**
-     * Save a message dict to the database.
-     * Mirrors Python's _save_message_to_db_async: pops id, type, user_id before create.
-     */
-    async saveMessageToDb(messageData) {
-        const data = { ...messageData };
-        delete data.id;
-        delete data.type;
-        const threadId = typeof data.thread_id === "string" ? data.thread_id : "";
-        delete data.thread_id;
-        const userId = this.userId ?? "1";
-        delete data.user_id;
-        await Message.create({
-            thread_id: threadId,
-            user_id: userId,
-            ...data
-        });
-    }
-    /**
-     * Recursively process tool results, handling asset-like objects.
-     * Mirrors Python's RegularChatProcessor._process_tool_result().
-     *
-     * - Asset-like objects (have type + uri/data): materialized via storage
-     * - Date/datetime: converted to ISO string
-     * - Arrays/objects: recursed into
-     * - Primitives: returned as-is
-     */
-    async processToolResult(obj, ctx) {
-        if (obj === null || obj === undefined)
-            return obj;
-        // Asset-like objects: { type: "image"|"audio"|"video"|..., uri?: string, data?: ... }
-        if (typeof obj === "object" && !Array.isArray(obj)) {
-            const record = obj;
-            // Check if it's an asset-like object (has type + uri or data)
-            if ("type" in record &&
-                ("uri" in record || "data" in record || "asset_id" in record)) {
-                // Use ProcessingContext's normalizeOutputValue to handle asset materialization
-                return ctx.normalizeOutputValue(record, "storage_url");
-            }
-            // Date objects
-            if (obj instanceof Date) {
-                return obj.toISOString();
-            }
-            // Regular objects — recurse into values
-            const result = {};
-            for (const [key, value] of Object.entries(record)) {
-                result[key] = await this.processToolResult(value, ctx);
-            }
-            return result;
-        }
-        // Arrays — recurse into items
-        if (Array.isArray(obj)) {
-            return Promise.all(obj.map((item) => this.processToolResult(item, ctx)));
-        }
-        // Uint8Array/Buffer — store as asset
-        if (obj instanceof Uint8Array) {
-            if (!ctx.storage)
-                return obj;
-            const key = `assets/${randomUUID()}.bin`;
-            const uri = await ctx.storage.store(key, obj);
-            return { type: "asset", uri };
-        }
-        // Primitives
-        return obj;
-    }
-    /**
-     * Query vector store collections and return concatenated context string.
-     * Mirrors Python's RegularChatProcessor._query_collections().
-     */
-    async queryCollections(collections, queryText, nResults = 5) {
-        if (!collections.length || !queryText)
-            return "";
-        try {
-            const { getVecStore } = await import("@nodetool-ai/vectorstore");
-            const store = await getVecStore();
-            const allResults = [];
-            for (const collectionName of collections) {
-                try {
-                    const collection = await store.getCollection({
-                        name: collectionName
-                    });
-                    const results = await collection.query({
-                        queryTexts: [queryText],
-                        nResults,
-                        include: ["documents", "metadatas"]
-                    });
-                    if (results.documents?.[0]?.length) {
-                        let collectionResults = `\n\n### Results from ${collectionName}:\n`;
-                        for (const doc of results.documents[0]) {
-                            if (!doc)
-                                continue;
-                            const preview = doc.length > 200 ? `${doc.slice(0, 200)}...` : doc;
-                            collectionResults += `\n- ${preview}`;
-                        }
-                        allResults.push(collectionResults);
-                    }
-                }
-                catch (err) {
-                    log.warn("Collection query failed", {
-                        collection: collectionName,
-                        error: err instanceof Error ? err.message : String(err)
-                    });
-                }
-            }
-            return allResults.join("\n");
-        }
-        catch (err) {
-            log.warn("Vector store init failed", {
-                error: err instanceof Error ? err.message : String(err)
-            });
-            return "";
-        }
-    }
-    /**
-     * Add collection context as a system message before the last user message.
-     * Mirrors Python's RegularChatProcessor._add_collection_context().
-     */
-    addCollectionContext(messages, collectionContext) {
-        // Find the last user message index
-        let lastUserIndex = -1;
-        for (let i = messages.length - 1; i >= 0; i--) {
-            if (messages[i].role === "user") {
-                lastUserIndex = i;
-                break;
-            }
-        }
-        if (lastUserIndex >= 0) {
-            const contextMessage = {
-                role: "system",
-                content: `Context from knowledge base:\n${collectionContext}`,
-                toolCallId: null,
-                toolCalls: null,
-                threadId: null
-            };
-            return [
-                ...messages.slice(0, lastUserIndex),
-                contextMessage,
-                ...messages.slice(lastUserIndex)
-            ];
-        }
-        return messages;
-    }
-    /**
-     * Handle an incoming chat message.
-     *
-     * Mirrors Python's full 3-layer flow:
-     *   handle_chat_message → handle_message_impl → process_messages
-     *     → _run_processor + RegularChatProcessor.process()
-     *
-     * The processor sends messages to a queue. _run_processor reads them:
-     *   - type === "message" → persist to DB AND forward to client
-     *   - anything else → forward to client only
-     *
-     * RegularChatProcessor.process():
-     *   1. Prepend system prompt if first message isn't system role
-     *   2. while True: messages_to_send = chat_history + unprocessed_messages
-     *   3. Stream chunks (type: "chunk") — forwarded to client (not persisted)
-     *   4. On tool call: build assistant Message + tool result Message (type: "message")
-     *      → persisted to DB AND forwarded to client
-     *   5. If unprocessed_messages empty, break
-     *   6. Send done chunk + final assistant Message
-     */
-    async handleChatMessage(data, requestSeq) {
-        const threadId = await this.ensureThreadExists(typeof data.thread_id === "string" ? data.thread_id : undefined);
-        data.thread_id = threadId;
-        // Apply defaults — matches Python's handle_chat_message
-        if (!data.model)
-            data.model = this.defaultModel;
-        if (!data.provider)
-            data.provider = this.defaultProvider;
-        const providerId = data.provider;
-        const model = data.model;
-        const workflowId = typeof data.workflow_id === "string" ? data.workflow_id : null;
-        const userId = this.userId ?? "1";
-        log.debug("Chat message", { threadId, model, provider: providerId });
-        // Save user message to DB — matches Python's _save_message_to_db_async(data)
-        await this.saveMessageToDb(data);
-        if (requestSeq !== undefined && requestSeq !== this.chatRequestSeq)
-            return;
-        if (!this.resolveProvider) {
-            await this.sendMessage({
-                type: "error",
-                message: "No provider resolver configured",
-                thread_id: threadId
-            });
-            return;
-        }
-        // Route to workflow processor when workflow_target or workflow_id is set — matches Python's handle_message_impl
-        // This check comes BEFORE agent_mode, matching Python's routing priority.
-        const workflowTarget = typeof data.workflow_target === "string" ? data.workflow_target : null;
-        if (workflowTarget === "workflow" || workflowId) {
-            await this.handleWorkflowMessage(data, requestSeq);
-            return;
-        }
-        // Route to media generation when the client requests a text-to-image or
-        // text-to-video turn. The composer attaches a `media_generation` field
-        // with mode + params; when mode is a media mode we invoke the provider's
-        // textToImage / textToVideo instead of a regular LLM round and return an
-        // assistant message containing MessageImageContent / MessageVideoContent.
-        const mediaGeneration = data.media_generation && typeof data.media_generation === "object"
-            ? data.media_generation
-            : null;
-        if (mediaGeneration &&
-            typeof mediaGeneration.mode === "string" &&
-            mediaGeneration.mode !== "chat") {
-            await this.handleMediaGenerationMessage(data, mediaGeneration, requestSeq);
-            return;
-        }
-        // Route to agent mode if requested — matches Python's handle_message_impl
-        const agentMode = data.agent_mode === true || data.agent_mode === "true";
-        if (agentMode) {
-            await this.handleAgentMessage(data, requestSeq);
-            return;
-        }
-        // Load history from DB, filter out agent_execution — matches Python's get_chat_history_from_db
-        const [dbMessages] = await Message.paginate(threadId, { limit: 1000 });
-        const chatHistory = [];
-        for (const m of dbMessages) {
-            const pm = this.dbMessageToProviderMessage(m);
-            if (pm)
-                chatHistory.push(pm);
-        }
-        const provider = await this.resolveProvider(providerId, userId);
-        // Extract tool names from raw tool data — supports both string[] and object[]
-        const rawTools = Array.isArray(data.tools) ? data.tools : [];
-        const toolNames = rawTools
-            .map((t) => {
-            if (typeof t === "string")
-                return t;
-            const tool = t;
-            return typeof tool.name === "string" ? tool.name : "";
-        })
-            .filter((n) => n.length > 0);
-        log.info("Chat tools from client", {
-            rawToolCount: rawTools.length,
-            rawToolTypes: rawTools.map((t) => typeof t),
-            toolNames
-        });
-        // Resolve server-side Tool instances for execution
-        let serverTools = [];
-        if (toolNames.length > 0 && this.resolveTools) {
-            serverTools = await this.resolveTools(toolNames, userId);
-        }
-        const serverToolMap = new Map(serverTools.map((t) => [t.name, t]));
-        log.info("Resolved server tools", {
-            requested: toolNames,
-            resolved: serverTools.map((t) => t.name),
-            hasResolveTools: !!this.resolveTools
-        });
-        // Build provider-format tool schemas from resolved Tool instances + client tools
-        const providerToolSchemas = serverTools.map((t) => t.toProviderTool());
-        // Only include client tools (ui_*) when a workflow is active
-        const clientToolNames = workflowId
-            ? Object.keys(this.clientToolsManifest)
-            : [];
-        if (workflowId) {
-            for (const [name, manifest] of Object.entries(this.clientToolsManifest)) {
-                providerToolSchemas.push({
-                    name,
-                    description: typeof manifest.description === "string"
-                        ? manifest.description
-                        : undefined,
-                    inputSchema: typeof manifest.inputSchema === "object"
-                        ? manifest.inputSchema
-                        : undefined
-                });
-            }
-        }
-        log.info("Provider tool schemas", {
-            serverToolCount: serverTools.length,
-            clientToolCount: clientToolNames.length,
-            clientTools: clientToolNames,
-            totalSchemas: providerToolSchemas.length,
-            schemaNames: providerToolSchemas.map((t) => t.name)
-        });
-        // Create a processing context for tool execution
-        const chatWorkspaceDir = workflowId && this.workspaceResolver
-            ? await this.workspaceResolver(workflowId, userId)
-            : tmpdir();
-        const ctx = createRuntimeContext({
-            jobId: randomUUID(),
-            userId,
-            workspaceDir: chatWorkspaceDir
-        });
-        // Prepend system prompt if first message isn't system role — matches Python
-        if (chatHistory.length === 0 || chatHistory[0].role !== "system") {
-            chatHistory.unshift({
-                role: "system",
-                content: REGULAR_SYSTEM_PROMPT,
-                toolCallId: null,
-                toolCalls: null,
-                threadId: null
-            });
-        }
-        // Query collections for RAG context — matches Python's _query_collections()
-        const collections = Array.isArray(data.collections)
-            ? data.collections.filter((c) => typeof c === "string")
-            : [];
-        const userContent = this.extractTextContent(data.content);
-        let collectionContext = "";
-        if (collections.length > 0 && userContent) {
-            collectionContext = await this.queryCollections(collections, userContent);
-            if (collectionContext) {
-                log.debug("Retrieved collection context", {
-                    chars: collectionContext.length
-                });
-            }
-        }
-        let content = "";
-        let unprocessedMessages = [];
-        // Tool execution loop — mirrors Python's RegularChatProcessor.process()
-        const MAX_TOOL_ROUNDS = 10;
-        let toolRound = 0;
-        const shouldIncludeTools = true;
-        try {
-            while (true) {
-                if (requestSeq !== undefined && requestSeq !== this.chatRequestSeq)
-                    return;
-                let messagesToSend = [...chatHistory, ...unprocessedMessages];
-                unprocessedMessages = [];
-                // Add collection context on first iteration — matches Python
-                if (collectionContext) {
-                    messagesToSend = this.addCollectionContext(messagesToSend, collectionContext);
-                    collectionContext = ""; // Clear after first use
-                }
-                const stream = provider.generateMessagesTraced({
-                    messages: messagesToSend,
-                    model,
-                    tools: shouldIncludeTools && providerToolSchemas.length > 0
-                        ? providerToolSchemas
-                        : undefined,
-                    threadId,
-                    onToolCall: shouldIncludeTools && providerToolSchemas.length > 0
-                        ? async (name, args) => {
-                            let toolResult;
-                            const serverTool = serverToolMap.get(name);
-                            if (serverTool) {
-                                try {
-                                    toolResult = await serverTool.process(ctx, args);
-                                }
-                                catch (err) {
-                                    const errMsg = err instanceof Error ? err.message : String(err);
-                                    toolResult = { error: errMsg };
-                                }
-                            }
-                            else if (this.clientToolsManifest[name]) {
-                                // Client-side tool — send to UI via ToolBridge
-                                const callId = `call_${Date.now()}`;
-                                await this.sendMessage({
-                                    type: "tool_call",
-                                    thread_id: threadId,
-                                    tool_call_id: callId,
-                                    name,
-                                    args
-                                });
-                                const clientResult = await this.toolBridge.createWaiter(callId, 300_000);
-                                toolResult =
-                                    clientResult.result ?? clientResult.content ?? clientResult;
-                            }
-                            else {
-                                toolResult = { error: `Tool "${name}" not available` };
-                            }
-                            const processed = await this.processToolResult(toolResult, ctx);
-                            return typeof processed === "string"
-                                ? processed
-                                : JSON.stringify(processed);
-                        }
-                        : undefined
-                });
-                const pendingToolCalls = [];
-                for await (const item of stream) {
-                    if (requestSeq !== undefined && requestSeq !== this.chatRequestSeq)
-                        return;
-                    if ("type" in item && item.type === "chunk") {
-                        // --- Text chunk --- forward to client (not persisted)
-                        const chunk = item;
-                        const text = chunk.content ?? "";
-                        content += text;
-                        // Set thread_id if not already set — matches Python
-                        if (!chunk.thread_id)
-                            chunk.thread_id = threadId;
-                        await this.sendMessage({ ...chunk });
-                    }
-                    else if ("name" in item && "id" in item) {
-                        // --- Tool call from provider (collect, don't execute yet) ---
-                        const tc = item;
-                        log.info("Tool call", { tool: tc.name, args: tc.args });
-                        pendingToolCalls.push({ tc });
-                    }
-                }
-                // Build ONE assistant message with ALL tool calls (OpenAI requires this)
-                if (pendingToolCalls.length > 0) {
-                    const allToolCalls = pendingToolCalls.map(({ tc }) => ({
-                        id: tc.id,
-                        name: tc.name,
-                        args: tc.args,
-                        result: null
-                    }));
-                    const assistantMsgData = {
-                        type: "message",
-                        role: "assistant",
-                        content: content || null,
-                        tool_calls: allToolCalls,
-                        thread_id: threadId,
-                        workflow_id: workflowId,
-                        provider: providerId,
-                        model
-                    };
-                    await this.saveMessageToDb(assistantMsgData);
-                    await this.sendMessage(assistantMsgData);
-                    unprocessedMessages.push({
-                        role: "assistant",
-                        content: content || null,
-                        toolCalls: pendingToolCalls.map(({ tc }) => ({
-                            id: tc.id,
-                            name: tc.name,
-                            args: tc.args
-                        })),
-                        toolCallId: null,
-                        threadId
-                    });
-                }
-                // Phase 2: Execute all collected tool calls in parallel
-                if (pendingToolCalls.length > 0) {
-                    const executeOne = async ({ tc }) => {
-                        try {
-                            let toolResult;
-                            const serverTool = serverToolMap.get(tc.name);
-                            if (serverTool) {
-                                try {
-                                    toolResult = await serverTool.process(ctx, tc.args);
-                                }
-                                catch (err) {
-                                    const errMsg = err instanceof Error ? err.message : String(err);
-                                    log.error("Tool execution failed", {
-                                        tool: tc.name,
-                                        error: errMsg
-                                    });
-                                    toolResult = { error: errMsg };
-                                }
-                            }
-                            else if (this.clientToolsManifest[tc.name]) {
-                                // Client-side tool via ToolBridge
-                                await this.sendMessage({
-                                    type: "tool_call",
-                                    thread_id: threadId,
-                                    tool_call_id: tc.id,
-                                    name: tc.name,
-                                    args: tc.args
-                                });
-                                const clientResult = await this.toolBridge.createWaiter(tc.id, 300_000);
-                                toolResult =
-                                    clientResult.result ?? clientResult.content ?? clientResult;
-                            }
-                            else {
-                                toolResult = { error: `Tool "${tc.name}" not available` };
-                            }
-                            // Process tool result — handle asset-like objects, dates, etc.
-                            const processedResult = await this.processToolResult(toolResult, ctx);
-                            const toolResultJson = JSON.stringify(processedResult);
-                            return { tc, toolResultJson };
-                        }
-                        catch (err) {
-                            const errMsg = err instanceof Error ? err.message : String(err);
-                            log.error("Tool executeOne failed", {
-                                tool: tc.name,
-                                error: errMsg
-                            });
-                            return { tc, toolResultJson: JSON.stringify({ error: errMsg }) };
-                        }
-                    };
-                    const results = await Promise.all(pendingToolCalls.map(executeOne));
-                    for (const { tc, toolResultJson } of results) {
-                        // Build tool result Message
-                        const toolMsgData = {
-                            type: "message",
-                            role: "tool",
-                            tool_call_id: tc.id,
-                            name: tc.name,
-                            content: toolResultJson,
-                            thread_id: threadId,
-                            workflow_id: workflowId,
-                            provider: providerId,
-                            model
-                        };
-                        await this.saveMessageToDb(toolMsgData);
-                        await this.sendMessage(toolMsgData);
-                        // Add tool result to unprocessed for next provider round
-                        unprocessedMessages.push({
-                            role: "tool",
-                            content: toolResultJson,
-                            toolCallId: tc.id,
-                            toolCalls: null,
-                            threadId
-                        });
-                    }
-                }
-                // If no unprocessed messages, generation is complete — matches Python's break condition
-                if (unprocessedMessages.length === 0) {
-                    break;
-                }
-                // Reset content for next tool round so the final message only contains
-                // text from the last generation pass (prior rounds were already streamed).
-                content = "";
-                toolRound++;
-                if (toolRound >= MAX_TOOL_ROUNDS) {
-                    log.warn("Max tool rounds reached, stopping tool loop", {
-                        rounds: toolRound
-                    });
-                    break;
-                }
-                log.debug("Unprocessed messages", {
-                    count: unprocessedMessages.length,
-                    round: toolRound
-                });
-            }
-            // Log provider call for cost tracking — matches Python's _log_provider_call()
-            await this._logProviderCall(userId, provider, providerId, model, workflowId);
-            // Signal completion — matches Python's done chunk + final assistant Message
-            await this.sendMessage({
-                type: "chunk",
-                content: "",
-                done: true,
-                thread_id: threadId
-            });
-            // Final assistant message — persisted and forwarded (type: "message")
-            const finalMsgData = {
-                type: "message",
-                role: "assistant",
-                content: content || null,
-                thread_id: threadId,
-                workflow_id: workflowId,
-                provider: providerId,
-                model
-            };
-            await this.saveMessageToDb(finalMsgData);
-            await this.sendMessage(finalMsgData);
-            log.debug("Chat complete", { threadId, chars: content.length });
-        }
-        catch (err) {
-            const errMsg = err instanceof Error ? err.message : String(err);
-            log.error("Chat processing error", { threadId, error: errMsg });
-            // Detect error type — matches Python's separate ConnectError / HTTPStatusError handlers
-            let errorType = "error";
-            let statusCode;
-            let formattedMsg = errMsg;
-            // Connection errors (ECONNREFUSED, ENOTFOUND, etc.)
-            if (errMsg.includes("ECONNREFUSED") ||
-                errMsg.includes("ENOTFOUND") ||
-                errMsg.includes("fetch failed") ||
-                errMsg.includes("nodename nor servname")) {
-                errorType = "connection_error";
-                if (errMsg.includes("ENOTFOUND") ||
-                    errMsg.includes("nodename nor servname")) {
-                    formattedMsg =
-                        "Connection error: Unable to resolve hostname. Please check your network connection and API endpoint configuration.";
-                }
-                else {
-                    formattedMsg = `Connection error: ${errMsg}`;
-                }
-            }
-            // HTTP status errors — check for status code in error
-            else if (err && typeof err === "object" && "status" in err) {
-                const status = err.status;
-                errorType = "http_status_error";
-                statusCode = status;
-                // Try to extract error message from response body
-                let bodyMsg = null;
-                try {
-                    if ("body" in err || "response" in err) {
-                        const body = err.body ?? err.response;
-                        if (body && typeof body === "object" && "error" in body) {
-                            const errorDetail = body.error;
-                            if (typeof errorDetail === "object" &&
-                                errorDetail &&
-                                "message" in errorDetail) {
-                                bodyMsg = String(errorDetail.message);
-                            }
-                        }
-                    }
-                }
-                catch {
-                    // Intentional: best-effort extraction of error message from response body
-                }
-                if (bodyMsg) {
-                    formattedMsg = bodyMsg;
-                }
-                else if (status === 400) {
-                    formattedMsg = `Bad request: ${errMsg}`;
-                }
-                else if (status === 401) {
-                    formattedMsg = "Authentication failed: Invalid API key or token";
-                }
-                else if (status === 403) {
-                    formattedMsg =
-                        "Access forbidden: You don't have permission for this resource";
-                }
-                else if (status === 404) {
-                    formattedMsg = "Not found: The requested resource was not found";
-                }
-                else if (status === 429) {
-                    formattedMsg = "Rate limited: Too many requests, please slow down";
-                }
-                else if (status >= 500) {
-                    formattedMsg = `Server error (${status}): The service is temporarily unavailable`;
-                }
-                else {
-                    formattedMsg = `HTTP error (${status}): ${errMsg}`;
-                }
-            }
-            await this.sendMessage({
-                type: "error",
-                message: formattedMsg,
-                error_type: errorType,
-                ...(statusCode !== undefined ? { status_code: statusCode } : {}),
-                thread_id: threadId,
-                workflow_id: workflowId
-            });
-            // Signal completion even on error — matches Python
-            await this.sendMessage({
-                type: "chunk",
-                content: "",
-                done: true,
-                thread_id: threadId
-            });
-            const errorMsgData = {
-                type: "message",
-                role: "assistant",
-                content: errorType === "connection_error"
-                    ? `I encountered a connection error: ${formattedMsg}. Please check your network connection and try again.`
-                    : errorType === "http_status_error"
-                        ? `I encountered an API error (HTTP ${statusCode}): ${formattedMsg}`
-                        : `I encountered an error: ${formattedMsg}`,
-                thread_id: threadId,
-                workflow_id: workflowId,
-                provider: providerId,
-                model
-            };
-            await this.saveMessageToDb(errorMsgData);
-            await this.sendMessage(errorMsgData);
-        }
-    }
-    /**
-     * Log a provider call for cost tracking — mirrors Python's _log_provider_call().
-     * Best-effort: never throws, logs warnings on failure.
-     */
-    async _logProviderCall(userId, provider, providerId, model, workflowId) {
-        if (!providerId || !model) {
-            log.warn("Cannot log provider call: missing provider or model");
-            return;
-        }
-        try {
-            const cost = provider.cost;
-            await Prediction.create({
-                user_id: userId,
-                provider: providerId,
-                model,
-                cost,
-                workflow_id: workflowId,
-                status: "completed",
-                node_id: ""
-            });
-            log.debug("Logged provider call", { provider: providerId, model, cost });
-        }
-        catch (err) {
-            if (err instanceof TypeError || err instanceof ReferenceError) {
-                log.warn("Failed to log provider call due to invalid data", {
-                    error: err instanceof Error ? err.message : String(err)
-                });
-            }
-            else {
-                log.error("Unexpected error logging provider call", {
-                    error: err instanceof Error ? err.message : String(err)
-                });
-            }
-        }
-    }
-    /**
-     * Detect message input node names from a workflow graph.
-     * Mirrors Python's WorkflowMessageProcessor._detect_message_input_names().
-     *
-     * Scans graph nodes for types ending in .MessageInput / .MessageListInput
-     * and returns their data.name values.
-     */
-    detectMessageInputNames(graph) {
-        let messageName = null;
-        let messagesName = null;
-        for (const node of graph.nodes) {
-            const nodeType = typeof node.type === "string" ? node.type : "";
-            const data = typeof node.data === "object" && node.data !== null
-                ? node.data
-                : {};
-            const nodeName = typeof data.name === "string" ? data.name.trim() : "";
-            if (!nodeName)
-                continue;
-            if (messageName === null &&
-                (nodeType === "nodetool.input.MessageInput" ||
-                    nodeType.endsWith(".MessageInput"))) {
-                messageName = nodeName;
-            }
-            if (messagesName === null &&
-                (nodeType === "nodetool.input.MessageListInput" ||
-                    nodeType.endsWith(".MessageListInput"))) {
-                messagesName = nodeName;
-            }
-        }
-        return { messageName, messagesName };
-    }
-    /**
-     * Convert workflow result dict into a response message with typed content.
-     * Mirrors Python's WorkflowMessageProcessor._create_response_message().
-     *
-     * Converts outputs to MessageContent items:
-     *  - string → { type: "text", text }
-     *  - list → { type: "text", text: joined }
-     *  - dict with type "image"/"video"/"audio" → media content
-     *  - other → { type: "text", text: stringified }
-     */
-    createWorkflowResponseContent(result) {
-        const content = [];
-        for (const [, value] of Object.entries(result)) {
-            if (value === null || value === undefined)
-                continue;
-            if (typeof value === "string") {
-                content.push({ type: "text", text: value });
-            }
-            else if (Array.isArray(value)) {
-                content.push({ type: "text", text: value.map(String).join(" ") });
-            }
-            else if (typeof value === "object") {
-                const obj = value;
-                const assetType = typeof obj.type === "string" ? obj.type : "";
-                if (assetType === "image") {
-                    content.push({
-                        type: "image",
-                        image: { uri: obj.uri, asset_id: obj.asset_id, data: obj.data }
-                    });
-                }
-                else if (assetType === "video") {
-                    content.push({
-                        type: "video",
-                        video: { uri: obj.uri, asset_id: obj.asset_id, data: obj.data }
-                    });
-                }
-                else if (assetType === "audio") {
-                    content.push({
-                        type: "audio",
-                        audio: { uri: obj.uri, asset_id: obj.asset_id, data: obj.data }
-                    });
-                }
-                else {
-                    content.push({ type: "text", text: JSON.stringify(obj) });
-                }
-            }
-            else {
-                content.push({ type: "text", text: String(value) });
-            }
-        }
-        if (content.length === 0) {
-            content.push({ type: "text", text: "Workflow completed successfully." });
-        }
-        return content;
-    }
-    /**
-     * Handle a chat message that targets a workflow.
-     *
-     * Mirrors Python's process_messages_for_workflow → WorkflowMessageProcessor/
-     * ChatWorkflowMessageProcessor flow:
-     *   1. Load workflow from DB
-     *   2. Detect message input node names from graph
-     *   3. Prepare params (serialized message + history)
-     *   4. Run workflow via WorkflowRunner
-     *   5. Stream events (job_update, node_update, output_update)
-     *   6. Collect output_update results
-     *   7. Send done chunk + response message with typed content
-     */
-    /**
-     * Handle a chat_message with a `media_generation` payload by invoking the
-     * selected provider's textToImage / textToVideo API, storing the resulting
-     * asset(s), and returning them to the client as an assistant `Message`
-     * whose `content` is an array of `MessageImageContent` / `MessageVideoContent`
-     * blocks.
-     *
-     * The generated bytes are persisted via `ctx.storage.store()` so each
-     * output receives a stable URI the client can resolve as a server asset.
-     * The `media_generation` echo on the assistant message lets the UI render
-     * the generation header (model, variation count, resolution, etc.) in the
-     * conversation stream.
-     */
-    async handleMediaGenerationMessage(data, mediaGeneration, requestSeq) {
-        const threadId = typeof data.thread_id === "string" ? data.thread_id : "";
-        const workflowId = typeof data.workflow_id === "string" ? data.workflow_id : null;
-        const userId = this.userId ?? "1";
-        const mode = String(mediaGeneration.mode ?? "");
-        const providerId = String(mediaGeneration.provider ?? data.provider ?? this.defaultProvider);
-        const modelId = String(mediaGeneration.model ?? data.model ?? this.defaultModel);
-        const prompt = this.extractTextContent(data.content);
-        log.info("Media generation", {
-            threadId,
-            mode,
-            provider: providerId,
-            model: modelId,
-            promptLen: prompt.length
-        });
-        if (!this.resolveProvider) {
-            await this.sendMessage({
-                type: "error",
-                message: "No provider resolver configured",
-                thread_id: threadId
-            });
-            return;
-        }
-        if (!modelId || modelId === "undefined") {
-            await this.sendMessage({
-                type: "error",
-                message: `Please select a ${mode} model before generating`,
-                thread_id: threadId
-            });
-            return;
-        }
-        if (!prompt) {
-            await this.sendMessage({
-                type: "error",
-                message: "Please enter a prompt",
-                thread_id: threadId
-            });
-            return;
-        }
-        if (requestSeq !== undefined && requestSeq !== this.chatRequestSeq)
-            return;
-        const provider = await this.resolveProvider(providerId, userId);
-        // Wire up progress forwarding so provider.emitMessage() reaches the client.
-        provider.setMessageEmitter((msg) => void this.sendMessage(msg));
-        // Store generated media as a proper Asset record and return the
-        // asset ID.  The DB message stores only `asset_id` — URLs are
-        // resolved at serve time by resolveContentUrls / sendMessage.
-        const storagePath = getAssetStoragePath();
-        const storeMediaAsset = async (bytes, contentType, ext) => {
-            const { join } = await import("node:path");
-            const { writeFile: fsWrite, mkdir: fsMkdir } = await import("node:fs/promises");
-            const asset = new Asset({
-                user_id: userId,
-                workflow_id: workflowId ?? null,
-                name: `${mode}_${Date.now()}`,
-                content_type: contentType,
-                parent_id: null
-            });
-            const fileName = `${asset.id}.${ext}`;
-            await fsMkdir(storagePath, { recursive: true });
-            await fsWrite(join(storagePath, fileName), bytes);
-            asset.size = bytes.length;
-            await asset.save();
-            return asset.id;
-        };
-        try {
-            if (mode === "image") {
-                const variations = Math.max(1, Math.min(Number(mediaGeneration.variations ?? 1), 8));
-                const width = typeof mediaGeneration.width === "number"
-                    ? mediaGeneration.width
-                    : undefined;
-                const height = typeof mediaGeneration.height === "number"
-                    ? mediaGeneration.height
-                    : undefined;
-                const imageModel = {
-                    id: modelId,
-                    name: modelId,
-                    provider: providerId
-                };
-                const params = {
-                    model: imageModel,
-                    prompt,
-                    width,
-                    height
-                };
-                // Surface a progress chunk so the UI can show the request flight
-                await this.sendMessage({
-                    type: "chunk",
-                    thread_id: threadId,
-                    content: "",
-                    content_type: "text",
-                    content_metadata: { media_generation: mediaGeneration },
-                    done: false
-                });
-                if (requestSeq !== undefined && requestSeq !== this.chatRequestSeq)
-                    return;
-                const imageBytesList = await provider.textToImages(params, variations);
-                const imageContents = [];
-                for (const bytes of imageBytesList) {
-                    const assetId = await storeMediaAsset(bytes, "image/png", "png");
-                    imageContents.push({
-                        type: "image_url",
-                        image: { type: "image", asset_id: assetId, mimeType: "image/png" }
-                    });
-                }
-                await this.sendMessage({
-                    type: "chunk",
-                    thread_id: threadId,
-                    content: "",
-                    done: true
-                });
-                const assistantMsgData = {
-                    type: "message",
-                    role: "assistant",
-                    content: imageContents,
-                    thread_id: threadId,
-                    workflow_id: workflowId,
-                    provider: providerId,
-                    model: modelId,
-                    media_generation: mediaGeneration
-                };
-                await this.saveMessageToDb(assistantMsgData);
-                await this.sendMessage(assistantMsgData);
-                return;
-            }
-            if (mode === "video") {
-                const aspectRatio = typeof mediaGeneration.aspect_ratio === "string"
-                    ? mediaGeneration.aspect_ratio
-                    : null;
-                const resolution = typeof mediaGeneration.resolution === "string"
-                    ? mediaGeneration.resolution
-                    : null;
-                const duration = typeof mediaGeneration.duration === "number"
-                    ? mediaGeneration.duration
-                    : null;
-                const videoModel = {
-                    id: modelId,
-                    name: modelId,
-                    provider: providerId
-                };
-                const params = {
-                    model: videoModel,
-                    prompt,
-                    aspectRatio,
-                    resolution,
-                    durationSeconds: duration
-                };
-                await this.sendMessage({
-                    type: "chunk",
-                    thread_id: threadId,
-                    content: "",
-                    content_type: "text",
-                    content_metadata: { media_generation: mediaGeneration },
-                    done: false
-                });
-                const bytes = await provider.textToVideo(params);
-                const assetId = await storeMediaAsset(bytes, "video/mp4", "mp4");
-                await this.sendMessage({
-                    type: "chunk",
-                    thread_id: threadId,
-                    content: "",
-                    done: true
-                });
-                const assistantMsgData = {
-                    type: "message",
-                    role: "assistant",
-                    content: [
-                        {
-                            type: "video",
-                            video: {
-                                type: "video",
-                                asset_id: assetId,
-                                format: "mp4",
-                                duration: duration
-                            }
-                        }
-                    ],
-                    thread_id: threadId,
-                    workflow_id: workflowId,
-                    provider: providerId,
-                    model: modelId,
-                    media_generation: mediaGeneration
-                };
-                await this.saveMessageToDb(assistantMsgData);
-                await this.sendMessage(assistantMsgData);
-                return;
-            }
-            if (mode === "audio") {
-                const voice = typeof mediaGeneration.voice === "string"
-                    ? mediaGeneration.voice
-                    : undefined;
-                const speed = typeof mediaGeneration.speed === "number"
-                    ? mediaGeneration.speed
-                    : 1.0;
-                const requestedFormatRaw = typeof mediaGeneration.audio_format === "string"
-                    ? mediaGeneration.audio_format.toLowerCase()
-                    : null;
-                const supportedFormats = new Set([
-                    "mp3",
-                    "wav",
-                    "pcm",
-                    "opus",
-                    "flac",
-                    "aac"
-                ]);
-                const requestedFormat = requestedFormatRaw && supportedFormats.has(requestedFormatRaw)
-                    ? requestedFormatRaw
-                    : null;
-                await this.sendMessage({
-                    type: "chunk",
-                    thread_id: threadId,
-                    content: "",
-                    content_type: "text",
-                    content_metadata: { media_generation: mediaGeneration },
-                    done: false
-                });
-                let assetId;
-                let audioMimeType;
-                // Some providers (e.g. HuggingFace, OpenAI) can return fully-encoded
-                // audio. Prefer that path when available and honor the requested
-                // container when the provider supports it.
-                const encoded = await provider.textToSpeechEncoded({
-                    text: prompt,
-                    model: modelId,
-                    voice,
-                    speed,
-                    audioFormat: requestedFormat ?? undefined
-                });
-                if (encoded) {
-                    const mimeToExt = {
-                        "audio/mpeg": "mp3",
-                        "audio/wav": "wav",
-                        "audio/ogg": "ogg",
-                        "audio/flac": "flac",
-                        "audio/aac": "aac"
-                    };
-                    const ext = mimeToExt[encoded.mimeType] ?? "flac";
-                    if (requestedFormat &&
-                        requestedFormat !== ext &&
-                        requestedFormat !== "pcm") {
-                        log.warn("Requested audio_format not supported by provider; returning native format", { providerId, modelId, requestedFormat, returnedMime: encoded.mimeType });
-                    }
-                    assetId = await storeMediaAsset(encoded.data, encoded.mimeType, ext);
-                    audioMimeType = encoded.mimeType;
-                }
-                else {
-                    // Streaming PCM path (OpenAI, Gemini, etc.)
-                    const pcmChunks = [];
-                    let totalBytes = 0;
-                    let chunkSampleRate = 24000;
-                    for await (const chunk of provider.textToSpeech({
-                        text: prompt,
-                        model: modelId,
-                        voice,
-                        speed,
-                        audioFormat: requestedFormat ?? undefined
-                    })) {
-                        if (requestSeq !== undefined &&
-                            requestSeq !== this.chatRequestSeq)
-                            return;
-                        if (chunk?.samples) {
-                            if (chunk.sampleRate)
-                                chunkSampleRate = chunk.sampleRate;
-                            const view = new Uint8Array(chunk.samples.buffer, chunk.samples.byteOffset, chunk.samples.byteLength);
-                            const copy = new Uint8Array(view);
-                            pcmChunks.push(copy);
-                            totalBytes += copy.byteLength;
-                        }
-                    }
-                    const merged = new Uint8Array(totalBytes);
-                    let off = 0;
-                    for (const c of pcmChunks) {
-                        merged.set(c, off);
-                        off += c.byteLength;
-                    }
-                    if (requestedFormat === "pcm") {
-                        // Return raw PCM Int16 bytes (no container).
-                        assetId = await storeMediaAsset(merged, "audio/pcm", "pcm");
-                        audioMimeType = "audio/pcm";
-                    }
-                    else {
-                        if (requestedFormat &&
-                            requestedFormat !== "wav" &&
-                            requestedFormat !== "pcm") {
-                            log.warn("Requested audio_format cannot be produced from streaming PCM; falling back to WAV", { providerId, modelId, requestedFormat });
-                        }
-                        // Wrap raw PCM Int16 in a WAV container so browsers can play it.
-                        const sampleRate = chunkSampleRate;
-                        const numChannels = 1;
-                        const bitsPerSample = 16;
-                        const byteRate = sampleRate * numChannels * (bitsPerSample / 8);
-                        const blockAlign = numChannels * (bitsPerSample / 8);
-                        const wavHeader = new ArrayBuffer(44);
-                        const dv = new DataView(wavHeader);
-                        const writeStr = (pos, str) => {
-                            for (let i = 0; i < str.length; i++)
-                                dv.setUint8(pos + i, str.charCodeAt(i));
-                        };
-                        writeStr(0, "RIFF");
-                        dv.setUint32(4, 36 + merged.byteLength, true);
-                        writeStr(8, "WAVE");
-                        writeStr(12, "fmt ");
-                        dv.setUint32(16, 16, true);
-                        dv.setUint16(20, 1, true);
-                        dv.setUint16(22, numChannels, true);
-                        dv.setUint32(24, sampleRate, true);
-                        dv.setUint32(28, byteRate, true);
-                        dv.setUint16(32, blockAlign, true);
-                        dv.setUint16(34, bitsPerSample, true);
-                        writeStr(36, "data");
-                        dv.setUint32(40, merged.byteLength, true);
-                        const wav = new Uint8Array(44 + merged.byteLength);
-                        wav.set(new Uint8Array(wavHeader), 0);
-                        wav.set(merged, 44);
-                        assetId = await storeMediaAsset(wav, "audio/wav", "wav");
-                        audioMimeType = "audio/wav";
-                    }
-                }
-                await this.sendMessage({
-                    type: "chunk",
-                    thread_id: threadId,
-                    content: "",
-                    done: true
-                });
-                const assistantMsgData = {
-                    type: "message",
-                    role: "assistant",
-                    content: [
-                        {
-                            type: "audio",
-                            audio: {
-                                type: "audio",
-                                asset_id: assetId,
-                                mimeType: audioMimeType
-                            }
-                        }
-                    ],
-                    thread_id: threadId,
-                    workflow_id: workflowId,
-                    provider: providerId,
-                    model: modelId,
-                    media_generation: mediaGeneration
-                };
-                await this.saveMessageToDb(assistantMsgData);
-                await this.sendMessage(assistantMsgData);
-                return;
-            }
-            if (mode === "image_edit" || mode === "image_to_video") {
-                // Resolve the source image from either the message content (most
-                // common path: user dropped an image into the composer) or from the
-                // explicit `source_asset_id` echo on the media_generation payload.
-                const sourceBytes = await this.resolveSourceImageBytes(data, mediaGeneration, userId);
-                if (!sourceBytes) {
-                    await this.sendMessage({
-                        type: "error",
-                        message: "A source image is required — drop or attach an image first",
-                        thread_id: threadId
-                    });
-                    return;
-                }
-                await this.sendMessage({
-                    type: "chunk",
-                    thread_id: threadId,
-                    content: "",
-                    content_type: "text",
-                    content_metadata: { media_generation: mediaGeneration },
-                    done: false
-                });
-                if (mode === "image_edit") {
-                    const variations = Math.max(1, Math.min(Number(mediaGeneration.variations ?? 1), 8));
-                    const targetWidth = typeof mediaGeneration.width === "number"
-                        ? mediaGeneration.width
-                        : undefined;
-                    const targetHeight = typeof mediaGeneration.height === "number"
-                        ? mediaGeneration.height
-                        : undefined;
-                    const strength = typeof mediaGeneration.strength === "number"
-                        ? mediaGeneration.strength
-                        : undefined;
-                    const numInferenceSteps = typeof mediaGeneration.num_inference_steps === "number"
-                        ? mediaGeneration.num_inference_steps
-                        : undefined;
-                    const editModel = {
-                        id: modelId,
-                        name: modelId,
-                        provider: providerId
-                    };
-                    const params = {
-                        model: editModel,
-                        prompt,
-                        targetWidth: targetWidth ?? null,
-                        targetHeight: targetHeight ?? null,
-                        strength: strength ?? null,
-                        numInferenceSteps: numInferenceSteps ?? null
-                    };
-                    if (requestSeq !== undefined && requestSeq !== this.chatRequestSeq)
-                        return;
-                    const imageBytesList = await provider.imageToImages(sourceBytes, params, variations);
-                    const imageContents = [];
-                    for (const bytes of imageBytesList) {
-                        const assetId = await storeMediaAsset(bytes, "image/png", "png");
-                        imageContents.push({
-                            type: "image_url",
-                            image: {
-                                type: "image",
-                                asset_id: assetId,
-                                mimeType: "image/png"
-                            }
-                        });
-                    }
-                    await this.sendMessage({
-                        type: "chunk",
-                        thread_id: threadId,
-                        content: "",
-                        done: true
-                    });
-                    const assistantMsgData = {
-                        type: "message",
-                        role: "assistant",
-                        content: imageContents,
-                        thread_id: threadId,
-                        workflow_id: workflowId,
-                        provider: providerId,
-                        model: modelId,
-                        media_generation: mediaGeneration
-                    };
-                    await this.saveMessageToDb(assistantMsgData);
-                    await this.sendMessage(assistantMsgData);
-                    return;
-                }
-                // image_to_video
-                const aspectRatio = typeof mediaGeneration.aspect_ratio === "string"
-                    ? mediaGeneration.aspect_ratio
-                    : null;
-                const resolution = typeof mediaGeneration.resolution === "string"
-                    ? mediaGeneration.resolution
-                    : null;
-                const duration = typeof mediaGeneration.duration === "number"
-                    ? mediaGeneration.duration
-                    : null;
-                const numInferenceSteps = typeof mediaGeneration.num_inference_steps === "number"
-                    ? mediaGeneration.num_inference_steps
-                    : null;
-                const i2vModel = {
-                    id: modelId,
-                    name: modelId,
-                    provider: providerId
-                };
-                const params = {
-                    model: i2vModel,
-                    prompt,
-                    aspectRatio,
-                    resolution,
-                    durationSeconds: duration,
-                    numInferenceSteps
-                };
-                const bytes = await provider.imageToVideo(sourceBytes, params);
-                const assetId = await storeMediaAsset(bytes, "video/mp4", "mp4");
-                await this.sendMessage({
-                    type: "chunk",
-                    thread_id: threadId,
-                    content: "",
-                    done: true
-                });
-                const assistantMsgData = {
-                    type: "message",
-                    role: "assistant",
-                    content: [
-                        {
-                            type: "video",
-                            video: {
-                                type: "video",
-                                asset_id: assetId,
-                                format: "mp4",
-                                duration
-                            }
-                        }
-                    ],
-                    thread_id: threadId,
-                    workflow_id: workflowId,
-                    provider: providerId,
-                    model: modelId,
-                    media_generation: mediaGeneration
-                };
-                await this.saveMessageToDb(assistantMsgData);
-                await this.sendMessage(assistantMsgData);
-                return;
-            }
-            // Modes not yet implemented on the backend — fall back to an informative
-            // error so the client can render the unsupported state cleanly.
-            await this.sendMessage({
-                type: "error",
-                message: `Media generation mode "${mode}" is not yet supported`,
-                thread_id: threadId
-            });
-        }
-        catch (err) {
-            const errMsg = err instanceof Error ? err.message : String(err);
-            log.error("Media generation error", { threadId, mode, error: errMsg });
-            await this.sendMessage({
-                type: "error",
-                message: `Generation failed: ${errMsg}`,
-                thread_id: threadId
-            });
-        }
-    }
-    /**
-     * Resolve the source image bytes for image-edit / image-to-video calls.
-     * Searches in priority order:
-     *   1. `media_generation.source_asset_id`  → load from Asset storage
-     *   2. The first `image_url` content block on the user message
-     *      (supports asset_id, http(s) uri, and inline data:base64 payloads)
-     * Returns `null` when no usable source image can be found.
-     */
-    async resolveSourceImageBytes(data, mediaGeneration, userId) {
-        const tryLoadAsset = async (assetId) => {
-            if (!assetId)
-                return null;
-            try {
-                const asset = await Asset.find(userId, assetId);
-                if (!asset)
-                    return null;
-                const ext = (asset.content_type ?? "image/png").split("/")[1] ?? "png";
-                const { join } = await import("node:path");
-                const { readFile } = await import("node:fs/promises");
-                return new Uint8Array(await readFile(join(getAssetStoragePath(), `${assetId}.${ext}`)));
-            }
-            catch (err) {
-                log.warn("resolveSourceImageBytes: asset load failed", {
-                    assetId,
-                    error: err instanceof Error ? err.message : String(err)
-                });
-                return null;
-            }
-        };
-        const explicitId = typeof mediaGeneration.source_asset_id === "string"
-            ? mediaGeneration.source_asset_id
-            : null;
-        if (explicitId) {
-            const fromAsset = await tryLoadAsset(explicitId);
-            if (fromAsset)
-                return fromAsset;
-        }
-        const content = data.content;
-        if (Array.isArray(content)) {
-            for (const c of content) {
-                if (!c || typeof c !== "object")
-                    continue;
-                const block = c;
-                if (block.type !== "image_url")
-                    continue;
-                const image = (block.image ?? {});
-                const assetId = typeof image.asset_id === "string"
-                    ? image.asset_id
-                    : null;
-                if (assetId) {
-                    const bytes = await tryLoadAsset(assetId);
-                    if (bytes)
-                        return bytes;
-                }
-                const uri = typeof image.uri === "string" ? image.uri : null;
-                if (uri) {
-                    if (uri.startsWith("data:")) {
-                        const commaIdx = uri.indexOf(",");
-                        if (commaIdx > -1) {
-                            const b64 = uri.slice(commaIdx + 1);
-                            try {
-                                return new Uint8Array(Buffer.from(b64, "base64"));
-                            }
-                            catch {
-                                /* fall through */
-                            }
-                        }
-                    }
-                    else if (uri.startsWith("http://") || uri.startsWith("https://")) {
-                        if (!isSafeExternalUrl(uri)) {
-                            log.warn("resolveSourceImageBytes: refusing to fetch non-public URL", { uri });
-                        }
-                        else {
-                            try {
-                                const resp = await fetch(uri);
-                                if (resp.ok) {
-                                    return new Uint8Array(await resp.arrayBuffer());
-                                }
-                            }
-                            catch (err) {
-                                log.warn("resolveSourceImageBytes: fetch failed", {
-                                    uri,
-                                    error: err instanceof Error ? err.message : String(err)
-                                });
-                            }
-                        }
-                    }
-                }
-                const data64 = typeof image.data === "string" ? image.data : null;
-                if (data64) {
-                    try {
-                        return new Uint8Array(Buffer.from(data64, "base64"));
-                    }
-                    catch {
-                        /* ignore */
-                    }
-                }
-            }
-        }
-        return null;
-    }
-    async handleWorkflowMessage(data, _requestSeq) {
-        const threadId = typeof data.thread_id === "string" ? data.thread_id : "";
-        const workflowId = typeof data.workflow_id === "string" ? data.workflow_id : null;
-        const providerId = typeof data.provider === "string" ? data.provider : this.defaultProvider;
-        const model = typeof data.model === "string" ? data.model : this.defaultModel;
-        const userId = this.userId ?? "1";
-        const jobId = randomUUID();
-        log.info("Workflow message", { threadId, workflowId, jobId });
-        try {
-            if (!workflowId) {
-                throw new Error("workflow_id is required for workflow processing");
-            }
-            // Load workflow from DB
-            const workflow = await Workflow.find(userId, workflowId);
-            if (!workflow) {
-                throw new Error(`Workflow ${workflowId} not found`);
-            }
-            const rawGraph = workflow.graph;
-            if (this.beforeRunJob) {
-                await this.beforeRunJob(rawGraph);
-            }
-            // Detect message input names from raw graph (reads node.data) — matches Python
-            const { messageName, messagesName } = this.detectMessageInputNames(rawGraph);
-            const graph = await this.hydrateGraph(rawGraph);
-            const messageInputName = (typeof data.workflow_message_input_name === "string"
-                ? data.workflow_message_input_name
-                : null) ??
-                messageName ??
-                "message";
-            const messagesInputName = (typeof data.workflow_messages_input_name === "string"
-                ? data.workflow_messages_input_name
-                : null) ??
-                messagesName ??
-                "messages";
-            // Build chat history for params — matches Python
-            const [dbMessages] = await Message.paginate(threadId, { limit: 1000 });
-            const chatHistorySerialized = dbMessages.map((m) => ({
-                role: m.role,
-                content: m.content,
-                created_at: m.created_at,
-                thread_id: m.thread_id
-            }));
-            // Serialize current message
-            const currentMessage = {
-                role: typeof data.role === "string" ? data.role : "user",
-                content: data.content,
-                thread_id: threadId,
-                workflow_id: workflowId,
-                provider: providerId,
-                model
-            };
-            // Prepare params — matches Python's WorkflowMessageProcessor
-            const params = {
-                [messageInputName]: currentMessage,
-                [messagesInputName]: [...chatHistorySerialized, currentMessage],
-                ...(typeof data.params === "object" && data.params !== null
-                    ? data.params
-                    : {})
-            };
-            // If chat workflow, add legacy params — matches Python's ChatWorkflowMessageProcessor
-            if (workflow.run_mode === "chat") {
-                const legacyChatInput = chatHistorySerialized.map((m) => ({
-                    role: m.role,
-                    content: this.extractTextContent(m.content),
-                    created_at: m.created_at
-                }));
-                params["chat_input"] = legacyChatInput;
-                if (messagesInputName !== "messages") {
-                    params["messages"] = legacyChatInput;
-                }
-            }
-            // Create processing context
-            const workspaceDir = this.workspaceResolver
-                ? await this.workspaceResolver(workflowId, userId)
-                : null;
-            const context = createRuntimeContext({
-                jobId,
-                workflowId,
-                userId,
-                workspaceDir,
-                assetOutputMode: this.mode === "text" ? "data_uri" : "temp_url"
-            });
-            // Expose executor/node-type resolution for sub-workflow nodes
-            context.setResolveExecutor((node) => this.resolveExecutor(node));
-            if (this.resolveNodeType) {
-                const resolverObj = typeof this.resolveNodeType === "function"
-                    ? { resolveNodeType: this.resolveNodeType }
-                    : this.resolveNodeType;
-                context.setResolveNodeType((nodeType) => resolverObj.resolveNodeType(nodeType));
-            }
-            // Create and run workflow
-            const runner = new WorkflowRunner(jobId, {
-                resolveExecutor: (node) => this.resolveExecutor(node),
-                executionContext: context,
-                validateNode: this.validateNode
-            });
-            const active = {
-                jobId,
-                workflowId,
-                context,
-                runner,
-                graph,
-                finished: false,
-                status: "running"
-            };
-            this.activeJobs.set(jobId, active);
-            // Persist job to DB (best-effort)
-            try {
-                await Job.create({
-                    id: jobId,
-                    workflow_id: workflowId,
-                    user_id: userId,
-                    status: "running",
-                    params,
-                    graph
-                });
-            }
-            catch (error) {
-                this.logError("workflow job persistence failed", error);
-            }
-            // Execute workflow and stream messages
-            const executePromise = runner.run({ job_id: jobId, workflow_id: workflowId, params }, graph);
-            // Stream events, collect output_update results
-            const result = {};
-            await this.sendMessage({
-                type: "job_update",
-                status: "running",
-                job_id: jobId,
-                workflow_id: workflowId
-            });
-            let finalOutputs = {};
-            void executePromise
-                .then((r) => {
-                active.status = r.status;
-                active.error = r.error;
-                finalOutputs = r.outputs ?? {};
-            })
-                .catch((err) => {
-                active.status = "failed";
-                active.error = err instanceof Error ? err.message : String(err);
-            })
-                .finally(() => {
-                active.finished = true;
-            });
-            while (!active.finished || active.context.hasMessages()) {
-                while (active.context.hasMessages()) {
-                    const msg = active.context.popMessage();
-                    if (!msg)
-                        break;
-                    const outbound = {
-                        ...msg,
-                        job_id: msg.job_id ?? jobId,
-                        workflow_id: msg.workflow_id ??
-                            workflowId
-                    };
-                    // Capture output_update values for the response message
-                    if (outbound.type === "output_update") {
-                        const nodeId = String(outbound.node_id ?? "");
-                        const graphNodes = graph.nodes ?? [];
-                        const node = graphNodes.find((n) => n.id === nodeId);
-                        const nodeType = typeof node?.type === "string" ? node.type : "";
-                        if (nodeType.includes("Output")) {
-                            const nodeName = typeof outbound.node_name === "string"
-                                ? outbound.node_name
-                                : nodeType;
-                            result[nodeName] = outbound.value;
-                        }
-                        else {
-                            continue; // Skip non-output node output_updates
-                        }
-                    }
-                    await this.sendMessage(outbound);
-                }
-                if (!active.finished) {
-                    await new Promise((resolve) => setTimeout(resolve, 10));
-                }
-            }
-            // Collect any outputs from the runner result — only Output-type nodes
-            // The kernel considers all leaf nodes as "output nodes", but for the
-            // response message we only want nodes whose type includes "Output"
-            // (matching Python's WorkflowMessageProcessor behavior).
-            for (const [nodeType, values] of Object.entries(finalOutputs)) {
-                if (!nodeType.includes("Output"))
-                    continue;
-                if (!result[nodeType] && Array.isArray(values) && values.length > 0) {
-                    result[nodeType] = values.length === 1 ? values[0] : values;
-                }
-            }
-            // Send terminal job_update if not already sent
-            await this.sendMessage({
-                type: "job_update",
-                status: active.status,
-                job_id: jobId,
-                workflow_id: workflowId,
-                error: active.error,
-                result: { outputs: finalOutputs }
-            });
-            // Persist final job status
-            try {
-                const job = (await Job.get(jobId));
-                if (job) {
-                    if (active.status === "completed")
-                        job.markCompleted();
-                    else if (active.status === "failed")
-                        job.markFailed(active.error ?? "Unknown error");
-                    else if (active.status === "cancelled")
-                        job.markCancelled();
-                    await job.save();
-                }
-            }
-            catch (error) {
-                this.logError("workflow job persistence (final) failed", error);
-            }
-            this.activeJobs.delete(jobId);
-            // Signal completion — done chunk with job_id + workflow_id
-            await this.sendMessage({
-                type: "chunk",
-                content: "",
-                done: true,
-                job_id: jobId,
-                workflow_id: workflowId,
-                thread_id: threadId
-            });
-            // Create response message from workflow outputs — matches Python's _create_response_message
-            const responseContent = this.createWorkflowResponseContent(result);
-            const responseMsg = {
-                type: "message",
-                role: "assistant",
-                content: responseContent,
-                thread_id: threadId,
-                workflow_id: workflowId,
-                provider: providerId,
-                model,
-                job_id: jobId
-            };
-            await this.saveMessageToDb(responseMsg);
-            await this.sendMessage(responseMsg);
-            log.debug("Workflow message complete", { threadId, workflowId, jobId });
-        }
-        catch (err) {
-            const errMsg = err instanceof Error ? err.message : String(err);
-            log.error("Workflow message error", {
-                threadId,
-                workflowId,
-                error: errMsg
-            });
-            await this.sendMessage({
-                type: "error",
-                message: `Error processing workflow: ${errMsg}`,
-                job_id: jobId,
-                workflow_id: workflowId,
-                thread_id: threadId
-            });
-            // Send done chunk even on error — matches Python
-            await this.sendMessage({
-                type: "chunk",
-                content: "",
-                done: true,
-                job_id: jobId,
-                workflow_id: workflowId,
-                thread_id: threadId
-            });
-        }
-    }
-    /**
-     * Build the map of configured BaseProvider instances for the given user.
-     * Cached per user — invalidate by clearing `configuredProvidersCache`.
-     * Used to expose `find_model` to the GraphPlanner agent so it can pick a
-     * real model+provider for generic AI nodes.
-     */
-    async getConfiguredProviders(userId) {
-        const cached = this.configuredProvidersCache.get(userId);
-        if (cached)
-            return cached;
-        const providersMod = await import("@nodetool-ai/runtime");
-        const ids = providersMod.listRegisteredProviderIds();
-        const result = {};
-        await Promise.all(ids.map(async (id) => {
-            try {
-                if (await providersMod.isProviderConfigured(id, userId)) {
-                    result[id] = await providersMod.getProvider(id, userId);
-                }
-            }
-            catch (err) {
-                log.debug("Skipping provider for find_model", {
-                    provider: id,
-                    error: err instanceof Error ? err.message : String(err)
-                });
-            }
-        }));
-        this.configuredProvidersCache.set(userId, result);
-        return result;
-    }
-    /**
-     * Handle agent mode messages.
-     * Mirrors Python's AgentMessageProcessor.process().
-     *
-     * Creates an Agent with the user's objective and streams execution events
-     * (Chunk, ToolCallUpdate, TaskUpdate, PlanningUpdate, LogUpdate, StepResult)
-     * to the client. Messages with type "message" are persisted to DB.
-     */
-    async handleAgentMessage(data, requestSeq) {
-        const threadId = typeof data.thread_id === "string" ? data.thread_id : "";
-        const providerId = data.provider;
-        const model = data.model;
-        const workflowId = typeof data.workflow_id === "string" ? data.workflow_id : null;
-        const userId = this.userId ?? "1";
-        const provider = await this.resolveProvider(providerId, userId);
-        // Extract objective from content
-        const objective = this.extractTextContent(data.content, "Complete the requested task");
-        // Generate unique execution ID — matches Python
-        const agentExecutionId = randomUUID();
-        // Resolve tools — matches Python's tool resolution
-        const { MultiModeAgent, ReadFileTool, WriteFileTool, BrowserTool, GoogleSearchTool, getAllMcpTools, resolveTool } = await import("@nodetool-ai/agents");
-        let selectedTools = [];
-        const rawToolNames = Array.isArray(data.tools)
-            ? data.tools.filter((t) => typeof t === "string")
-            : [];
-        // Build configured providers up-front so both `getAllMcpTools` and the
-        // MultiModeAgent below share the same map. Cached per-user in
-        // `getConfiguredProviders`. Independent of the NodeRegistry — the
-        // multi-task planner needs `find_model` and the media-generation tools
-        // even when no registry is wired (i.e. graph mode is unavailable).
-        const agentProviders = await this.getConfiguredProviders(userId);
-        if (rawToolNames.length > 0) {
-            // User explicitly specified tools — resolve by name
-            for (const name of rawToolNames) {
-                const tool = resolveTool(name);
-                if (tool)
-                    selectedTools.push(tool);
-            }
-            log.debug("Selected tools for agent", {
-                tools: selectedTools.map((t) => t.name)
-            });
-        }
-        else {
-            // No tools specified — use the current built-in defaults plus NodeTool's
-            // MCP-style backend tools. When a NodeRegistry is wired up, the MCP
-            // helper swaps the REST search/list/get tools for the in-process biased
-            // versions and adds `find_model`, so any agent loop (not just the
-            // GraphPlanner) gets the same node-selection bias.
-            selectedTools = [
-                new ReadFileTool(),
-                new WriteFileTool(),
-                new BrowserTool(),
-                new GoogleSearchTool(),
-                ...getAllMcpTools({
-                    registry: this.nodeRegistry,
-                    providers: agentProviders
-                })
-            ];
-            log.debug("Using default + MCP tools for agent", {
-                count: selectedTools.length
-            });
-        }
-        // Server-side tools from resolveTools option
-        if (rawToolNames.length > 0 && this.resolveTools) {
-            const serverTools = await this.resolveTools(rawToolNames, userId);
-            for (const st of serverTools) {
-                if (!selectedTools.find((t) => t.name === st.name)) {
-                    selectedTools.push(st);
-                }
-            }
-        }
-        // Include UI proxy tools if client provided a manifest via tool bridge — matches Python
-        if (Object.keys(this.clientToolsManifest).length > 0) {
-            const sendMsg = this.sendMessage.bind(this);
-            for (const [, manifest] of Object.entries(this.clientToolsManifest)) {
-                try {
-                    selectedTools.push(new UIToolProxy(manifest, this.toolBridge, sendMsg));
-                }
-                catch (err) {
-                    log.warn("Failed to register UI tool proxy", {
-                        error: err instanceof Error ? err.message : String(err)
-                    });
-                }
-            }
-            log.debug("Added UI tool proxies to agent", {
-                count: Object.keys(this.clientToolsManifest).length
-            });
-        }
-        // Create ProcessingContext for agent execution
-        const agentWorkspaceDir = workflowId && this.workspaceResolver
-            ? await this.workspaceResolver(workflowId, userId)
-            : tmpdir();
-        const ctx = createRuntimeContext({
-            jobId: randomUUID(),
-            userId,
-            workspaceDir: agentWorkspaceDir
-        });
-        const maxStepIterations = typeof data.max_step_iterations === "number" &&
-            data.max_step_iterations > 0
-            ? Math.floor(data.max_step_iterations)
-            : 20;
-        const maxSteps = typeof data.max_steps === "number" && data.max_steps > 0
-            ? Math.floor(data.max_steps)
-            : undefined;
-        // Pick the planner. Explicit `agent_planner` from the client wins; if
-        // omitted, default to "graph" when a NodeRegistry is wired (the
-        // workflow-builder path) and "multi" otherwise (TaskPlanner →
-        // ParallelTaskExecutor). Either way the request only reaches the
-        // graph path when a registry is actually available.
-        const requestedPlanner = data.agent_planner === "graph" || data.agent_planner === "multi"
-            ? data.agent_planner
-            : null;
-        const defaultPlanner = this.nodeRegistry
-            ? "graph"
-            : "multi";
-        const plannerType = requestedPlanner ?? defaultPlanner;
-        const useGraphPlanner = plannerType === "graph" && !!this.nodeRegistry;
-        if (requestedPlanner === "graph" && !this.nodeRegistry) {
-            log.warn("Client requested graph planner but no NodeRegistry is wired — falling back to multi-task planner.");
-        }
-        const markdownOutputSchema = {
-            type: "object",
-            properties: {
-                markdown: {
-                    type: "string",
-                    description: "The markdown content of the response"
-                }
-            },
-            required: ["markdown"]
-        };
-        try {
-            // Both planner types route through MultiModeAgent in plan mode; the
-            // `useGraphPlanner` flag picks GraphPlanner vs TaskPlanner under the
-            // hood. The legacy plain `Agent` is no longer used for agent_mode.
-            const agent = new MultiModeAgent({
-                name: "Assistant",
-                objective,
-                provider,
-                model,
-                mode: "plan",
-                tools: selectedTools,
-                useGraphPlanner,
-                registry: useGraphPlanner ? this.nodeRegistry : undefined,
-                providers: useGraphPlanner ? agentProviders : undefined,
-                maxStepIterations,
-                ...(maxSteps !== undefined ? { maxSteps } : {}),
-                outputSchema: markdownOutputSchema
-            });
-            for await (const item of agent.execute(ctx)) {
-                if (requestSeq !== undefined && requestSeq !== this.chatRequestSeq)
-                    return;
-                const msgType = item.type;
-                if (msgType === "chunk") {
-                    // Stream text chunks to client
-                    const chunk = item;
-                    await this.sendMessage({
-                        type: "chunk",
-                        content: chunk.content ?? "",
-                        done: chunk.done ?? false,
-                        thinking: chunk.thinking ?? false,
-                        thread_id: chunk.thread_id ?? threadId
-                    });
-                }
-                else if (msgType === "tool_call_update") {
-                    // Forward tool call updates live AND persist them as an
-                    // agent_execution message so that reopening a thread preserves the
-                    // full per-step debug trace (which tools were called, with what args).
-                    const tc = item;
-                    await this.sendMessage({
-                        type: "tool_call_update",
-                        thread_id: threadId,
-                        workflow_id: workflowId,
-                        tool_call_id: tc.tool_call_id ?? null,
-                        name: tc.name,
-                        message: tc.message ?? `Calling ${tc.name}...`,
-                        args: tc.args,
-                        step_id: tc.step_id ?? null,
-                        node_id: tc.node_id ?? null,
-                        agent_execution_id: agentExecutionId
-                    });
-                    const persisted = {
-                        type: "message",
-                        role: "agent_execution",
-                        execution_event_type: "tool_call_update",
-                        agent_execution_id: agentExecutionId,
-                        content: {
-                            type: "tool_call_update",
-                            tool_call_id: tc.tool_call_id ?? null,
-                            name: tc.name,
-                            message: tc.message ?? `Calling ${tc.name}...`,
-                            args: tc.args ?? {},
-                            step_id: tc.step_id ?? null,
-                            node_id: tc.node_id ?? null
-                        },
-                        thread_id: threadId,
-                        workflow_id: workflowId,
-                        provider: providerId,
-                        model,
-                        agent_mode: true
-                    };
-                    await this.saveMessageToDb(persisted);
-                }
-                else if (msgType === "task_update") {
-                    // Send task update as agent_execution message — persisted by _run_processor pattern
-                    const tu = item;
-                    const contentDict = {
-                        type: "task_update",
-                        event: tu.event,
-                        task: tu.task ?? null,
-                        step: tu.step ?? null
-                    };
-                    const msg = {
-                        type: "message",
-                        role: "agent_execution",
-                        execution_event_type: "task_update",
-                        agent_execution_id: agentExecutionId,
-                        content: contentDict,
-                        thread_id: threadId,
-                        workflow_id: workflowId,
-                        provider: providerId,
-                        model,
-                        agent_mode: true
-                    };
-                    await this.saveMessageToDb(msg);
-                    await this.sendMessage(msg);
-                }
-                else if (msgType === "planning_update") {
-                    // Send planning update as agent_execution message
-                    const pu = item;
-                    const contentDict = {
-                        type: "planning_update",
-                        phase: pu.phase,
-                        status: pu.status,
-                        content: pu.content,
-                        node_id: pu.node_id
-                    };
-                    const msg = {
-                        type: "message",
-                        role: "agent_execution",
-                        execution_event_type: "planning_update",
-                        agent_execution_id: agentExecutionId,
-                        content: contentDict,
-                        thread_id: threadId,
-                        workflow_id: workflowId,
-                        provider: providerId,
-                        model,
-                        agent_mode: true
-                    };
-                    await this.saveMessageToDb(msg);
-                    await this.sendMessage(msg);
-                    // Also send persistent LogUpdate for completed phases — matches Python
-                    if (pu.status === "Success" || pu.status === "Failed") {
-                        const logMsg = {
-                            type: "message",
-                            role: "agent_execution",
-                            execution_event_type: "log_update",
-                            agent_execution_id: agentExecutionId,
-                            content: {
-                                type: "log_update",
-                                node_id: pu.node_id ?? "agent",
-                                node_name: "Agent",
-                                content: `${pu.phase}: ${pu.content ?? ""}`,
-                                severity: pu.status === "Failed" ? "error" : "info"
-                            },
-                            thread_id: threadId,
-                            workflow_id: workflowId,
-                            provider: providerId,
-                            model,
-                            agent_mode: true
-                        };
-                        await this.saveMessageToDb(logMsg);
-                        await this.sendMessage(logMsg);
-                    }
-                }
-                else if (msgType === "log_update") {
-                    // Forward log updates as agent_execution messages
-                    const lu = item;
-                    const msg = {
-                        type: "message",
-                        role: "agent_execution",
-                        execution_event_type: "log_update",
-                        agent_execution_id: agentExecutionId,
-                        content: {
-                            type: "log_update",
-                            node_id: lu.node_id,
-                            node_name: lu.node_name,
-                            content: lu.content,
-                            severity: lu.severity
-                        },
-                        thread_id: threadId,
-                        workflow_id: workflowId,
-                        provider: providerId,
-                        model,
-                        agent_mode: true
-                    };
-                    await this.saveMessageToDb(msg);
-                    await this.sendMessage(msg);
-                }
-                else if (msgType === "step_result") {
-                    const sr = item;
-                    // Only forward non-task step results — task result handled via agent.results
-                    if (!sr.is_task_result) {
-                        const contentDict = {
-                            type: "step_result",
-                            result: sr.result,
-                            step: sr.step ?? null,
-                            error: sr.error,
-                            is_task_result: sr.is_task_result
-                        };
-                        const msg = {
-                            type: "message",
-                            role: "agent_execution",
-                            execution_event_type: "step_result",
-                            agent_execution_id: agentExecutionId,
-                            content: contentDict,
-                            thread_id: threadId,
-                            workflow_id: workflowId,
-                            provider: providerId,
-                            model,
-                            agent_mode: true
-                        };
-                        await this.saveMessageToDb(msg);
-                        await this.sendMessage(msg);
-                    }
-                }
-            }
-            // Normalize final agent output — matches Python
-            const results = agent.getResults();
-            let content;
-            if (typeof results === "string") {
-                content = results;
-            }
-            else if (results &&
-                typeof results === "object" &&
-                "markdown" in results) {
-                const md = results.markdown;
-                content = typeof md === "string" ? md : String(results);
-            }
-            else if (results != null && typeof results === "object") {
-                // Structured result — run one more LLM call to present it
-                const resultsJson = JSON.stringify(results, null, 2);
-                content = await this.presentStructuredResults(provider, model, objective, resultsJson, threadId);
-            }
-            else {
-                content = results != null ? String(results) : "";
-            }
-            // Send final assistant message — persisted
-            const finalMsg = {
-                type: "message",
-                role: "assistant",
-                content,
-                thread_id: threadId,
-                workflow_id: workflowId,
-                provider: providerId,
-                model,
-                agent_mode: true
-            };
-            await this.saveMessageToDb(finalMsg);
-            await this.sendMessage(finalMsg);
-            // Signal completion
-            await this.sendMessage({
-                type: "chunk",
-                content: "",
-                done: true,
-                thread_id: threadId,
-                workflow_id: workflowId
-            });
-            log.debug("Agent execution complete", { threadId });
-        }
-        catch (err) {
-            const errMsg = err instanceof Error ? err.message : String(err);
-            log.error("Agent execution error", { threadId, error: errMsg });
-            await this.sendMessage({
-                type: "error",
-                message: `Agent execution error: ${errMsg}`,
-                error_type: "agent_error",
-                thread_id: threadId,
-                workflow_id: workflowId
-            });
-            // Signal completion even on error
-            await this.sendMessage({
-                type: "chunk",
-                content: "",
-                done: true,
-                thread_id: threadId,
-                workflow_id: workflowId
-            });
-            // Return error assistant message
-            const errorFinalMsg = {
-                type: "message",
-                role: "assistant",
-                content: `Agent execution error: ${errMsg}`,
-                thread_id: threadId,
-                workflow_id: workflowId,
-                provider: providerId,
-                model,
-                agent_mode: true
-            };
-            await this.saveMessageToDb(errorFinalMsg);
-            await this.sendMessage(errorFinalMsg);
-        }
-    }
-    async handleInference(data, requestSeq) {
-        const providerId = typeof data.provider === "string" ? data.provider : this.defaultProvider;
-        const model = typeof data.model === "string" ? data.model : this.defaultModel;
-        const rawMessages = Array.isArray(data.messages) ? data.messages : [];
-        log.debug("Inference request", {
-            model,
-            provider: providerId,
-            messages: rawMessages.length
-        });
-        const messages = rawMessages.map((m) => {
-            const msg = m;
-            return {
-                role: (typeof msg.role === "string"
-                    ? msg.role
-                    : "user"),
-                content: typeof msg.content === "string"
-                    ? msg.content
-                    : Array.isArray(msg.content)
-                        ? msg.content
-                        : "",
-                toolCallId: typeof msg.toolCallId === "string" ? msg.toolCallId : null,
-                toolCalls: Array.isArray(msg.toolCalls)
-                    ? msg.toolCalls
-                    : null,
-                threadId: null
-            };
-        });
-        if (!this.resolveProvider) {
-            await this.sendMessage({
-                type: "error",
-                message: "No provider resolver configured"
-            });
-            return;
-        }
-        const rawTools = Array.isArray(data.tools) ? data.tools : [];
-        const tools = rawTools
-            .map((t) => {
-            const tool = t;
-            return {
-                name: typeof tool.name === "string" ? tool.name : "",
-                description: typeof tool.description === "string" ? tool.description : undefined,
-                inputSchema: typeof tool.inputSchema === "object"
-                    ? tool.inputSchema
-                    : undefined
-            };
-        })
-            .filter((t) => t.name.length > 0);
-        const provider = await this.resolveProvider(providerId, this.userId ?? "1");
-        for await (const item of provider.generateMessagesTraced({
-            messages,
-            model,
-            tools: tools.length > 0 ? tools : undefined
-        })) {
-            if (requestSeq !== this.chatRequestSeq)
-                break; // cancelled
-            if ("type" in item && item.type === "chunk") {
-                await this.sendMessage({
-                    ...item,
-                    seq: requestSeq
-                });
-            }
-            else if ("name" in item) {
-                const toolItem = item;
-                log.info("Tool call", { tool: toolItem.name, args: toolItem.args });
-                await this.sendMessage({
-                    type: "tool_call",
-                    id: toolItem.id,
-                    name: toolItem.name,
-                    args: toolItem.args,
-                    seq: requestSeq
-                });
-            }
-        }
-        if (requestSeq === this.chatRequestSeq) {
-            log.debug("Inference complete");
-            await this.sendMessage({ type: "inference_done", seq: requestSeq });
-        }
-    }
-    async handleCommand(command) {
-        const data = command.data ?? {};
-        const jobId = typeof data.job_id === "string" ? data.job_id : undefined;
-        const workflowId = typeof data.workflow_id === "string" ? data.workflow_id : undefined;
-        log.debug("Command", { command: command.command });
-        switch (command.command) {
-            case "clear_models":
-                return this.clearModels();
-            case "run_job":
-                await this.runJob(data);
-                return { message: "Job started", workflow_id: workflowId ?? null };
-            case "reconnect_job":
-                if (!jobId)
-                    return { error: "job_id is required" };
-                void this.reconnectJob(jobId, workflowId);
-                return {
-                    message: `Reconnecting to job ${jobId}`,
-                    job_id: jobId,
-                    workflow_id: workflowId ?? null
-                };
-            case "resume_job":
-                if (!jobId)
-                    return { error: "job_id is required" };
-                void this.resumeJob(jobId, workflowId);
-                return {
-                    message: `Resumption initiated for job ${jobId}`,
-                    job_id: jobId,
-                    workflow_id: workflowId ?? null
-                };
-            case "stream_input":
-                if (!jobId)
-                    return { error: "job_id is required" };
-                {
-                    const active = this.activeJobs.get(jobId);
-                    log.info("stream_input command", {
-                        jobId,
-                        hasActive: !!active,
-                        inputName: data.input,
-                        handle: data.handle,
-                        hasValue: data.value !== undefined,
-                        activeJobIds: [...this.activeJobs.keys()]
-                    });
-                    if (!active)
-                        return { error: "No active job/context" };
-                    const inputName = typeof data.input === "string" ? data.input : "";
-                    if (!inputName.trim())
-                        return { error: "Invalid input name" };
-                    const value = data.value;
-                    const handle = typeof data.handle === "string" ? data.handle : undefined;
-                    try {
-                        await active.runner.pushInputValue(inputName, value, handle);
-                        return {
-                            message: "Input item streamed",
-                            job_id: jobId,
-                            workflow_id: workflowId ?? active.workflowId
-                        };
-                    }
-                    catch (err) {
-                        log.error("stream_input failed", {
-                            error: err instanceof Error ? err.message : String(err)
-                        });
-                        return {
-                            error: err instanceof Error ? err.message : String(err),
-                            job_id: jobId,
-                            workflow_id: workflowId ?? active.workflowId
-                        };
-                    }
-                }
-            case "end_input_stream":
-                if (!jobId)
-                    return { error: "job_id is required" };
-                {
-                    const active = this.activeJobs.get(jobId);
-                    if (!active)
-                        return { error: "No active job/context" };
-                    const inputName = typeof data.input === "string" ? data.input : "";
-                    if (!inputName.trim())
-                        return { error: "Invalid input name" };
-                    const handle = typeof data.handle === "string" ? data.handle : undefined;
-                    try {
-                        active.runner.finishInputStream(inputName, handle);
-                        return {
-                            message: "Input stream ended",
-                            job_id: jobId,
-                            workflow_id: workflowId ?? active.workflowId
-                        };
-                    }
-                    catch (err) {
-                        return {
-                            error: err instanceof Error ? err.message : String(err),
-                            job_id: jobId,
-                            workflow_id: workflowId ?? active.workflowId
-                        };
-                    }
-                }
-            case "cancel_job":
-                if (!jobId)
-                    return { error: "job_id is required" };
-                return this.cancelJob(jobId, workflowId);
-            case "get_status":
-                return this.getStatus(jobId);
-            case "set_mode": {
-                const mode = data.mode;
-                if (mode !== "binary" && mode !== "text") {
-                    return { error: "mode must be binary or text" };
-                }
-                this.mode = mode;
-                return { message: `Mode set to ${mode}` };
-            }
-            case "chat_message": {
-                const threadId = data.thread_id;
-                if (typeof threadId !== "string" || threadId.length === 0) {
-                    return { error: "thread_id is required for chat_message command" };
-                }
-                this.chatRequestSeq += 1;
-                const seq = this.chatRequestSeq;
-                this.currentTask = this.handleChatMessage(data, seq);
-                void this.currentTask.catch(async (err) => {
-                    this.logError("chat_message processing failed", err);
-                    await this.sendMessage({
-                        type: "error",
-                        message: err instanceof Error ? err.message : String(err)
-                    });
-                });
-                return {
-                    message: "Chat message processing started",
-                    thread_id: threadId
-                };
-            }
-            case "inference": {
-                this.chatRequestSeq += 1;
-                const seq = this.chatRequestSeq;
-                this.currentTask = this.handleInference(data, seq);
-                void this.currentTask.catch(async (err) => {
-                    this.logError("inference processing failed", err);
-                    await this.sendMessage({
-                        type: "error",
-                        message: err instanceof Error ? err.message : String(err)
-                    });
-                });
-                return { message: "Inference started" };
-            }
-            case "stop": {
-                const threadId = typeof data.thread_id === "string" ? data.thread_id : undefined;
-                // Always increment seq to cancel any in-progress chat or inference
-                this.chatRequestSeq += 1;
-                this.currentTask = null;
-                if (jobId) {
-                    const active = this.activeJobs.get(jobId);
-                    if (active) {
-                        active.runner.cancel();
-                        active.finished = true;
-                        active.status = "cancelled";
-                    }
-                }
-                this.toolBridge.cancelAll();
-                await this.sendMessage({
-                    type: "generation_stopped",
-                    message: "Generation stopped by user",
-                    job_id: jobId ?? null,
-                    thread_id: threadId ?? null
-                });
-                return {
-                    message: "Stop command processed",
-                    job_id: jobId ?? null,
-                    thread_id: threadId ?? null
-                };
-            }
-            default:
-                return { error: "Unknown command" };
-        }
-    }
-    startHeartbeat() {
-        this.stopHeartbeat();
-        this.heartbeatTimer = setInterval(() => {
-            this.sendMessage({ type: "ping", ts: Date.now() / 1000 }).catch((err) => {
-                log.warn("Failed to send heartbeat ping", { error: String(err) });
-            });
-        }, 25_000);
-    }
-    stopHeartbeat() {
-        if (this.heartbeatTimer) {
-            clearInterval(this.heartbeatTimer);
-            this.heartbeatTimer = null;
-        }
-    }
-    startStatsBroadcast() {
-        this.stopStatsBroadcast();
-        this.statsTimer = setInterval(() => {
-            this.sendMessage({
-                type: "system_stats",
-                stats: this.getSystemStats()
-            }).catch((err) => {
-                log.warn("Failed to send system stats", { error: String(err) });
-            });
-        }, 30_000);
-    }
-    stopStatsBroadcast() {
-        if (this.statsTimer) {
-            clearInterval(this.statsTimer);
-            this.statsTimer = null;
-        }
-    }
-    registerObserver() {
-        if (this.observerRegistered)
-            return;
-        ModelObserver.subscribe(this.onModelChange);
-        this.observerRegistered = true;
-    }
-    unregisterObserver() {
-        if (!this.observerRegistered)
-            return;
-        ModelObserver.unsubscribe(this.onModelChange);
-        this.observerRegistered = false;
-    }
-    onModelChange = (instance, event) => {
-        if (!this.websocket)
-            return;
-        void this.sendMessage({
-            type: "resource_change",
-            event,
-            resource_type: instance.constructor.name.toLowerCase(),
-            resource: {
-                id: instance.partitionValue(),
-                etag: instance.getEtag()
-            }
-        });
-    };
-    async run(websocket) {
-        await this.connect(websocket, this.userId ?? undefined, this.authToken ?? undefined);
-        try {
-            await this.receiveMessages();
-        }
-        finally {
-            await this.disconnect();
-        }
-    }
-    async receiveMessages() {
-        while (true) {
-            const data = await this.receiveMessage();
-            if (data === null)
-                break;
-            const msgType = typeof data.type === "string" ? data.type : null;
-            if (msgType === "client_tools_manifest") {
-                const tools = Array.isArray(data.tools) ? data.tools : [];
-                this.clientToolsManifest = {};
-                for (const tool of tools) {
-                    if (tool &&
-                        typeof tool === "object" &&
-                        typeof tool.name === "string") {
-                        const name = tool.name;
-                        this.clientToolsManifest[name] = tool;
-                    }
-                }
-                continue;
-            }
-            if (msgType === "tool_result") {
-                const toolCallId = typeof data.tool_call_id === "string" ? data.tool_call_id : null;
-                if (toolCallId) {
-                    this.toolBridge.resolveResult(toolCallId, data);
-                }
-                continue;
-            }
-            if (msgType === "ping") {
-                await this.sendMessage({ type: "pong", ts: Date.now() / 1000 });
-                continue;
-            }
-            if (typeof data.command === "string") {
-                try {
-                    const command = data;
-                    const response = await this.handleCommand(command);
-                    await this.sendMessage(response);
-                }
-                catch (err) {
-                    this.logError("invalid_command handling failed", err);
-                    await this.sendMessage({
-                        error: "invalid_command",
-                        details: err instanceof Error ? err.message : String(err)
-                    });
-                }
-                continue;
-            }
-            await this.sendMessage({
-                error: "invalid_message",
-                message: "All messages must include a 'command' field. Use 'chat_message' command for chat."
-            });
-        }
-    }
-}
-//# sourceMappingURL=unified-websocket-runner.js.map