@wingman-ai/gateway 0.4.2 → 0.4.3

package/dist/tests/terminal-bench-official.test.js

@@ -0,0 +1,188 @@
+import { describe, expect, it } from "vitest";
+import { buildHarborRunArgs, buildPythonPathEnv, buildRuntimePathEnv, createDockerShimScript, extractHarborErrorMessage, isMissingComposeProviderError, isPodmanBackedDockerVersionOutput, normalizeHarborFailureMessage, parseDockerHostCandidate, parseHarborRunOutput } from "../bench/official.js";
+describe("terminal bench official runner (harbor tb2)", ()=>{
+    it("builds harbor args with overrides", ()=>{
+        const args = buildHarborRunArgs({
+            dataset: "terminal-bench@2.0",
+            taskNames: [
+                "a",
+                "b"
+            ],
+            agent: "oracle",
+            nConcurrent: 1,
+            nAttempts: 1
+        }, {
+            taskNames: [
+                "single"
+            ],
+            agent: "codex",
+            nConcurrent: 2,
+            nAttempts: 3,
+            nTasks: 2,
+            model: "openai/gpt-4.1-mini",
+            agentKwargs: {
+                foo: "bar"
+            }
+        });
+        expect(args).toEqual([
+            "run",
+            "--dataset",
+            "terminal-bench@2.0",
+            "--agent",
+            "codex",
+            "--model",
+            "openai/gpt-4.1-mini",
+            "--n-concurrent",
+            "2",
+            "--n-attempts",
+            "3",
+            "--n-tasks",
+            "2",
+            "--agent-kwarg",
+            "foo=bar",
+            "--task-name",
+            "single"
+        ]);
+    });
+    it("builds harbor args with explicit registry url", ()=>{
+        const args = buildHarborRunArgs({
+            dataset: "terminal-bench@2.0",
+            registryUrl: "https://raw.githubusercontent.com/laude-institute/harbor/main/registry.json?source=wingman",
+            agent: "oracle"
+        }, {});
+        expect(args).toEqual([
+            "run",
+            "--dataset",
+            "terminal-bench@2.0",
+            "--registry-url",
+            "https://raw.githubusercontent.com/laude-institute/harbor/main/registry.json?source=wingman",
+            "--agent",
+            "oracle"
+        ]);
+    });
+    it("builds harbor args without task names when running all dataset tasks", ()=>{
+        const args = buildHarborRunArgs({
+            dataset: "terminal-bench@2.0",
+            agent: "oracle",
+            nConcurrent: 1
+        }, {
+            taskNames: []
+        });
+        expect(args).toEqual([
+            "run",
+            "--dataset",
+            "terminal-bench@2.0",
+            "--agent",
+            "oracle",
+            "--n-concurrent",
+            "1"
+        ]);
+    });
+    it("builds harbor args with custom import-path agent", ()=>{
+        const args = buildHarborRunArgs({
+            dataset: "terminal-bench@2.0",
+            taskNames: [
+                "hello-world"
+            ],
+            agent: "oracle",
+            agentImportPath: "my_pkg.my_agent:MyAgent",
+            agentKwargs: {
+                wingman_agent: "coding",
+                model_name: "should-not-pass"
+            },
+            nConcurrent: 1
+        }, {
+            agentKwargs: {
+                wingman_cli_path: "./bin/wingman"
+            }
+        });
+        expect(args).toEqual([
+            "run",
+            "--dataset",
+            "terminal-bench@2.0",
+            "--agent-import-path",
+            "my_pkg.my_agent:MyAgent",
+            "--n-concurrent",
+            "1",
+            "--agent-kwarg",
+            "wingman_agent=coding",
+            "--agent-kwarg",
+            "wingman_cli_path=./bin/wingman",
+            "--task-name",
+            "hello-world"
+        ]);
+    });
+    it("parses resolved/unresolved/accuracy and pass@k", ()=>{
+        const parsed = parseHarborRunOutput(`
+│ Resolved Trials   │ 1        │
+│ Unresolved Trials │ 1        │
+│ Accuracy          │ 50.00%   │
+│ Pass@1            │ 50.00%   │
+Results saved to /tmp/harbor/runs/run-1
+`);
+        expect(parsed.resolvedTrials).toBe(1);
+        expect(parsed.unresolvedTrials).toBe(1);
+        expect(parsed.accuracyPercent).toBe(50);
+        expect(parsed.passAtK["1"]).toBe(50);
+        expect(parsed.runOutputPath).toBe("/tmp/harbor/runs/run-1");
+    });
+    it("builds a docker shim script and path for podman fallback", ()=>{
+        const script = createDockerShimScript("/usr/local/bin/podman");
+        expect(script).toContain("TARGET_BINARY='/usr/local/bin/podman'");
+        expect(script).toContain("exec podman-compose");
+        expect(script).toContain("exec podman cp");
+        expect(script).toContain("exec podman exec");
+        expect(script).toContain("label=com.docker.compose.project");
+        expect(script).toContain("--project-directory");
+        expect(script.startsWith("#!/bin/bash")).toBe(true);
+        expect(buildRuntimePathEnv("/tmp/runtime-bin", "/usr/bin")).toBe("/tmp/runtime-bin:/usr/bin");
+        expect(buildPythonPathEnv("/tmp/repo", "/usr/lib/python")).toBe("/tmp/repo:/usr/lib/python");
+    });
+    it("extracts a concise harbor error message", ()=>{
+        const message = extractHarborErrorMessage(`
+Traceback...
+ValueError: No tasks found matching pattern: jq-data-processing
+`);
+        expect(message).toBe("ValueError: No tasks found matching pattern: jq-data-processing");
+    });
+    it("extracts a specific dataset resolution error over generic fallback", ()=>{
+        const message = extractHarborErrorMessage(`
+Traceback...
+ValueError: Error getting dataset terminal-bench@2.0
+ValueError: Either datasets or tasks must be provided.
+`);
+        expect(message).toBe("ValueError: Error getting dataset terminal-bench@2.0");
+    });
+    it("rewrites generic empty-task selection error", ()=>{
+        const message = normalizeHarborFailureMessage({
+            rawMessage: "ValueError: Either datasets or tasks must be provided.",
+            args: [
+                "run",
+                "--dataset",
+                "terminal-bench@2.0",
+                "--task-name",
+                "heterogeneous-dates"
+            ],
+            dataset: "terminal-bench@2.0"
+        });
+        expect(message).toBe('No tasks matched "heterogeneous-dates" in dataset "terminal-bench@2.0". Verify task ids for Terminal-Bench 2.0.');
+    });
+    it("normalizes podman docker host candidates", ()=>{
+        expect(parseDockerHostCandidate("unix:///tmp/podman.sock")).toBe("unix:///tmp/podman.sock");
+        expect(parseDockerHostCandidate("/tmp/podman.sock")).toBe("unix:///tmp/podman.sock");
+        expect(parseDockerHostCandidate("'unix:///tmp/podman.sock'")).toBe("unix:///tmp/podman.sock");
+        expect(parseDockerHostCandidate("<nil>")).toBeUndefined();
+        expect(parseDockerHostCandidate(void 0)).toBeUndefined();
+    });
+    it("detects missing compose provider errors", ()=>{
+        expect(isMissingComposeProviderError(`
+Error: looking up compose provider failed
+* exec: "podman-compose": executable file not found in $PATH
+`)).toBe(true);
+        expect(isMissingComposeProviderError("some other error")).toBe(false);
+    });
+    it("detects podman-backed docker version output", ()=>{
+        expect(isPodmanBackedDockerVersionOutput("Emulate Docker CLI using podman")).toBe(true);
+        expect(isPodmanBackedDockerVersionOutput("Docker version 27.0.0")).toBe(false);
+    });
+});

