@wingman-ai/gateway 0.2.4 → 0.3.0

package/dist/tools/mcp-fal-ai.js

@@ -0,0 +1,1025 @@
+import * as __rspack_external__fal_runtime_js_230694eb from "./fal/runtime.js";
+import * as __rspack_external__fal_summary_js_64406a32 from "./fal/summary.js";
+import * as __rspack_external__fal_ai_client_24ca7f48 from "@fal-ai/client";
+import * as __rspack_external__modelcontextprotocol_sdk_server_mcp_js_2c42c5d0 from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as __rspack_external__modelcontextprotocol_sdk_server_stdio_js_4f861174 from "@modelcontextprotocol/sdk/server/stdio.js";
+import * as __rspack_external_node_crypto_9ba42079 from "node:crypto";
+import * as __rspack_external_node_fs_5ea92f0c from "node:fs";
+import * as __rspack_external_node_path_c5b9b54f from "node:path";
+import * as __rspack_external_zod from "zod";
+var __webpack_modules__ = {
+    "./src/tools/mcp-fal-ai.ts" (module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.a(module, async function(__rspack_load_async_deps, __rspack_async_done) {
+            try {
+                __webpack_require__.r(__webpack_exports__);
+                var node_crypto__rspack_import_0 = __webpack_require__("node:crypto");
+                var node_fs__rspack_import_1 = __webpack_require__("node:fs");
+                var node_path__rspack_import_2 = __webpack_require__("node:path");
+                var _fal_ai_client__rspack_import_3 = __webpack_require__("@fal-ai/client");
+                var _modelcontextprotocol_sdk_server_mcp_js__rspack_import_4 = __webpack_require__("@modelcontextprotocol/sdk/server/mcp.js");
+                var _modelcontextprotocol_sdk_server_stdio_js__rspack_import_5 = __webpack_require__("@modelcontextprotocol/sdk/server/stdio.js");
+                var zod__rspack_import_6 = __webpack_require__("zod");
+                var _fal_runtime_js__rspack_import_7 = __webpack_require__("./fal/runtime.js");
+                var _fal_summary_js__rspack_import_8 = __webpack_require__("./fal/summary.js");
+                const FAL_DEFAULT_POLL_INTERVAL_MS = parsePositiveInt(process.env.FAL_MCP_POLL_INTERVAL_MS) || 2500;
+                const FAL_DEFAULT_STATUS_TIMEOUT_MS = parsePositiveInt(process.env.FAL_MCP_STATUS_TIMEOUT_MS) || 60000;
+                const FAL_HTTP_TIMEOUT_MS = parsePositiveInt(process.env.FAL_MCP_HTTP_TIMEOUT_MS) || 120000;
+                const FAL_DEFAULT_LOG_LIMIT = 40;
+                const FAL_API_KEY_ENV = process.env.FAL_API_KEY?.trim() || process.env.FAL_KEY?.trim() || "";
+                const FAL_REVIEW_MODE = normalizeReviewMode(process.env.FAL_MCP_REVIEW_MODE);
+                const FAL_MODELS = {
+                    imageOrTexture: process.env.FAL_MODEL_IMAGE_OR_TEXTURE?.trim() || "fal-ai/nano-banana-pro",
+                    imageEdit: process.env.FAL_MODEL_IMAGE_EDIT?.trim() || "fal-ai/kling-image/v3/image-to-image",
+                    audioMusic: process.env.FAL_MODEL_AUDIO_OR_MUSIC?.trim() || "fal-ai/elevenlabs/music",
+                    audioSoundEffect: process.env.FAL_MODEL_SOUND_EFFECT?.trim() || "beatoven/sound-effect-generation",
+                    videoFromImage: process.env.FAL_MODEL_VIDEO_FROM_IMAGE?.trim() || "fal-ai/kling-video/o3/standard/image-to-video"
+                };
+                const FAL_WORKDIR = (0, _fal_runtime_js__rspack_import_7.resolveFalWorkdir)();
+                const FAL_STATE_DIR = (0, _fal_runtime_js__rspack_import_7.resolveFalStateDir)();
+                const FAL_OUTPUT_DIR = (0, _fal_runtime_js__rspack_import_7.resolveFalOutputDir)();
+                const JOBS_DIR = (0, node_path__rspack_import_2.join)(FAL_STATE_DIR, "jobs");
+                const PENDING_DIR = (0, node_path__rspack_import_2.join)(FAL_STATE_DIR, "pending");
+                const inMemoryJobs = new Map();
+                const server = new _modelcontextprotocol_sdk_server_mcp_js__rspack_import_4.McpServer({
+                    name: "wingman-fal-ai",
+                    version: "0.1.0"
+                });
+                const sharedInputSchema = zod__rspack_import_6.object({
+                    apiKey: zod__rspack_import_6.string().min(1).optional().describe("Optional FAL API key override for this tool call."),
+                    modelInput: zod__rspack_import_6.record(zod__rspack_import_6.string(), zod__rspack_import_6.any()).optional().describe("Optional raw model input overrides merged into the default payload."),
+                    waitForCompletion: zod__rspack_import_6.boolean().optional().default(false).describe("If true, block in-tool and poll status until complete or timeout."),
+                    timeoutSeconds: zod__rspack_import_6.number().int().min(1).max(3600).optional().describe("Optional timeout in seconds for waitForCompletion mode."),
+                    pollIntervalMs: zod__rspack_import_6.number().int().min(250).max(30000).optional().describe("Optional polling interval in ms for waitForCompletion mode.")
+                });
+                const generateImageOrTextureSchema = sharedInputSchema.extend({
+                    prompt: zod__rspack_import_6.string().min(1)
+                });
+                const generateImageEditSchema = sharedInputSchema.extend({
+                    prompt: zod__rspack_import_6.string().min(1),
+                    sourceImage: zod__rspack_import_6.string().min(1).describe("Source image as data URL, local file path, or http(s) URL.")
+                });
+                const generateAudioOrMusicSchema = sharedInputSchema.extend({
+                    prompt: zod__rspack_import_6.string().min(1),
+                    audioMode: zod__rspack_import_6["enum"]([
+                        "music",
+                        "sound_effect"
+                    ]).optional().default("music").describe("Use 'music' for songs/tracks or 'sound_effect' for effects.")
+                });
+                const generateVideoFromImageSchema = sharedInputSchema.extend({
+                    prompt: zod__rspack_import_6.string().min(1),
+                    sourceImage: zod__rspack_import_6.string().min(1).describe("Source image as data URL, local file path, or http(s) URL.")
+                });
+                const falGenerationStatusSchema = zod__rspack_import_6.object({
+                    jobId: zod__rspack_import_6.string().min(1).describe("Job id returned from a generate_* tool."),
+                    action: zod__rspack_import_6["enum"]([
+                        "check",
+                        "wait",
+                        "cancel",
+                        "accept",
+                        "deny"
+                    ]).optional().default("check").describe("Status action. Use wait for polling, accept/deny for review flow."),
+                    includeLogs: zod__rspack_import_6.boolean().optional().default(true).describe("Include recent queue logs in the result payload."),
+                    timeoutSeconds: zod__rspack_import_6.number().int().min(1).max(3600).optional().describe("Timeout in seconds when action=wait."),
+                    pollIntervalMs: zod__rspack_import_6.number().int().min(250).max(30000).optional().describe("Polling interval in ms when action=wait."),
+                    apiKey: zod__rspack_import_6.string().min(1).optional().describe("Optional FAL API key override for queue status calls.")
+                });
+                server.registerTool("generate_image_or_texture", {
+                    title: "FAL Generate Image Or Texture",
+                    description: "Generate an image or texture with FAL using a queue-backed async job. Returns a job id. Use fal_generation_status for updates and completion.",
+                    inputSchema: generateImageOrTextureSchema
+                }, async ({ prompt, modelInput, apiKey, waitForCompletion, timeoutSeconds, pollIntervalMs })=>{
+                    const resolvedApiKey = resolveFalApiKey(apiKey);
+                    const client = (0, _fal_ai_client__rspack_import_3.createFalClient)({
+                        credentials: resolvedApiKey
+                    });
+                    const payload = mergeModelInput({
+                        prompt
+                    }, modelInput);
+                    const job = await submitFalJob({
+                        client,
+                        modelId: FAL_MODELS.imageOrTexture,
+                        modality: "image",
+                        toolName: "generate_image_or_texture",
+                        prompt,
+                        input: payload
+                    });
+                    if (waitForCompletion) return runStatusAction({
+                        job,
+                        action: "wait",
+                        includeLogs: true,
+                        client,
+                        timeoutMs: normalizeTimeoutMs(timeoutSeconds),
+                        pollIntervalMs: normalizePollIntervalMs(pollIntervalMs)
+                    });
+                    return toToolResult(job);
+                });
+                server.registerTool("generate_image_edit", {
+                    title: "FAL Generate Image Edit",
+                    description: "Edit an image using FAL image-to-image queue jobs. Returns a job id. Use fal_generation_status for updates and completion.",
+                    inputSchema: generateImageEditSchema
+                }, async ({ prompt, sourceImage, modelInput, apiKey, waitForCompletion, timeoutSeconds, pollIntervalMs })=>{
+                    const resolvedApiKey = resolveFalApiKey(apiKey);
+                    const client = (0, _fal_ai_client__rspack_import_3.createFalClient)({
+                        credentials: resolvedApiKey
+                    });
+                    const sourceImageUrl = await resolveImageSourceToFalUrl(sourceImage, client);
+                    const payload = mergeModelInput({
+                        prompt,
+                        image_url: sourceImageUrl
+                    }, modelInput);
+                    const job = await submitFalJob({
+                        client,
+                        modelId: FAL_MODELS.imageEdit,
+                        modality: "image",
+                        toolName: "generate_image_edit",
+                        prompt,
+                        input: payload
+                    });
+                    if (waitForCompletion) return runStatusAction({
+                        job,
+                        action: "wait",
+                        includeLogs: true,
+                        client,
+                        timeoutMs: normalizeTimeoutMs(timeoutSeconds),
+                        pollIntervalMs: normalizePollIntervalMs(pollIntervalMs)
+                    });
+                    return toToolResult(job);
+                });
+                server.registerTool("generate_audio_or_music", {
+                    title: "FAL Generate Audio Or Music",
+                    description: "Generate audio or music through FAL queue jobs. Returns a job id. Use fal_generation_status for updates and completion.",
+                    inputSchema: generateAudioOrMusicSchema
+                }, async ({ prompt, audioMode, modelInput, apiKey, waitForCompletion, timeoutSeconds, pollIntervalMs })=>{
+                    const resolvedApiKey = resolveFalApiKey(apiKey);
+                    const client = (0, _fal_ai_client__rspack_import_3.createFalClient)({
+                        credentials: resolvedApiKey
+                    });
+                    const modelId = "sound_effect" === audioMode ? FAL_MODELS.audioSoundEffect : FAL_MODELS.audioMusic;
+                    const payload = mergeModelInput({
+                        prompt
+                    }, modelInput);
+                    const job = await submitFalJob({
+                        client,
+                        modelId,
+                        modality: "audio",
+                        toolName: "generate_audio_or_music",
+                        prompt,
+                        input: payload
+                    });
+                    if (waitForCompletion) return runStatusAction({
+                        job,
+                        action: "wait",
+                        includeLogs: true,
+                        client,
+                        timeoutMs: normalizeTimeoutMs(timeoutSeconds),
+                        pollIntervalMs: normalizePollIntervalMs(pollIntervalMs)
+                    });
+                    return toToolResult(job);
+                });
+                server.registerTool("generate_video_from_image", {
+                    title: "FAL Generate Video From Image",
+                    description: "Generate a video from an image using FAL queue jobs. Returns a job id. Use fal_generation_status for updates and completion.",
+                    inputSchema: generateVideoFromImageSchema
+                }, async ({ prompt, sourceImage, modelInput, apiKey, waitForCompletion, timeoutSeconds, pollIntervalMs })=>{
+                    const resolvedApiKey = resolveFalApiKey(apiKey);
+                    const client = (0, _fal_ai_client__rspack_import_3.createFalClient)({
+                        credentials: resolvedApiKey
+                    });
+                    const sourceImageUrl = await resolveImageSourceToFalUrl(sourceImage, client);
+                    const payload = mergeModelInput({
+                        prompt,
+                        image_url: sourceImageUrl
+                    }, modelInput);
+                    const job = await submitFalJob({
+                        client,
+                        modelId: FAL_MODELS.videoFromImage,
+                        modality: "video",
+                        toolName: "generate_video_from_image",
+                        prompt,
+                        input: payload
+                    });
+                    if (waitForCompletion) return runStatusAction({
+                        job,
+                        action: "wait",
+                        includeLogs: true,
+                        client,
+                        timeoutMs: normalizeTimeoutMs(timeoutSeconds),
+                        pollIntervalMs: normalizePollIntervalMs(pollIntervalMs)
+                    });
+                    return toToolResult(job);
+                });
+                server.registerTool("fal_generation_status", {
+                    title: "FAL Generation Status",
+                    description: "Check, wait, cancel, or review FAL generation jobs. Use action=wait to poll until completion. Use action=accept/deny when review mode is enabled.",
+                    inputSchema: falGenerationStatusSchema
+                }, async ({ jobId, action, includeLogs, timeoutSeconds, pollIntervalMs, apiKey })=>{
+                    const existing = loadJobState(jobId);
+                    if (!existing) throw new Error(`Unknown FAL job "${jobId}". Submit a new generation first or check the job id.`);
+                    if ("accept" === action || "deny" === action) return runReviewDecision(existing, action);
+                    if ("check" === action && isTerminal(existing.status)) return toToolResult(existing);
+                    const resolvedApiKey = resolveFalApiKey(apiKey);
+                    const client = (0, _fal_ai_client__rspack_import_3.createFalClient)({
+                        credentials: resolvedApiKey
+                    });
+                    return runStatusAction({
+                        job: existing,
+                        action,
+                        includeLogs,
+                        client,
+                        timeoutMs: normalizeTimeoutMs(timeoutSeconds),
+                        pollIntervalMs: normalizePollIntervalMs(pollIntervalMs)
+                    });
+                });
+                function normalizeReviewMode(raw) {
+                    return raw?.trim().toLowerCase() === "hil" ? "hil" : "auto";
+                }
+                function parsePositiveInt(raw) {
+                    if (!raw) return null;
+                    const parsed = Number.parseInt(raw, 10);
+                    return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+                }
+                function normalizeTimeoutMs(timeoutSeconds) {
+                    if (timeoutSeconds && timeoutSeconds > 0) return 1000 * timeoutSeconds;
+                    return FAL_DEFAULT_STATUS_TIMEOUT_MS;
+                }
+                function normalizePollIntervalMs(interval) {
+                    if (interval && interval >= 250) return interval;
+                    return FAL_DEFAULT_POLL_INTERVAL_MS;
+                }
+                function resolveFalApiKey(override) {
+                    const candidate = override?.trim() || FAL_API_KEY_ENV;
+                    if (!candidate) throw new Error("FAL API key missing. Set FAL_API_KEY (or FAL_KEY) in MCP env, or pass apiKey in tool input.");
+                    return candidate;
+                }
+                function sanitizeJobId(value) {
+                    const normalized = (value || "").trim();
+                    if (!normalized) return (0, node_crypto__rspack_import_0.randomUUID)();
+                    const sanitized = normalized.replace(/[^a-zA-Z0-9._-]/g, "_");
+                    return sanitized.slice(0, 120) || (0, node_crypto__rspack_import_0.randomUUID)();
+                }
+                function buildJobPath(jobId) {
+                    return (0, node_path__rspack_import_2.join)(JOBS_DIR, `${sanitizeJobId(jobId)}.json`);
+                }
+                function loadJobState(jobId) {
+                    const normalized = sanitizeJobId(jobId);
+                    const cached = inMemoryJobs.get(normalized);
+                    if (cached) return cached;
+                    const path = buildJobPath(normalized);
+                    if (!(0, node_fs__rspack_import_1.existsSync)(path)) return null;
+                    try {
+                        const parsed = JSON.parse((0, node_fs__rspack_import_1.readFileSync)(path, "utf-8"));
+                        if (!parsed || "object" != typeof parsed) return null;
+                        inMemoryJobs.set(normalized, parsed);
+                        return parsed;
+                    } catch  {
+                        return null;
+                    }
+                }
+                function saveJobState(job) {
+                    const normalizedId = sanitizeJobId(job.jobId);
+                    const normalized = {
+                        ...job,
+                        jobId: normalizedId,
+                        updatedAt: new Date().toISOString()
+                    };
+                    (0, node_fs__rspack_import_1.mkdirSync)(JOBS_DIR, {
+                        recursive: true
+                    });
+                    (0, node_fs__rspack_import_1.writeFileSync)(buildJobPath(normalizedId), JSON.stringify(normalized, null, 2));
+                    inMemoryJobs.set(normalizedId, normalized);
+                    return normalized;
+                }
+                function mapQueueStatus(status) {
+                    switch(status){
+                        case "IN_QUEUE":
+                            return "in_queue";
+                        case "IN_PROGRESS":
+                            return "in_progress";
+                        case "COMPLETED":
+                            return "completed";
+                        default:
+                            return "failed";
+                    }
+                }
+                function isTerminal(status) {
+                    return "completed" === status || "failed" === status || "cancelled" === status || "awaiting_review" === status || "denied" === status;
+                }
+                function mergeModelInput(base, overrides) {
+                    if (!overrides || "object" != typeof overrides) return base;
+                    return {
+                        ...base,
+                        ...overrides
+                    };
+                }
+                async function resolveImageSourceToFalUrl(source, client) {
+                    const trimmed = source.trim();
+                    if (!trimmed) throw new Error("sourceImage cannot be empty.");
+                    if (/^https?:\/\//i.test(trimmed)) return trimmed;
+                    const inline = parseBase64DataUrl(trimmed);
+                    if (inline) {
+                        if (!inline.mimeType.startsWith("image/")) throw new Error(`Expected image data URL, got ${inline.mimeType}.`);
+                        const bytes = Buffer.from(inline.data, "base64");
+                        if (0 === bytes.length) throw new Error("sourceImage data URL is empty.");
+                        return uploadToFalStorage(client, bytes, inline.mimeType, "source-image");
+                    }
+                    const localPath = (0, _fal_runtime_js__rspack_import_7.resolveFalLocalMediaPath)(trimmed, FAL_WORKDIR);
+                    if (!(0, node_fs__rspack_import_1.existsSync)(localPath) || !(0, node_fs__rspack_import_1.statSync)(localPath).isFile()) throw new Error(`sourceImage must be a data URL, http(s) URL, or local file path: ${source}`);
+                    const bytes = (0, node_fs__rspack_import_1.readFileSync)(localPath);
+                    if (0 === bytes.length) throw new Error(`sourceImage file is empty: ${localPath}`);
+                    const mimeType = mimeTypeFromPath(localPath) || "image/png";
+                    if (!mimeType.startsWith("image/")) throw new Error(`sourceImage must be an image file, got ${mimeType}.`);
+                    return uploadToFalStorage(client, bytes, mimeType, (0, node_path__rspack_import_2.basename)(localPath));
+                }
+                async function uploadToFalStorage(client, bytes, mimeType, name) {
+                    const ext = extensionFromMimeType(mimeType);
+                    const blob = new Blob([
+                        bytes
+                    ], {
+                        type: mimeType
+                    });
+                    const file = new File([
+                        blob
+                    ], `${sanitizeName(name)}.${ext}`, {
+                        type: mimeType
+                    });
+                    return client.storage.upload(file, {
+                        lifecycle: {
+                            expiresIn: "1d"
+                        }
+                    });
+                }
+                async function submitFalJob(input) {
+                    const queued = await input.client.queue.submit(input.modelId, {
+                        input: input.input
+                    });
+                    const now = new Date().toISOString();
+                    const job = {
+                        jobId: sanitizeJobId(queued.request_id || (0, node_crypto__rspack_import_0.randomUUID)()),
+                        requestId: queued.request_id,
+                        toolName: input.toolName,
+                        modelId: input.modelId,
+                        modality: input.modality,
+                        prompt: input.prompt,
+                        status: mapQueueStatus(queued.status),
+                        reviewRequired: "hil" === FAL_REVIEW_MODE,
+                        reviewState: null,
+                        error: null,
+                        submittedAt: now,
+                        updatedAt: now,
+                        queueStatus: queued.status,
+                        queueStatusUrl: "string" == typeof queued.status_url ? queued.status_url : null,
+                        queueResponseUrl: "string" == typeof queued.response_url ? queued.response_url : null,
+                        queueCancelUrl: "string" == typeof queued.cancel_url ? queued.cancel_url : null,
+                        logs: [],
+                        media: [],
+                        rawResult: null
+                    };
+                    return saveJobState(job);
+                }
+                async function runStatusAction(input) {
+                    let job = input.job;
+                    if ("cancel" === input.action) {
+                        if (isTerminal(job.status)) return toToolResult(job);
+                        await input.client.queue.cancel(job.modelId, {
+                            requestId: job.requestId
+                        });
+                        job = saveJobState({
+                            ...job,
+                            status: "cancelled",
+                            error: null
+                        });
+                        return toToolResult(job);
+                    }
+                    const deadline = "wait" === input.action ? Date.now() + Math.max(1000, input.timeoutMs) : 0;
+                    for(;;){
+                        job = await refreshQueueStatus(job, input.client, input.includeLogs);
+                        if ("completed" === job.status) job = await materializeCompletedJob(job, input.client);
+                        if (isTerminal(job.status)) return toToolResult(job);
+                        if ("wait" !== input.action) return toToolResult(job);
+                        if (Date.now() >= deadline) return toToolResult(job);
+                        await sleep(input.pollIntervalMs);
+                    }
+                }
+                async function refreshQueueStatus(job, client, includeLogs) {
+                    const status = await client.queue.status(job.modelId, {
+                        requestId: job.requestId,
+                        logs: includeLogs
+                    });
+                    const statusWithLogs = status;
+                    const logs = includeLogs && Array.isArray(statusWithLogs.logs) ? statusWithLogs.logs.map((entry)=>"string" == typeof entry?.message ? entry.message : "").filter((entry)=>entry.trim().length > 0).slice(-FAL_DEFAULT_LOG_LIMIT) : job.logs;
+                    return saveJobState({
+                        ...job,
+                        status: mapQueueStatus(status.status),
+                        queueStatus: status.status,
+                        queueStatusUrl: "string" == typeof status.status_url ? status.status_url : null,
+                        queueResponseUrl: "string" == typeof status.response_url ? status.response_url : null,
+                        queueCancelUrl: "string" == typeof status.cancel_url ? status.cancel_url : null,
+                        logs
+                    });
+                }
+                async function materializeCompletedJob(job, client) {
+                    if (job.rawResult && job.media.length > 0) {
+                        if (job.reviewRequired && "pending" === job.reviewState) return saveJobState({
+                            ...job,
+                            status: "awaiting_review"
+                        });
+                        return saveJobState({
+                            ...job,
+                            status: "completed"
+                        });
+                    }
+                    try {
+                        const result = await client.queue.result(job.modelId, {
+                            requestId: job.requestId
+                        });
+                        const rawData = result?.data ?? null;
+                        const candidates = extractMediaCandidates(rawData, job.modality);
+                        const media = candidates.length > 0 ? await materializeMediaCandidates(job, candidates) : [];
+                        const nextStatus = job.reviewRequired && media.length > 0 ? "awaiting_review" : "completed";
+                        const reviewState = job.reviewRequired && media.length > 0 ? "pending" : media.length > 0 ? "accepted" : null;
+                        return saveJobState({
+                            ...job,
+                            status: nextStatus,
+                            reviewState,
+                            error: null,
+                            media,
+                            rawResult: rawData
+                        });
+                    } catch (error) {
+                        return saveJobState({
+                            ...job,
+                            status: "failed",
+                            error: errorToString(error)
+                        });
+                    }
+                }
+                async function materializeMediaCandidates(job, candidates) {
+                    const destinationRoot = job.reviewRequired ? (0, node_path__rspack_import_2.join)(PENDING_DIR, job.jobId) : resolveFinalOutputDir(job.modality);
+                    (0, node_fs__rspack_import_1.mkdirSync)(destinationRoot, {
+                        recursive: true
+                    });
+                    const records = [];
+                    for (const [index, candidate] of candidates.entries()){
+                        let bytes;
+                        let mimeType;
+                        try {
+                            const downloaded = await downloadRemoteFile(candidate.url);
+                            bytes = downloaded.bytes;
+                            mimeType = normalizeMimeType(downloaded.mimeType) || candidate.mimeType || "application/octet-stream";
+                        } catch  {
+                            continue;
+                        }
+                        const extension = extensionFromMimeType(mimeType) || extensionFromUrl(candidate.url);
+                        const hash = (0, node_crypto__rspack_import_0.createHash)("sha256").update(bytes).digest("hex").slice(0, 12);
+                        const filename = `${Date.now()}-${index + 1}-${hash}.${extension || "bin"}`;
+                        const outputPath = (0, node_path__rspack_import_2.join)(destinationRoot, filename);
+                        (0, node_fs__rspack_import_1.writeFileSync)(outputPath, bytes);
+                        records.push({
+                            id: `${job.jobId}-${index + 1}`,
+                            modality: classifyModality(candidate, mimeType),
+                            mimeType,
+                            remoteUrl: candidate.url,
+                            path: outputPath,
+                            name: candidate.label || filename,
+                            sizeBytes: bytes.length,
+                            createdAt: new Date().toISOString()
+                        });
+                    }
+                    return records;
+                }
+                function resolveFinalOutputDir(modality) {
+                    const folder = "image" === modality ? "images" : "audio" === modality ? "audio" : "video" === modality ? "video" : "files";
+                    const dir = (0, node_path__rspack_import_2.join)(FAL_OUTPUT_DIR, folder);
+                    (0, node_fs__rspack_import_1.mkdirSync)(dir, {
+                        recursive: true
+                    });
+                    return dir;
+                }
+                function runReviewDecision(job, decision) {
+                    if (true !== job.reviewRequired || "pending" !== job.reviewState) throw new Error(`Job ${job.jobId} is not waiting for review. Current reviewState=${job.reviewState || "none"}.`);
+                    if ("deny" === decision) {
+                        for (const media of job.media)if (media.path) try {
+                            (0, node_fs__rspack_import_1.unlinkSync)(media.path);
+                        } catch  {}
+                        try {
+                            (0, node_fs__rspack_import_1.rmSync)((0, node_path__rspack_import_2.join)(PENDING_DIR, job.jobId), {
+                                recursive: true,
+                                force: true
+                            });
+                        } catch  {}
+                        const denied = saveJobState({
+                            ...job,
+                            status: "denied",
+                            reviewState: "denied",
+                            media: job.media.map((entry)=>({
+                                    ...entry,
+                                    path: null
+                                }))
+                        });
+                        return toToolResult(denied);
+                    }
+                    const acceptedMedia = job.media.map((entry)=>{
+                        if (!entry.path) return entry;
+                        const targetDir = resolveFinalOutputDir(entry.modality);
+                        const targetPath = (0, node_path__rspack_import_2.join)(targetDir, (0, node_path__rspack_import_2.basename)(entry.path));
+                        moveFile(entry.path, targetPath);
+                        return {
+                            ...entry,
+                            path: targetPath
+                        };
+                    });
+                    try {
+                        (0, node_fs__rspack_import_1.rmSync)((0, node_path__rspack_import_2.join)(PENDING_DIR, job.jobId), {
+                            recursive: true,
+                            force: true
+                        });
+                    } catch  {}
+                    const accepted = saveJobState({
+                        ...job,
+                        status: "completed",
+                        reviewState: "accepted",
+                        media: acceptedMedia
+                    });
+                    return toToolResult(accepted);
+                }
+                function moveFile(sourcePath, targetPath) {
+                    try {
+                        (0, node_fs__rspack_import_1.renameSync)(sourcePath, targetPath);
+                        return;
+                    } catch  {
+                        (0, node_fs__rspack_import_1.copyFileSync)(sourcePath, targetPath);
+                        (0, node_fs__rspack_import_1.unlinkSync)(sourcePath);
+                    }
+                }
+                function extractMediaCandidates(payload, fallbackModality) {
+                    const output = [];
+                    const seen = new Set();
+                    const walk = (value, path, parent)=>{
+                        if (!value) return;
+                        if (Array.isArray(value)) {
+                            for (const item of value)walk(item, path, parent);
+                            return;
+                        }
+                        if ("string" == typeof value) {
+                            const trimmed = value.trim();
+                            if (!/^https?:\/\//i.test(trimmed)) return;
+                            if (seen.has(trimmed)) return;
+                            const hint = path[path.length - 1] || "";
+                            const mimeType = inferMimeTypeFromContext(trimmed, parent);
+                            if (!looksLikeMediaCandidate(trimmed, hint, mimeType)) return;
+                            seen.add(trimmed);
+                            output.push({
+                                url: trimmed,
+                                mimeType,
+                                modality: inferModalityFromHint(hint, mimeType, fallbackModality),
+                                label: buildCandidateLabel(path)
+                            });
+                            return;
+                        }
+                        if ("object" != typeof value) return;
+                        const record = value;
+                        for (const [key, nested] of Object.entries(record))walk(nested, [
+                            ...path,
+                            key
+                        ], record);
+                    };
+                    walk(payload, [], null);
+                    return output;
+                }
+                function looksLikeMediaCandidate(url, hint, mimeType) {
+                    if (mimeType) {
+                        if (mimeType.startsWith("image/") || mimeType.startsWith("audio/") || mimeType.startsWith("video/")) return true;
+                    }
+                    const normalizedHint = hint.toLowerCase();
+                    for (const fragment of [
+                        "image",
+                        "audio",
+                        "music",
+                        "video",
+                        "file",
+                        "media"
+                    ])if (normalizedHint.includes(fragment)) return true;
+                    const extension = extensionFromUrl(url).toLowerCase();
+                    return Boolean(mimeTypeFromExtension(extension));
+                }
+                function buildCandidateLabel(path) {
+                    if (0 === path.length) return;
+                    return sanitizeName(path.join("-")) || void 0;
+                }
+                function inferMimeTypeFromContext(url, parent) {
+                    if (parent) for (const key of [
+                        "mime_type",
+                        "mimeType",
+                        "content_type",
+                        "contentType"
+                    ]){
+                        const value = parent[key];
+                        if ("string" == typeof value && value.trim()) return normalizeMimeType(value);
+                    }
+                    const extension = extensionFromUrl(url);
+                    if (!extension) return;
+                    return mimeTypeFromExtension(extension) || void 0;
+                }
+                function inferModalityFromHint(hint, mimeType, fallback) {
+                    const normalizedHint = hint.toLowerCase();
+                    if (mimeType) {
+                        if (mimeType.startsWith("image/")) return "image";
+                        if (mimeType.startsWith("audio/")) return "audio";
+                        if (mimeType.startsWith("video/")) return "video";
+                    }
+                    if (normalizedHint.includes("image")) return "image";
+                    if (normalizedHint.includes("audio") || normalizedHint.includes("music")) return "audio";
+                    if (normalizedHint.includes("video")) return "video";
+                    return fallback;
+                }
+                function classifyModality(candidate, mimeType) {
+                    if (mimeType.startsWith("image/")) return "image";
+                    if (mimeType.startsWith("audio/")) return "audio";
+                    if (mimeType.startsWith("video/")) return "video";
+                    return candidate.modality;
+                }
+                async function downloadRemoteFile(url) {
+                    const response = await fetchWithTimeout(url, {
+                        method: "GET",
+                        headers: {
+                            "User-Agent": "wingman-mcp-fal-ai"
+                        }
+                    });
+                    if (!response.ok) throw new Error(`Failed to download media (${response.status}): ${url}`);
+                    const mimeType = normalizeMimeType(response.headers.get("content-type") || "");
+                    const arrayBuffer = await response.arrayBuffer();
+                    const bytes = Buffer.from(arrayBuffer);
+                    if (0 === bytes.length) throw new Error(`Downloaded media is empty: ${url}`);
+                    return {
+                        bytes,
+                        mimeType
+                    };
+                }
+                function parseBase64DataUrl(dataUrl) {
+                    const match = dataUrl.match(/^data:([^;,]+);base64,(.+)$/i);
+                    if (!match) return null;
+                    return {
+                        mimeType: normalizeMimeType(match[1]),
+                        data: match[2].trim()
+                    };
+                }
+                function extensionFromUrl(url) {
+                    try {
+                        const parsed = new URL(url);
+                        const extension = (0, node_path__rspack_import_2.extname)(parsed.pathname || "").replace(/^\./, "").toLowerCase();
+                        return extension;
+                    } catch  {
+                        return "";
+                    }
+                }
+                function normalizeMimeType(raw) {
+                    return raw.split(";")[0]?.trim().toLowerCase() || "";
+                }
+                function mimeTypeFromExtension(extension) {
+                    switch(extension.replace(/^\./, "").toLowerCase()){
+                        case "png":
+                            return "image/png";
+                        case "jpg":
+                        case "jpeg":
+                            return "image/jpeg";
+                        case "webp":
+                            return "image/webp";
+                        case "gif":
+                            return "image/gif";
+                        case "bmp":
+                            return "image/bmp";
+                        case "tif":
+                        case "tiff":
+                            return "image/tiff";
+                        case "avif":
+                            return "image/avif";
+                        case "mp3":
+                            return "audio/mpeg";
+                        case "wav":
+                            return "audio/wav";
+                        case "ogg":
+                            return "audio/ogg";
+                        case "m4a":
+                            return "audio/mp4";
+                        case "webm":
+                            return "video/webm";
+                        case "mp4":
+                            return "video/mp4";
+                        case "mov":
+                            return "video/quicktime";
+                        default:
+                            return null;
+                    }
+                }
+                function mimeTypeFromPath(pathname) {
+                    return mimeTypeFromExtension((0, node_path__rspack_import_2.extname)(pathname).replace(/^\./, ""));
+                }
+                function extensionFromMimeType(mimeType) {
+                    switch(normalizeMimeType(mimeType)){
+                        case "image/jpeg":
+                            return "jpg";
+                        case "image/png":
+                            return "png";
+                        case "image/webp":
+                            return "webp";
+                        case "image/gif":
+                            return "gif";
+                        case "image/bmp":
+                            return "bmp";
+                        case "image/tiff":
+                            return "tiff";
+                        case "image/avif":
+                            return "avif";
+                        case "audio/mpeg":
+                            return "mp3";
+                        case "audio/wav":
+                            return "wav";
+                        case "audio/ogg":
+                            return "ogg";
+                        case "audio/mp4":
+                            return "m4a";
+                        case "video/mp4":
+                            return "mp4";
+                        case "video/webm":
+                            return "webm";
+                        case "video/quicktime":
+                            return "mov";
+                        default:
+                            {
+                                const subtype = normalizeMimeType(mimeType).split("/")[1] || "";
+                                const sanitized = subtype.replace(/[^a-z0-9]/g, "");
+                                return sanitized || "bin";
+                            }
+                    }
+                }
+                function sanitizeName(value) {
+                    const normalized = (value || "").trim().toLowerCase();
+                    const sanitized = normalized.replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+                    return sanitized.slice(0, 80) || "asset";
+                }
+                function toGatewayFileUrl(pathname) {
+                    return `/api/fs/file?path=${encodeURIComponent(pathname)}`;
+                }
+                function buildStructuredImages(media) {
+                    return media.filter((entry)=>"image" === entry.modality).map((entry)=>({
+                            path: entry.path,
+                            url: entry.path ? toGatewayFileUrl(entry.path) : entry.remoteUrl,
+                            mimeType: entry.mimeType,
+                            name: entry.name
+                        }));
+                }
+                function toToolResult(job) {
+                    const summary = (0, _fal_summary_js__rspack_import_8.buildFalGenerationSummary)({
+                        toolName: job.toolName,
+                        jobId: job.jobId,
+                        status: job.status,
+                        modelId: job.modelId,
+                        reviewState: job.reviewState,
+                        media: job.media.map((entry)=>({
+                                modality: entry.modality,
+                                path: entry.path,
+                                remoteUrl: entry.remoteUrl,
+                                mimeType: entry.mimeType
+                            })),
+                        error: job.error,
+                        cwd: FAL_WORKDIR
+                    });
+                    const content = [
+                        {
+                            type: "text",
+                            text: summary
+                        }
+                    ];
+                    for (const media of job.media)if ("image" === media.modality && media.path) try {
+                        const bytes = (0, node_fs__rspack_import_1.readFileSync)(media.path);
+                        if (bytes.length > 0 && bytes.length <= 5242880) content.push({
+                            type: "image",
+                            data: bytes.toString("base64"),
+                            mimeType: media.mimeType || "image/png"
+                        });
+                    } catch  {}
+                    return {
+                        content,
+                        structuredContent: {
+                            jobId: job.jobId,
+                            requestId: job.requestId,
+                            toolName: job.toolName,
+                            modelId: job.modelId,
+                            modality: job.modality,
+                            status: job.status,
+                            reviewRequired: job.reviewRequired,
+                            reviewState: job.reviewState,
+                            error: job.error,
+                            submittedAt: job.submittedAt,
+                            updatedAt: job.updatedAt,
+                            queueStatus: job.queueStatus,
+                            queueStatusUrl: job.queueStatusUrl,
+                            queueResponseUrl: job.queueResponseUrl,
+                            queueCancelUrl: job.queueCancelUrl,
+                            logs: job.logs,
+                            images: buildStructuredImages(job.media),
+                            media: job.media.map((entry)=>({
+                                    id: entry.id,
+                                    modality: entry.modality,
+                                    mimeType: entry.mimeType,
+                                    name: entry.name,
+                                    path: entry.path,
+                                    url: entry.path ? toGatewayFileUrl(entry.path) : entry.remoteUrl,
+                                    remoteUrl: entry.remoteUrl,
+                                    sizeBytes: entry.sizeBytes,
+                                    createdAt: entry.createdAt
+                                }))
+                        }
+                    };
+                }
+                async function fetchWithTimeout(url, init, timeoutMs = FAL_HTTP_TIMEOUT_MS) {
+                    const controller = new AbortController();
+                    const timeout = setTimeout(()=>controller.abort(), Math.max(1000, timeoutMs));
+                    try {
+                        return await fetch(url, {
+                            ...init,
+                            signal: controller.signal
+                        });
+                    } finally{
+                        clearTimeout(timeout);
+                    }
+                }
+                function sleep(ms) {
+                    return new Promise((resolve)=>setTimeout(resolve, ms));
+                }
+                function errorToString(error) {
+                    if (error instanceof Error) return error.message;
+                    if ("string" == typeof error) return error;
+                    try {
+                        return JSON.stringify(error);
+                    } catch  {
+                        return String(error);
+                    }
+                }
+                (0, node_fs__rspack_import_1.mkdirSync)(FAL_STATE_DIR, {
+                    recursive: true
+                });
+                (0, node_fs__rspack_import_1.mkdirSync)(FAL_OUTPUT_DIR, {
+                    recursive: true
+                });
+                (0, node_fs__rspack_import_1.mkdirSync)(JOBS_DIR, {
+                    recursive: true
+                });
+                (0, node_fs__rspack_import_1.mkdirSync)(PENDING_DIR, {
+                    recursive: true
+                });
+                const transport = new _modelcontextprotocol_sdk_server_stdio_js__rspack_import_5.StdioServerTransport();
+                await server.connect(transport);
+                console.error([
+                    "wingman-mcp-fal-ai ready",
+                    `workdir=${FAL_WORKDIR}`,
+                    `stateDir=${FAL_STATE_DIR}`,
+                    `outputDir=${FAL_OUTPUT_DIR}`,
+                    `reviewMode=${FAL_REVIEW_MODE}`,
+                    `defaultImageModel=${FAL_MODELS.imageOrTexture}`
+                ].join(" | "));
+                __rspack_async_done();
+            } catch (e) {
+                __rspack_async_done(e);
+            }
+        }, 1);
+    },
+    "./fal/runtime.js" (module) {
+        module.exports = __rspack_external__fal_runtime_js_230694eb;
+    },
+    "./fal/summary.js" (module) {
+        module.exports = __rspack_external__fal_summary_js_64406a32;
+    },
+    "@fal-ai/client" (module) {
+        module.exports = __rspack_external__fal_ai_client_24ca7f48;
+    },
+    "@modelcontextprotocol/sdk/server/mcp.js" (module) {
+        module.exports = __rspack_external__modelcontextprotocol_sdk_server_mcp_js_2c42c5d0;
+    },
+    "@modelcontextprotocol/sdk/server/stdio.js" (module) {
+        module.exports = __rspack_external__modelcontextprotocol_sdk_server_stdio_js_4f861174;
+    },
+    "node:crypto" (module) {
+        module.exports = __rspack_external_node_crypto_9ba42079;
+    },
+    "node:fs" (module) {
+        module.exports = __rspack_external_node_fs_5ea92f0c;
+    },
+    "node:path" (module) {
+        module.exports = __rspack_external_node_path_c5b9b54f;
+    },
+    zod (module) {
+        module.exports = __rspack_external_zod;
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    var hasSymbol = "function" == typeof Symbol;
+    var rspackQueues = hasSymbol ? Symbol("rspack queues") : "__rspack_queues";
+    var rspackExports = __webpack_require__.aE = hasSymbol ? Symbol("rspack exports") : "__webpack_exports__";
+    var rspackError = hasSymbol ? Symbol("rspack error") : "__rspack_error";
+    var rspackDone = hasSymbol ? Symbol("rspack done") : "__rspack_done";
+    var rspackDefer = __webpack_require__.zS = hasSymbol ? Symbol("rspack defer") : "__rspack_defer";
+    var resolveQueue = (queue)=>{
+        if (queue && queue.d < 1) {
+            queue.d = 1;
+            queue.forEach((fn)=>fn.r--);
+            queue.forEach((fn)=>fn.r-- ? fn.r++ : fn());
+        }
+    };
+    var wrapDeps = (deps)=>deps.map((dep)=>{
+            if (null !== dep && "object" == typeof dep) {
+                if (!dep[rspackQueues] && dep[rspackDefer]) {
+                    var asyncDeps = dep[rspackDefer];
+                    var hasUnresolvedAsyncSubgraph = asyncDeps.some((id)=>{
+                        var cache = __webpack_module_cache__[id];
+                        return !cache || false === cache[rspackDone];
+                    });
+                    if (!hasUnresolvedAsyncSubgraph) return dep;
+                    var d = dep;
+                    dep = {
+                        then (callback) {
+                            Promise.all(asyncDeps.map(__webpack_require__)).then(()=>callback(d));
+                        }
+                    };
+                }
+                if (dep[rspackQueues]) return dep;
+                if (dep.then) {
+                    var queue = [];
+                    queue.d = 0;
+                    dep.then((r)=>{
+                        obj[rspackExports] = r;
+                        resolveQueue(queue);
+                    }, (e)=>{
+                        obj[rspackError] = e;
+                        resolveQueue(queue);
+                    });
+                    var obj = {};
+                    obj[rspackDefer] = false;
+                    obj[rspackQueues] = (fn)=>fn(queue);
+                    return obj;
+                }
+            }
+            var ret = {};
+            ret[rspackQueues] = ()=>{};
+            ret[rspackExports] = dep;
+            return ret;
+        });
+    __webpack_require__.a = (module, body, hasAwait)=>{
+        var queue;
+        hasAwait && ((queue = []).d = -1);
+        var depQueues = new Set();
+        var exports = module.exports;
+        var currentDeps;
+        var outerResolve;
+        var reject;
+        var promise = new Promise((resolve, rej)=>{
+            reject = rej;
+            outerResolve = resolve;
+        });
+        promise[rspackExports] = exports;
+        promise[rspackQueues] = (fn)=>{
+            queue && fn(queue), depQueues.forEach(fn), promise["catch"](()=>{});
+        };
+        module.exports = promise;
+        var handle = (deps)=>{
+            currentDeps = wrapDeps(deps);
+            var fn;
+            var getResult = ()=>currentDeps.map((d)=>{
+                    if (d[rspackDefer]) return d;
+                    if (d[rspackError]) throw d[rspackError];
+                    return d[rspackExports];
+                });
+            var promise = new Promise((resolve)=>{
+                fn = ()=>resolve(getResult);
+                fn.r = 0;
+                var fnQueue = (q)=>q !== queue && !depQueues.has(q) && (depQueues.add(q), q && !q.d && (fn.r++, q.push(fn)));
+                currentDeps.map((dep)=>dep[rspackDefer] || dep[rspackQueues](fnQueue));
+            });
+            return fn.r ? promise : getResult();
+        };
+        var done = (err)=>(err ? reject(promise[rspackError] = err) : outerResolve(exports), resolveQueue(queue), promise[rspackDone] = true);
+        body(handle, done);
+        queue && queue.d < 0 && (queue.d = 0);
+    };
+})();
+(()=>{
+    __webpack_require__.r = (exports)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports, '__esModule', {
+            value: true
+        });
+    };
+})();
+__webpack_require__("./src/tools/mcp-fal-ai.ts");