@fusionkit/cli 0.1.4 → 0.1.6

package/dist/fusion/stack.js

@@ -0,0 +1,295 @@
+/**
+ * The fusion model stack: the single `fusionkit serve` router that fronts every
+ * panel model plus synthesis, and the in-process gateway that turns it into the
+ * judge-streamed-trajectory front door.
+ */
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { MlxBackend, startGateway } from "@fusionkit/model-gateway";
+import { startFusionStepGateway } from "../gateway.js";
+import { createPortlessSession } from "../shared/portless.js";
+import { freePort, spawnLogged, terminate, waitForHttp } from "../shared/proc.js";
+import { defaultKeyEnv, fusionkitPyCommand, loadEnvFileInto } from "./env.js";
+/**
+ * Heuristic: does the captured output indicate a permanent failure (bad key,
+ * inaccessible model) that a retry cannot fix? Used to fail fast with a clear
+ * message instead of burning the retry budget on a hopeless start.
+ */
+function looksPermanentFailure(log) {
+    return /401|403|invalid[ _-]?api[ _-]?key|unauthorized|forbidden|authentication|permission|model[^\n]*(not found|does not exist)|no such model|model_not_found/i.test(log);
+}
+/**
+ * Default provider base URL when a cloud spec carries no explicit `baseUrl`.
+ * fusionkit's `ModelEndpoint` requires `base_url`, so the router config must
+ * always set it (the `serve-endpoint` shim filled this in for us before). Mirrors
+ * `PROVIDER_DEFAULT_BASE_URL` in fusionkit's openai_endpoint.py.
+ */
+function providerDefaultBaseUrl(provider) {
+    switch (provider) {
+        case "openai":
+            return "https://api.openai.com";
+        case "anthropic":
+            return "https://api.anthropic.com";
+        case "google":
+            return "https://generativelanguage.googleapis.com";
+        case "openai-compatible":
+            return "http://127.0.0.1";
+        default: {
+            const exhaustive = provider;
+            throw new Error(`unknown provider ${String(exhaustive)}`);
+        }
+    }
+}
+/** Pick the panel spec that backs the judge (by model name), else the first. */
+function judgeSpecFor(specs, judgeModel) {
+    const first = specs[0];
+    if (first === undefined)
+        throw new Error("at least one panel model is required");
+    if (judgeModel === undefined)
+        return first;
+    return specs.find((spec) => spec.model === judgeModel) ?? first;
+}
+/**
+ * Build the `fusionkit serve` config (YAML) for the consolidated router: one
+ * endpoint per panel model. Cloud models call their provider directly (keyed by
+ * `api_key_env`); MLX models are fronted as `openai-compatible` endpoints
+ * pointing at their in-process gateway loopback URL. The judge endpoint doubles
+ * as the synthesizer. Values are JSON-quoted (valid YAML flow scalars).
+ */
+function routerConfigYaml(input) {
+    const lines = ["endpoints:"];
+    for (const spec of input.specs) {
+        const provider = spec.provider ?? "mlx";
+        lines.push(`  - id: ${JSON.stringify(spec.id)}`);
+        lines.push(`    model: ${JSON.stringify(spec.model)}`);
+        if (provider === "mlx") {
+            lines.push("    provider: openai-compatible");
+            lines.push(`    base_url: ${JSON.stringify(input.mlxUrls[spec.id] ?? "")}`);
+            lines.push("    api_key: not-needed");
+        }
+        else {
+            // `base_url` is required by fusionkit's ModelEndpoint, so always emit one
+            // (the spec's, or the provider default).
+            const baseUrl = spec.baseUrl ?? providerDefaultBaseUrl(provider);
+            lines.push(`    provider: ${provider}`);
+            lines.push(`    base_url: ${JSON.stringify(baseUrl)}`);
+            const keyEnv = spec.keyEnv ?? defaultKeyEnv(provider);
+            if (keyEnv !== undefined)
+                lines.push(`    api_key_env: ${JSON.stringify(keyEnv)}`);
+        }
+    }
+    lines.push(`default_model: ${JSON.stringify(input.judgeId)}`);
+    lines.push(`judge_model: ${JSON.stringify(input.judgeId)}`);
+    lines.push(`synthesizer_model: ${JSON.stringify(input.judgeId)}`);
+    // Generous budget: reasoning models (gpt-5.x) spend tokens on reasoning before
+    // producing content, so a small cap can yield an empty answer.
+    lines.push("sampling: {temperature: 0.2, top_p: 0.9, max_tokens: 8192}");
+    lines.push("");
+    return lines.join("\n");
+}
+/**
+ * Spawn the single `fusionkit serve` router fronting every panel model + the
+ * synthesizer. MLX specs first get an in-process OpenAI-compatible gateway
+ * (loopback) that the router proxies to; cloud specs call their provider
+ * directly. Returns the router URL, an id->routerUrl endpoint map, and a close
+ * that tears down the router process and any MLX gateways it fronts.
+ */
+export async function startRouter(options) {
+    const { specs, report } = options;
+    const judgeSpec = judgeSpecFor(specs, options.judgeModel);
+    const models = specs.map((spec) => ({ id: spec.id, model: spec.model }));
+    const identity = specs.map((spec) => spec.id).sort().join(",");
+    const announceStart = (label) => {
+        if (report)
+            report({ kind: "server.start", id: "router", label });
+        else
+            options.log(`fusion: starting ${label}...`);
+    };
+    const announceReady = (detail) => {
+        if (report)
+            report({ kind: "server.ready", id: "router", detail });
+        else
+            options.log(`fusion: router ready on ${detail}`);
+    };
+    announceStart(`router · ${specs.map((spec) => spec.id).join(", ")}`);
+    // The router inherits the parent env plus the FusionKit checkout's `.env` (so
+    // provider keys load seamlessly), without overriding anything already exported.
+    // It calls providers directly and MLX over loopback (never a portless HTTPS
+    // URL), so it needs no portless CA — and must keep its default certifi bundle
+    // intact to verify real provider certificates.
+    const env = { ...process.env };
+    if (options.fusionkitDir !== undefined) {
+        loadEnvFileInto(join(options.fusionkitDir, ".env"), env);
+    }
+    const backends = [];
+    const gateways = [];
+    const mlxUrls = {};
+    const closeBackends = async () => {
+        await Promise.allSettled(gateways.map((gateway) => gateway.close()));
+        await Promise.allSettled(backends.map((backend) => backend.stop()));
+    };
+    try {
+        // MLX backends are memory-heavy (each loads a model into RAM), so they start
+        // sequentially before the router that fronts them.
+        for (const spec of specs) {
+            if ((spec.provider ?? "mlx") !== "mlx")
+                continue;
+            const backend = new MlxBackend({ model: spec.model });
+            await backend.start();
+            const gateway = await startGateway({ backend });
+            backends.push(backend);
+            gateways.push(gateway);
+            mlxUrls[spec.id] = gateway.url();
+        }
+        const config = routerConfigYaml({ specs, mlxUrls, judgeId: judgeSpec.id });
+        const configDir = mkdtempSync(join(tmpdir(), "fusion-router-"));
+        const configPath = join(configDir, "router.yaml");
+        writeFileSync(configPath, config);
+        const runner = fusionkitPyCommand(options.fusionkitDir);
+        const port = await freePort();
+        const proc = spawnLogged(runner.command, [...runner.prefix, "serve", "--config", configPath, "--host", "127.0.0.1", "--port", String(port)], {
+            ...(runner.cwd !== undefined ? { cwd: runner.cwd } : {}),
+            ...(options.logsDir !== undefined ? { logFile: join(options.logsDir, "router.log") } : {}),
+            env
+        });
+        proc.child.once("exit", () => rmSync(configDir, { recursive: true, force: true }));
+        const url = `http://127.0.0.1:${port}`;
+        try {
+            await waitForHttp(`${url}/v1/models`, proc, {
+                timeoutMs: 60_000,
+                label: "fusion router",
+                requireOk: true
+            });
+        }
+        catch (error) {
+            terminate(proc.child);
+            // A provider-side rejection (bad key / model) will not be fixed by a
+            // retry, so surface the distilled cause with guidance.
+            const hint = looksPermanentFailure(proc.log()) ? " (check model names and provider API keys)" : "";
+            throw new Error(`${error instanceof Error ? error.message : String(error)}${hint}`);
+        }
+        announceReady(url);
+        const endpoints = Object.fromEntries(specs.map((spec) => [spec.id, url]));
+        return {
+            url,
+            port,
+            ...(proc.child.pid !== undefined ? { pid: proc.child.pid } : {}),
+            endpoints,
+            models,
+            judgeModel: judgeSpec.id,
+            identity,
+            close: async () => {
+                terminate(proc.child);
+                await closeBackends();
+            }
+        };
+    }
+    catch (error) {
+        await closeBackends();
+        throw error;
+    }
+}
+export async function startFusionStack(options) {
+    const report = options.report;
+    const portless = options.portless ?? (await createPortlessSession({ enabled: false }));
+    // Full override (pre-running per-model endpoints + a pre-running synthesis
+    // URL, e.g. tests): use them verbatim and spawn no router.
+    const override = options.endpoints !== undefined && options.synthesisUrl !== undefined;
+    const judgeModelName = options.judgeModel ?? options.models[0]?.model ?? "";
+    const models = options.models.map((spec) => ({ id: spec.id, model: spec.model }));
+    let modelEndpoints;
+    let fusionBackendUrl;
+    let routerClose = () => { };
+    if (override) {
+        modelEndpoints = options.endpoints;
+        fusionBackendUrl = options.synthesisUrl;
+    }
+    else {
+        // Discover-or-spawn the single router (models + synthesis), reusing a
+        // compatible running instance (same endpoint id set) across runs.
+        const expectedIdentity = options.models.map((spec) => spec.id).sort().join(",");
+        const resolved = await portless.discoverOrSpawn({
+            name: "router",
+            identity: expectedIdentity,
+            healthCheck: async (loopbackUrl) => {
+                try {
+                    const response = await fetch(`${loopbackUrl}/v1/models`, { signal: AbortSignal.timeout(2000) });
+                    if (!response.ok)
+                        return undefined;
+                    const body = (await response.json());
+                    return (body.data ?? [])
+                        .map((entry) => entry.id)
+                        .filter((id) => typeof id === "string" && id !== "fusionkit/router")
+                        .sort()
+                        .join(",");
+                }
+                catch {
+                    return undefined;
+                }
+            },
+            spawn: async () => {
+                if (report)
+                    report({ kind: "server.start", id: "router", label: "router" });
+                const router = await startRouter({
+                    specs: options.models,
+                    ...(options.judgeModel !== undefined ? { judgeModel: options.judgeModel } : {}),
+                    ...(options.fusionkitDir !== undefined ? { fusionkitDir: options.fusionkitDir } : {}),
+                    ...(options.logsDir !== undefined ? { logsDir: options.logsDir } : {}),
+                    ...(report !== undefined ? { report } : {}),
+                    log: options.log
+                });
+                return {
+                    port: router.port,
+                    ...(router.pid !== undefined ? { pid: router.pid } : {}),
+                    close: router.close
+                };
+            }
+        });
+        // The harness + the in-process step call reach the router over loopback (the
+        // portless name is for humans); see the CA-at-startup note in portless.ts.
+        modelEndpoints = Object.fromEntries(options.models.map((spec) => [spec.id, resolved.loopbackUrl]));
+        fusionBackendUrl = resolved.loopbackUrl;
+        routerClose = resolved.close;
+    }
+    try {
+        if (report)
+            report({ kind: "gateway.start" });
+        // The judge-streamed-trajectory front door: each panel model produces a
+        // trajectory and the judge emits the trajectory the user's tool executes.
+        const gatewayConfig = {
+            fusionBackendUrl,
+            repo: options.repo,
+            outputRoot: options.outputRoot,
+            harnesses: ["agent"],
+            models,
+            judgeModel: judgeModelName,
+            modelEndpoints,
+            ...(options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {})
+        };
+        const gateway = await startFusionStepGateway({
+            config: gatewayConfig,
+            host: options.host ?? "127.0.0.1",
+            port: options.port ?? 0,
+            ...(options.authToken !== undefined ? { authToken: options.authToken } : {})
+        });
+        // The gateway runs in-process (dies with this CLI), so it gets a per-run
+        // portless name rather than being a cross-run singleton.
+        const fusionUrl = portless.register("gateway", gateway.port());
+        if (report)
+            report({ kind: "gateway.ready", detail: fusionUrl });
+        return {
+            fusionUrl,
+            endpoints: modelEndpoints,
+            close: async () => {
+                await gateway.close();
+                portless.unregister("gateway");
+                await routerClose();
+            }
+        };
+    }
+    catch (error) {
+        await routerClose();
+        throw error;
+    }
+}