package/dist/tests/terminal-bench-runner.test.cjs

@@ -0,0 +1,82 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_os_namespaceObject = require("node:os");
+const external_node_path_namespaceObject = require("node:path");
+const external_vitest_namespaceObject = require("vitest");
+const runner_cjs_namespaceObject = require("../bench/runner.cjs");
+(0, external_vitest_namespaceObject.describe)("terminal bench runner", ()=>{
+    const workdirs = [];
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        for (const workdir of workdirs)(0, external_node_fs_namespaceObject.rmSync)(workdir, {
+            recursive: true,
+            force: true
+        });
+        workdirs.length = 0;
+    });
+    (0, external_vitest_namespaceObject.it)("runs tasks with command adapter and writes artifacts", async ()=>{
+        const workdir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-bench-runner-"));
+        workdirs.push(workdir);
+        const benchmarkDir = (0, external_node_path_namespaceObject.join)(workdir, "bench");
+        const tasksDir = (0, external_node_path_namespaceObject.join)(benchmarkDir, "tasks");
+        const sandboxDir = (0, external_node_path_namespaceObject.join)(benchmarkDir, "sandbox");
+        (0, external_node_fs_namespaceObject.mkdirSync)(tasksDir, {
+            recursive: true
+        });
+        (0, external_node_fs_namespaceObject.mkdirSync)(sandboxDir, {
+            recursive: true
+        });
+        (0, external_node_fs_namespaceObject.writeFileSync)((0, external_node_path_namespaceObject.join)(tasksDir, "suite.json"), JSON.stringify({
+            tasks: [
+                {
+                    id: "write-output",
+                    prompt: "FILE_OK",
+                    workingDirectory: "sandbox",
+                    setup: [
+                        {
+                            command: "rm",
+                            args: [
+                                "-f",
+                                "output.txt"
+                            ]
+                        }
+                    ],
+                    validator: {
+                        type: "file_contains",
+                        path: "output.txt",
+                        includes: [
+                            "FILE_OK"
+                        ]
+                    }
+                }
+            ]
+        }, null, 2));
+        (0, external_node_fs_namespaceObject.writeFileSync)((0, external_node_path_namespaceObject.join)(benchmarkDir, "config.json"), JSON.stringify({
+            taskFile: "tasks/suite.json",
+            resultsDir: "results",
+            adapter: {
+                type: "command",
+                command: {
+                    command: "sh",
+                    args: [
+                        "-lc",
+                        "printf '%s\\n' \"$WINGMAN_BENCH_PROMPT\" > output.txt; echo COMPLETE"
+                    ]
+                }
+            }
+        }, null, 2));
+        const summary = await (0, runner_cjs_namespaceObject.runTerminalBench)({
+            configPath: (0, external_node_path_namespaceObject.join)(benchmarkDir, "config.json")
+        });
+        (0, external_vitest_namespaceObject.expect)(summary.metrics.totalTasks).toBe(1);
+        (0, external_vitest_namespaceObject.expect)(summary.metrics.passedTasks).toBe(1);
+        (0, external_vitest_namespaceObject.expect)(summary.metrics.failedTasks).toBe(0);
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)((0, external_node_path_namespaceObject.join)(summary.resultsDir, "summary.json"))).toBe(true);
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)((0, external_node_path_namespaceObject.join)(summary.resultsDir, "write-output.assistant.txt"))).toBe(true);
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.readFileSync)((0, external_node_path_namespaceObject.join)(sandboxDir, "output.txt"), "utf-8")).toContain("FILE_OK");
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/terminal-bench-runner.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/terminal-bench-runner.test.js

