@aigne/cli 1.1.0 → 1.3.0

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## [1.3.0](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.2.0...cli-v1.3.0) (2025-04-17)
+
+
+### Features
+
+* **ci:** support coverage examples with model matrix ([#59](https://github.com/AIGNE-io/aigne-framework/issues/59)) ([1edd704](https://github.com/AIGNE-io/aigne-framework/commit/1edd70426b80a69e3751b2d5fe818297711d0777))
+* **cli:** support convert agents from studio ([#64](https://github.com/AIGNE-io/aigne-framework/issues/64)) ([f544bc7](https://github.com/AIGNE-io/aigne-framework/commit/f544bc77a2fb07e034b317ceb6a46aadd35830c9))
+* **cli:** support model and download customization for aigne run ([#61](https://github.com/AIGNE-io/aigne-framework/issues/61)) ([51f6619](https://github.com/AIGNE-io/aigne-framework/commit/51f6619e6c591a84f1f2339b26ef66d89fa9486e))
+
+## [1.2.0](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.1.0...cli-v1.2.0) (2025-04-15)
+
+
+### Features
+
+* add TerminalTracer for better UX in terminal ([#56](https://github.com/AIGNE-io/aigne-framework/issues/56)) ([9875a5d](https://github.com/AIGNE-io/aigne-framework/commit/9875a5d46abb55073340ffae841fed6bd6b83ff4))
+* **cli:** support run agents from remote URL ([#60](https://github.com/AIGNE-io/aigne-framework/issues/60)) ([5f49920](https://github.com/AIGNE-io/aigne-framework/commit/5f4992089d36f9e780ba55a912a1d35508cad28e))
+
+
+### Bug Fixes
+
+* remove usage of new Node.js exists API for compatibility ([#57](https://github.com/AIGNE-io/aigne-framework/issues/57)) ([c10cc08](https://github.com/AIGNE-io/aigne-framework/commit/c10cc086d8ecd0744f38cdb1367d4c8816b723b3))
+
 ## [1.1.0](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.0.0...cli-v1.1.0) (2025-04-08)
 
 

package/dist/cli.js

@@ -1,3 +1,9 @@
 #!/usr/bin/env node
+import PrettyError from "pretty-error";
 import { createAIGNECommand } from "./commands/aigne.js";
-createAIGNECommand().parse();
+createAIGNECommand()
+    .parseAsync()
+    .catch((error) => {
+    console.error(new PrettyError().render(error));
+    process.exit(1);
+});

package/dist/commands/run.js

@@ -1,35 +1,88 @@
-import { isAbsolute, resolve } from "node:path";
+import { cp, mkdir, rm } from "node:fs/promises";
+import { homedir } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
 import { ExecutionEngine } from "@aigne/core";
-import { runChatLoopInTerminal } from "@aigne/core/utils/run-chat-loop.js";
+import { loadModel } from "@aigne/core/loader/index.js";
+import { isNonNullable } from "@aigne/core/utils/type-utils.js";
 import { Command } from "commander";
+import { isV1Package, toAIGNEPackage } from "../utils/agent-v1.js";
+import { downloadAndExtract } from "../utils/download.js";
+import { runChatLoopInTerminal } from "../utils/run-chat-loop.js";
 export function createRunCommand() {
     return new Command("run")
         .description("Run a chat loop with the specified agent")
-        .argument("[path]", "Path to the agents directory", ".")
+        .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)")
         .action(async (path, options) => {
-        const absolutePath = isAbsolute(path) ? path : resolve(process.cwd(), path);
-        const engine = await ExecutionEngine.load({ path: absolutePath });
-        let agent;
-        if (options.agent) {
-            agent = engine.agents[options.agent];
-            if (!agent) {
-                console.error(`Agent "${options.agent}" not found.`);
-                console.log("Available agents:");
-                for (const agent of engine.agents) {
-                    console.log(`- ${agent.name}`);
-                }
-                throw new Error(`Agent "${options.agent}" not found`);
-            }
-        }
-        else {
-            agent = engine.agents[0];
-            if (!agent)
-                throw new Error("No agents found in the specified path");
+        if (path.startsWith("http")) {
+            await downloadAndRunPackage(path, options);
+            return;
         }
-        const user = engine.call(agent);
-        await runChatLoopInTerminal(user, {});
+        const absolutePath = isAbsolute(path) ? path : resolve(process.cwd(), path);
+        await runEngine(path, absolutePath, options);
     })
         .showHelpAfterError(true)
         .showSuggestionAfterError(true);
 }
+async function runEngine(originalPath, 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 })
+        : undefined;
+    const engine = await ExecutionEngine.load({ path, model });
+    let agent;
+    if (options.agent) {
+        agent = engine.agents[options.agent];
+        if (!agent) {
+            console.error(`Agent "${options.agent}" not found in ${originalPath}`);
+            console.log("Available agents:");
+            for (const agent of engine.agents) {
+                console.log(`- ${agent.name}`);
+            }
+            throw new Error(`Agent "${options.agent}" not found in ${originalPath}`);
+        }
+    }
+    else {
+        agent = engine.agents[0];
+        if (!agent)
+            throw new Error(`No agents found in ${originalPath}`);
+    }
+    const user = engine.call(agent);
+    await runChatLoopInTerminal(user, {});
+}
+async function downloadAndRunPackage(url, options) {
+    let dir;
+    let downloadDir;
+    if (options.downloadDir) {
+        dir = isAbsolute(options.downloadDir)
+            ? options.downloadDir
+            : resolve(process.cwd(), options.downloadDir);
+        downloadDir = join(dir, ".download");
+    }
+    else {
+        dir = getLocalPackagePathFromUrl(url);
+        downloadDir = getLocalPackagePathFromUrl(url, { subdir: ".download" });
+    }
+    // clean up the download directory
+    await rm(downloadDir, { recursive: true, force: true });
+    await mkdir(dir, { recursive: true });
+    await mkdir(downloadDir, { recursive: true });
+    await downloadAndExtract(url, downloadDir);
+    if (await isV1Package(downloadDir)) {
+        await toAIGNEPackage(downloadDir, dir);
+    }
+    else {
+        await cp(downloadDir, dir, { recursive: true, force: true });
+    }
+    await runEngine(url, dir, options);
+}
+function getLocalPackagePathFromUrl(url, { subdir } = {}) {
+    const root = [homedir(), ".aigne", subdir].filter(isNonNullable);
+    const u = new URL(url);
+    return join(...root, u.hostname, u.pathname);
+}

package/dist/tracer/terminal.d.ts

@@ -0,0 +1,52 @@
+import { type Agent, type Context, type Message } from "@aigne/core";
+import type { ContextUsage } from "@aigne/core/execution-engine/usage";
+import { type DefaultRenderer, Listr, type ListrRenderer, type ListrTaskWrapper } from "@aigne/listr2";
+export interface TerminalTracerOptions {
+    verbose?: 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: any;
+        context: Context;
+    }>;
+    protected newListr(): MyListr;
+    formatAgentStartedOutput(agent: Agent, data: Message): string;
+    formatAgentSucceedOutput(agent: Agent, data: Message): string;
+    formatAgentFailedOutput(agent: Agent, data: Error): string;
+    formatMessage(data: unknown): string;
+    formatTokenUsage(usage: Partial<ContextUsage>, extra?: {
+        [key: string]: string;
+    }): string;
+    formatTimeUsage(startTime: number, endTime: number): string;
+    formatTaskTitle(agent: Agent, { task, usage, time }?: {
+        task?: Task;
+        usage?: boolean;
+        time?: boolean;
+    }): string;
+}
+type Task = ReturnType<typeof Promise.withResolvers<void>> & {
+    listr: ReturnType<typeof Promise.withResolvers<{
+        ctx: object;
+        subtask: Listr;
+        taskWrapper: ListrTaskWrapper<unknown, typeof DefaultRenderer, typeof ListrRenderer>;
+    }>>;
+    startTime?: number;
+    endTime?: number;
+    usage?: Partial<ContextUsage>;
+    extraTitleMetadata?: {
+        [key: string]: string;
+    };
+};
+declare class MyListr extends Listr {
+    private taskPromise;
+    private isTaskPromiseResolved;
+    resolveWaitingTask(): void;
+    add(...args: Parameters<Listr["add"]>): ReturnType<Listr["add"]>;
+    waitTaskAndRun(ctx?: unknown): Promise<any>;
+}
+export {};

package/dist/tracer/terminal.js

@@ -0,0 +1,179 @@
+import { inspect } from "node:util";
+import { ChatModel, } from "@aigne/core";
+import { Listr, ListrDefaultRendererLogLevels, Spinner, figures, } from "@aigne/listr2";
+import chalk from "chalk";
+import { z } from "zod";
+import { parseDuration } from "../utils/time.js";
+const DEBUG_DEPTH = z.number().int().default(2).safeParse(Number(process.env.DEBUG_DEPTH)).data;
+export class TerminalTracer {
+    context;
+    options;
+    constructor(context, options = {}) {
+        this.context = context;
+        this.options = options;
+    }
+    spinner = new Spinner();
+    tasks = {};
+    async run(agent, input) {
+        try {
+            this.spinner.start();
+            const context = this.context.newContext({ reset: true });
+            const listr = this.newListr();
+            context.on("agentStarted", async ({ contextId, parentContextId, agent, input, timestamp }) => {
+                const task = {
+                    ...Promise.withResolvers(),
+                    listr: Promise.withResolvers(),
+                    startTime: timestamp,
+                };
+                this.tasks[contextId] = task;
+                const listrTask = {
+                    title: this.formatTaskTitle(agent),
+                    task: (ctx, taskWrapper) => {
+                        const subtask = taskWrapper.newListr([{ task: () => task.promise }]);
+                        task.listr.resolve({ subtask, taskWrapper, ctx });
+                        return subtask;
+                    },
+                    rendererOptions: {
+                        persistentOutput: true,
+                        outputBar: Number.POSITIVE_INFINITY,
+                        bottomBar: Number.POSITIVE_INFINITY,
+                    },
+                };
+                const parentTask = parentContextId ? this.tasks[parentContextId] : undefined;
+                if (parentTask) {
+                    parentTask.listr.promise.then(({ subtask }) => {
+                        subtask.add(listrTask);
+                    });
+                }
+                else {
+                    listr.add(listrTask);
+                }
+                const { taskWrapper } = await task.listr.promise;
+                if (this.options.verbose) {
+                    taskWrapper.output = this.formatAgentStartedOutput(agent, input);
+                }
+            });
+            context.on("agentSucceed", async ({ agent, contextId, parentContextId, output, timestamp }) => {
+                const task = this.tasks[contextId];
+                if (!task)
+                    return;
+                task.endTime = timestamp;
+                const { taskWrapper, ctx } = await task.listr.promise;
+                if (agent instanceof ChatModel) {
+                    const { usage, model } = output;
+                    task.usage = usage;
+                    task.extraTitleMetadata ??= {};
+                    if (model)
+                        task.extraTitleMetadata.model = model;
+                }
+                taskWrapper.title = this.formatTaskTitle(agent, { task, usage: true, time: true });
+                if (this.options.verbose) {
+                    taskWrapper.output = this.formatAgentSucceedOutput(agent, output);
+                }
+                if (!parentContextId || !this.tasks[parentContextId]) {
+                    Object.assign(ctx, output);
+                }
+                task.resolve();
+            });
+            context.on("agentFailed", async ({ agent, contextId, error, timestamp }) => {
+                const task = this.tasks[contextId];
+                if (!task)
+                    return;
+                task.endTime = timestamp;
+                const { taskWrapper } = await task.listr.promise;
+                taskWrapper.title = this.formatTaskTitle(agent, { task, usage: true, time: true });
+                taskWrapper.output = this.formatAgentFailedOutput(agent, error);
+                task.reject(error);
+            });
+            const [result] = await Promise.all([
+                listr.waitTaskAndRun(),
+                context.call(agent, input).finally(() => {
+                    listr.resolveWaitingTask();
+                }),
+            ]);
+            return { result, context };
+        }
+        finally {
+            this.spinner.stop();
+        }
+    }
+    newListr() {
+        return new MyListr([], {
+            concurrent: true,
+            rendererOptions: {
+                collapseSubtasks: false,
+                writeBottomBarDirectly: true,
+                icon: {
+                    [ListrDefaultRendererLogLevels.PENDING]: () => this.spinner.fetch(),
+                    [ListrDefaultRendererLogLevels.OUTPUT_WITH_BOTTOMBAR]: "",
+                },
+            },
+        });
+    }
+    formatAgentStartedOutput(agent, data) {
+        return `\
+${chalk.grey(figures.pointer)} call agent ${agent.name} started with input:
+${this.formatMessage(data)}`;
+    }
+    formatAgentSucceedOutput(agent, data) {
+        return `\
+${chalk.grey(figures.tick)} call agent ${agent.name} succeed with output:
+${this.formatMessage(data)}`;
+    }
+    formatAgentFailedOutput(agent, data) {
+        return `\
+${chalk.grey(figures.cross)} call agent ${agent.name} failed with error:
+${this.formatMessage(data)}`;
+    }
+    formatMessage(data) {
+        return inspect(data, { colors: true, depth: DEBUG_DEPTH });
+    }
+    formatTokenUsage(usage, extra) {
+        const items = [
+            [chalk.yellow(usage.inputTokens), chalk.grey("input tokens")],
+            [chalk.cyan(usage.outputTokens), chalk.grey("output tokens")],
+            usage.agentCalls ? [chalk.magenta(usage.agentCalls), chalk.grey("agent calls")] : undefined,
+        ];
+        const content = items.filter((i) => !!i).map((i) => i.join(" "));
+        if (extra) {
+            content.unshift(...Object.entries(extra)
+                .filter(([k, v]) => k && v)
+                .map(([k, v]) => `${chalk.grey(k)}: ${v}`));
+        }
+        return `${chalk.grey("(")}${content.join(chalk.green(", "))}${chalk.grey(")")}`;
+    }
+    formatTimeUsage(startTime, endTime) {
+        const duration = endTime - startTime;
+        return chalk.grey(`[${parseDuration(duration)}]`);
+    }
+    formatTaskTitle(agent, { task, usage, time } = {}) {
+        let title = `call agent ${agent.name}`;
+        if (usage && task?.usage)
+            title += ` ${this.formatTokenUsage(task.usage, task.extraTitleMetadata)}`;
+        if (time && task?.startTime && task.endTime)
+            title += ` ${this.formatTimeUsage(task.startTime, task.endTime)}`;
+        return title;
+    }
+}
+class MyListr extends Listr {
+    taskPromise = Promise.withResolvers();
+    isTaskPromiseResolved = false;
+    resolveWaitingTask() {
+        if (!this.isTaskPromiseResolved) {
+            this.taskPromise.resolve();
+            this.isTaskPromiseResolved = true;
+        }
+    }
+    add(...args) {
+        const result = super.add(...args);
+        this.resolveWaitingTask();
+        return result;
+    }
+    async waitTaskAndRun(ctx) {
+        if (!this.tasks.length)
+            await this.taskPromise.promise;
+        if (!this.tasks.length)
+            return ctx;
+        return super.run(ctx);
+    }
+}

package/dist/utils/agent-v1.d.ts

@@ -0,0 +1,134 @@
+export declare function isV1Package(src: string): Promise<boolean>;
+export declare function toAIGNEPackage(src: string, dst: string): Promise<void>;
+export type Parameter = {
+    id: string;
+    key?: string;
+    hidden?: boolean;
+    required?: boolean;
+    placeholder?: string;
+} & ({
+    type?: "string" | "number" | "boolean" | "language";
+} | {
+    type?: "select";
+    options?: {
+        id: string;
+        label?: string;
+        value?: string;
+    }[];
+});
+export interface VariableTypeBase {
+    id: string;
+    name?: string;
+    description?: string;
+    required?: boolean;
+    hidden?: boolean;
+}
+export type OutputVariable = VariableTypeBase & ({
+    type?: undefined;
+} | {
+    type: "string";
+    defaultValue?: string;
+} | {
+    type: "number";
+    defaultValue?: number;
+} | {
+    type: "boolean";
+    defaultValue?: boolean;
+} | {
+    type: "object";
+    properties?: OutputVariable[];
+} | {
+    type: "array";
+    element?: OutputVariable;
+});
+export type AgentV1 = {
+    id: string;
+    name?: string;
+    description?: string;
+    parameters?: Parameter[];
+    outputVariables?: OutputVariable[];
+} & ({
+    type: "prompt";
+    prompts?: Prompt[];
+    temperature?: number;
+    topP?: number;
+    presencePenalty?: number;
+    frequencyPenalty?: number;
+    maxTokens?: number;
+    model?: string;
+} | {
+    type: "router";
+    defaultToolId?: string;
+    prompt?: string;
+    decisionType?: "ai";
+    routes?: Tool[];
+    temperature?: number;
+    topP?: number;
+    presencePenalty?: number;
+    frequencyPenalty?: number;
+    maxTokens?: number;
+    model?: string;
+} | {
+    type: "image";
+    prompt?: string;
+    model?: string;
+    n?: number;
+    quality?: string;
+    style?: string;
+    size?: string;
+    modelSettings?: {
+        [key: string]: unknown;
+    };
+} | {
+    type: "api";
+    requestParameters?: {
+        id: string;
+        key?: string;
+        value?: string;
+    }[];
+    requestMethod?: string;
+    requestUrl?: string;
+    requestHeaders: {
+        id: string;
+        key?: string;
+        value?: string;
+    }[];
+} | {
+    type: "function";
+    code?: string;
+} | {
+    type: "callAgent";
+    agents?: Tool[];
+});
+export interface ProjectDefinitionV1 {
+    project: {
+        name?: string;
+        description?: string;
+    };
+    agents: AgentV1[];
+}
+export type Prompt = {
+    type: "message";
+    data: PromptMessage;
+    visibility?: "hidden";
+} | {
+    type: "executeBlock";
+    visibility?: "hidden";
+};
+export type PromptMessage = {
+    id: string;
+    role: Role;
+    content?: string;
+    name?: string;
+};
+export type Role = "system" | "user" | "assistant";
+export type Tool = {
+    blockletDid?: string;
+    projectId?: string;
+    id: string;
+    from?: "assistant" | "blockletAPI" | "knowledge";
+    parameters?: {
+        [key: string]: unknown;
+    };
+    functionName?: string;
+};

package/dist/utils/agent-v1.js

@@ -0,0 +1,209 @@
+import { readFile, stat, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { glob } from "glob";
+import { parse, stringify } from "yaml";
+export async function isV1Package(src) {
+    return stat(join(src, "project.yaml"))
+        .then((res) => res.isFile())
+        .catch((error) => {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    });
+}
+export async function toAIGNEPackage(src, dst) {
+    const definition = await loadAgentV1Package(src);
+    const aigne = {
+        chat_model: {
+            name: "gpt-4o-mini", // TODO: get from config
+        },
+        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);
+    }
+    await writeFile(join(dst, "aigne.yaml"), stringify(aigne));
+}
+async function loadAgentV1Package(path) {
+    const agentFilePaths = await glob("prompts/**/*.yaml", {
+        cwd: path,
+    });
+    const project = parse(await readFile(join(path, "project.yaml"), "utf8"));
+    const definition = {
+        project,
+        agents: [],
+    };
+    for (const filename of agentFilePaths) {
+        const agent = parse(await readFile(join(path, filename), "utf8"));
+        definition.agents.push(agent);
+    }
+    return definition;
+}
+function assistantToAigneV2(agent, project) {
+    const converter = RUNNABLE_MAP[agent.type];
+    if (!converter)
+        throw new Error(`Unsupported runnable type: ${agent.type}`);
+    return converter(agent, project);
+}
+const RUNNABLE_MAP = {
+    prompt: (agent) => {
+        if (agent.type !== "prompt")
+            throw new Error(`Expected runnable type 'prompt', but got '${agent.type}'`);
+        const obj = {
+            name: agent.name || agent.id,
+            description: agent.description,
+            input_schema: convertInputSchema(agent),
+            output_schema: convertOutputSchema(agent),
+            instructions: agent.prompts
+                ?.filter((i) => i.visibility !== "hidden" && i.type === "message")
+                .map((i) => i.data.content) // TODO: should support multiple messages with different roles
+                .join("\n"),
+        };
+        return {
+            content: stringify(obj),
+        };
+    },
+    function: async (agent) => {
+        if (agent.type !== "function")
+            throw new Error(`Expected runnable type 'function', but got '${agent.type}'`);
+        const inputNames = agent.parameters?.map((i) => i.key).filter(Boolean) ?? [];
+        return {
+            content: await formatCode(`\
+export default async function agent({${inputNames.join(", ")}}) {
+${agent.code}
+}
+
+agent.agent_name = ${JSON.stringify(agent.name || agent.id)};
+
+agent.description = ${agent.description ? JSON.stringify(agent.description) : "undefined"};
+
+agent.input_schema = ${JSON.stringify(convertInputSchema(agent))};
+
+agent.output_schema = ${JSON.stringify(convertOutputSchema(agent))};
+`),
+        };
+    },
+    router: (agent, project) => {
+        if (agent.type !== "router")
+            throw new Error(`Expected runnable type 'router', but got '${agent.type}'`);
+        return {
+            content: stringify({
+                name: agent.name || agent.id,
+                description: agent.description,
+                instructions: agent.prompt,
+                input_schema: convertInputSchema(agent),
+                output_schema: convertOutputSchema(agent),
+                tools: agent.routes?.map((i) => {
+                    const tool = project.agents.find((j) => j.id === i.id);
+                    if (!tool)
+                        throw new Error(`Tool ${i.id} not found in project definition`);
+                    return getAgentFilename(tool);
+                }),
+                tool_choice: "router",
+            }),
+        };
+    },
+};
+function getAgentFilename(agent) {
+    switch (agent.type) {
+        case "prompt":
+        case "router":
+            return `${agent.name || agent.id}.yaml`;
+        case "function":
+            return `${agent.name || agent.id}.js`;
+        default:
+            throw new Error(`Unsupported agent type: ${agent.type}`);
+    }
+}
+async function formatCode(code) {
+    const [prettier, typescriptPlugin, estreePlugin] = await Promise.all([
+        import("prettier"),
+        import("prettier/plugins/typescript"),
+        import("prettier/plugins/estree"),
+    ]);
+    return prettier.format(code, {
+        parser: "typescript",
+        plugins: [typescriptPlugin, estreePlugin.default],
+        printWidth: 120,
+        useTabs: false,
+        tabWidth: 2,
+        trailingComma: "es5",
+        bracketSameLine: true,
+        semi: true,
+        singleQuote: true,
+    });
+}
+function convertInputSchema(agent) {
+    const parameters = (agent.parameters ?? []).filter((i) => !!i.key && !i.hidden);
+    const properties = parameters.map((i) => [i.key, parameterToJsonSchema(i)]);
+    return {
+        type: "object",
+        properties: Object.fromEntries(properties),
+        required: parameters.filter((i) => i.required).map((i) => i.key),
+    };
+}
+function parameterToJsonSchema(parameter) {
+    switch (parameter.type) {
+        case undefined:
+        case "string":
+        case "language":
+            return {
+                type: "string",
+                description: parameter.placeholder,
+            };
+        case "select":
+            return {
+                type: "string",
+                enum: parameter.options?.map((i) => i.value),
+                description: parameter.placeholder,
+            };
+        case "number":
+        case "boolean":
+            return {
+                type: parameter.type,
+                description: parameter.placeholder,
+            };
+        default:
+            throw new Error(`Unsupported parameter type: ${parameter.type}`);
+    }
+}
+function convertOutputSchema(agent) {
+    const outputs = agent.outputVariables?.filter((i) => !!i.name && !i.hidden) ?? [];
+    const properties = outputs
+        .map((i) => [i.name, variableTypeToJsonSchema(i)])
+        .filter((i) => !!i[1]);
+    return {
+        type: "object",
+        properties: Object.fromEntries(properties),
+        required: outputs.filter((i) => i.required).map((i) => i.name),
+    };
+}
+function variableTypeToJsonSchema(output) {
+    if (output.type === "object") {
+        if (!output.properties)
+            return undefined;
+        return {
+            type: "object",
+            properties: Object.fromEntries(output.properties
+                .filter((i) => !!i.name)
+                .map((i) => [i.name, variableTypeToJsonSchema(i)])
+                .filter((i) => !!i[1])),
+            required: output.properties.filter((i) => i.required && i.name).map((i) => i.name),
+        };
+    }
+    if (output.type === "array") {
+        if (!output.element)
+            return undefined;
+        return {
+            type: "array",
+            items: variableTypeToJsonSchema(output.element),
+        };
+    }
+    return {
+        type: output.type || "string",
+        description: output.description,
+    };
+}

package/dist/utils/download.d.ts

@@ -0,0 +1 @@
+export declare function downloadAndExtract(url: string, dir: string): Promise<void>;

package/dist/utils/download.js

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

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

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

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

@@ -0,0 +1,76 @@
+import { inspect } from "node:util";
+import { MESSAGE_KEY, createMessage } from "@aigne/core";
+import { logger } from "@aigne/core/utils/logger.js";
+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 = {}) {
+    const { initialCall = process.env.INITIAL_CALL, skipLoop = process.env.SKIP_LOOP === "true" } = options;
+    options.verbose ??= logger.enabled("aigne:core");
+    // Disable the logger, use TerminalTracer instead
+    logger.disable();
+    let prompt;
+    if (options?.welcome)
+        console.log(options.welcome);
+    if (initialCall) {
+        await callAgent(userAgent, initialCall, { ...options });
+        if (skipLoop)
+            return;
+    }
+    for (let i = 0;; i++) {
+        prompt = inquirer.prompt([
+            {
+                type: "input",
+                name: "question",
+                message: "💬",
+                default: i === 0 ? options?.defaultQuestion : undefined,
+            },
+        ]);
+        let question;
+        try {
+            question = (await prompt).question;
+        }
+        catch {
+            // ignore abort error from inquirer
+        }
+        if (!question?.trim())
+            continue;
+        const cmd = COMMANDS[question.trim()];
+        if (cmd) {
+            const result = cmd();
+            if (result.message)
+                console.log(result.message);
+            if (result?.exit)
+                break;
+            continue;
+        }
+        await callAgent(userAgent, question, { ...options });
+    }
+}
+async function callAgent(userAgent, input, options) {
+    const tracer = new TerminalTracer(userAgent.context, { verbose: options.verbose });
+    const { result, context } = await tracer.run(userAgent, options.inputKey && typeof input === "string"
+        ? { [options.inputKey]: input }
+        : createMessage(input));
+    console.log(`
+${chalk.grey(figures.tick)} 💬 ${inspect(input, { colors: true })}
+${chalk.grey(figures.tick)} 🤖 ${tracer.formatTokenUsage(context.usage)}
+${formatAIResponse(result)}
+`);
+}
+const COMMANDS = {
+    "/exit": () => ({ exit: true }),
+    "/help": () => ({
+        message: `\
+Commands:
+  /exit - exit the chat loop
+  /help - show this help message
+`,
+    }),
+};
+function formatAIResponse({ [MESSAGE_KEY]: msg, ...message } = {}) {
+    const text = msg && typeof msg === "string" ? msg : undefined;
+    const json = Object.keys(message).length > 0 ? inspect(message, { colors: true }) : undefined;
+    return [text, json].filter(Boolean).join("\n");
+}

package/dist/utils/time.d.ts

@@ -0,0 +1 @@
+export declare function parseDuration(duration: number): string;

package/dist/utils/time.js

@@ -0,0 +1,12 @@
+export function parseDuration(duration) {
+    const milliseconds = duration % 1000;
+    const seconds = Math.floor(duration / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const ms = Math.round(milliseconds / 10)
+        .toString()
+        .padStart(2, "0");
+    const s = `${Number.parseFloat(`${seconds % 60}.${ms}`)}s`;
+    if (minutes === 0)
+        return s;
+    return `${minutes}m${s}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/cli",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "cli for AIGNE framework",
   "publishConfig": {
     "access": "public"
@@ -34,27 +34,34 @@
     }
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.8.0",
+    "@aigne/listr2": "^1.0.7",
+    "@modelcontextprotocol/sdk": "^1.9.0",
     "chalk": "^5.4.1",
     "commander": "^13.1.0",
     "express": "^5.1.0",
+    "glob": "^11.0.1",
     "gradient-string": "^3.0.0",
-    "inquirer": "^12.5.0",
-    "openai": "^4.91.1",
+    "inquirer": "^12.5.2",
+    "openai": "^4.94.0",
+    "prettier": "^3.5.3",
+    "pretty-error": "^4.0.0",
+    "tar": "^7.4.3",
     "zod": "^3.24.2",
-    "@aigne/core": "^1.6.0"
+    "@aigne/core": "^1.8.0"
   },
   "devDependencies": {
-    "@types/bun": "^1.2.8",
+    "@types/archiver": "^6.0.3",
+    "@types/bun": "^1.2.9",
     "@types/express": "^5.0.1",
+    "@types/glob": "^8.1.0",
     "@types/gradient-string": "^1.1.6",
-    "@types/node": "^22.14.0",
+    "@types/node": "^22.14.1",
+    "archiver": "^7.0.1",
     "detect-port": "^2.1.0",
     "npm-run-all": "^4.1.5",
     "rimraf": "^6.0.1",
-    "typescript": "^5.8.2",
-    "ufo": "^1.6.0",
-    "@aigne/test-utils": "^1.0.0"
+    "typescript": "^5.8.3",
+    "ufo": "^1.6.1"
   },
   "scripts": {
     "lint": "tsc --noEmit",