package/dist/fusion-config.d.ts

@@ -9,7 +9,6 @@ export type FusionConfig = {
     local?: boolean;
     observe?: boolean;
     portless?: boolean;
-    cursorKitDir?: string | null;
     port?: number | null;
 };
 export declare class FusionConfigError extends Error {

package/dist/fusion-config.js

@@ -96,12 +96,6 @@ export function parseFusionConfig(raw, source) {
             throw new FusionConfigError(`${source}: portless must be a boolean`);
         config.portless = raw.portless;
     }
-    if (raw.cursorKitDir !== undefined && raw.cursorKitDir !== null) {
-        if (typeof raw.cursorKitDir !== "string") {
-            throw new FusionConfigError(`${source}: cursorKitDir must be a string or null`);
-        }
-        config.cursorKitDir = raw.cursorKitDir;
-    }
     if (raw.port !== undefined && raw.port !== null) {
         if (typeof raw.port !== "number" || !Number.isInteger(raw.port) || raw.port < 0) {
             throw new FusionConfigError(`${source}: port must be a non-negative integer or null`);

package/dist/fusion-init.js

@@ -51,7 +51,7 @@ export async function runFusionInit(input) {
         options: [
             { value: "codex", label: "codex", hint: "OpenAI Codex CLI" },
             { value: "claude", label: "claude", hint: "Claude Code" },
-            { value: "cursor", label: "cursor", hint: "cursor-agent (needs a Cursorkit checkout)" },
+            { value: "cursor", label: "cursor", hint: "cursor-agent (logged-in CLI)" },
             { value: "serve", label: "serve", hint: "just run the gateway and print setup" }
         ],
         defaultIndex: 0
@@ -83,14 +83,6 @@ export async function runFusionInit(input) {
     }
     const judgeDefault = panel[0]?.model ?? "";
     const judgeModel = await text({ message: "Judge model (for synthesis)", defaultValue: judgeDefault });
-    let cursorKitDir;
-    if (tool === "cursor") {
-        const answer = await text({
-            message: "Cursorkit checkout dir (optional, can set FUSIONKIT_CURSORKIT_DIR later)"
-        });
-        if (answer.length > 0)
-            cursorKitDir = answer;
-    }
     const observe = await confirm({ message: "Enable the observability dashboard by default?", defaultValue: false });
     const config = {
         version: FUSION_CONFIG_VERSION,
@@ -98,8 +90,7 @@ export async function runFusionInit(input) {
         panel,
         ...(judgeModel.length > 0 ? { judgeModel } : {}),
         local: preset === "local",
-        observe,
-        ...(cursorKitDir !== undefined ? { cursorKitDir } : {})
+        observe
     };
     let path;
     try {

package/dist/fusion-quickstart.d.ts

@@ -10,229 +10,18 @@
  *
  * No mocks: the panel is real models, candidates are real patches verified by
  * really running the repo's tests, and the judge is a real model.
- */
-import type { ChildProcess } from "node:child_process";
-import type { EnsembleModel } from "@fusionkit/ensemble";
-import type { PortlessSession } from "./shared/portless.js";
-export type FusionTool = "codex" | "claude" | "cursor" | "serve";
+ *
+ * This module is the run orchestrator; the supporting pieces live in `./fusion/`
+ * (env + defaults, the observability dashboard, the model stack, and preflight)
+ * and are re-exported here so existing import paths keep working.
+ */
+import type { FusionTool, RunFusionOptions } from "./fusion/env.js";
+export * from "./fusion/env.js";
+export * from "./fusion/observability.js";
+export * from "./fusion/stack.js";
+export * from "./fusion/preflight.js";
+/** Launchable fusion tools (registry-derived) plus the `serve` pseudo-tool. */
 export declare const FUSION_TOOLS: readonly FusionTool[];
-export type PanelProvider = "mlx" | "openai" | "anthropic" | "google" | "openai-compatible";
-/**
- * One panel model. `mlx` models run locally via the in-repo provisioner; cloud
- * providers (openai/anthropic/google/openai-compatible) are fronted as
- * OpenAI-compatible endpoints by FusionKit's `serve-endpoint` command, run via
- * `uvx fusionkit` (no checkout required).
- */
-export type PanelModelSpec = {
-    id: string;
-    model: string;
-    provider?: PanelProvider;
-    baseUrl?: string;
-    keyEnv?: string;
-};
-/**
- * The PyPI version of the `fusionkit` Python distribution that provides the
- * synthesizer (`fusionkit serve`) and the single-model OpenAI shim
- * (`fusionkit serve-endpoint`). Pinned so `uvx` resolves a reproducible build.
- */
-export declare const FUSIONKIT_PYPI_VERSION = "0.2.0";
-/**
- * Default cloud panel — works cross-platform with only `OPENAI_API_KEY` and
- * `ANTHROPIC_API_KEY` set. The judge defaults to the first entry.
- */
-export declare const DEFAULT_CLOUD_PANEL: readonly PanelModelSpec[];
-/** The locally cached MLX trio (Apple Silicon only) used behind `--local`. */
-export declare const DEFAULT_TRIO: readonly PanelModelSpec[];
-/**
- * How to invoke the `fusionkit` Python CLI: from PyPI via `uvx` by default
- * (no checkout), or from a local checkout via `uv run` when `fusionkitDir` is
- * given (a dev override). Returns the command plus the argv prefix that
- * precedes the subcommand (`serve`, `serve-endpoint`, ...).
- */
-export declare function fusionkitPyCommand(fusionkitDir?: string): {
-    command: string;
-    prefix: string[];
-    cwd?: string;
-};
-/**
- * Parse a `.env` file (KEY=VALUE lines, `#` comments, optional `export`,
- * single/double quotes) and fill any keys not already present in `env`.
- * Existing env values win, so an explicitly exported key is never overridden.
- */
-export declare function loadEnvFileInto(path: string, env: Record<string, string | undefined>): void;
-/** Default env var holding the API key for each cloud provider. */
-export declare function defaultKeyEnv(provider: PanelProvider): string | undefined;
-/** The git repository root containing `dir`, or undefined if it is not in a repo. */
-export declare function gitToplevel(dir: string): string | undefined;
-/**
- * Compute the binaries and API keys the run requires given the tool, panel, and
- * options. Pre-running endpoints (`--model-endpoint`) and a pre-running
- * `--synthesis-url` drop the corresponding requirements.
- */
-export declare function preflightRequirements(tool: FusionTool, models: PanelModelSpec[], options: RunFusionOptions): {
-    requiredBins: string[];
-    requiredEnv: string[];
-};
-/** Fixed port for the local observability dashboard (the scope app). */
-export declare const SCOPE_DASHBOARD_PORT = 4317;
-/**
- * Locate the isolated scope dashboard app (handoffkit/apps/scope) by walking up
- * from this module. Works from both the compiled dist and src layouts. Only the
- * monorepo dev fallback uses this — published installs ship a prebuilt bundle.
- */
-export declare function findScopeAppDir(): string;
-/**
- * Path to the prebuilt, self-contained dashboard server staged into the CLI
- * package (`scope/server.js`, a sibling of `dist/`), or undefined when it is
- * absent — i.e. a monorepo dev checkout where the bundle was never staged. Both
- * the compiled `dist/fusion-quickstart.js` and the `src/` layout resolve to the
- * same `<cli-package>/scope/server.js`.
- */
-export declare function bundledScopeServer(): string | undefined;
-export type Observability = {
-    url: string;
-    ingestUrl: string;
-    traceDir: string;
-    close: () => Promise<void>;
-};
-export declare function startObservability(input: {
-    log: (line: string) => void;
-    logFile?: string;
-    report?: StackReporter;
-    portless: PortlessSession;
-}): Promise<Observability>;
-/**
- * The single `fusionkit serve` router: one process that fronts every panel
- * model (passthrough, routed by the endpoint id in the request `model` field)
- * and also performs trajectory synthesis. `endpoints` maps each panel id to the
- * router URL so the harness reaches its model through the one base URL.
- */
-export type Router = {
-    url: string;
-    port: number;
-    /** The router process pid (owns its portless route across runs). */
-    pid?: number;
-    endpoints: Record<string, string>;
-    models: EnsembleModel[];
-    /** The endpoint id used as the judge/synthesizer. */
-    judgeModel: string;
-    /** Sorted endpoint ids — the router's discover-or-spawn identity token. */
-    identity: string;
-    close: () => Promise<void>;
-};
-/**
- * Structured boot progress. When a reporter is supplied the stack emits these
- * events instead of the plain `fusion: ...` log lines, so a live TUI (or any
- * other consumer) can render per-stage status. Without one, callers keep getting
- * the existing line logs.
- */
-export type StackEvent = {
-    kind: "server.start";
-    id: string;
-    label: string;
-} | {
-    kind: "server.ready";
-    id: string;
-    detail: string;
-} | {
-    kind: "server.fail";
-    id: string;
-    detail: string;
-} | {
-    kind: "synth.start";
-} | {
-    kind: "synth.ready";
-    detail: string;
-} | {
-    kind: "gateway.start";
-} | {
-    kind: "gateway.ready";
-    detail: string;
-} | {
-    kind: "dashboard.start";
-} | {
-    kind: "dashboard.ready";
-    detail: string;
-} | {
-    kind: "dashboard.fail";
-    detail: string;
-};
-export type StackReporter = (event: StackEvent) => void;
-/**
- * Spawn the single `fusionkit serve` router fronting every panel model + the
- * synthesizer. MLX specs first get an in-process OpenAI-compatible gateway
- * (loopback) that the router proxies to; cloud specs call their provider
- * directly. Returns the router URL, an id->routerUrl endpoint map, and a close
- * that tears down the router process and any MLX gateways it fronts.
- */
-export declare function startRouter(options: {
-    specs: PanelModelSpec[];
-    judgeModel?: string;
-    fusionkitDir?: string;
-    logsDir?: string;
-    report?: StackReporter;
-    log: (line: string) => void;
-}): Promise<Router>;
-export type FusionStack = {
-    fusionUrl: string;
-    endpoints: Record<string, string>;
-    close: () => Promise<void>;
-};
-export type StartFusionStackOptions = {
-    repo: string;
-    outputRoot: string;
-    models: PanelModelSpec[];
-    endpoints?: Record<string, string>;
-    fusionkitDir?: string;
-    judgeModel?: string;
-    /** Pre-running fusionkit serve URL for trajectory synthesis (skips spawn). */
-    synthesisUrl?: string;
-    host?: string;
-    port?: number;
-    authToken?: string;
-    timeoutMs?: number;
-    logsDir?: string;
-    report?: StackReporter;
-    /** Active portless session; defaults to a disabled (loopback) session. */
-    portless?: PortlessSession;
-    log: (line: string) => void;
-};
-export declare function startFusionStack(options: StartFusionStackOptions): Promise<FusionStack>;
-/**
- * Start the Cursorkit bridge with its local-model backend pointed at the fusion
- * gateway, and resolve once it is listening. Returns the child and its port.
- */
-export declare function startCursorBridge(input: {
-    cursorKitDir: string;
-    fusionUrl: string;
-    logFile?: string;
-    caCertPath?: string;
-    log: (line: string) => void;
-}): Promise<{
-    child: ChildProcess;
-    port: number;
-}>;
-export type RunFusionOptions = {
-    models?: PanelModelSpec[];
-    endpoints?: Record<string, string>;
-    fusionkitDir?: string;
-    repo?: string;
-    judgeModel?: string;
-    synthesisUrl?: string;
-    cursorKitDir?: string;
-    authToken?: string;
-    port?: number;
-    timeoutMs?: number;
-    /** Use the local MLX panel trio (Apple Silicon) instead of the cloud panel. */
-    local?: boolean;
-    /** Boot the local scope dashboard and stream trace events into it. */
-    observe?: boolean;
-    /** Skip the interactive cost/scope confirmation for the cloud panel. */
-    yes?: boolean;
-    /** Route services through portless (stable named URLs + singletons). Default on. */
-    portless?: boolean;
-    log?: (line: string) => void;
-};
 /** Whether portless is enabled: explicit flag/config wins, else on unless PORTLESS=0. */
 export declare function portlessEnabled(options: RunFusionOptions): boolean;
 export declare function runFusion(tool: FusionTool, toolArgs: string[], options?: RunFusionOptions): Promise<number>;