@@ -0,0 +1,76 @@
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { runTerminalBench } from "../bench/runner.js";
+describe("terminal bench runner", ()=>{
+    const workdirs = [];
+    afterEach(()=>{
+        for (const workdir of workdirs)rmSync(workdir, {
+            recursive: true,
+            force: true
+        });
+        workdirs.length = 0;
+    });
+    it("runs tasks with command adapter and writes artifacts", async ()=>{
+        const workdir = mkdtempSync(join(tmpdir(), "wingman-bench-runner-"));
+        workdirs.push(workdir);
+        const benchmarkDir = join(workdir, "bench");
+        const tasksDir = join(benchmarkDir, "tasks");
+        const sandboxDir = join(benchmarkDir, "sandbox");
+        mkdirSync(tasksDir, {
+            recursive: true
+        });
+        mkdirSync(sandboxDir, {
+            recursive: true
+        });
+        writeFileSync(join(tasksDir, "suite.json"), JSON.stringify({
+            tasks: [
+                {
+                    id: "write-output",
+                    prompt: "FILE_OK",
+                    workingDirectory: "sandbox",
+                    setup: [
+                        {
+                            command: "rm",
+                            args: [
+                                "-f",
+                                "output.txt"
+                            ]
+                        }
+                    ],
+                    validator: {
+                        type: "file_contains",
+                        path: "output.txt",
+                        includes: [
+                            "FILE_OK"
+                        ]
+                    }
+                }
+            ]
+        }, null, 2));
+        writeFileSync(join(benchmarkDir, "config.json"), JSON.stringify({
+            taskFile: "tasks/suite.json",
+            resultsDir: "results",
+            adapter: {
+                type: "command",
+                command: {
+                    command: "sh",
+                    args: [
+                        "-lc",
+                        "printf '%s\\n' \"$WINGMAN_BENCH_PROMPT\" > output.txt; echo COMPLETE"
+                    ]
+                }
+            }
+        }, null, 2));
+        const summary = await runTerminalBench({
+            configPath: join(benchmarkDir, "config.json")
+        });
+        expect(summary.metrics.totalTasks).toBe(1);
+        expect(summary.metrics.passedTasks).toBe(1);
+        expect(summary.metrics.failedTasks).toBe(0);
+        expect(existsSync(join(summary.resultsDir, "summary.json"))).toBe(true);
+        expect(existsSync(join(summary.resultsDir, "write-output.assistant.txt"))).toBe(true);
+        expect(readFileSync(join(sandboxDir, "output.txt"), "utf-8")).toContain("FILE_OK");
+    });
+});

