@aigne/cli 1.9.1 → 1.10.1

package/CHANGELOG.md

@@ -1,5 +1,50 @@
 # Changelog
 
+## [1.10.1](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.10.0...cli-v1.10.1) (2025-05-25)
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/anthropic bumped to 0.2.0
+    * @aigne/bedrock bumped to 0.2.0
+    * @aigne/core bumped to 1.17.0
+    * @aigne/deepseek bumped to 0.2.0
+    * @aigne/gemini bumped to 0.2.0
+    * @aigne/ollama bumped to 0.2.0
+    * @aigne/open-router bumped to 0.2.0
+    * @aigne/openai bumped to 0.2.0
+    * @aigne/xai bumped to 0.2.0
+
+## [1.10.0](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.9.1...cli-v1.10.0) (2025-05-23)
+
+
+### Features
+
+* add `--chat` option for `run` command ([#120](https://github.com/AIGNE-io/aigne-framework/issues/120)) ([7699550](https://github.com/AIGNE-io/aigne-framework/commit/76995507001ca33b09b29f72ff588dae513cb340))
+* **models:** publish model adapters as standalone packages ([#126](https://github.com/AIGNE-io/aigne-framework/issues/126)) ([588b8ae](https://github.com/AIGNE-io/aigne-framework/commit/588b8aea6abcee5fa87def1358bf51f84021c6ef))
+
+
+### Bug Fixes
+
+* **cli:** listr ctx maybe undefined ([#130](https://github.com/AIGNE-io/aigne-framework/issues/130)) ([dfc7b13](https://github.com/AIGNE-io/aigne-framework/commit/dfc7b139e05cf9b6e0314f42f308d25e9b70ea5c))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/anthropic bumped to 0.1.0
+    * @aigne/bedrock bumped to 0.1.0
+    * @aigne/core bumped to 1.16.0
+    * @aigne/deepseek bumped to 0.1.0
+    * @aigne/gemini bumped to 0.1.0
+    * @aigne/ollama bumped to 0.1.0
+    * @aigne/open-router bumped to 0.1.0
+    * @aigne/openai bumped to 0.1.0
+    * @aigne/xai bumped to 0.1.0
+
 ## [1.9.1](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.9.0...cli-v1.9.1) (2025-05-15)
 
 

package/README.md

@@ -16,12 +16,12 @@ Command-line tool for [AIGNE Framework](https://github.com/AIGNE-io/aigne-framew
 
 ## Features
 
-- **Project Creation**: Quickly create new AIGNE projects with predefined file structures and configurations
-- **Agent Running**: Easily run and test AIGNE agents
-- **Testing Support**: Built-in test command for unit testing and integration testing
-- **MCP Services**: Support for launching agents as MCP servers for integration with external systems
-- **Interactive Interface**: Beautiful command-line interface providing an intuitive user experience
-- **Multi-model Support**: Support for OpenAI, Claude, XAI, and other model providers
+* **Project Creation**: Quickly create new AIGNE projects with predefined file structures and configurations
+* **Agent Running**: Easily run and test AIGNE agents
+* **Testing Support**: Built-in test command for unit testing and integration testing
+* **MCP Services**: Support for launching agents as MCP servers for integration with external systems
+* **Interactive Interface**: Beautiful command-line interface providing an intuitive user experience
+* **Multi-model Support**: Support for OpenAI, Claude, XAI, and other model providers
 
 ## Installation
 
@@ -77,8 +77,9 @@ aigne create my-project
 ```
 
 The interactive creation process will ask for:
-- Project name
-- Project template (currently supports the default template)
+
+* Project name
+* Project template (currently supports the default template)
 
 ## Run Command
 
@@ -93,14 +94,17 @@ aigne run path/to/agents
 
 # Run the agent from a remote URL
 aigne run https://example.com/aigne-project
+
+# Run a specific agent
+aigne run --entry-agent myAgent
 ```
 
 Available options:
-- `--agent <agent>` - Specify the agent name to use (defaults to the first agent found)
-- `--download-dir <dir>` - Specify the directory to download the package to (used in URL mode)
-- `--model-provider <provider>` - Specify the model provider (openai, claude, xai)
-- `--model-name <model>` - Specify the model name
-- `--verbose` - Enable verbose logging
+
+* `--entry-agent <entry-agent>` - Specify the agent name to run (defaults to the first agent found)
+* `--cache-dir <dir>` - Specify the directory to download the package to (used in URL mode)
+* `--model <provider[:model]>` - Specify the AI model in format 'provider\[:model]' where model is optional (e.g., 'openai' or 'openai:gpt-4o-mini')
+* `--verbose` - Enable verbose logging
 
 ## Test Command
 

package/README.zh.md

@@ -16,12 +16,12 @@
 
 ## 特性
 
-- **项目创建**：快速创建新的 AIGNE 项目，包含预设的文件结构和配置
-- **代理运行**：轻松运行和测试 AIGNE 代理
-- **测试支持**：内置测试命令，方便进行单元测试和集成测试
-- **MCP 服务**：支持将代理作为 MCP 服务器启动，与外部系统集成
-- **交互式界面**：美观的命令行界面，提供直观的使用体验
-- **多模型支持**：支持 OpenAI、Claude、XAI 等多种模型提供商
+* **项目创建**：快速创建新的 AIGNE 项目，包含预设的文件结构和配置
+* **代理运行**：轻松运行和测试 AIGNE 代理
+* **测试支持**：内置测试命令，方便进行单元测试和集成测试
+* **MCP 服务**：支持将代理作为 MCP 服务器启动，与外部系统集成
+* **交互式界面**：美观的命令行界面，提供直观的使用体验
+* **多模型支持**：支持 OpenAI、Claude、XAI 等多种模型提供商
 
 ## 安装
 
@@ -77,8 +77,9 @@ aigne create my-project
 ```
 
 交互式创建过程会询问：
-- 项目名称
-- 项目模板（目前支持 default 模板）
+
+* 项目名称
+* 项目模板（目前支持 default 模板）
 
 ## 运行命令 (run)
 
@@ -93,14 +94,17 @@ aigne run path/to/agents
 
 # 运行远程 URL 中的代理
 aigne run https://example.com/aigne-project
+
+# 指定特定代理运行
+aigne run --entry-agent myAgent
 ```
 
 可用选项：
-- `--agent <agent>` - 指定要使用的代理名称（默认为找到的第一个代理）
-- `--download-dir <dir>` - 指定下载包的目录（URL模式下使用）
-- `--model-provider <provider>` - 指定模型提供商（openai、claude、xai）
-- `--model-name <model>` - 指定模型名称
-- `--verbose` - 启用详细日志记录
+
+* `--entry-agent <代理>` - 指定要运行的代理名称（默认为找到的第一个代理）
+* `--cache-dir <目录>` - 指定下载包的目录（URL模式下使用）
+* `--model <提供商[:模型]>` - 指定AI模型，格式为'提供商\[:模型]'，其中模型是可选的（如'openai'或'openai:gpt-4o-mini'）
+* `--verbose` - 启用详细日志记录
 
 ## 测试命令 (test)
 

package/dist/commands/run.d.ts

@@ -1,2 +1,2 @@
-import { Command } from "commander";
+import type { Command } from "commander";
 export declare function createRunCommand(): Command;

package/dist/commands/run.js

@@ -7,36 +7,33 @@ import { loadModel } from "@aigne/core/loader/index.js";
 import { logger } from "@aigne/core/utils/logger.js";
 import { isNonNullable } from "@aigne/core/utils/type-utils.js";
 import { Listr, PRESET_TIMER } from "@aigne/listr2";
-import { Command } from "commander";
+import { availableModels } from "../constants.js";
 import { isV1Package, toAIGNEPackage } from "../utils/agent-v1.js";
 import { downloadAndExtract } from "../utils/download.js";
-import { runChatLoopInTerminal } from "../utils/run-chat-loop.js";
+import { createRunAIGNECommand, parseModelOption, runAgentWithAIGNE, } from "../utils/run-with-aigne.js";
 export function createRunCommand() {
-    return new Command("run")
-        .description("Run a chat loop with the specified agent")
+    return createRunAIGNECommand()
+        .description("Run AIGNE from the specified agent")
         .argument("[path]", "Path to the agents directory or URL to aigne project", ".")
-        .option("--agent <agent>", "Name of the agent to use (defaults to the first agent found)")
-        .option("--download-dir <dir>", "Directory to download the package to (defaults to the ~/.aigne/xxx)")
-        .option("--model-provider <provider>", "Model provider to use, available providers: openai, claude, xai (defaults to the aigne.yaml definition or openai)")
-        .option("--model-name <model>", "Model name to use, available models depend on the provider (defaults to the aigne.yaml definition or gpt-4o-mini)")
-        .option("--verbose", "Enable verbose logging", false)
+        .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 (path, options) => {
-        if (options.verbose)
-            logger.enable("*");
-        const { downloadDir, dir } = prepareDirs(path, options);
+        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 (downloadDir) {
+                    if (cacheDir) {
                         return task.newListr([
                             {
                                 title: "Download package",
-                                task: () => downloadPackage(path, downloadDir),
+                                task: () => downloadPackage(path, cacheDir),
                             },
                             {
                                 title: "Extract package",
-                                task: () => extractPackage(downloadDir, dir),
+                                task: () => extractPackage(cacheDir, dir),
                             },
                         ]);
                     }
@@ -53,24 +50,24 @@ export function createRunCommand() {
                 task: (ctx) => {
                     const { aigne } = ctx;
                     assert(aigne);
-                    let agent;
-                    if (options.agent) {
-                        agent = aigne.agents[options.agent];
-                        if (!agent) {
-                            console.error(`Agent "${options.agent}" not found in ${path}`);
+                    let entryAgent;
+                    if (options.entryAgent) {
+                        entryAgent = aigne.agents[options.entryAgent];
+                        if (!entryAgent) {
+                            console.error(`Agent "${options.entryAgent}" not found in ${path}`);
                             console.log("Available agents:");
                             for (const agent of aigne.agents) {
                                 console.log(`- ${agent.name}`);
                             }
-                            throw new Error(`Agent "${options.agent}" not found in ${path}`);
+                            throw new Error(`Agent "${options.entryAgent}" not found in ${path}`);
                         }
                     }
                     else {
-                        agent = aigne.agents[0];
-                        if (!agent)
+                        entryAgent = aigne.agents[0];
+                        if (!entryAgent)
                             throw new Error(`No agents found in ${path}`);
                     }
-                    ctx.agent = agent;
+                    ctx.agent = entryAgent;
                 },
             },
         ], {
@@ -81,53 +78,53 @@ export function createRunCommand() {
         }).run();
         assert(aigne);
         assert(agent);
-        const user = aigne.invoke(agent);
-        await runChatLoopInTerminal(user);
-        await aigne.shutdown();
+        try {
+            await runAgentWithAIGNE(aigne, agent, { ...options });
+        }
+        finally {
+            await aigne.shutdown();
+        }
     })
         .showHelpAfterError(true)
         .showSuggestionAfterError(true);
 }
 async function loadAIGNE(path, options) {
-    if (options.modelName && !options.modelProvider) {
-        throw new Error("please specify --model-provider when using the --model-name option");
-    }
-    const model = options.modelProvider
-        ? await loadModel({ provider: options.modelProvider, name: options.modelName })
+    const model = options.model
+        ? await loadModel(availableModels, parseModelOption(options.model))
         : undefined;
-    return await AIGNE.load(path, { model });
+    return await AIGNE.load(path, { models: availableModels, model });
 }
-async function downloadPackage(url, downloadDir) {
-    await rm(downloadDir, { recursive: true, force: true });
-    await mkdir(downloadDir, { recursive: true });
-    await downloadAndExtract(url, downloadDir);
+async function downloadPackage(url, cacheDir) {
+    await rm(cacheDir, { recursive: true, force: true });
+    await mkdir(cacheDir, { recursive: true });
+    await downloadAndExtract(url, cacheDir);
 }
-async function extractPackage(downloadDir, dir) {
+async function extractPackage(cacheDir, dir) {
     await mkdir(dir, { recursive: true });
-    if (await isV1Package(downloadDir)) {
-        await toAIGNEPackage(downloadDir, dir);
+    if (await isV1Package(cacheDir)) {
+        await toAIGNEPackage(cacheDir, dir);
     }
     else {
-        await cp(downloadDir, dir, { recursive: true, force: true });
+        await cp(cacheDir, dir, { recursive: true, force: true });
     }
 }
 function prepareDirs(path, options) {
     let dir;
-    let downloadDir;
+    let cacheDir;
     if (!path.startsWith("http")) {
         dir = isAbsolute(path) ? path : resolve(process.cwd(), path);
     }
-    else if (options.downloadDir) {
-        dir = isAbsolute(options.downloadDir)
-            ? options.downloadDir
-            : resolve(process.cwd(), options.downloadDir);
-        downloadDir = join(dir, ".download");
+    else if (options.cacheDir) {
+        dir = isAbsolute(options.cacheDir)
+            ? options.cacheDir
+            : resolve(process.cwd(), options.cacheDir);
+        cacheDir = join(dir, ".download");
     }
     else {
         dir = getLocalPackagePathFromUrl(path);
-        downloadDir = getLocalPackagePathFromUrl(path, { subdir: ".download" });
+        cacheDir = getLocalPackagePathFromUrl(path, { subdir: ".download" });
     }
-    return { downloadDir, dir };
+    return { cacheDir, dir };
 }
 function getLocalPackagePathFromUrl(url, { subdir } = {}) {
     const root = [homedir(), ".aigne", subdir].filter(isNonNullable);

package/dist/commands/serve.js

@@ -2,6 +2,7 @@ import { isAbsolute, resolve } from "node:path";
 import { AIGNE } from "@aigne/core";
 import { tryOrThrow } from "@aigne/core/utils/type-utils.js";
 import { Command } from "commander";
+import { availableModels } from "../constants.js";
 import { serveMCPServer } from "../utils/serve-mcp.js";
 const DEFAULT_PORT = () => tryOrThrow(() => {
     const { PORT } = process.env;
@@ -23,7 +24,7 @@ export function createServeCommand() {
         .action(async (path, options) => {
         const absolutePath = isAbsolute(path) ? path : resolve(process.cwd(), path);
         const port = options.port || DEFAULT_PORT();
-        const aigne = await AIGNE.load(absolutePath);
+        const aigne = await AIGNE.load(absolutePath, { models: availableModels });
         if (options.mcp)
             await serveMCPServer({
                 aigne,

package/dist/constants.d.ts

@@ -1 +1,5 @@
+import { AnthropicChatModel } from "@aigne/anthropic";
+import { BedrockChatModel } from "@aigne/bedrock";
+import { OpenAIChatModel } from "@aigne/openai";
 export declare const AIGNE_CLI_VERSION: string;
+export declare const availableModels: (typeof OpenAIChatModel | typeof AnthropicChatModel | typeof BedrockChatModel)[];

package/dist/constants.js

@@ -1,2 +1,20 @@
+import { AnthropicChatModel } from "@aigne/anthropic";
+import { BedrockChatModel } from "@aigne/bedrock";
+import { DeepSeekChatModel } from "@aigne/deepseek";
+import { GeminiChatModel } from "@aigne/gemini";
+import { OllamaChatModel } from "@aigne/ollama";
+import { OpenRouterChatModel } from "@aigne/open-router";
+import { OpenAIChatModel } from "@aigne/openai";
+import { XAIChatModel } from "@aigne/xai";
 import pkg from "../package.json" with { type: "json" };
 export const AIGNE_CLI_VERSION = pkg.version;
+export const availableModels = [
+    OpenAIChatModel,
+    AnthropicChatModel,
+    BedrockChatModel,
+    DeepSeekChatModel,
+    GeminiChatModel,
+    OllamaChatModel,
+    OpenRouterChatModel,
+    XAIChatModel,
+];

package/dist/tracer/terminal.d.ts

@@ -1,18 +1,18 @@
 import { type Agent, type Context, type ContextUsage, MESSAGE_KEY, type Message } from "@aigne/core";
-import { type DefaultRenderer, Listr, type ListrRenderer, type ListrTaskWrapper } from "@aigne/listr2";
+import { type Listr } from "@aigne/listr2";
+import { type AIGNEListrTaskWrapper } from "../utils/listr.js";
 import { promiseWithResolvers } from "../utils/promise-with-resolvers.js";
 export interface TerminalTracerOptions {
-    aiResponsePrefix?: (context: Context) => string;
+    printRequest?: boolean;
 }
 export declare class TerminalTracer {
     readonly context: Context;
     readonly options: TerminalTracerOptions;
     constructor(context: Context, options?: TerminalTracerOptions);
-    private spinner;
     private tasks;
     run(agent: Agent, input: Message): Promise<{
         result: Message;
-        context: Context;
+        context: Context<import("@aigne/core").UserContext>;
     }>;
     formatTokenUsage(usage: Partial<ContextUsage>, extra?: {
         [key: string]: string;
@@ -24,13 +24,14 @@ export declare class TerminalTracer {
         time?: boolean;
     }): string;
     private marked;
-    formatAIResponse({ [MESSAGE_KEY]: msg, ...message }?: Message): string;
+    formatRequest(_context: Context, { [MESSAGE_KEY]: msg, ...message }?: Message): string | undefined;
+    formatResult(context: Context, { [MESSAGE_KEY]: msg, ...message }?: Message): string;
 }
 type Task = ReturnType<typeof promiseWithResolvers<void>> & {
     listr: ReturnType<typeof promiseWithResolvers<{
         ctx: object;
         subtask: Listr;
-        taskWrapper: ListrTaskWrapper<unknown, typeof DefaultRenderer, typeof ListrRenderer>;
+        taskWrapper: AIGNEListrTaskWrapper;
     }>>;
     startTime?: number;
     endTime?: number;

package/dist/tracer/terminal.js

@@ -1,13 +1,12 @@
 import { EOL } from "node:os";
-import { format, inspect } from "node:util";
+import { inspect } from "node:util";
 import { ChatModel, MESSAGE_KEY, } from "@aigne/core";
-import { logger } from "@aigne/core/utils/logger.js";
-import { mergeAgentResponseChunk } from "@aigne/core/utils/stream-utils.js";
-import { Listr, ListrDefaultRendererLogLevels, Spinner, } from "@aigne/listr2";
+import { LogLevel, logger } from "@aigne/core/utils/logger.js";
+import { figures } from "@aigne/listr2";
 import { markedTerminal } from "@aigne/marked-terminal";
 import chalk from "chalk";
 import { Marked } from "marked";
-import wrap from "wrap-ansi";
+import { AIGNEListr } from "../utils/listr.js";
 import { promiseWithResolvers } from "../utils/promise-with-resolvers.js";
 import { parseDuration } from "../utils/time.js";
 export class TerminalTracer {
@@ -17,26 +16,13 @@ export class TerminalTracer {
         this.context = context;
         this.options = options;
     }
-    spinner = new Spinner();
     tasks = {};
     async run(agent, input) {
-        this.spinner.start();
         const context = this.context.newContext({ reset: true });
         const listr = new AIGNEListr({
-            formatResult: (result) => {
-                return [this.options.aiResponsePrefix?.(context) || "", this.formatAIResponse(result)];
-            },
-        }, [], {
-            concurrent: true,
-            rendererOptions: {
-                collapseSubtasks: false,
-                writeBottomBarDirectly: true,
-                icon: {
-                    [ListrDefaultRendererLogLevels.PENDING]: () => this.spinner.fetch(),
-                    [ListrDefaultRendererLogLevels.OUTPUT_WITH_BOTTOMBAR]: "",
-                },
-            },
-        });
+            formatRequest: () => this.options.printRequest ? this.formatRequest(context, input) : undefined,
+            formatResult: (result) => [this.formatResult(context, result)].filter(Boolean),
+        }, [], { concurrent: true });
         const onAgentStarted = async ({ contextId, parentContextId, agent, timestamp, }) => {
             const task = {
                 ...promiseWithResolvers(),
@@ -99,12 +85,10 @@ export class TerminalTracer {
         context.on("agentSucceed", onAgentSucceed);
         context.on("agentFailed", onAgentFailed);
         try {
-            const stream = await context.invoke(agent, input, { streaming: true });
-            const result = await listr.run(stream);
+            const result = await listr.run(() => context.invoke(agent, input, { streaming: true }));
             return { result, context };
         }
         finally {
-            this.spinner.stop();
             context.off("agentStarted", onAgentStarted);
             context.off("agentSucceed", onAgentSucceed);
             context.off("agentFailed", onAgentFailed);
@@ -137,62 +121,22 @@ export class TerminalTracer {
         return title;
     }
     marked = new Marked().use(markedTerminal({ forceHyperLink: false }));
-    formatAIResponse({ [MESSAGE_KEY]: msg, ...message } = {}) {
+    formatRequest(_context, { [MESSAGE_KEY]: msg, ...message } = {}) {
+        if (!logger.enabled(LogLevel.INFO))
+            return;
+        const prefix = `${chalk.grey(figures.pointer)} 💬 `;
         const text = msg && typeof msg === "string" ? this.marked.parse(msg, { async: false }).trim() : undefined;
         const json = Object.keys(message).length > 0 ? inspect(message, { colors: true }) : undefined;
-        return [text, json].filter(Boolean).join("\n");
-    }
-}
-class AIGNEListr extends Listr {
-    myOptions;
-    result = {};
-    isStreamRunning = false;
-    logs = [];
-    constructor(myOptions, ...args) {
-        super(...args);
-        this.myOptions = myOptions;
-        const renderer = new this.rendererClass(this.tasks, this.rendererClassOptions, this.events);
-        const spinner = renderer.spinner;
-        // Override the `create` method of renderer to customize the output
-        const create = renderer.create;
-        renderer.create = (...args) => {
-            const [tasks, output] = create.call(renderer, ...args);
-            const l = [
-                "",
-                tasks,
-                "",
-                ...this.myOptions.formatResult(this.result).map((i) => this.wrap(i)),
-                this.isStreamRunning ? spinner.fetch() : "",
-            ];
-            return [l.join(EOL), [output, ...this.logs.splice(0)].filter(Boolean).join(EOL)];
-        };
-        // @ts-ignore initialize the renderer
-        this.renderer = renderer;
-    }
-    async run(stream) {
-        const originalLog = logger.log;
-        try {
-            logger.log = (...args) => this.logs.push(format(...args));
-            this.add({ task: () => this.extractStream(stream) });
-            return await super.run().then(() => ({ ...this.result }));
-        }
-        finally {
-            logger.log = originalLog;
-        }
+        return [prefix, [text, json].filter(Boolean).join(EOL)].join(" ");
     }
-    async extractStream(stream) {
-        this.isStreamRunning = true;
-        this.result = {};
-        for await (const value of stream) {
-            mergeAgentResponseChunk(this.result, value);
-        }
-        this.isStreamRunning = false;
-        return this.result;
-    }
-    wrap(str) {
-        return wrap(str, process.stdout.columns ?? 80, {
-            hard: true,
-            trim: false,
-        });
+    formatResult(context, { [MESSAGE_KEY]: msg, ...message } = {}) {
+        const prefix = logger.enabled(LogLevel.INFO)
+            ? `${chalk.grey(figures.tick)} 🤖 ${this.formatTokenUsage(context.usage)}`
+            : null;
+        const text = msg && typeof msg === "string" ? this.marked.parse(msg, { async: false }).trim() : undefined;
+        const json = Object.keys(message).length > 0
+            ? inspect(message, { colors: process.stdout.isTTY })
+            : undefined;
+        return [prefix, text, json].filter(Boolean).join(EOL);
     }
 }

package/dist/utils/listr.d.ts

@@ -0,0 +1,46 @@
+import type { AgentResponseStream, Message } from "@aigne/core";
+import type { PromiseOrValue } from "@aigne/core/utils/type-utils";
+import { DefaultRenderer, Listr, type ListrDefaultRendererOptions, ListrLogger, type ListrSimpleRendererOptions, type ListrTaskWrapper, SimpleRenderer, Spinner } from "@aigne/listr2";
+import type { createLogUpdate } from "log-update";
+export type AIGNEListrTaskWrapper = ListrTaskWrapper<unknown, typeof AIGNEListrRenderer, typeof AIGNEListrFallbackRenderer>;
+export declare class AIGNEListr extends Listr<object, typeof AIGNEListrRenderer, typeof AIGNEListrFallbackRenderer> {
+    myOptions: {
+        formatRequest: () => string | undefined;
+        formatResult: (result: Message) => string[];
+    };
+    private result;
+    private logs;
+    private spinner;
+    constructor(myOptions: {
+        formatRequest: () => string | undefined;
+        formatResult: (result: Message) => string[];
+    }, ...[task, options, parentTask]: ConstructorParameters<typeof Listr<object, typeof AIGNEListrRenderer, typeof AIGNEListrFallbackRenderer>>);
+    run(stream: () => PromiseOrValue<AgentResponseStream<Message>>): Promise<Message>;
+    private extractStream;
+}
+export interface AIGNEListrRendererOptions extends ListrDefaultRendererOptions {
+    aigne?: {
+        getStdoutLogs?: () => string[];
+        getBottomBarLogs?: () => string[];
+    };
+}
+export declare class AIGNEListrRenderer extends DefaultRenderer {
+    static rendererOptions: AIGNEListrRendererOptions;
+    get _updater(): ReturnType<typeof createLogUpdate>;
+    get _logger(): ListrLogger;
+    get _options(): AIGNEListrRendererOptions;
+    get _spinner(): Spinner;
+    update(): void;
+    create({ running, ...options }: Parameters<DefaultRenderer["create"]>[0] & {
+        running?: boolean;
+    }): string;
+    _wrap(str: string): string;
+}
+export interface AIGNEListrFallbackRendererOptions extends ListrSimpleRendererOptions, Pick<AIGNEListrRendererOptions, "aigne"> {
+}
+export declare class AIGNEListrFallbackRenderer extends SimpleRenderer {
+    static rendererOptions: AIGNEListrFallbackRendererOptions;
+    get _logger(): ListrLogger;
+    get _options(): AIGNEListrFallbackRendererOptions;
+    end(): void;
+}

package/dist/utils/listr.js

@@ -0,0 +1,139 @@
+import { EOL } from "node:os";
+import { format } from "node:util";
+import { LogLevel, logger } from "@aigne/core/utils/logger.js";
+import { mergeAgentResponseChunk } from "@aigne/core/utils/stream-utils.js";
+import { DefaultRenderer, Listr, ListrDefaultRendererLogLevels, ListrLogger, SimpleRenderer, Spinner, } from "@aigne/listr2";
+import wrap from "wrap-ansi";
+export class AIGNEListr extends Listr {
+    myOptions;
+    result = {};
+    logs = [];
+    spinner;
+    constructor(myOptions, ...[task, options, parentTask]) {
+        const aigneOptions = {
+            getStdoutLogs: () => {
+                return this.logs.splice(0);
+            },
+            getBottomBarLogs: () => {
+                return this.myOptions.formatResult(this.result);
+            },
+        };
+        super(task, {
+            ...options,
+            renderer: AIGNEListrRenderer,
+            rendererOptions: {
+                collapseSubtasks: false,
+                icon: {
+                    [ListrDefaultRendererLogLevels.PENDING]: () => this.spinner.fetch(),
+                },
+                aigne: aigneOptions,
+            },
+            fallbackRenderer: AIGNEListrFallbackRenderer,
+            fallbackRendererOptions: {
+                aigne: aigneOptions,
+                logger: new (class extends ListrLogger {
+                    log(...[level, ...args]) {
+                        // ignore stdout logs if level `INFO` is not enabled
+                        if (!this.options?.toStderr?.includes(level) && !logger.enabled(LogLevel.INFO)) {
+                            return;
+                        }
+                        super.log(level, ...args);
+                    }
+                })(),
+            },
+        }, parentTask);
+        this.myOptions = myOptions;
+        this.spinner = new Spinner();
+    }
+    async run(stream) {
+        const originalLog = logger.logMessage;
+        try {
+            this.ctx = {};
+            this.spinner.start();
+            logger.logMessage = (...args) => this.logs.push(format(...args));
+            if (logger.enabled(LogLevel.INFO)) {
+                const request = this.myOptions.formatRequest();
+                if (request)
+                    console.log(request);
+            }
+            const _stream = await stream();
+            this.add({ task: () => this.extractStream(_stream) });
+            return await super.run().then(() => ({ ...this.result }));
+        }
+        finally {
+            logger.logMessage = originalLog;
+            this.spinner.stop();
+        }
+    }
+    async extractStream(stream) {
+        this.result = {};
+        for await (const value of stream) {
+            mergeAgentResponseChunk(this.result, value);
+        }
+        return this.result;
+    }
+}
+export class AIGNEListrRenderer extends DefaultRenderer {
+    static rendererOptions = {
+        ...DefaultRenderer.rendererOptions,
+    };
+    get _updater() {
+        // @ts-ignore `updater` is a private property
+        return this.updater;
+    }
+    get _logger() {
+        // @ts-ignore `logger` is a private property
+        return this.logger;
+    }
+    get _options() {
+        // @ts-ignore `options` is a private property
+        return this.options;
+    }
+    get _spinner() {
+        // @ts-ignore `spinner` is a private property
+        return this.spinner;
+    }
+    update() {
+        this._updater(this.create({ running: true }));
+    }
+    create({ running = false, ...options }) {
+        const logs = this._options.aigne?.getStdoutLogs?.();
+        if (logs?.length) {
+            this._updater.clear();
+            this._logger.toStdout(logs.join(EOL));
+        }
+        const tasks = [super.create(options)];
+        const bottomBar = this._options.aigne?.getBottomBarLogs?.();
+        if (bottomBar?.length) {
+            tasks.push([...bottomBar, running ? this._spinner.fetch() : ""].map((i) => this._wrap(i)).join(EOL));
+        }
+        return tasks.join(EOL.repeat(2));
+    }
+    _wrap(str) {
+        return wrap(str, process.stdout.columns ?? 80, {
+            hard: true,
+            trim: false,
+        });
+    }
+}
+export class AIGNEListrFallbackRenderer extends SimpleRenderer {
+    static rendererOptions = {
+        ...SimpleRenderer.rendererOptions,
+    };
+    get _logger() {
+        // @ts-ignore `logger` is a private property
+        return this.logger;
+    }
+    get _options() {
+        // @ts-ignore `options` is a private property
+        return this.options;
+    }
+    end() {
+        const logs = [this._options.aigne?.getStdoutLogs?.(), this._options.aigne?.getBottomBarLogs?.()]
+            .filter(Boolean)
+            .flat()
+            .join(EOL);
+        if (logs)
+            this._logger.toStdout(logs);
+    }
+}

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

@@ -1,4 +1,4 @@
-import { type Message, type UserAgent as input } from "@aigne/core";
+import { type Message, type UserAgent } from "@aigne/core";
 export interface ChatLoopOptions {
     initialCall?: Message | string;
     welcome?: string;
@@ -6,4 +6,4 @@ export interface ChatLoopOptions {
     inputKey?: string;
     skipLoop?: boolean;
 }
-export declare function runChatLoopInTerminal(userAgent: input, options?: ChatLoopOptions): Promise<void>;
+export declare function runChatLoopInTerminal(userAgent: UserAgent, options?: ChatLoopOptions): Promise<void>;

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

@@ -1,6 +1,4 @@
 import { createMessage } from "@aigne/core";
-import { figures } from "@aigne/listr2";
-import chalk from "chalk";
 import inquirer from "inquirer";
 import { TerminalTracer } from "../tracer/terminal.js";
 export async function runChatLoopInTerminal(userAgent, options = {}) {
@@ -44,11 +42,7 @@ export async function runChatLoopInTerminal(userAgent, options = {}) {
     }
 }
 async function callAgent(userAgent, input, options) {
-    const tracer = new TerminalTracer(userAgent.context, {
-        aiResponsePrefix: (context) => {
-            return `${chalk.grey(figures.tick)} 🤖 ${tracer.formatTokenUsage(context.usage)}`;
-        },
-    });
+    const tracer = new TerminalTracer(userAgent.context);
     await tracer.run(userAgent, options.inputKey && typeof input === "string"
         ? { [options.inputKey]: input }
         : createMessage(input));

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

@@ -0,0 +1,32 @@
+import { AIGNE, type Agent, type ChatModelOptions } 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 ChatLoopOptions } from "./run-chat-loop.js";
+export interface RunAIGNECommandOptions {
+    chat?: boolean;
+    model?: string;
+    temperature?: number;
+    topP?: number;
+    presencePenalty?: number;
+    frequencyPenalty?: number;
+    input?: string;
+    logLevel?: LogLevel;
+}
+export declare const createRunAIGNECommand: (name?: string) => Command;
+export declare const parseModelOption: (model?: string) => {
+    provider: string | undefined;
+    name: string | undefined;
+};
+export declare function runWithAIGNE(agentCreator: ((aigne: AIGNE) => PromiseOrValue<Agent>) | Agent, { argv, chatLoopOptions, modelOptions, }?: {
+    argv?: typeof process.argv;
+    chatLoopOptions?: ChatLoopOptions;
+    modelOptions?: ChatModelOptions;
+}): Promise<void>;
+export declare function runAgentWithAIGNE(aigne: AIGNE, agent: Agent, { chatLoopOptions, modelOptions, ...options }?: {
+    chatLoopOptions?: ChatLoopOptions;
+    modelOptions?: ChatModelOptions;
+} & RunAIGNECommandOptions): Promise<{
+    result: import("@aigne/core").Message;
+    context: import("@aigne/core").Context<import("@aigne/core").UserContext>;
+} | undefined>;

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

@@ -0,0 +1,90 @@
+import { fstat } from "node:fs";
+import { isatty } from "node:tty";
+import { promisify } from "node:util";
+import { AIGNE, UserAgent, createMessage } from "@aigne/core";
+import { loadModel } from "@aigne/core/loader/index.js";
+import { LogLevel, logger } from "@aigne/core/utils/logger.js";
+import { readAllString } from "@aigne/core/utils/stream-utils.js";
+import { tryOrThrow } from "@aigne/core/utils/type-utils.js";
+import { Command } from "commander";
+import PrettyError from "pretty-error";
+import { ZodError, z } from "zod";
+import { availableModels } from "../constants.js";
+import { TerminalTracer } from "../tracer/terminal.js";
+import { runChatLoopInTerminal } from "./run-chat-loop.js";
+export const createRunAIGNECommand = (name = "run") => new Command(name)
+    .description("Run agent with AIGNE in terminal")
+    .option("--chat", "Run chat loop in terminal", false)
+    .option("--model <provider[:model]>", `AI model to use in format 'provider[:model]' where model is optional. Examples: 'openai' or 'openai:gpt-4o-mini'. Available providers: ${availableModels.map((i) => i.name.toLowerCase().replace(/ChatModel$/i, "")).join(", ")} (default: openai)`)
+    .option("--temperature <temperature>", "Temperature for the model (controls randomness, higher values produce more random outputs). Range: 0.0-2.0", customZodError("--temperature", (s) => z.coerce.number().min(0).max(2).parse(s)))
+    .option("--top-p <top-p>", "Top P (nucleus sampling) parameter for the model (controls diversity). Range: 0.0-1.0", customZodError("--top-p", (s) => z.coerce.number().min(0).max(1).parse(s)))
+    .option("--presence-penalty <presence-penalty>", "Presence penalty for the model (penalizes repeating the same tokens). Range: -2.0 to 2.0", customZodError("--presence-penalty", (s) => z.coerce.number().min(-2).max(2).parse(s)))
+    .option("--frequency-penalty <frequency-penalty>", "Frequency penalty for the model (penalizes frequency of token usage). Range: -2.0 to 2.0", customZodError("--frequency-penalty", (s) => z.coerce.number().min(-2).max(2).parse(s)))
+    .option("--input -i <input>", "Input to the agent")
+    .option("--log-level <level>", `Log level for detailed debugging information. Values: ${Object.values(LogLevel).join(", ")}`, customZodError("--log-level", (s) => z.nativeEnum(LogLevel).parse(s)), LogLevel.INFO);
+export const parseModelOption = (model) => {
+    const { provider, name } = model?.match(/(?<provider>[^:]+)(:(?<name>(\S+)))?/)?.groups ?? {};
+    return { provider, name };
+};
+export async function runWithAIGNE(agentCreator, { argv = process.argv, chatLoopOptions, modelOptions, } = {}) {
+    await createRunAIGNECommand()
+        .showHelpAfterError(true)
+        .showSuggestionAfterError(true)
+        .action(async (options) => {
+        if (options.logLevel) {
+            logger.level = options.logLevel;
+        }
+        const model = await loadModel(availableModels, {
+            ...parseModelOption(options.model),
+            temperature: options.temperature,
+            topP: options.topP,
+            presencePenalty: options.presencePenalty,
+            frequencyPenalty: options.frequencyPenalty,
+        }, modelOptions);
+        const aigne = new AIGNE({ model });
+        try {
+            const agent = typeof agentCreator === "function" ? await agentCreator(aigne) : agentCreator;
+            await runAgentWithAIGNE(aigne, agent, { ...options, chatLoopOptions, modelOptions });
+        }
+        finally {
+            await aigne.shutdown();
+        }
+    })
+        .parseAsync(argv)
+        .catch((error) => {
+        console.error(new PrettyError().render(error));
+        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, { chatLoopOptions, modelOptions, ...options } = {}) {
+    if (options.chat) {
+        if (!isatty(process.stdout.fd)) {
+            throw new Error("--chat mode requires a TTY terminal");
+        }
+        const userAgent = agent instanceof UserAgent ? agent : aigne.invoke(agent);
+        await runChatLoopInTerminal(userAgent, {
+            ...chatLoopOptions,
+        });
+        return;
+    }
+    const input = options.input ||
+        (isatty(process.stdin.fd) || !(await stdinHasData())
+            ? null
+            : await readAllString(process.stdin)) ||
+        chatLoopOptions?.initialCall ||
+        chatLoopOptions?.defaultQuestion ||
+        {};
+    const tracer = new TerminalTracer(aigne.newContext(), {
+        printRequest: logger.enabled(LogLevel.INFO),
+    });
+    return await tracer.run(agent, chatLoopOptions?.inputKey && typeof input === "string"
+        ? { [chatLoopOptions.inputKey]: input }
+        : createMessage(input));
+}
+async function stdinHasData() {
+    const stats = await promisify(fstat)(0);
+    return stats.isFIFO() || stats.isFile();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/cli",
-  "version": "1.9.1",
+  "version": "1.10.1",
   "description": "cli for AIGNE framework",
   "publishConfig": {
     "access": "public"
@@ -35,7 +35,7 @@
     }
   },
   "dependencies": {
-    "@aigne/listr2": "^1.0.9",
+    "@aigne/listr2": "^1.0.10",
     "@aigne/marked-terminal": "^7.3.1",
     "@modelcontextprotocol/sdk": "^1.11.0",
     "chalk": "^5.4.1",
@@ -45,12 +45,19 @@
     "gradient-string": "^3.0.0",
     "inquirer": "^12.6.0",
     "marked": "^15.0.11",
-    "openai": "^4.97.0",
     "prettier": "^3.5.3",
     "pretty-error": "^4.0.0",
     "tar": "^7.4.3",
     "zod": "^3.24.4",
-    "@aigne/core": "^1.15.0"
+    "@aigne/anthropic": "^0.2.0",
+    "@aigne/bedrock": "^0.2.0",
+    "@aigne/core": "^1.17.0",
+    "@aigne/deepseek": "^0.2.0",
+    "@aigne/gemini": "^0.2.0",
+    "@aigne/ollama": "^0.2.0",
+    "@aigne/openai": "^0.2.0",
+    "@aigne/open-router": "^0.2.0",
+    "@aigne/xai": "^0.2.0"
   },
   "devDependencies": {
     "@types/archiver": "^6.0.3",