@aigne/cli 1.43.1 → 1.44.1

package/CHANGELOG.md

@@ -1,5 +1,54 @@
 # Changelog
 
+## [1.44.1](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.44.0...cli-v1.44.1) (2025-09-05)
+
+
+### Bug Fixes
+
+* should not return local path from aigne hub service ([#460](https://github.com/AIGNE-io/aigne-framework/issues/460)) ([c959717](https://github.com/AIGNE-io/aigne-framework/commit/c95971774f7e84dbeb3313f60b3e6464e2bb22e4))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/agent-library bumped to 1.21.38
+    * @aigne/agentic-memory bumped to 1.0.38
+    * @aigne/aigne-hub bumped to 0.8.8
+    * @aigne/core bumped to 1.58.1
+    * @aigne/default-memory bumped to 1.2.1
+    * @aigne/openai bumped to 0.14.1
+  * devDependencies
+    * @aigne/test-utils bumped to 0.5.45
+
+## [1.44.0](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.43.1...cli-v1.44.0) (2025-09-05)
+
+
+### Features
+
+* add modalities support for chat model ([#454](https://github.com/AIGNE-io/aigne-framework/issues/454)) ([70d1bf6](https://github.com/AIGNE-io/aigne-framework/commit/70d1bf631f4e711235d89c6df8ee210a19179b30))
+* **cli:** unify `run` and apps command arguments ([#436](https://github.com/AIGNE-io/aigne-framework/issues/436)) ([9c6b632](https://github.com/AIGNE-io/aigne-framework/commit/9c6b6323f8cfc2afe632d8ae392eab446981fc64))
+
+
+### Bug Fixes
+
+* add file protocol to local file links in terminal tracer ([#455](https://github.com/AIGNE-io/aigne-framework/issues/455)) ([14890f9](https://github.com/AIGNE-io/aigne-framework/commit/14890f9ead679f38a7cc0b1ff31a97d2fe9056cb))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/agent-library bumped to 1.21.37
+    * @aigne/agentic-memory bumped to 1.0.37
+    * @aigne/aigne-hub bumped to 0.8.7
+    * @aigne/core bumped to 1.58.0
+    * @aigne/default-memory bumped to 1.2.0
+    * @aigne/observability-api bumped to 0.10.2
+    * @aigne/openai bumped to 0.14.0
+  * devDependencies
+    * @aigne/test-utils bumped to 0.5.44
+
 ## [1.43.1](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.43.0...cli-v1.43.1) (2025-09-01)
 
 

package/dist/cli.js

@@ -2,7 +2,6 @@
 import { existsSync, realpathSync, statSync } from "node:fs";
 import chalk from "chalk";
 import { config } from "dotenv-flow";
-import { hideBin } from "yargs/helpers";
 import { createAIGNECommand } from "./commands/aigne.js";
 import { highlightUrl } from "./utils/string-utils.js";
 config({ silent: true });
@@ -26,7 +25,7 @@ export default createAIGNECommand({ aigneFilePath })
         process.exit(1);
     }
 })
-    .parseAsync(hideBin([...process.argv.slice(0, 2), ...process.argv.slice(aigneFilePath ? 3 : 2)]))
+    .parseAsync(process.argv.slice(aigneFilePath ? 3 : 2))
     .catch((error) => {
     console.log(""); // Add an empty line for better readability
     console.error(`${chalk.red("Error:")} ${highlightUrl(error.message)}`);

package/dist/commands/app.d.ts

@@ -1,14 +1,15 @@
-import { AIGNE, type Message } from "@aigne/core";
+import { type Agent, AIGNE, type Message } from "@aigne/core";
 import type { CommandModule } from "yargs";
+import { type AgentRunCommonOptions } from "../utils/yargs.js";
 export declare function createAppCommands(): CommandModule[];
+export declare const agentCommandModule: ({ dir, agent, }: {
+    dir: string;
+    agent: Agent;
+}) => CommandModule<unknown, AgentRunCommonOptions>;
 export declare function invokeCLIAgentFromDir(options: {
     dir: string;
     agent: string;
-    input: Message & {
-        input?: string[];
-        format?: "yaml" | "json";
-        model?: string;
-    };
+    input: Message & AgentRunCommonOptions;
 }): Promise<void>;
 export declare function loadApplication({ name, dir, forceUpgrade, }: {
     name: string;

package/dist/commands/app.js

@@ -4,12 +4,13 @@ import { mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { AIGNE } from "@aigne/core";
+import { logger } from "@aigne/core/utils/logger.js";
 import { Listr, PRESET_TIMER } from "@aigne/listr2";
 import { joinURL } from "ufo";
 import { downloadAndExtract } from "../utils/download.js";
 import { loadAIGNE } from "../utils/load-aigne.js";
 import { runAgentWithAIGNE } from "../utils/run-with-aigne.js";
-import { parseAgentInput, withAgentInputSchema } from "../utils/yargs.js";
+import { parseAgentInput, withAgentInputSchema, } from "../utils/yargs.js";
 import { serveMCPServerFromDir } from "./serve-mcp.js";
 const NPM_PACKAGE_CACHE_TIME_MS = 1000 * 60 * 60 * 24; // 1 day
 const builtinApps = [
@@ -36,7 +37,7 @@ export function createAppCommands() {
             if (aigne.cli.chat) {
                 yargs.command({ ...agentCommandModule({ dir, agent: aigne.cli.chat }), command: "$0" });
             }
-            for (const agent of aigne.cli?.agents ?? []) {
+            for (const agent of aigne.cli.agents) {
                 yargs.command(agentCommandModule({ dir, agent }));
             }
             yargs.version(`${app.name} v${version}`).alias("version", "v");
@@ -83,28 +84,39 @@ const upgradeCommandModule = ({ name, dir, isLatest, version, }) => ({
         console.log(`\n✅ ${name} is already at the latest version (${version})`);
     },
 });
-const agentCommandModule = ({ dir, agent, }) => {
+export const agentCommandModule = ({ dir, agent, }) => {
     return {
         command: agent.name,
         aliases: agent.alias || [],
         describe: agent.description || "",
         builder: async (yargs) => withAgentInputSchema(yargs, agent),
-        handler: async (input) => {
-            await invokeCLIAgentFromDir({ dir, agent: agent.name, input });
+        handler: async (options) => {
+            if (options.logLevel)
+                logger.level = options.logLevel;
+            await invokeCLIAgentFromDir({ dir, agent: agent.name, input: options });
         },
     };
 };
 export async function invokeCLIAgentFromDir(options) {
     const aigne = await loadAIGNE({
         path: options.dir,
-        modelOptions: { model: options.input.model },
+        modelOptions: options.input,
     });
     try {
-        const { chat, agents } = aigne.cli;
-        const agent = chat && chat.name === options.agent ? chat : agents[options.agent];
+        const { chat } = aigne.cli;
+        const agent = chat && chat.name === options.agent
+            ? chat
+            : aigne.cli.agents[options.agent] ||
+                aigne.agents[options.agent] ||
+                aigne.skills[options.agent] ||
+                aigne.mcpServer.agents[options.agent];
         assert(agent, `Agent ${options.agent} not found in ${options.dir}`);
         const input = await parseAgentInput(options.input, agent);
-        await runAgentWithAIGNE(aigne, agent, { input, chat: agent === chat });
+        await runAgentWithAIGNE(aigne, agent, {
+            ...options.input,
+            input,
+            chat: agent === chat || options.input.chat,
+        });
     }
     finally {
         await aigne.shutdown();

package/dist/commands/run.d.ts

@@ -1,4 +1,6 @@
 import type { CommandModule } from "yargs";
 export declare function createRunCommand({ aigneFilePath, }?: {
     aigneFilePath?: string;
-}): CommandModule;
+}): CommandModule<unknown, {
+    path?: string;
+}>;

package/dist/commands/run.js

@@ -1,155 +1,97 @@
-import assert from "node:assert";
 import { cp, mkdir, rm } from "node:fs/promises";
 import { homedir } from "node:os";
 import { isAbsolute, join, resolve } from "node:path";
-import { logger } from "@aigne/core/utils/logger.js";
-import { isNonNullable } from "@aigne/core/utils/type-utils.js";
+import { flat, isNonNullable } from "@aigne/core/utils/type-utils.js";
 import { Listr, PRESET_TIMER } from "@aigne/listr2";
-import { input as inputInquirer, select as selectInquirer } from "@inquirer/prompts";
-import { ListrInquirerPromptAdapter } from "@listr2/prompt-adapter-inquirer";
 import { config } from "dotenv-flow";
+import yargs from "yargs";
 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";
+import { agentCommandModule } from "./app.js";
 export function createRunCommand({ aigneFilePath, } = {}) {
     return {
         command: "run [path]",
-        describe: "Run AIGNE from the specified agent",
-        builder: (yargs) => {
-            return createRunAIGNECommand(yargs)
+        describe: "Run AIGNE for the specified path",
+        builder: async (yargs) => {
+            return yargs
                 .positional("path", {
-                describe: "Path to the agents directory or URL to aigne project",
                 type: "string",
+                describe: "Path to the agents directory or URL to an aigne project",
                 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",
-            })
-                .option("aigne-hub-url", {
-                describe: "Custom AIGNE Hub service URL. Used to fetch remote agent definitions or models. ",
-                type: "string",
             })
+                .help(false)
+                .version(false)
                 .strict(false);
         },
-        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 originalLog = {};
-            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 });
-                        ctx.logs = [];
-                        for (const method of ["debug", "log", "info", "warn", "error"]) {
-                            originalLog[method] = console[method];
-                            console[method] = (...args) => {
-                                ctx.logs.push(...args);
-                                task.output = args.join(" ");
-                            };
-                        }
-                        try {
-                            const aigne = await loadAIGNE({
-                                path: dir,
-                                modelOptions: {
-                                    ...options,
-                                    inquirerPromptFn: (prompt) => {
-                                        if (prompt.type === "input") {
-                                            return task
-                                                .prompt(ListrInquirerPromptAdapter)
-                                                .run(inputInquirer, prompt)
-                                                .then((res) => ({ [prompt.name]: res }));
-                                        }
-                                        return task
-                                            .prompt(ListrInquirerPromptAdapter)
-                                            .run(selectInquirer, prompt)
-                                            .then((res) => ({ [prompt.name]: res }));
-                                    },
-                                },
-                            });
-                            ctx.aigne = aigne;
-                        }
-                        finally {
-                            Object.assign(console, originalLog);
-                        }
-                    },
-                },
-                {
-                    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}`);
-                        }
-                        ctx.agent = entryAgent;
-                    },
-                },
-            ], {
-                rendererOptions: {
-                    collapseSubtasks: false,
-                    showErrorMessage: false,
-                    timer: PRESET_TIMER,
-                },
-            })
-                .run()
-                .then((ctx) => {
-                ctx.logs.forEach((log) => console.log(log));
-                return ctx;
-            });
-            assert(aigne);
-            assert(agent);
-            const input = await parseAgentInputByCommander(agent, options);
-            try {
-                await runAgentWithAIGNE(aigne, agent, { ...options, input });
+        handler: async (options) => {
+            const p = aigneFilePath || options.path;
+            if (!p)
+                throw new Error("No path specified");
+            const { aigne, path } = await loadApplication(p);
+            const subYargs = yargs().scriptName("").usage("aigne run <path> <agent> [...options]");
+            if (aigne.cli.chat) {
+                subYargs.command({
+                    ...agentCommandModule({ dir: path, agent: aigne.cli.chat }),
+                    command: "$0",
+                });
             }
-            finally {
-                await aigne.shutdown();
+            // Allow user to run all of agents in the AIGNE instances
+            for (const agent of flat(aigne.cli.agents, aigne.agents, aigne.skills, aigne.cli.chat, aigne.mcpServer.agents)) {
+                subYargs.command(agentCommandModule({ dir: path, agent }));
             }
+            const argv = process.argv.slice(aigneFilePath ? 3 : 2);
+            if (argv[0] === "run")
+                argv.shift(); // remove 'run' command
+            // For compatibility with old `run` command like: `aigne run --path /xx/xx --entry-agent xx --xx`
+            if (argv[0] === "--path" || argv[0] === "--url")
+                argv.shift(); // remove --path flag
+            if (argv[0] === options.path)
+                argv.shift(); // remove path/url args
+            if (argv[0] === "--entry-agent")
+                argv.shift();
+            await subYargs
+                .strict()
+                .demandCommand()
+                .alias("h", "help")
+                .alias("v", "version")
+                .fail((message, error, yargs) => {
+                // We catch all errors below, here just print the help message non-error case like demandCommand
+                if (!error) {
+                    yargs.showHelp();
+                    console.error(`\n${message}`);
+                    process.exit(1);
+                }
+            })
+                .parseAsync(argv);
         },
     };
 }
+async function loadApplication(path) {
+    const { cacheDir, dir } = prepareDirs(path);
+    if (cacheDir) {
+        await new Listr([
+            {
+                title: "Download package",
+                task: () => downloadPackage(path, cacheDir),
+            },
+            {
+                title: "Extract package",
+                task: () => extractPackage(cacheDir, dir),
+            },
+        ], {
+            rendererOptions: {
+                collapseSubtasks: false,
+                showErrorMessage: false,
+                timer: PRESET_TIMER,
+            },
+        }).run();
+    }
+    // Load env files in the aigne directory
+    config({ path: dir, silent: true });
+    const aigne = await loadAIGNE({ path: dir });
+    return { aigne, path: dir };
+}
 async function downloadPackage(url, cacheDir) {
     await rm(cacheDir, { recursive: true, force: true });
     await mkdir(cacheDir, { recursive: true });
@@ -164,18 +106,12 @@ async function extractPackage(cacheDir, dir) {
         await cp(cacheDir, dir, { recursive: true, force: true });
     }
 }
-function prepareDirs(path, options) {
+function prepareDirs(path) {
     let dir;
     let cacheDir;
     if (!path.startsWith("http")) {
         dir = isAbsolute(path) ? path : resolve(process.cwd(), path);
     }
-    else if (options.cacheDir) {
-        dir = isAbsolute(options.cacheDir)
-            ? options.cacheDir
-            : resolve(process.cwd(), options.cacheDir);
-        cacheDir = join(dir, ".download");
-    }
     else {
         dir = getLocalPackagePathFromUrl(path);
         cacheDir = getLocalPackagePathFromUrl(path, { subdir: ".download" });

package/dist/tracer/terminal.d.ts

@@ -5,6 +5,7 @@ import { type Listr } from "@aigne/listr2";
 import { type AIGNEListrTaskWrapper } from "../utils/listr.js";
 export interface TerminalTracerOptions {
     outputKey?: string;
+    fileOutputKey?: string;
 }
 export declare class TerminalTracer {
     readonly context: Context;
@@ -31,12 +32,15 @@ export declare class TerminalTracer {
     }): Promise<string>;
     private marked;
     get outputKey(): string;
+    get dataOutputKey(): string;
     formatRequest(agent: Agent, _context: Context, m?: Message, { running }?: {
         running?: boolean | undefined;
     }): string | undefined;
-    formatResult(agent: Agent, context: Context, m?: Message, { running }?: {
+    formatResult(agent: Agent, context: Context, m?: Message, { running, renderImage }?: {
         running?: boolean | undefined;
-    }): string;
+        renderImage?: boolean | undefined;
+    }): string | Promise<string>;
+    formatResultData(output: Message): Promise<string | undefined>;
     protected runningInspectOptions: InspectOptions;
 }
 type Task = ReturnType<typeof promiseWithResolvers<void>> & {

package/dist/tracer/terminal.js

@@ -1,6 +1,6 @@
 import { EOL } from "node:os";
 import { inspect } from "node:util";
-import { AIAgent, ChatModel, DEFAULT_OUTPUT_KEY, mergeContextUsage, newEmptyContextUsage, UserAgent, } from "@aigne/core";
+import { AIAgent, ChatModel, DEFAULT_FILE_OUTPUT_KEY, DEFAULT_OUTPUT_KEY, mergeContextUsage, newEmptyContextUsage, UserAgent, } from "@aigne/core";
 import { promiseWithResolvers } from "@aigne/core/utils/promise.js";
 import { flat, omit } from "@aigne/core/utils/type-utils.js";
 import { figures } from "@aigne/listr2";
@@ -8,6 +8,9 @@ import { markedTerminal } from "@aigne/marked-terminal";
 import * as prompts from "@inquirer/prompts";
 import chalk from "chalk";
 import { Marked } from "marked";
+import terminalImage from "terminal-image";
+import terminalLink from "terminal-link";
+import { withProtocol } from "ufo";
 import { AIGNE_HUB_CREDITS_NOT_ENOUGH_ERROR_TYPE } from "../constants.js";
 import checkbox from "../utils/inquirer/checkbox.js";
 import { AIGNEListr, AIGNEListrRenderer } from "../utils/listr.js";
@@ -27,7 +30,7 @@ export class TerminalTracer {
         const context = this.context.newContext({ reset: true });
         const listr = new AIGNEListr({
             formatRequest: (options) => this.formatRequest(agent, context, input, options),
-            formatResult: (result, options) => [this.formatResult(agent, context, result, options)].filter(Boolean),
+            formatResult: (result, options) => this.formatResult(agent, context, result, options),
         }, [], { concurrent: true, exitOnError: false });
         this.listr = listr;
         const collapsedMap = new Map();
@@ -228,7 +231,9 @@ export class TerminalTracer {
             });
             return retry;
         })();
-        return this.buyCreditsPromptPromise.finally(() => {
+        return this.buyCreditsPromptPromise
+            .catch(() => "exit")
+            .finally(() => {
             // Clear the promise so that we can show the prompt again if needed
             this.buyCreditsPromptPromise = undefined;
         });
@@ -282,6 +287,9 @@ export class TerminalTracer {
     get outputKey() {
         return this.options.outputKey || DEFAULT_OUTPUT_KEY;
     }
+    get dataOutputKey() {
+        return this.options.fileOutputKey || DEFAULT_FILE_OUTPUT_KEY;
+    }
     formatRequest(agent, _context, m = {}, { running = false } = {}) {
         const prefix = `${chalk.grey(figures.pointer)} 💬 `;
         const inputKey = agent instanceof AIAgent ? agent.inputKey : undefined;
@@ -296,12 +304,12 @@ export class TerminalTracer {
             return undefined;
         return `${prefix}${r}`;
     }
-    formatResult(agent, context, m = {}, { running = false } = {}) {
+    formatResult(agent, context, m = {}, { running = false, renderImage = false } = {}) {
         const { isTTY } = process.stdout;
         const outputKey = this.outputKey || (agent instanceof AIAgent ? agent.outputKey : undefined);
         const prefix = `${chalk.grey(figures.tick)} 🤖 ${this.formatTokenUsage(context.usage)}`;
         const msg = outputKey ? m[outputKey] : undefined;
-        const message = outputKey ? omit(m, outputKey) : m;
+        const message = outputKey ? omit(m, outputKey, this.dataOutputKey) : m;
         const text = msg && typeof msg === "string"
             ? isTTY
                 ? this.marked.parse(msg, { async: false }).trim()
@@ -310,8 +318,43 @@ export class TerminalTracer {
         const json = Object.keys(message).length > 0
             ? inspect(message, { colors: isTTY, ...(running ? this.runningInspectOptions : undefined) })
             : undefined;
+        if (renderImage) {
+            return this.formatResultData(m).then((images) => {
+                return [prefix, text, images, json].filter(Boolean).join(EOL.repeat(2));
+            });
+        }
         return [prefix, text, json].filter(Boolean).join(EOL.repeat(2));
     }
+    async formatResultData(output) {
+        const data = output[this.dataOutputKey];
+        if (!Array.isArray(data))
+            return;
+        const options = {
+            height: 30,
+        };
+        return (await Promise.all(data.map(async (item) => {
+            const image = item.type === "local"
+                ? await terminalImage.file(item.path, options)
+                : item.type === "file"
+                    ? await terminalImage.buffer(Buffer.from(item.data, "base64"), options)
+                    : undefined;
+            const link = item.type === "local"
+                ? withProtocol(item.path, "file://")
+                : item.type === "url"
+                    ? item.url
+                    : undefined;
+            const text = [
+                link ? chalk.cyan(terminalLink(link, link)) : undefined,
+                item.filename,
+                item.mimeType ? chalk.gray(item.mimeType) : undefined,
+            ]
+                .filter(Boolean)
+                .join(" ");
+            return [image, text].filter(Boolean).join(EOL);
+        })))
+            .filter(Boolean)
+            .join(EOL);
+    }
     runningInspectOptions = {
         maxArrayLength: 3,
         maxStringLength: 200,

package/dist/utils/agent-v1.js

@@ -18,12 +18,16 @@ export async function toAIGNEPackage(src, dst) {
             name: "gpt-4o-mini", // TODO: get from config
         },
         agents: [],
+        cli: {
+            agents: [],
+        },
     };
     for (const agent of definition.agents) {
         const { content } = await assistantToAIGNEV2(agent, definition);
         const filename = getAgentFilename(agent);
         await writeFile(join(dst, filename), content);
         aigne.agents.push(filename);
+        aigne.cli.agents.push(filename);
     }
     await writeFile(join(dst, "aigne.yaml"), stringify(aigne));
 }

package/dist/utils/aigne-hub/model.js

@@ -1,5 +1,5 @@
 import { AIGNE_HUB_DEFAULT_MODEL, findModel } from "@aigne/aigne-hub";
-import { flat } from "@aigne/core/utils/type-utils.js";
+import { flat, pick } from "@aigne/core/utils/type-utils.js";
 import chalk from "chalk";
 import inquirer from "inquirer";
 import { AIGNE_HUB_PROVIDER } from "./constants.js";
@@ -55,10 +55,13 @@ export async function loadChatModel(options) {
         inquirer.prompt);
     const params = {
         model,
-        temperature: options?.temperature,
-        topP: options?.topP,
-        frequencyPenalty: options?.frequencyPenalty,
-        presencePenalty: options?.presencePenalty,
+        ...pick(options ?? {}, [
+            "modalities",
+            "temperature",
+            "topP",
+            "frequencyPenalty",
+            "presencePenalty",
+        ]),
     };
     const { match, all } = findModel(provider);
     if (!match) {

package/dist/utils/listr.d.ts

@@ -8,7 +8,8 @@ export declare class AIGNEListr extends Listr<object, typeof AIGNEListrRenderer,
         formatRequest: () => string | undefined;
         formatResult: (result: Message, options?: {
             running?: boolean;
-        }) => string[];
+            renderImage?: boolean;
+        }) => string | Promise<string>;
     };
     private result;
     private error?;
@@ -18,7 +19,8 @@ export declare class AIGNEListr extends Listr<object, typeof AIGNEListrRenderer,
         formatRequest: () => string | undefined;
         formatResult: (result: Message, options?: {
             running?: boolean;
-        }) => string[];
+            renderImage?: boolean;
+        }) => string | Promise<string>;
     }, ...[task, options, parentTask]: ConstructorParameters<typeof Listr<object, typeof AIGNEListrRenderer, typeof AIGNEListrFallbackRenderer>>);
     run(stream: () => PromiseOrValue<AgentResponseStream<Message>>): Promise<Message>;
     private extractStream;

package/dist/utils/listr.js

@@ -16,7 +16,12 @@ export class AIGNEListr extends Listr {
                 return this.logs.splice(0);
             },
             getBottomBarLogs: (options) => {
-                return this.myOptions.formatResult(this.result, options);
+                if (!options?.running)
+                    return [];
+                const r = this.myOptions.formatResult(this.result);
+                if (typeof r !== "string")
+                    throw new Error("Must return a string result for running task");
+                return [r];
             },
         };
         super(task, {
@@ -71,11 +76,13 @@ export class AIGNEListr extends Listr {
             }
             const _stream = await stream();
             this.add({ task: () => this.extractStream(_stream) });
-            return await super.run().then(() => {
+            const result = await super.run().then(() => {
                 if (this.error)
                     throw this.error;
                 return { ...this.result };
             });
+            console.log(await this.myOptions.formatResult(this.result, { running: false, renderImage: true }));
+            return result;
         }
         finally {
             logger.logMessage = originalLog;

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

@@ -1,7 +1,7 @@
 import { AIGNE, type ChatModelOptions } from "@aigne/core";
 import type { LoadCredentialOptions } from "./aigne-hub/type.js";
-import type { RunAIGNECommandOptions } from "./run-with-aigne.js";
-export interface RunOptions extends RunAIGNECommandOptions {
+import type { AgentRunCommonOptions } from "./yargs.js";
+export interface RunOptions extends AgentRunCommonOptions {
     path: string;
     entryAgent?: string;
     cacheDir?: string;

package/dist/utils/run-chat-loop.d.ts

@@ -1,10 +1,13 @@
-import type { Message, UserAgent } from "@aigne/core";
+import { type Message, type UserAgent } from "@aigne/core";
 export declare const DEFAULT_CHAT_INPUT_KEY = "message";
 export interface ChatLoopOptions {
     initialCall?: Message | string;
     welcome?: string;
     defaultQuestion?: string;
     inputKey?: string;
+    fileInputKey?: string;
     outputKey?: string;
+    dataOutputKey?: string;
+    input?: Message;
 }
 export declare function runChatLoopInTerminal(userAgent: UserAgent<any, any>, options?: ChatLoopOptions): Promise<void>;

package/dist/utils/run-chat-loop.js

@@ -1,3 +1,7 @@
+import { readFile } from "node:fs/promises";
+import { basename } from "node:path";
+import { ChatModel } from "@aigne/core";
+import { isNonNullable, omit } from "@aigne/core/utils/type-utils.js";
 import inquirer from "inquirer";
 import { TerminalTracer } from "../tracer/terminal.js";
 export const DEFAULT_CHAT_INPUT_KEY = "message";
@@ -7,7 +11,10 @@ export async function runChatLoopInTerminal(userAgent, options = {}) {
     if (options?.welcome)
         console.log(options.welcome);
     if (initialCall) {
-        await callAgent(userAgent, initialCall, { ...options });
+        await callAgent(userAgent, initialCall, options);
+        if (options.input && options.fileInputKey) {
+            options.input = omit(options.input, options.fileInputKey);
+        }
     }
     for (let i = 0;; i++) {
         prompt = inquirer.prompt([
@@ -36,12 +43,50 @@ export async function runChatLoopInTerminal(userAgent, options = {}) {
                 break;
             continue;
         }
-        await callAgent(userAgent, question, { ...options });
+        const input = {};
+        if (options.fileInputKey) {
+            const { message, files } = await extractFilesFromQuestion(question);
+            input[options.inputKey || DEFAULT_CHAT_INPUT_KEY] = message;
+            input[options.fileInputKey] = files;
+        }
+        else {
+            input[options.inputKey || DEFAULT_CHAT_INPUT_KEY] = question;
+        }
+        await callAgent(userAgent, input, options);
+        if (options.input && options.fileInputKey) {
+            options.input = omit(options.input, options.fileInputKey);
+        }
+    }
+}
+async function extractFilesFromQuestion(question) {
+    const fileRegex = /@\S+/g;
+    const paths = question.match(fileRegex) || [];
+    const files = (await Promise.all(paths.map(async (path) => {
+        const p = path.slice(1);
+        const filename = basename(p);
+        const data = await readFile(p, "base64").catch((error) => {
+            if (error.code === "ENOENT")
+                return null;
+            throw error;
+        });
+        if (!data)
+            return;
+        return {
+            path,
+            file: { type: "file", data, filename, mimeType: ChatModel.getMimeType(filename) },
+        };
+    }))).filter(isNonNullable);
+    // Remove file paths from question
+    for (const { path } of files) {
+        question = question.replaceAll(path, "");
     }
+    return { message: question, files: files.map((i) => i.file) };
 }
 async function callAgent(userAgent, input, options) {
     const tracer = new TerminalTracer(userAgent.context, options);
-    await tracer.run(userAgent, typeof input === "string" ? { [options.inputKey || DEFAULT_CHAT_INPUT_KEY]: input } : input);
+    await tracer.run(userAgent, typeof input === "string"
+        ? { ...options.input, [options.inputKey || DEFAULT_CHAT_INPUT_KEY]: input }
+        : { ...options.input, ...input });
 }
 const COMMANDS = {
     "/exit": () => ({ exit: true }),

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

@@ -1,50 +1,8 @@
 import { type Agent, type 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 type { Argv } from "yargs";
 import { type ChatLoopOptions } from "./run-chat-loop.js";
-export interface RunAIGNECommandOptions {
-    chat?: boolean;
-    model?: string;
-    temperature?: number;
-    topP?: number;
-    presencePenalty?: number;
-    frequencyPenalty?: number;
-    input?: string[];
-    format?: "text" | "json" | "yaml";
-    output?: string;
-    outputKey?: string;
-    logLevel?: LogLevel;
-    force?: boolean;
-}
-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;
-} & {
-    "aigne-hub-url": string | undefined;
-}>;
-export declare function parseAgentInputByCommander(agent: Agent, options?: RunAIGNECommandOptions & {
+import { type AgentRunCommonOptions } from "./yargs.js";
+export declare function parseAgentInputByCommander(agent: Agent, options?: AgentRunCommonOptions & {
     inputKey?: string;
     argv?: string[];
     defaultInput?: string | Message;
@@ -55,11 +13,11 @@ export declare function runWithAIGNE(agentCreator: ((aigne: AIGNE) => PromiseOrV
     modelOptions?: ChatModelOptions;
     outputKey?: string;
 }): Promise<void>;
-export declare function runAgentWithAIGNE(aigne: AIGNE, agent: Agent, { outputKey, chatLoopOptions, modelOptions, ...options }?: {
+export declare function runAgentWithAIGNE(aigne: AIGNE, agent: Agent, { outputKey, fileOutputKey, chatLoopOptions, ...options }?: {
     outputKey?: string;
+    fileOutputKey?: string;
     chatLoopOptions?: ChatLoopOptions;
-    modelOptions?: ChatModelOptions;
     input?: Message;
-} & Omit<RunAIGNECommandOptions, "input">): Promise<{
+} & Omit<AgentRunCommonOptions, "input">): Promise<{
     result: Message;
 } | undefined>;

package/dist/utils/run-with-aigne.js

@@ -2,89 +2,16 @@ import { mkdir, stat, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join } from "node:path";
 import { isatty } from "node:tty";
 import { exists } from "@aigne/agent-library/utils/fs.js";
-import { availableModels } from "@aigne/aigne-hub";
-import { DEFAULT_OUTPUT_KEY, UserAgent, } from "@aigne/core";
-import { getLevelFromEnv, LogLevel, logger } from "@aigne/core/utils/logger.js";
-import { isEmpty, isNil, omitBy, pick, tryOrThrow, } from "@aigne/core/utils/type-utils.js";
+import { AIAgent, DEFAULT_OUTPUT_KEY, UserAgent, } from "@aigne/core";
+import { logger } from "@aigne/core/utils/logger.js";
+import { isEmpty, isNil, omitBy, pick } from "@aigne/core/utils/type-utils.js";
 import chalk from "chalk";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
-import { ZodError, z } from "zod";
 import { TerminalTracer } from "../tracer/terminal.js";
 import { loadAIGNE } from "./load-aigne.js";
 import { DEFAULT_CHAT_INPUT_KEY, runChatLoopInTerminal, } from "./run-chat-loop.js";
-import { parseAgentInput, withAgentInputSchema } from "./yargs.js";
-export const createRunAIGNECommand = (yargs) => yargs
-    .option("chat", {
-    describe: "Run chat loop in terminal",
-    type: "boolean",
-    default: false,
-})
-    .option("model", {
-    describe: `AI model to use in format 'provider[:model]' where model is optional. Examples: 'openai' or 'openai:gpt-4o-mini'. Available providers: ${availableModels()
-        .map((i) => {
-        if (typeof i.name === "string") {
-            return i.name.toLowerCase().replace(/ChatModel$/i, "");
-        }
-        return i.name.map((n) => n.toLowerCase().replace(/ChatModel$/i, ""));
-    })
-        .join(", ")} (default: openai)`,
-    type: "string",
-})
-    .option("temperature", {
-    describe: "Temperature for the model (controls randomness, higher values produce more random outputs). Range: 0.0-2.0",
-    type: "number",
-    coerce: customZodError("--temperature", (s) => z.coerce.number().min(0).max(2).parse(s)),
-})
-    .option("top-p", {
-    describe: "Top P (nucleus sampling) parameter for the model (controls diversity). Range: 0.0-1.0",
-    type: "number",
-    coerce: customZodError("--top-p", (s) => z.coerce.number().min(0).max(1).parse(s)),
-})
-    .option("presence-penalty", {
-    describe: "Presence penalty for the model (penalizes repeating the same tokens). Range: -2.0 to 2.0",
-    type: "number",
-    coerce: customZodError("--presence-penalty", (s) => z.coerce.number().min(-2).max(2).parse(s)),
-})
-    .option("frequency-penalty", {
-    describe: "Frequency penalty for the model (penalizes frequency of token usage). Range: -2.0 to 2.0",
-    type: "number",
-    coerce: customZodError("--frequency-penalty", (s) => z.coerce.number().min(-2).max(2).parse(s)),
-})
-    .option("input", {
-    describe: "Input to the agent, use @<file> to read from a file",
-    type: "array",
-    alias: "i",
-})
-    .option("format", {
-    describe: "Input format for the agent (available: text, json, yaml default: text)",
-    type: "string",
-})
-    .option("output", {
-    describe: "Output file to save the result (default: stdout)",
-    type: "string",
-    alias: "o",
-})
-    .option("output-key", {
-    describe: "Key in the result to save to the output file",
-    type: "string",
-    default: DEFAULT_OUTPUT_KEY,
-})
-    .option("force", {
-    describe: "Truncate the output file if it exists, and create directory if the output path is not exists",
-    type: "boolean",
-    default: false,
-})
-    .option("log-level", {
-    describe: `Log level for detailed debugging information. Values: ${Object.values(LogLevel).join(", ")}`,
-    type: "string",
-    default: getLevelFromEnv(logger.options.ns) || LogLevel.SILENT,
-    coerce: customZodError("--log-level", (s) => z.nativeEnum(LogLevel).parse(s)),
-})
-    .option("aigne-hub-url", {
-    describe: "Custom AIGNE Hub service URL. Used to fetch remote agent definitions or models. ",
-    type: "string",
-});
+import { parseAgentInput, withAgentInputSchema, withRunAgentCommonOptions, } from "./yargs.js";
 export async function parseAgentInputByCommander(agent, options = {}) {
     const args = await withAgentInputSchema(yargs(), agent)
         .showHelpOnFail(false)
@@ -94,14 +21,18 @@ export async function parseAgentInputByCommander(agent, options = {}) {
     if (isEmpty(input)) {
         const defaultInput = options.defaultInput || process.env.INITIAL_CALL;
         Object.assign(input, typeof defaultInput === "string"
-            ? { [options?.inputKey || DEFAULT_CHAT_INPUT_KEY]: defaultInput }
+            ? {
+                [options?.inputKey ||
+                    (agent instanceof AIAgent ? agent.inputKey : undefined) ||
+                    DEFAULT_CHAT_INPUT_KEY]: defaultInput,
+            }
             : defaultInput);
     }
     return input;
 }
 export async function runWithAIGNE(agentCreator, { argv = process.argv, chatLoopOptions, modelOptions, outputKey, } = {}) {
     await yargs()
-        .command("$0", "Run an agent with AIGNE", (yargs) => createRunAIGNECommand(yargs), async (options) => {
+        .command("$0", "Execute an AI agent using the AIGNE framework with specified configuration", (yargs) => withRunAgentCommonOptions(yargs), async (options) => {
         if (options.logLevel) {
             logger.level = options.logLevel;
         }
@@ -122,7 +53,6 @@ export async function runWithAIGNE(agentCreator, { argv = process.argv, chatLoop
                 ...options,
                 outputKey: outputKey || options.outputKey,
                 chatLoopOptions,
-                modelOptions,
                 input,
             });
         }
@@ -132,16 +62,19 @@ export async function runWithAIGNE(agentCreator, { argv = process.argv, chatLoop
     })
         .alias("h", "help")
         .alias("v", "version")
+        .fail((message, error, yargs) => {
+        if (!error)
+            yargs.showHelp();
+        console.error(`\n${message || error?.message}`);
+        process.exit(1);
+    })
         .parseAsync(hideBin(argv))
         .catch((error) => {
         console.error(`${chalk.red("Error:")} ${error.message}`);
         process.exit(1);
     });
 }
-function customZodError(label, fn) {
-    return ((...args) => tryOrThrow(() => fn(...args), (e) => new Error(`${label} ${e instanceof ZodError ? e.issues[0]?.message : e.message}`)));
-}
-export async function runAgentWithAIGNE(aigne, agent, { outputKey, chatLoopOptions, modelOptions, ...options } = {}) {
+export async function runAgentWithAIGNE(aigne, agent, { outputKey, fileOutputKey, chatLoopOptions, ...options } = {}) {
     if (options.output) {
         const outputPath = isAbsolute(options.output)
             ? options.output
@@ -167,10 +100,12 @@ export async function runAgentWithAIGNE(aigne, agent, { outputKey, chatLoopOptio
         await runChatLoopInTerminal(userAgent, {
             ...chatLoopOptions,
             outputKey,
+            fileInputKey: agent instanceof AIAgent ? agent.fileInputKey : undefined,
+            input: options.input,
         });
         return;
     }
-    const tracer = new TerminalTracer(aigne.newContext(), { outputKey });
+    const tracer = new TerminalTracer(aigne.newContext(), { outputKey, fileOutputKey });
     const { result } = await tracer.run(agent, options.input ?? {});
     if (options.output) {
         const message = result[outputKey || DEFAULT_OUTPUT_KEY];

package/dist/utils/yargs.d.ts

@@ -1,6 +1,47 @@
 import { type Agent, type Message } from "@aigne/core";
+import { LogLevel } from "@aigne/core/utils/logger.js";
 import type { Argv } from "yargs";
 import { ZodType } from "zod";
+export type InferArgv<T> = T extends Argv<infer U> ? U : never;
+export declare const withRunAgentCommonOptions: (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[] | undefined;
+} & {
+    "input-file": string[] | undefined;
+} & {
+    format: string | undefined;
+} & {
+    output: string | undefined;
+} & {
+    "output-key": string;
+} & {
+    force: boolean;
+} & {
+    "log-level": LogLevel;
+} & {
+    "aigne-hub-url": string | undefined;
+}>;
+type _AgentRunCommonOptions = Partial<InferArgv<ReturnType<typeof withAgentInputSchema>>>;
+/** Convert literal string types like 'foo-bar' to 'FooBar' */
+type PascalCase<S extends string> = string extends S ? string : S extends `${infer T}-${infer U}` ? `${Capitalize<T>}${PascalCase<U>}` : Capitalize<S>;
+/** Convert literal string types like 'foo-bar' to 'fooBar' */
+type CamelCase<S extends string> = string extends S ? string : S extends `${infer T}-${infer U}` ? `${T}${PascalCase<U>}` : S;
+/** Convert literal string types like 'foo-bar' to 'fooBar', allowing all `PropertyKey` types */
+type CamelCaseKey<K extends PropertyKey> = K extends string ? Exclude<CamelCase<K>, ""> : K;
+export type AgentRunCommonOptions = {
+    [key in keyof _AgentRunCommonOptions as CamelCaseKey<key>]: _AgentRunCommonOptions[key];
+};
 export declare function inferZodType(type: ZodType, opts?: {
     array?: boolean;
     optional?: boolean;
@@ -10,11 +51,34 @@ export declare function inferZodType(type: ZodType, opts?: {
     optional?: boolean;
 };
 export declare function withAgentInputSchema(yargs: Argv, agent: Agent): Argv<{
-    input?: string[];
-    format?: "json" | "yaml";
+    chat: boolean;
+} & {
+    model: string | undefined;
+} & {
+    temperature: number | undefined;
+} & {
+    "top-p": number | undefined;
+} & {
+    "presence-penalty": number | undefined;
+} & {
+    "frequency-penalty": number | undefined;
+} & {
+    input: string[] | undefined;
+} & {
+    "input-file": string[] | undefined;
+} & {
+    format: string | undefined;
+} & {
+    output: string | undefined;
+} & {
+    "output-key": string;
+} & {
+    force: boolean;
+} & {
+    "log-level": LogLevel;
+} & {
+    "aigne-hub-url": string | undefined;
 }>;
-export declare function parseAgentInput(i: Message & {
-    input?: string[];
-    format?: "json" | "yaml";
-}, agent: Agent): Promise<any>;
+export declare function parseAgentInput(i: Message & AgentRunCommonOptions, agent: Agent): Promise<any>;
 export declare function stdinHasData(): Promise<boolean>;
+export {};

package/dist/utils/yargs.js

@@ -1,12 +1,99 @@
 import { fstat } from "node:fs";
 import { readFile } from "node:fs/promises";
-import { extname } from "node:path";
+import { basename, extname } from "node:path";
 import { isatty } from "node:tty";
 import { promisify } from "node:util";
-import { AIAgent, readAllString } from "@aigne/core";
-import { pick } from "@aigne/core/utils/type-utils.js";
+import { availableModels } from "@aigne/aigne-hub";
+import { AIAgent, ChatModel, DEFAULT_OUTPUT_KEY, readAllString, } from "@aigne/core";
+import { getLevelFromEnv, LogLevel, logger } from "@aigne/core/utils/logger.js";
+import { pick, tryOrThrow } from "@aigne/core/utils/type-utils.js";
 import { parse } from "yaml";
-import { ZodAny, ZodArray, ZodBoolean, ZodNumber, ZodObject, ZodString, ZodType, ZodUnknown, } from "zod";
+import z, { ZodAny, ZodArray, ZodBoolean, ZodError, ZodNumber, ZodObject, ZodString, ZodType, ZodUnknown, } from "zod";
+const MODEL_OPTIONS_GROUP_NAME = "Model Options";
+export const withRunAgentCommonOptions = (yargs) => yargs
+    .option("chat", {
+    describe: "Run chat loop in terminal",
+    type: "boolean",
+    default: false,
+})
+    .option("model", {
+    group: MODEL_OPTIONS_GROUP_NAME,
+    describe: `AI model to use in format 'provider[:model]' where model is optional. Examples: 'openai' or 'openai:gpt-4o-mini'. Available providers: ${availableModels()
+        .map((i) => {
+        if (typeof i.name === "string") {
+            return i.name.toLowerCase().replace(/ChatModel$/i, "");
+        }
+        return i.name.map((n) => n.toLowerCase().replace(/ChatModel$/i, ""));
+    })
+        .join(", ")} (default: openai)`,
+    type: "string",
+})
+    .option("temperature", {
+    group: MODEL_OPTIONS_GROUP_NAME,
+    describe: "Temperature for the model (controls randomness, higher values produce more random outputs). Range: 0.0-2.0",
+    type: "number",
+    coerce: customZodError("--temperature", (s) => z.coerce.number().min(0).max(2).parse(s)),
+})
+    .option("top-p", {
+    group: MODEL_OPTIONS_GROUP_NAME,
+    describe: "Top P (nucleus sampling) parameter for the model (controls diversity). Range: 0.0-1.0",
+    type: "number",
+    coerce: customZodError("--top-p", (s) => z.coerce.number().min(0).max(1).parse(s)),
+})
+    .option("presence-penalty", {
+    group: MODEL_OPTIONS_GROUP_NAME,
+    describe: "Presence penalty for the model (penalizes repeating the same tokens). Range: -2.0 to 2.0",
+    type: "number",
+    coerce: customZodError("--presence-penalty", (s) => z.coerce.number().min(-2).max(2).parse(s)),
+})
+    .option("frequency-penalty", {
+    group: MODEL_OPTIONS_GROUP_NAME,
+    describe: "Frequency penalty for the model (penalizes frequency of token usage). Range: -2.0 to 2.0",
+    type: "number",
+    coerce: customZodError("--frequency-penalty", (s) => z.coerce.number().min(-2).max(2).parse(s)),
+})
+    .option("input", {
+    describe: "Input to the agent, use @<file> to read from a file",
+    type: "string",
+    array: true,
+    alias: "i",
+})
+    .option("input-file", {
+    describe: "Input files to the agent",
+    type: "string",
+    array: true,
+})
+    .option("format", {
+    describe: "Input format for the agent (available: text, json, yaml default: text)",
+    type: "string",
+    choices: ["text", "json", "yaml"],
+})
+    .option("output", {
+    describe: "Output file to save the result (default: stdout)",
+    type: "string",
+    alias: "o",
+})
+    .option("output-key", {
+    describe: "Key in the result to save to the output file",
+    type: "string",
+    default: DEFAULT_OUTPUT_KEY,
+})
+    .option("force", {
+    describe: "Truncate the output file if it exists, and create directory if the output path does not exists",
+    type: "boolean",
+    default: false,
+})
+    .option("log-level", {
+    describe: `Log level for detailed debugging information. Values: ${Object.values(LogLevel).join(", ")}`,
+    type: "string",
+    default: getLevelFromEnv(logger.options.ns) || LogLevel.SILENT,
+    coerce: customZodError("--log-level", (s) => z.nativeEnum(LogLevel).parse(s)),
+})
+    .option("aigne-hub-url", {
+    group: MODEL_OPTIONS_GROUP_NAME,
+    describe: "Custom AIGNE Hub service URL. Used to fetch remote agent definitions or models.",
+    type: "string",
+});
 export function inferZodType(type, opts = {}) {
     if (type instanceof ZodUnknown || type instanceof ZodAny) {
         return { type: "string", optional: true };
@@ -30,6 +117,7 @@ export function withAgentInputSchema(yargs, agent) {
     for (const [option, config] of Object.entries(inputSchema)) {
         const type = inferZodType(config);
         yargs.option(option, {
+            group: "Agent Parameters",
             type: type.type,
             description: config.description,
             array: type.array,
@@ -38,18 +126,7 @@ export function withAgentInputSchema(yargs, agent) {
             yargs.demandOption(option);
         }
     }
-    return yargs
-        .option("input", {
-        type: "string",
-        array: true,
-        description: "Input to the agent, use @<file> to read from a file",
-        alias: ["i"],
-    })
-        .option("format", {
-        type: "string",
-        description: 'Input format, can be "json" or "yaml"',
-        choices: ["json", "yaml"],
-    });
+    return withRunAgentCommonOptions(yargs);
 }
 export async function parseAgentInput(i, agent) {
     const inputSchema = agent.inputSchema instanceof ZodObject ? agent.inputSchema.shape : {};
@@ -62,6 +139,16 @@ export async function parseAgentInput(i, agent) {
         }
         return [key, val];
     })));
+    if (agent instanceof AIAgent && agent.fileInputKey) {
+        const files = [];
+        for (const file of i.inputFile ?? []) {
+            const raw = await readFile(file.replace(/^@/, ""), "base64");
+            const filename = basename(file);
+            const mimeType = ChatModel.getMimeType(filename) || "application/octet-stream";
+            files.push({ type: "file", data: raw, filename, mimeType });
+        }
+        Object.assign(input, { [agent.fileInputKey]: files });
+    }
     const rawInput = i.input ||
         (isatty(process.stdin.fd) || !(await stdinHasData())
             ? null
@@ -105,3 +192,6 @@ export async function stdinHasData() {
     const stats = await promisify(fstat)(0);
     return stats.isFIFO() || stats.isFile();
 }
+function customZodError(label, fn) {
+    return ((...args) => tryOrThrow(() => fn(...args), (e) => new Error(`${label} ${e instanceof ZodError ? e.issues[0]?.message : e.message}`)));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/cli",
-  "version": "1.43.1",
+  "version": "1.44.1",
   "description": "Your command center for agent development",
   "publishConfig": {
     "access": "public"
@@ -74,18 +74,20 @@
     "p-wait-for": "^5.0.2",
     "prettier": "^3.6.2",
     "tar": "^7.4.3",
+    "terminal-image": "^3.1.1",
+    "terminal-link": "^4.0.0",
     "wrap-ansi": "^9.0.0",
     "yaml": "^2.8.0",
     "yargs": "^18.0.0",
     "yoctocolors-cjs": "^2.1.3",
     "zod": "^3.25.67",
-    "@aigne/agent-library": "^1.21.36",
-    "@aigne/agentic-memory": "^1.0.36",
-    "@aigne/aigne-hub": "^0.8.6",
-    "@aigne/core": "^1.57.5",
-    "@aigne/default-memory": "^1.1.18",
-    "@aigne/observability-api": "^0.10.1",
-    "@aigne/openai": "^0.13.7"
+    "@aigne/agentic-memory": "^1.0.38",
+    "@aigne/agent-library": "^1.21.38",
+    "@aigne/aigne-hub": "^0.8.8",
+    "@aigne/core": "^1.58.1",
+    "@aigne/default-memory": "^1.2.1",
+    "@aigne/openai": "^0.14.1",
+    "@aigne/observability-api": "^0.10.2"
   },
   "devDependencies": {
     "@inquirer/testing": "^2.1.49",
@@ -102,7 +104,7 @@
     "rimraf": "^6.0.1",
     "typescript": "^5.8.3",
     "ufo": "^1.6.1",
-    "@aigne/test-utils": "^0.5.43"
+    "@aigne/test-utils": "^0.5.45"
   },
   "scripts": {
     "lint": "tsc --noEmit",