package/dist/tests/terminal-bench-scoring.test.cjs

@@ -0,0 +1,128 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_os_namespaceObject = require("node:os");
+const external_node_path_namespaceObject = require("node:path");
+const external_vitest_namespaceObject = require("vitest");
+const scoring_cjs_namespaceObject = require("../bench/scoring.cjs");
+function createTask(id, status, durationMs) {
+    return {
+        taskId: id,
+        status,
+        workingDirectory: "/tmp",
+        prompt: "prompt",
+        startedAt: new Date().toISOString(),
+        endedAt: new Date().toISOString(),
+        durationMs,
+        setup: {
+            runCount: 0
+        },
+        adapter: {
+            exitCode: "passed" === status ? 0 : 1,
+            timedOut: false,
+            durationMs,
+            stdout: "",
+            stderr: "",
+            assistantText: "ok",
+            tokens: {
+                inputTokens: 100,
+                outputTokens: 200,
+                totalTokens: 300
+            }
+        },
+        validator: {
+            passed: "passed" === status,
+            details: status
+        },
+        artifacts: {
+            stdoutFile: "stdout.log",
+            stderrFile: "stderr.log",
+            assistantFile: "assistant.txt",
+            recordFile: "record.json"
+        }
+    };
+}
+function createConfig(workdir) {
+    return {
+        version: 1,
+        configPath: (0, external_node_path_namespaceObject.join)(workdir, "config.json"),
+        taskFilePath: (0, external_node_path_namespaceObject.join)(workdir, "tasks.json"),
+        resultsDir: (0, external_node_path_namespaceObject.join)(workdir, "results"),
+        run: {
+            defaultTimeoutMs: 10000,
+            continueOnFailure: true
+        },
+        adapter: {
+            type: "command",
+            command: {
+                command: "echo"
+            }
+        },
+        tasks: [],
+        scoring: {
+            weights: {
+                passRate: 0.8,
+                reliability: 0.2,
+                duration: 0,
+                cost: 0
+            },
+            budgets: {},
+            pricing: {
+                inputPer1kTokensUsd: 0.001,
+                outputPer1kTokensUsd: 0.002
+            }
+        },
+        qualityGate: {
+            enabled: true,
+            baselineFile: (0, external_node_path_namespaceObject.join)(workdir, "baseline.json"),
+            minPassRateDelta: -0.1,
+            maxCostIncreaseRatio: 1,
+            maxAvgDurationIncreaseRatio: 1
+        },
+        metadata: {}
+    };
+}
+(0, external_vitest_namespaceObject.describe)("terminal bench scoring", ()=>{
+    const workdirs = [];
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        for (const workdir of workdirs)(0, external_node_fs_namespaceObject.rmSync)(workdir, {
+            recursive: true,
+            force: true
+        });
+        workdirs.length = 0;
+    });
+    (0, external_vitest_namespaceObject.it)("computes summary metrics and applies quality gate", async ()=>{
+        const workdir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-bench-score-"));
+        workdirs.push(workdir);
+        const baseline = {
+            metrics: {
+                passRate: 1,
+                totalCostUsd: 0.001,
+                avgDurationMs: 100
+            }
+        };
+        (0, external_node_fs_namespaceObject.writeFileSync)((0, external_node_path_namespaceObject.join)(workdir, "baseline.json"), JSON.stringify(baseline));
+        const summary = await (0, scoring_cjs_namespaceObject.buildTerminalBenchSummary)({
+            runId: "run-1",
+            startedAt: new Date().toISOString(),
+            endedAt: new Date().toISOString(),
+            config: createConfig(workdir),
+            resultsDir: (0, external_node_path_namespaceObject.join)(workdir, "results", "run-1"),
+            tasks: [
+                createTask("a", "passed", 100),
+                createTask("b", "failed", 200)
+            ]
+        });
+        (0, external_vitest_namespaceObject.expect)(summary.metrics.totalTasks).toBe(2);
+        (0, external_vitest_namespaceObject.expect)(summary.metrics.passedTasks).toBe(1);
+        (0, external_vitest_namespaceObject.expect)(summary.metrics.passRate).toBeCloseTo(0.5);
+        (0, external_vitest_namespaceObject.expect)(summary.metrics.totalTokens).toBe(600);
+        (0, external_vitest_namespaceObject.expect)(summary.metrics.totalCostUsd).toBeCloseTo(0.001);
+        (0, external_vitest_namespaceObject.expect)(summary.qualityGate.passed).toBe(false);
+        (0, external_vitest_namespaceObject.expect)(summary.qualityGate.messages.length).toBeGreaterThan(0);
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/terminal-bench-scoring.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/terminal-bench-scoring.test.js

@@ -0,0 +1,122 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { buildTerminalBenchSummary } from "../bench/scoring.js";
+function createTask(id, status, durationMs) {
+    return {
+        taskId: id,
+        status,
+        workingDirectory: "/tmp",
+        prompt: "prompt",
+        startedAt: new Date().toISOString(),
+        endedAt: new Date().toISOString(),
+        durationMs,
+        setup: {
+            runCount: 0
+        },
+        adapter: {
+            exitCode: "passed" === status ? 0 : 1,
+            timedOut: false,
+            durationMs,
+            stdout: "",
+            stderr: "",
+            assistantText: "ok",
+            tokens: {
+                inputTokens: 100,
+                outputTokens: 200,
+                totalTokens: 300
+            }
+        },
+        validator: {
+            passed: "passed" === status,
+            details: status
+        },
+        artifacts: {
+            stdoutFile: "stdout.log",
+            stderrFile: "stderr.log",
+            assistantFile: "assistant.txt",
+            recordFile: "record.json"
+        }
+    };
+}
+function createConfig(workdir) {
+    return {
+        version: 1,
+        configPath: join(workdir, "config.json"),
+        taskFilePath: join(workdir, "tasks.json"),
+        resultsDir: join(workdir, "results"),
+        run: {
+            defaultTimeoutMs: 10000,
+            continueOnFailure: true
+        },
+        adapter: {
+            type: "command",
+            command: {
+                command: "echo"
+            }
+        },
+        tasks: [],
+        scoring: {
+            weights: {
+                passRate: 0.8,
+                reliability: 0.2,
+                duration: 0,
+                cost: 0
+            },
+            budgets: {},
+            pricing: {
+                inputPer1kTokensUsd: 0.001,
+                outputPer1kTokensUsd: 0.002
+            }
+        },
+        qualityGate: {
+            enabled: true,
+            baselineFile: join(workdir, "baseline.json"),
+            minPassRateDelta: -0.1,
+            maxCostIncreaseRatio: 1,
+            maxAvgDurationIncreaseRatio: 1
+        },
+        metadata: {}
+    };
+}
+describe("terminal bench scoring", ()=>{
+    const workdirs = [];
+    afterEach(()=>{
+        for (const workdir of workdirs)rmSync(workdir, {
+            recursive: true,
+            force: true
+        });
+        workdirs.length = 0;
+    });
+    it("computes summary metrics and applies quality gate", async ()=>{
+        const workdir = mkdtempSync(join(tmpdir(), "wingman-bench-score-"));
+        workdirs.push(workdir);
+        const baseline = {
+            metrics: {
+                passRate: 1,
+                totalCostUsd: 0.001,
+                avgDurationMs: 100
+            }
+        };
+        writeFileSync(join(workdir, "baseline.json"), JSON.stringify(baseline));
+        const summary = await buildTerminalBenchSummary({
+            runId: "run-1",
+            startedAt: new Date().toISOString(),
+            endedAt: new Date().toISOString(),
+            config: createConfig(workdir),
+            resultsDir: join(workdir, "results", "run-1"),
+            tasks: [
+                createTask("a", "passed", 100),
+                createTask("b", "failed", 200)
+            ]
+        });
+        expect(summary.metrics.totalTasks).toBe(2);
+        expect(summary.metrics.passedTasks).toBe(1);
+        expect(summary.metrics.passRate).toBeCloseTo(0.5);
+        expect(summary.metrics.totalTokens).toBe(600);
+        expect(summary.metrics.totalCostUsd).toBeCloseTo(0.001);
+        expect(summary.qualityGate.passed).toBe(false);
+        expect(summary.qualityGate.messages.length).toBeGreaterThan(0);
+    });
+});

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

@@ -20,7 +20,7 @@ var __webpack_modules__ = {
                 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",
+                    imageOrTexture: process.env.FAL_MODEL_IMAGE_OR_TEXTURE?.trim() || "fal-ai/nano-banana-2",
                     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",

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

@@ -28,7 +28,7 @@ var __webpack_modules__ = {
                 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",
+                    imageOrTexture: process.env.FAL_MODEL_IMAGE_OR_TEXTURE?.trim() || "fal-ai/nano-banana-2",
                     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",