@aigne/cli 1.26.0 → 1.26.1-1

package/dist/commands/run.js

@@ -12,94 +12,109 @@ import { isV1Package, toAIGNEPackage } from "../utils/agent-v1.js";
 import { downloadAndExtract } from "../utils/download.js";
 import { loadAIGNE } from "../utils/load-aigne.js";
 import { createRunAIGNECommand, parseAgentInputByCommander, runAgentWithAIGNE, } from "../utils/run-with-aigne.js";
-export function createRunCommand({ aigneFilePath } = {}) {
-    return createRunAIGNECommand()
-        .description("Run AIGNE from the specified agent")
-        .option("--url, --path <path_or_url>", "Path to the agents directory or URL to aigne project", ".")
-        .option("--entry-agent <entry-agent>", "Name of the agent to run (defaults to the first agent found)")
-        .option("--cache-dir <dir>", "Directory to download the package to (defaults to the ~/.aigne/xxx)")
-        .action(async (options) => {
-        const path = aigneFilePath || options.path;
-        if (options.logLevel)
-            logger.level = options.logLevel;
-        const { cacheDir, dir } = prepareDirs(path, options);
-        const { aigne, agent } = await new Listr([
-            {
-                title: "Prepare environment",
-                task: (_, task) => {
-                    if (cacheDir) {
-                        return task.newListr([
-                            {
-                                title: "Download package",
-                                task: () => downloadPackage(path, cacheDir),
-                            },
-                            {
-                                title: "Extract package",
-                                task: () => extractPackage(cacheDir, dir),
-                            },
-                        ]);
-                    }
+export function createRunCommand({ aigneFilePath, } = {}) {
+    return {
+        command: "run [path]",
+        describe: "Run AIGNE from the specified agent",
+        builder: (yargs) => {
+            return createRunAIGNECommand(yargs)
+                .positional("path", {
+                describe: "Path to the agents directory or URL to aigne project",
+                type: "string",
+                default: ".",
+                alias: ["url"],
+            })
+                .option("entry-agent", {
+                describe: "Name of the agent to run (defaults to the first agent found)",
+                type: "string",
+            })
+                .option("cache-dir", {
+                describe: "Directory to download the package to (defaults to the ~/.aigne/xxx)",
+                type: "string",
+            });
+        },
+        handler: async (argv) => {
+            const options = argv;
+            const path = aigneFilePath || options.path;
+            if (options.logLevel)
+                logger.level = options.logLevel;
+            const { cacheDir, dir } = prepareDirs(path, options);
+            const { aigne, agent } = await new Listr([
+                {
+                    title: "Prepare environment",
+                    task: (_, task) => {
+                        if (cacheDir) {
+                            return task.newListr([
+                                {
+                                    title: "Download package",
+                                    task: () => downloadPackage(path, cacheDir),
+                                },
+                                {
+                                    title: "Extract package",
+                                    task: () => extractPackage(cacheDir, dir),
+                                },
+                            ]);
+                        }
+                    },
                 },
-            },
-            {
-                title: "Initialize AIGNE",
-                task: async (ctx, task) => {
-                    // Load env files in the aigne directory
-                    config({ path: dir, silent: true });
-                    const aigne = await loadAIGNE(dir, { ...options, model: options.model || process.env.MODEL }, {
-                        inquirerPromptFn: (prompt) => {
-                            return task
-                                .prompt(ListrInquirerPromptAdapter)
-                                .run(select, prompt)
-                                .then((res) => ({ [prompt.name]: res }));
-                        },
-                    });
-                    ctx.aigne = aigne;
+                {
+                    title: "Initialize AIGNE",
+                    task: async (ctx, task) => {
+                        // Load env files in the aigne directory
+                        config({ path: dir, silent: true });
+                        const aigne = await loadAIGNE(dir, { ...options, model: options.model || process.env.MODEL }, {
+                            inquirerPromptFn: (prompt) => {
+                                return task
+                                    .prompt(ListrInquirerPromptAdapter)
+                                    .run(select, prompt)
+                                    .then((res) => ({ [prompt.name]: res }));
+                            },
+                        });
+                        ctx.aigne = aigne;
+                    },
                 },
-            },
-            {
-                task: (ctx) => {
-                    const { aigne } = ctx;
-                    assert(aigne);
-                    let entryAgent;
-                    if (options.entryAgent) {
-                        entryAgent = aigne.agents[options.entryAgent];
-                        if (!entryAgent) {
-                            throw new Error(`\
+                {
+                    task: (ctx) => {
+                        const { aigne } = ctx;
+                        assert(aigne);
+                        let entryAgent;
+                        if (options.entryAgent) {
+                            entryAgent = aigne.agents[options.entryAgent];
+                            if (!entryAgent) {
+                                throw new Error(`\
 Agent "${options.entryAgent}" not found in ${aigne.rootDir}
 
 Available agents:
 ${aigne.agents.map((agent) => `  - ${agent.name}`).join("\n")}
 `);
+                            }
+                        }
+                        else {
+                            entryAgent = aigne.agents[0];
+                            if (!entryAgent)
+                                throw new Error(`No any agent found in ${aigne.rootDir}`);
                         }
-                    }
-                    else {
-                        entryAgent = aigne.agents[0];
-                        if (!entryAgent)
-                            throw new Error(`No any agent found in ${aigne.rootDir}`);
-                    }
-                    ctx.agent = entryAgent;
+                        ctx.agent = entryAgent;
+                    },
+                },
+            ], {
+                rendererOptions: {
+                    collapseSubtasks: false,
+                    showErrorMessage: false,
+                    timer: PRESET_TIMER,
                 },
-            },
-        ], {
-            rendererOptions: {
-                collapseSubtasks: false,
-                showErrorMessage: false,
-                timer: PRESET_TIMER,
-            },
-        }).run();
-        assert(aigne);
-        assert(agent);
-        const input = await parseAgentInputByCommander(agent, options);
-        try {
-            await runAgentWithAIGNE(aigne, agent, { ...options, input });
-        }
-        finally {
-            await aigne.shutdown();
-        }
-    })
-        .showHelpAfterError(true)
-        .showSuggestionAfterError(true);
+            }).run();
+            assert(aigne);
+            assert(agent);
+            const input = await parseAgentInputByCommander(agent, options);
+            try {
+                await runAgentWithAIGNE(aigne, agent, { ...options, input });
+            }
+            finally {
+                await aigne.shutdown();
+            }
+        },
+    };
 }
 async function downloadPackage(url, cacheDir) {
     await rm(cacheDir, { recursive: true, force: true });
@@ -121,7 +136,7 @@ function prepareDirs(path, options) {
     if (!path.startsWith("http")) {
         dir = isAbsolute(path) ? path : resolve(process.cwd(), path);
     }
-    else if (options.cacheDir) {
+    else if (options?.cacheDir) {
         dir = isAbsolute(options.cacheDir)
             ? options.cacheDir
             : resolve(process.cwd(), options.cacheDir);
@@ -133,7 +148,7 @@ function prepareDirs(path, options) {
     }
     return { cacheDir, dir };
 }
-function getLocalPackagePathFromUrl(url, { subdir } = {}) {
+export function getLocalPackagePathFromUrl(url, { subdir } = {}) {
     const root = [homedir(), ".aigne", subdir].filter(isNonNullable);
     const u = new URL(url);
     return join(...root, u.hostname, u.pathname);

package/dist/commands/serve-mcp.d.ts

@@ -1,4 +1,11 @@
-import { Command } from "commander";
-export declare function createServeMCPCommand({ aigneFilePath }?: {
+import type { CommandModule } from "yargs";
+interface ServeMCPOptions {
+    path: string;
+    host: string;
+    port?: number;
+    pathname: string;
+}
+export declare function createServeMCPCommand({ aigneFilePath, }?: {
     aigneFilePath?: string;
-}): Command;
+}): CommandModule<{}, ServeMCPOptions>;
+export {};

package/dist/commands/serve-mcp.js

@@ -1,6 +1,5 @@
 import { isAbsolute, resolve } from "node:path";
 import { tryOrThrow } from "@aigne/core/utils/type-utils.js";
-import { Command } from "commander";
 import { loadAIGNE } from "../utils/load-aigne.js";
 import { serveMCPServer } from "../utils/serve-mcp.js";
 const DEFAULT_PORT = () => tryOrThrow(() => {
@@ -12,26 +11,45 @@ const DEFAULT_PORT = () => tryOrThrow(() => {
         throw new Error(`Invalid PORT: ${PORT}`);
     return port;
 }, (error) => new Error(`parse PORT error ${error.message}`));
-export function createServeMCPCommand({ aigneFilePath } = {}) {
-    return new Command("serve-mcp")
-        .description("Serve the agents in the specified directory as a MCP server (streamable http)")
-        .option("--url, --path <path_or_url>", "Path to the agents directory or URL to aigne project", ".")
-        .option("--host <host>", "Host to run the MCP server on, use 0.0.0.0 to publicly expose the server", "localhost")
-        .option("--port <port>", "Port to run the MCP server on", (s) => Number.parseInt(s))
-        .option("--pathname <pathname>", "Pathname to the service", "/mcp")
-        .action(async (options) => {
-        const path = aigneFilePath || options.path;
-        const absolutePath = isAbsolute(path) ? path : resolve(process.cwd(), path);
-        const port = options.port || DEFAULT_PORT();
-        const aigne = await loadAIGNE(absolutePath);
-        await serveMCPServer({
-            aigne,
-            host: options.host,
-            port,
-            pathname: options.pathname,
-        });
-        console.log(`MCP server is running on http://${options.host}:${port}${options.pathname}`);
-    })
-        .showHelpAfterError(true)
-        .showSuggestionAfterError(true);
+export function createServeMCPCommand({ aigneFilePath, } = {}) {
+    return {
+        command: "serve-mcp",
+        describe: "Serve the agents in the specified directory as a MCP server (streamable http)",
+        builder: (yargs) => {
+            return yargs
+                .option("path", {
+                describe: "Path to the agents directory or URL to aigne project",
+                type: "string",
+                default: ".",
+                alias: ["url"],
+            })
+                .option("host", {
+                describe: "Host to run the MCP server on, use 0.0.0.0 to publicly expose the server",
+                type: "string",
+                default: "localhost",
+            })
+                .option("port", {
+                describe: "Port to run the MCP server on",
+                type: "number",
+            })
+                .option("pathname", {
+                describe: "Pathname to the service",
+                type: "string",
+                default: "/mcp",
+            });
+        },
+        handler: async (options) => {
+            const path = aigneFilePath || options.path;
+            const absolutePath = isAbsolute(path) ? path : resolve(process.cwd(), path);
+            const port = options.port || DEFAULT_PORT();
+            const aigne = await loadAIGNE(absolutePath);
+            await serveMCPServer({
+                aigne,
+                host: options.host,
+                port,
+                pathname: options.pathname,
+            });
+            console.log(`MCP server is running on http://${options.host}:${port}${options.pathname}`);
+        },
+    };
 }

package/dist/commands/test.d.ts

@@ -1,4 +1,8 @@
-import { Command } from "commander";
-export declare function createTestCommand({ aigneFilePath }?: {
+import type { CommandModule } from "yargs";
+interface TestOptions {
+    path: string;
+}
+export declare function createTestCommand({ aigneFilePath, }?: {
     aigneFilePath?: string;
-}): Command;
+}): CommandModule<{}, TestOptions>;
+export {};

package/dist/commands/test.js

@@ -1,19 +1,25 @@
 import assert from "node:assert";
 import { spawnSync } from "node:child_process";
 import { isAbsolute, resolve } from "node:path";
-import { Command } from "commander";
 import { loadAIGNE } from "../utils/load-aigne.js";
-export function createTestCommand({ aigneFilePath } = {}) {
-    return new Command("test")
-        .description("Run tests in the specified agents directory")
-        .option("--url, --path <path_or_url>", "Path to the agents directory or URL to aigne project", ".")
-        .action(async (options) => {
-        const path = aigneFilePath || options.path;
-        const absolutePath = isAbsolute(path) ? path : resolve(process.cwd(), path);
-        const aigne = await loadAIGNE(absolutePath);
-        assert(aigne.rootDir);
-        spawnSync("node", ["--test"], { cwd: aigne.rootDir, stdio: "inherit" });
-    })
-        .showHelpAfterError(true)
-        .showSuggestionAfterError(true);
+export function createTestCommand({ aigneFilePath, } = {}) {
+    return {
+        command: "test",
+        describe: "Run tests in the specified agents directory",
+        builder: (yargs) => {
+            return yargs.option("path", {
+                describe: "Path to the agents directory or URL to aigne project",
+                type: "string",
+                default: ".",
+                alias: ["url"],
+            });
+        },
+        handler: async (options) => {
+            const path = aigneFilePath || options.path;
+            const absolutePath = isAbsolute(path) ? path : resolve(process.cwd(), path);
+            const aigne = await loadAIGNE(absolutePath);
+            assert(aigne.rootDir);
+            spawnSync("node", ["--test"], { cwd: aigne.rootDir, stdio: "inherit" });
+        },
+    };
 }

package/dist/utils/download.d.ts

@@ -1 +1,3 @@
-export declare function downloadAndExtract(url: string, dir: string): Promise<void>;
+export declare function downloadAndExtract(url: string, dir: string, options?: {
+    strip?: number;
+}): Promise<void>;

package/dist/utils/download.js

@@ -1,7 +1,7 @@
 import { Readable } from "node:stream";
 import { finished } from "node:stream/promises";
 import { x } from "tar";
-export async function downloadAndExtract(url, dir) {
+export async function downloadAndExtract(url, dir, options = {}) {
     const response = await fetch(url).catch((error) => {
         throw new Error(`Failed to download package from ${url}: ${error.message}`);
     });
@@ -12,7 +12,7 @@ export async function downloadAndExtract(url, dir) {
         throw new Error(`Failed to download package from ${url}: Unexpected to get empty response`);
     }
     try {
-        await finished(Readable.fromWeb(response.body).pipe(x({ C: dir })));
+        await finished(Readable.fromWeb(response.body).pipe(x({ C: dir, ...options })));
     }
     catch (error) {
         error.message = `Failed to extract package from ${url}: ${error.message}`;

package/dist/utils/load-aigne.d.ts

@@ -6,6 +6,7 @@ export declare const decrypt: (m: string, s: string, i: string) => string;
 export declare const encrypt: (m: string, s: string, i: string) => string;
 export declare const encodeEncryptionKey: (key: string) => string;
 export declare const decodeEncryptionKey: (str: string) => Uint8Array<ArrayBuffer>;
+export declare const AIGNE_ENV_FILE: string;
 export interface RunOptions extends RunAIGNECommandOptions {
     path: string;
     entryAgent?: string;
@@ -40,7 +41,14 @@ interface CreateConnectOptions {
 }
 export declare function createConnect({ connectUrl, openPage, fetchInterval, retry, source, connectAction, wrapSpinner, closeOnSuccess, intervalFetchConfig, }: CreateConnectOptions): Promise<FetchResult>;
 export declare const formatModelName: (models: LoadableModel[], model: string, inquirerPrompt: typeof inquirer.prompt) => Promise<string>;
-export declare function loadAIGNE(path: string, options?: RunOptions, checkAuthorizeOptions?: {
+export declare function connectToAIGNEHub(url: string): Promise<{
+    accessKey: string;
+    url: string;
+} | {
+    accessKey: undefined;
+    url: undefined;
+}>;
+export declare function loadAIGNE(path: string, options?: RunOptions, actionOptions?: {
     inquirerPromptFn?: (prompt: {
         type: string;
         name: string;
@@ -51,5 +59,6 @@ export declare function loadAIGNE(path: string, options?: RunOptions, checkAutho
         }[];
         default: any;
     }) => Promise<any>;
+    runTest?: boolean;
 }): Promise<AIGNE<import("@aigne/core").UserContext>>;
 export {};

package/dist/utils/load-aigne.js

@@ -3,7 +3,8 @@ import { readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { AIGNE } from "@aigne/core";
-import { loadModel } from "@aigne/core/loader/index.js";
+import { loadAIGNEFile, loadModel } from "@aigne/core/loader/index.js";
+import { logger } from "@aigne/core/utils/logger.js";
 import { AesCrypter } from "@ocap/mcrypto/lib/crypter/aes-legacy.js";
 import crypto from "crypto";
 import inquirer from "inquirer";
@@ -20,15 +21,16 @@ const escapeFn = (str) => str.replace(/\+/g, "-").replace(/\//g, "_").replace(/=
 const unescapeFn = (str) => (str + "===".slice((str.length + 3) % 4)).replace(/-/g, "+").replace(/_/g, "/");
 export const encodeEncryptionKey = (key) => escapeFn(Buffer.from(key).toString("base64"));
 export const decodeEncryptionKey = (str) => new Uint8Array(Buffer.from(unescapeFn(str), "base64"));
+const TEST_ENV = process.env.CI || process.env.NODE_ENV === "test";
+export const AIGNE_ENV_FILE = TEST_ENV
+    ? join(homedir(), ".aigne", "test-aigne-hub-connected.yaml")
+    : join(homedir(), ".aigne", "aigne-hub-connected.yaml");
 const request = async (config) => {
     const headers = {};
     if (config.requestCount !== undefined) {
         headers["X-Request-Count"] = config.requestCount.toString();
     }
-    const response = await fetch(config.url, {
-        method: config.method || "GET",
-        headers,
-    });
+    const response = await fetch(config.url, { method: config.method || "GET", headers });
     if (!response.ok)
         throw new Error(`HTTP error! status: ${response.status}`);
     const data = await response.json();
@@ -108,7 +110,7 @@ export const formatModelName = async (models, model, inquirerPrompt) => {
     if (m.apiKeyEnvName && process.env[m.apiKeyEnvName]) {
         return model;
     }
-    if (process.env.CI || process.env.NODE_ENV === "test") {
+    if (TEST_ENV) {
         return `${AGENT_HUB_PROVIDER}:${provider}/${name}`;
     }
     const result = await inquirerPrompt({
@@ -131,21 +133,63 @@ export const formatModelName = async (models, model, inquirerPrompt) => {
         return model;
     return `${AGENT_HUB_PROVIDER}:${provider}/${name}`;
 };
-export async function loadAIGNE(path, options, checkAuthorizeOptions) {
+export async function connectToAIGNEHub(url) {
+    const { origin, host } = new URL(url);
+    const connectUrl = joinURL(origin, WELLKNOWN_SERVICE_PATH_PREFIX);
+    const BLOCKLET_JSON_PATH = "__blocklet__.js?type=json";
+    const blockletInfo = await fetch(joinURL(origin, BLOCKLET_JSON_PATH));
+    const blocklet = await blockletInfo.json();
+    const aigneHubMount = (blocklet?.componentMountPoints || []).find((m) => m.did === "z8ia3xzq2tMq8CRHfaXj1BTYJyYnEcHbqP8cJ");
+    try {
+        const result = await createConnect({
+            connectUrl: connectUrl,
+            connectAction: "gen-simple-access-key",
+            source: `@aigne/cli connect to AIGNE hub`,
+            closeOnSuccess: true,
+            openPage: (pageUrl) => open(pageUrl),
+        });
+        const accessKeyOptions = {
+            accessKey: result.accessKeySecret,
+            url: joinURL(origin, aigneHubMount?.mountPoint || ""),
+        };
+        // After redirection, write the AIGNE Hub access token
+        const aigneDir = join(homedir(), ".aigne");
+        if (!existsSync(aigneDir)) {
+            mkdirSync(aigneDir, { recursive: true });
+        }
+        const envs = parse(await readFile(AIGNE_ENV_FILE, "utf8").catch(() => stringify({})));
+        await writeFile(AIGNE_ENV_FILE, stringify({
+            ...envs,
+            [host]: {
+                AIGNE_HUB_API_KEY: accessKeyOptions.accessKey,
+                AIGNE_HUB_API_URL: accessKeyOptions.url,
+            },
+        })).catch((err) => {
+            logger.error("Failed to write AIGNE Hub access token to .aigne/aigne-hub-connected.yaml", err.message);
+            throw err;
+        });
+        return accessKeyOptions;
+    }
+    catch (error) {
+        logger.error("Failed to connect to AIGNE Hub", error.message);
+        return { accessKey: undefined, url: undefined };
+    }
+}
+export async function loadAIGNE(path, options, actionOptions) {
     const models = availableModels();
-    const AIGNE_ENV_FILE = join(homedir(), ".aigne", "aigne-hub-connected.yaml");
     const AIGNE_HUB_URL = process.env.AIGNE_HUB_API_URL || DEFAULT_URL;
     const connectUrl = joinURL(new URL(AIGNE_HUB_URL).origin, WELLKNOWN_SERVICE_PATH_PREFIX);
-    const inquirerPrompt = (checkAuthorizeOptions?.inquirerPromptFn ??
+    const inquirerPrompt = (actionOptions?.inquirerPromptFn ??
         inquirer.prompt);
+    const { aigne } = await loadAIGNEFile(path).catch(() => ({ aigne: null }));
     let accessKeyOptions = {};
-    const modelName = await formatModelName(models, options?.model || "", inquirerPrompt);
-    if (process.env.CI || process.env.NODE_ENV === "test") {
+    const modelName = await formatModelName(models, options?.model || `${aigne?.model?.provider ?? ""}:${aigne?.model?.name ?? ""}`, inquirerPrompt);
+    if (TEST_ENV && !actionOptions?.runTest) {
         const model = await loadModel(models, parseModelOption(modelName), undefined, accessKeyOptions);
         return await AIGNE.load(path, { models, memories: availableMemories, model });
     }
     if ((modelName.toLocaleLowerCase() || "").includes(AGENT_HUB_PROVIDER)) {
-        const { origin, host } = new URL(AIGNE_HUB_URL);
+        const { host } = new URL(AIGNE_HUB_URL);
         try {
             // aigne-hub access token
             if (!existsSync(AIGNE_ENV_FILE)) {
@@ -188,37 +232,7 @@ export async function loadAIGNE(path, options, checkAuthorizeOptions) {
                     console.warn("The AIGNE Hub connection has been cancelled");
                     process.exit(0);
                 }
-                const BLOCKLET_JSON_PATH = "__blocklet__.js?type=json";
-                const blockletInfo = await fetch(joinURL(origin, BLOCKLET_JSON_PATH));
-                const blocklet = await blockletInfo.json();
-                const aigneHubMount = (blocklet?.componentMountPoints || []).find((m) => m.did === "z8ia3xzq2tMq8CRHfaXj1BTYJyYnEcHbqP8cJ");
-                try {
-                    const result = await createConnect({
-                        connectUrl: connectUrl,
-                        connectAction: "gen-simple-access-key",
-                        source: `@aigne/cli connect to AIGNE hub`,
-                        closeOnSuccess: true,
-                        openPage: (pageUrl) => open(pageUrl),
-                    });
-                    accessKeyOptions = {
-                        accessKey: result.accessKeySecret,
-                        url: joinURL(origin, aigneHubMount?.mountPoint || ""),
-                    };
-                    // After redirection, write the AIGNE Hub access token
-                    const aigneDir = join(homedir(), ".aigne");
-                    if (!existsSync(aigneDir)) {
-                        mkdirSync(aigneDir, { recursive: true });
-                    }
-                    await writeFile(AIGNE_ENV_FILE, stringify({
-                        [host]: {
-                            AIGNE_HUB_API_KEY: accessKeyOptions.accessKey,
-                            AIGNE_HUB_API_URL: accessKeyOptions.url,
-                        },
-                    }));
-                }
-                catch (error) {
-                    console.error(error);
-                }
+                accessKeyOptions = await connectToAIGNEHub(connectUrl);
             }
         }
     }

package/dist/utils/run-with-aigne.d.ts

@@ -1,7 +1,7 @@
 import { type Agent, AIGNE, type ChatModelOptions, type Message } from "@aigne/core";
 import { LogLevel } from "@aigne/core/utils/logger.js";
 import { type PromiseOrValue } from "@aigne/core/utils/type-utils.js";
-import { Command } from "commander";
+import type { Argv } from "yargs";
 import { type ChatLoopOptions } from "./run-chat-loop.js";
 export interface RunAIGNECommandOptions {
     chat?: boolean;
@@ -17,7 +17,31 @@ export interface RunAIGNECommandOptions {
     logLevel?: LogLevel;
     force?: boolean;
 }
-export declare const createRunAIGNECommand: (name?: string) => Command;
+export declare const createRunAIGNECommand: (yargs: Argv) => Argv<{
+    chat: boolean;
+} & {
+    model: string | undefined;
+} & {
+    temperature: number | undefined;
+} & {
+    "top-p": number | undefined;
+} & {
+    "presence-penalty": number | undefined;
+} & {
+    "frequency-penalty": number | undefined;
+} & {
+    input: (string | number)[] | undefined;
+} & {
+    format: string | undefined;
+} & {
+    output: string | undefined;
+} & {
+    "output-key": string;
+} & {
+    force: boolean;
+} & {
+    "log-level": LogLevel;
+}>;
 export declare function parseAgentInputByCommander(agent: Agent, options?: RunAIGNECommandOptions & {
     inputKey?: string;
     argv?: string[];