@aigne/cli 1.29.0 → 1.30.1

package/CHANGELOG.md

@@ -1,5 +1,51 @@
 # Changelog
 
+## [1.30.1](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.30.0...cli-v1.30.1) (2025-08-04)
+
+
+### Bug Fixes
+
+* **cli:** persist prompts log and improve terminal output ([#307](https://github.com/AIGNE-io/aigne-framework/issues/307)) ([ac8116f](https://github.com/AIGNE-io/aigne-framework/commit/ac8116fc46f26169e7619860c392fb9f66bc3fee))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/agent-library bumped to 1.21.10
+    * @aigne/agentic-memory bumped to 1.0.10
+    * @aigne/aigne-hub bumped to 0.4.1
+    * @aigne/openai bumped to 0.10.10
+    * @aigne/core bumped to 1.43.0
+    * @aigne/default-memory bumped to 1.0.10
+
+## [1.30.0](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.29.0...cli-v1.30.0) (2025-08-01)
+
+
+### Features
+
+* **cli:** add `--model` option for aigne applications ([#302](https://github.com/AIGNE-io/aigne-framework/issues/302)) ([5d63743](https://github.com/AIGNE-io/aigne-framework/commit/5d63743b8a47be64fd49245983f4f2f9da3197a0))
+* **cli:** add `upgrade` command for aigne app ([#299](https://github.com/AIGNE-io/aigne-framework/issues/299)) ([1bf461a](https://github.com/AIGNE-io/aigne-framework/commit/1bf461ab644b2d810ef81cd3092475496dfc7ddc))
+* support google model and skip check mode when connected to Hub ([#300](https://github.com/AIGNE-io/aigne-framework/issues/300)) ([e992c0f](https://github.com/AIGNE-io/aigne-framework/commit/e992c0f3335a7c512fa807d5b8ad10c9c3bf2351))
+
+
+### Bug Fixes
+
+* **cli:** indicator not responsive in macos terminal ([#304](https://github.com/AIGNE-io/aigne-framework/issues/304)) ([336f75b](https://github.com/AIGNE-io/aigne-framework/commit/336f75b8a7dfaf28d78e9a4cfcb4ac8c6a29c469))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/agent-library bumped to 1.21.9
+    * @aigne/agentic-memory bumped to 1.0.9
+    * @aigne/aigne-hub bumped to 0.4.0
+    * @aigne/openai bumped to 0.10.9
+    * @aigne/core bumped to 1.42.0
+    * @aigne/default-memory bumped to 1.0.9
+    * @aigne/observability-api bumped to 0.9.0
+
 ## [1.29.0](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.28.0...cli-v1.29.0) (2025-07-31)
 
 

package/dist/commands/aigne.js

@@ -1,3 +1,4 @@
+import chalk from "chalk";
 import yargs from "yargs";
 import { AIGNE_CLI_VERSION } from "../constants.js";
 import { asciiLogo } from "../utils/ascii-logo.js";
@@ -10,6 +11,7 @@ import { createServeMCPCommand } from "./serve-mcp.js";
 import { createTestCommand } from "./test.js";
 export function createAIGNECommand(options) {
     console.log(asciiLogo);
+    console.log(`${chalk.grey("TIPS:")} use ${chalk.greenBright("aigne observe")} to start the observability server.\n`);
     return yargs()
         .scriptName("aigne")
         .usage("CLI for AIGNE framework")

package/dist/commands/app.d.ts

@@ -7,13 +7,16 @@ export declare function invokeCLIAgentFromDir(options: {
     input: Message & {
         input?: string[];
         format?: "yaml" | "json";
+        model?: string;
     };
 }): Promise<void>;
-export declare function loadApplication({ name, dir, }: {
+export declare function loadApplication({ name, dir, forceUpgrade, }: {
     name: string;
     dir?: string;
+    forceUpgrade?: boolean;
 }): Promise<{
     aigne: AIGNE;
     dir: string;
     version: string;
+    isCache?: boolean;
 }>;

package/dist/commands/app.js

@@ -1,16 +1,16 @@
 import assert from "node:assert";
-import { spawnSync } from "node:child_process";
+import { spawn } from "node:child_process";
 import { readFile, stat, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { extname, join } from "node:path";
 import { isatty } from "node:tty";
+import { loadModel } from "@aigne/aigne-hub";
 import { AIAgent, AIGNE, readAllString } from "@aigne/core";
 import { pick } from "@aigne/core/utils/type-utils.js";
 import { Listr, PRESET_TIMER } from "@aigne/listr2";
 import { joinURL } from "ufo";
 import { parse } from "yaml";
 import { ZodObject, ZodString } from "zod";
-import { availableModels } from "../constants.js";
 import { downloadAndExtract } from "../utils/download.js";
 import { loadAIGNE } from "../utils/load-aigne.js";
 import { runAgentWithAIGNE, stdinHasData } from "../utils/run-with-aigne.js";
@@ -29,8 +29,14 @@ export function createAppCommands() {
         describe: app.describe,
         aliases: app.aliases,
         builder: async (yargs) => {
-            const { aigne, dir, version } = await loadApplication({ name: app.name });
-            yargs.command(serveMcpCommandModule({ name: app.name, dir }));
+            const { aigne, dir, version, isCache } = await loadApplication({ name: app.name });
+            yargs
+                .option("model", {
+                type: "string",
+                description: "Model to use for the application, example: openai:gpt-4.1 or google:gemini-2.5-flash",
+            })
+                .command(serveMcpCommandModule({ name: app.name, dir }))
+                .command(upgradeCommandModule({ name: app.name, dir, isLatest: !isCache, version }));
             for (const agent of aigne.cli?.agents ?? []) {
                 yargs.command(agentCommandModule({ dir, agent }));
             }
@@ -64,6 +70,20 @@ const serveMcpCommandModule = ({ name, dir, }) => ({
         await serveMCPServerFromDir({ ...options, dir });
     },
 });
+const upgradeCommandModule = ({ name, dir, isLatest, version, }) => ({
+    command: "upgrade",
+    describe: `Upgrade ${name} to the latest version`,
+    handler: async () => {
+        if (!isLatest) {
+            const result = await loadApplication({ name, dir, forceUpgrade: true });
+            if (version !== result.version) {
+                console.log(`\n✅ Upgraded ${name} to version ${version}`);
+                return;
+            }
+        }
+        console.log(`\n✅ ${name} is already at the latest version (${version})`);
+    },
+});
 const agentCommandModule = ({ dir, agent, }) => {
     const inputSchema = agent.inputSchema instanceof ZodObject ? agent.inputSchema.shape : {};
     return {
@@ -99,7 +119,7 @@ const agentCommandModule = ({ dir, agent, }) => {
     };
 };
 export async function invokeCLIAgentFromDir(options) {
-    const aigne = await loadAIGNE(options.dir);
+    const aigne = await loadAIGNE(options.dir, { model: options.input.model });
     try {
         const agent = aigne.cli.agents[options.agent];
         assert(agent, `Agent ${options.agent} not found in ${options.dir}`);
@@ -158,27 +178,28 @@ async function readFileAsInput(value, { format } = {}) {
     }
     return value;
 }
-export async function loadApplication({ name, dir, }) {
+export async function loadApplication({ name, dir, forceUpgrade = false, }) {
     name = `@aigne/${name}`;
     dir ??= join(homedir(), ".aigne", "registry.npmjs.org", name);
-    const check = await isInstallationAvailable(dir);
+    const check = forceUpgrade ? undefined : await isInstallationAvailable(dir);
     if (check?.available) {
         return {
-            aigne: await AIGNE.load(dir, { models: availableModels() }),
+            aigne: await AIGNE.load(dir, { loadModel }),
             dir,
             version: check.version,
+            isCache: true,
         };
     }
     const result = await new Listr([
         {
-            title: "Fetching application metadata",
+            title: `Fetching ${name} metadata`,
             task: async (ctx) => {
                 const info = await getNpmTgzInfo(name);
                 Object.assign(ctx, info);
             },
         },
         {
-            title: "Downloading application",
+            title: `Downloading ${name}`,
             skip: (ctx) => ctx.version === check?.version,
             task: async (ctx) => {
                 await downloadAndExtract(ctx.url, dir, { strip: 1 });
@@ -186,7 +207,6 @@ export async function loadApplication({ name, dir, }) {
         },
         {
             title: "Installing dependencies",
-            skip: (ctx) => ctx.version === check?.version,
             task: async () => {
                 await installDependencies(dir);
             },
@@ -199,7 +219,7 @@ export async function loadApplication({ name, dir, }) {
         },
     }).run();
     return {
-        aigne: await AIGNE.load(dir, { models: availableModels() }),
+        aigne: await AIGNE.load(dir, { loadModel }),
         dir,
         version: result.version,
     };
@@ -219,14 +239,22 @@ async function isInstallationAvailable(dir, { cacheTimeMs = NPM_PACKAGE_CACHE_TI
     return { version, available };
 }
 async function installDependencies(dir) {
-    const { stderr, status } = spawnSync("npm", ["install", "--omit", "dev"], {
-        cwd: dir,
-        stdio: "pipe",
+    await new Promise((resolve, reject) => {
+        const child = spawn("npm", ["install", "--omit", "dev"], { cwd: dir, stdio: "pipe" });
+        let stderr = "";
+        child.stderr.on("data", (data) => {
+            stderr += data.toString();
+        });
+        child.on("error", (error) => reject(error));
+        child.on("exit", (code) => {
+            if (code === 0)
+                resolve();
+            else {
+                console.error(stderr);
+                reject(new Error(`npm install failed with code ${code}`));
+            }
+        });
     });
-    if (status !== 0) {
-        console.error(stderr.toString());
-        throw new Error(`Failed to install dependencies in ${dir}`);
-    }
     await writeFile(join(dir, ".aigne-cli.json"), JSON.stringify({ installedAt: Date.now() }, null, 2));
 }
 async function getNpmTgzInfo(name) {

package/dist/commands/connect.d.ts

@@ -2,5 +2,12 @@ import type { CommandModule } from "yargs";
 interface ConnectOptions {
     url?: string;
 }
+interface StatusInfo {
+    host: string;
+    apiUrl: string;
+    apiKey: string;
+}
+export declare function getConnectionStatus(): Promise<StatusInfo[]>;
+export declare function displayStatus(statusList: StatusInfo[]): Promise<void>;
 export declare function createConnectCommand(): CommandModule<unknown, ConnectOptions>;
 export {};

package/dist/commands/connect.js

@@ -4,7 +4,11 @@ import chalk from "chalk";
 import { parse } from "yaml";
 import { getUserInfo } from "../utils/aigne-hub-user.js";
 import { AIGNE_ENV_FILE, connectToAIGNEHub } from "../utils/load-aigne.js";
-async function getConnectionStatus() {
+const formatNumber = (balance) => {
+    const balanceNum = String(balance).split(".")[0];
+    return chalk.yellow((balanceNum || "").replace(/\B(?=(\d{3})+(?!\d))/g, ","));
+};
+export async function getConnectionStatus() {
     if (!existsSync(AIGNE_ENV_FILE)) {
         return [];
     }
@@ -25,7 +29,7 @@ async function getConnectionStatus() {
         return [];
     }
 }
-async function displayStatus(statusList) {
+export async function displayStatus(statusList) {
     if (statusList.length === 0) {
         console.log(chalk.yellow("No AIGNE Hub connections found."));
         console.log("Use 'aigne connect <url>' to connect to a hub.");
@@ -46,11 +50,16 @@ async function displayStatus(statusList) {
         console.log(`   Status: ${statusText}`);
         if (userInfo) {
             console.log(`   User: ${userInfo?.user.fullName}`);
-            console.log(`   Email: ${userInfo?.user.email}`);
+            console.log(`   User DID: ${userInfo?.user.did}`);
+            if (userInfo?.user.email) {
+                console.log(`   Email: ${userInfo?.user.email}`);
+            }
             if (userInfo?.creditBalance) {
-                console.log(`   Plan: ${userInfo?.creditBalance?.balance}/${userInfo?.creditBalance?.total}`);
+                const balance = formatNumber(userInfo?.creditBalance?.balance);
+                const total = formatNumber(userInfo?.creditBalance?.total);
+                console.log(`   Plan: ${balance} / ${total}`);
             }
-            console.log(`   Billing URL: ${userInfo?.paymentLink}`);
+            console.log(`   Billing URL: ${userInfo?.paymentLink ? chalk.green(userInfo.paymentLink) : chalk.red("N/A")}`);
         }
         console.log("");
     }

package/dist/constants.d.ts

@@ -1,5 +1,3 @@
-import type { LoadableModel } from "@aigne/core/loader/index.js";
 import { DefaultMemory } from "@aigne/default-memory";
 export declare const AIGNE_CLI_VERSION: any;
-export declare function availableModels(): LoadableModel[];
 export declare const availableMemories: (typeof DefaultMemory)[];

package/dist/constants.js

@@ -1,82 +1,6 @@
 import { createRequire } from "node:module";
 import { AgenticMemory } from "@aigne/agentic-memory";
-import { AIGNEHubChatModel } from "@aigne/aigne-hub";
-import { AnthropicChatModel } from "@aigne/anthropic";
-import { BedrockChatModel } from "@aigne/bedrock";
-import { DeepSeekChatModel } from "@aigne/deepseek";
 import { DefaultMemory } from "@aigne/default-memory";
-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 { NodeHttpHandler, streamCollector } from "@smithy/node-http-handler";
-import { HttpsProxyAgent } from "https-proxy-agent";
 const require = createRequire(import.meta.url);
 export const AIGNE_CLI_VERSION = require("../package.json").version;
-export function availableModels() {
-    const proxy = ["HTTPS_PROXY", "https_proxy", "HTTP_PROXY", "http_proxy", "ALL_PROXY", "all_proxy"]
-        .map((i) => process.env[i])
-        .filter(Boolean)[0];
-    const httpAgent = proxy ? new HttpsProxyAgent(proxy) : undefined;
-    const clientOptions = {
-        fetchOptions: {
-            // @ts-ignore
-            agent: httpAgent,
-        },
-    };
-    return [
-        {
-            name: OpenAIChatModel.name,
-            apiKeyEnvName: "OPENAI_API_KEY",
-            create: (params) => new OpenAIChatModel({ ...params, clientOptions }),
-        },
-        {
-            name: AnthropicChatModel.name,
-            apiKeyEnvName: "ANTHROPIC_API_KEY",
-            create: (params) => new AnthropicChatModel({ ...params, clientOptions }),
-        },
-        {
-            name: BedrockChatModel.name,
-            apiKeyEnvName: "AWS_ACCESS_KEY_ID",
-            create: (params) => new BedrockChatModel({
-                ...params,
-                clientOptions: {
-                    requestHandler: NodeHttpHandler.create({ httpAgent, httpsAgent: httpAgent }),
-                    streamCollector,
-                },
-            }),
-        },
-        {
-            name: DeepSeekChatModel.name,
-            apiKeyEnvName: "DEEPSEEK_API_KEY",
-            create: (params) => new DeepSeekChatModel({ ...params, clientOptions }),
-        },
-        {
-            name: GeminiChatModel.name,
-            apiKeyEnvName: "GEMINI_API_KEY",
-            create: (params) => new GeminiChatModel({ ...params, clientOptions }),
-        },
-        {
-            name: OllamaChatModel.name,
-            apiKeyEnvName: "OLLAMA_API_KEY",
-            create: (params) => new OllamaChatModel({ ...params, clientOptions }),
-        },
-        {
-            name: OpenRouterChatModel.name,
-            apiKeyEnvName: "OPEN_ROUTER_API_KEY",
-            create: (params) => new OpenRouterChatModel({ ...params, clientOptions }),
-        },
-        {
-            name: XAIChatModel.name,
-            apiKeyEnvName: "XAI_API_KEY",
-            create: (params) => new XAIChatModel({ ...params, clientOptions }),
-        },
-        {
-            name: AIGNEHubChatModel.name,
-            apiKeyEnvName: "AIGNE_HUB_API_KEY",
-            create: (params) => new AIGNEHubChatModel({ ...params, clientOptions }),
-        },
-    ];
-}
 export const availableMemories = [DefaultMemory, AgenticMemory];

package/dist/tracer/terminal.js

@@ -70,9 +70,11 @@ export class TerminalTracer {
                                 return undefined;
                             return async (config) => {
                                 const { taskWrapper } = await task.listr.promise;
-                                return taskWrapper
+                                const result = await taskWrapper
                                     .prompt(ListrInquirerPromptAdapter)
                                     .run(method, config);
+                                console.log(`${chalk.blue("✔")} ${chalk.bold(config.message)} ${result}`);
+                                return result;
                             };
                         },
                     }),

package/dist/utils/listr.d.ts

@@ -37,6 +37,7 @@ export declare class AIGNEListrRenderer extends DefaultRenderer {
     get _options(): AIGNEListrRendererOptions;
     get _spinner(): Spinner;
     update(): void;
+    private isPreviousPrompt;
     create({ running, ...options }: Parameters<DefaultRenderer["create"]>[0] & {
         running?: boolean;
     }): string;

package/dist/utils/listr.js

@@ -47,21 +47,26 @@ export class AIGNEListr extends Listr {
     }
     async run(stream) {
         const originalLog = logger.logMessage;
+        const originalConsole = { ...console };
         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);
             }
+            logger.logMessage = (...args) => this.logs.push(format(...args));
+            for (const method of ["debug", "log", "info", "warn", "error"]) {
+                console[method] = (...args) => this.logs.push(format(...args));
+            }
             const _stream = await stream();
             this.add({ task: () => this.extractStream(_stream) });
             return await super.run().then(() => ({ ...this.result }));
         }
         finally {
             logger.logMessage = originalLog;
+            Object.assign(console, originalConsole);
             this.spinner.stop();
         }
     }
@@ -92,35 +97,44 @@ export class AIGNEListrRenderer extends DefaultRenderer {
     update() {
         this._updater(this.create({ running: true }));
     }
+    isPreviousPrompt = false;
     create({ running = false, ...options }) {
         const logs = this._options.aigne?.getStdoutLogs?.();
         if (logs?.length) {
             this._updater.clear();
             this._logger.toStdout(logs.join(EOL));
         }
-        let tasks = super.create({ ...options, prompt: false });
-        const bottomBar = this._options.aigne?.getBottomBarLogs?.({ running });
-        if (bottomBar?.length) {
-            tasks += EOL.repeat(2);
-            const output = [...bottomBar, running ? this._spinner.fetch() : ""]
-                .map((i) => this._wrap(i))
-                .join(EOL);
-            // If the task is not running, we show all lines
-            if (!running) {
-                tasks += output;
-            }
-            // For running tasks, we only show the last few lines
-            else {
-                const { rows } = process.stdout;
-                const lines = rows - tasks.split(EOL).length - 2;
-                tasks += output.split(EOL).slice(-Math.max(4, lines)).join(EOL);
-            }
-        }
+        let buffer = "";
         const prompt = super["renderPrompt"]();
         if (prompt.length) {
-            tasks += `${EOL.repeat(2)}${prompt.join(EOL)}`;
+            buffer += prompt.join(EOL);
+            this.isPreviousPrompt = true;
+        }
+        // Skip a frame if previous render was a prompt, and reset the flag
+        else if (this.isPreviousPrompt) {
+            this.isPreviousPrompt = false;
+        }
+        else {
+            buffer += super.create({ ...options, prompt: false });
+            const bottomBar = this._options.aigne?.getBottomBarLogs?.({ running });
+            if (bottomBar?.length) {
+                buffer += EOL.repeat(2);
+                const output = [...bottomBar, running ? this._spinner.fetch() : ""]
+                    .map((i) => this._wrap(i))
+                    .join(EOL);
+                // If the task is not running, we show all lines
+                if (!running) {
+                    buffer += output;
+                }
+                // For running tasks, we only show the last few lines
+                else {
+                    const { rows } = process.stdout;
+                    const lines = rows - buffer.split(EOL).length - 2;
+                    buffer += output.split(EOL).slice(-Math.max(4, lines)).join(EOL);
+                }
+            }
         }
-        return tasks;
+        return buffer;
     }
     _wrap(str) {
         return wrap(str, process.stdout.columns ?? 80, {

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

@@ -1,5 +1,5 @@
+import { availableModels } from "@aigne/aigne-hub";
 import { AIGNE } from "@aigne/core";
-import type { LoadableModel } from "@aigne/core/loader/index.js";
 import inquirer from "inquirer";
 import { type RunAIGNECommandOptions } from "./run-with-aigne.js";
 export declare const decrypt: (m: string, s: string, i: string) => string;
@@ -40,7 +40,7 @@ interface CreateConnectOptions {
     }) => Promise<FetchResult>;
 }
 export declare function createConnect({ connectUrl, openPage, fetchInterval, retry, source, connectAction, wrapSpinner, closeOnSuccess, intervalFetchConfig, }: CreateConnectOptions): Promise<FetchResult>;
-export declare const formatModelName: (models: LoadableModel[], model: string, inquirerPrompt: typeof inquirer.prompt) => Promise<string>;
+export declare const formatModelName: (models: ReturnType<typeof availableModels>, model: string, inquirerPrompt: typeof inquirer.prompt) => Promise<string>;
 export declare function connectToAIGNEHub(url: string): Promise<{
     accessKey: string;
     url: string;
@@ -48,7 +48,11 @@ export declare function connectToAIGNEHub(url: string): Promise<{
     accessKey: undefined;
     url: undefined;
 }>;
-export declare function loadAIGNE(path: string, options?: RunOptions, actionOptions?: {
+export declare const checkConnectionStatus: (host: string) => Promise<{
+    apiKey: any;
+    url: string;
+}>;
+export declare function loadAIGNE(path: string, options?: Pick<RunOptions, "model">, actionOptions?: {
     inquirerPromptFn?: (prompt: {
         type: string;
         name: string;

package/dist/utils/load-aigne.js

@@ -2,8 +2,9 @@ import { existsSync, mkdirSync } from "node:fs";
 import { readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { availableModels, findModel, loadModel } from "@aigne/aigne-hub";
 import { AIGNE } from "@aigne/core";
-import { loadAIGNEFile, loadModel } from "@aigne/core/loader/index.js";
+import { loadAIGNEFile } from "@aigne/core/loader/index.js";
 import { logger } from "@aigne/core/utils/logger.js";
 import { AesCrypter } from "@ocap/mcrypto/lib/crypter/aes-legacy.js";
 import crypto from "crypto";
@@ -12,7 +13,7 @@ import open from "open";
 import pWaitFor from "p-wait-for";
 import { joinURL, withQuery } from "ufo";
 import { parse, stringify } from "yaml";
-import { availableMemories, availableModels } from "../constants.js";
+import { availableMemories } from "../constants.js";
 import { parseModelOption } from "./run-with-aigne.js";
 const aes = new AesCrypter();
 export const decrypt = (m, s, i) => aes.decrypt(m, crypto.pbkdf2Sync(i, s, 256, 32, "sha512").toString("hex"));
@@ -104,10 +105,11 @@ export const formatModelName = async (models, model, inquirerPrompt) => {
     if (providerName.includes(AGENT_HUB_PROVIDER)) {
         return model;
     }
-    const m = models.find((m) => m.name.toLowerCase().includes(providerName.toLowerCase()));
+    const m = findModel(models, providerName);
     if (!m)
         throw new Error(`Unsupported model: ${provider} ${name}`);
-    if (m.apiKeyEnvName && process.env[m.apiKeyEnvName]) {
+    const apiKeyEnvName = Array.isArray(m.apiKeyEnvName) ? m.apiKeyEnvName : [m.apiKeyEnvName];
+    if (apiKeyEnvName.some((name) => name && process.env[name])) {
         return model;
     }
     if (TEST_ENV) {
@@ -123,7 +125,7 @@ export const formatModelName = async (models, model, inquirerPrompt) => {
                 value: true,
             },
             {
-                name: `Exit and bring my owner API Key by set ${m.apiKeyEnvName}`,
+                name: `Exit and bring my owner API Key by set ${apiKeyEnvName.join(", ")}`,
                 value: false,
             },
         ],
@@ -175,42 +177,48 @@ export async function connectToAIGNEHub(url) {
         return { accessKey: undefined, url: undefined };
     }
 }
+export const checkConnectionStatus = async (host) => {
+    // aigne-hub access token
+    if (!existsSync(AIGNE_ENV_FILE)) {
+        throw new Error("AIGNE_HUB_API_KEY file not found, need to login first");
+    }
+    const data = await readFile(AIGNE_ENV_FILE, "utf8");
+    if (!data.includes("AIGNE_HUB_API_KEY")) {
+        throw new Error("AIGNE_HUB_API_KEY key not found, need to login first");
+    }
+    const envs = parse(data);
+    if (!envs[host]) {
+        throw new Error("AIGNE_HUB_API_KEY host not found, need to login first");
+    }
+    const env = envs[host];
+    if (!env.AIGNE_HUB_API_KEY) {
+        throw new Error("AIGNE_HUB_API_KEY key not found, need to login first");
+    }
+    return {
+        apiKey: env.AIGNE_HUB_API_KEY,
+        url: joinURL(env.AIGNE_HUB_API_URL),
+    };
+};
+const mockInquirerPrompt = (() => Promise.resolve({ useAigneHub: true }));
 export async function loadAIGNE(path, options, actionOptions) {
     const models = availableModels();
     const AIGNE_HUB_URL = process.env.AIGNE_HUB_API_URL || DEFAULT_URL;
     const connectUrl = joinURL(new URL(AIGNE_HUB_URL).origin, WELLKNOWN_SERVICE_PATH_PREFIX);
     const inquirerPrompt = (actionOptions?.inquirerPromptFn ??
         inquirer.prompt);
+    const { host } = new URL(AIGNE_HUB_URL);
     const { aigne } = await loadAIGNEFile(path).catch(() => ({ aigne: null }));
-    let accessKeyOptions = {};
-    const modelName = await formatModelName(models, options?.model || `${aigne?.model?.provider ?? ""}:${aigne?.model?.name ?? ""}`, inquirerPrompt);
+    const result = await checkConnectionStatus(host).catch(() => null);
+    const alreadyConnected = Boolean(result?.apiKey);
+    const modelName = await formatModelName(models, options?.model || `${aigne?.model?.provider ?? ""}:${aigne?.model?.name ?? ""}`, alreadyConnected ? mockInquirerPrompt : inquirerPrompt);
+    let credential = {};
     if (TEST_ENV && !actionOptions?.runTest) {
-        const model = await loadModel(models, parseModelOption(modelName), undefined, accessKeyOptions);
-        return await AIGNE.load(path, { models, memories: availableMemories, model });
+        const model = await loadModel(parseModelOption(modelName));
+        return await AIGNE.load(path, { loadModel, memories: availableMemories, model });
     }
     if ((modelName.toLocaleLowerCase() || "").includes(AGENT_HUB_PROVIDER)) {
-        const { host } = new URL(AIGNE_HUB_URL);
         try {
-            // aigne-hub access token
-            if (!existsSync(AIGNE_ENV_FILE)) {
-                throw new Error("AIGNE_HUB_API_KEY file not found, need to login first");
-            }
-            const data = await readFile(AIGNE_ENV_FILE, "utf8");
-            if (!data.includes("AIGNE_HUB_API_KEY")) {
-                throw new Error("AIGNE_HUB_API_KEY key not found, need to login first");
-            }
-            const envs = parse(data);
-            if (!envs[host]) {
-                throw new Error("AIGNE_HUB_API_KEY host not found, need to login first");
-            }
-            const env = envs[host];
-            if (!env.AIGNE_HUB_API_KEY) {
-                throw new Error("AIGNE_HUB_API_KEY key not found, need to login first");
-            }
-            accessKeyOptions = {
-                accessKey: env.AIGNE_HUB_API_KEY,
-                url: joinURL(env.AIGNE_HUB_API_URL),
-            };
+            credential = await checkConnectionStatus(host);
         }
         catch (error) {
             if (error instanceof Error && error.message.includes("login first")) {
@@ -232,10 +240,10 @@ export async function loadAIGNE(path, options, actionOptions) {
                     console.warn("The AIGNE Hub connection has been cancelled");
                     process.exit(0);
                 }
-                accessKeyOptions = await connectToAIGNEHub(connectUrl);
+                credential = await connectToAIGNEHub(connectUrl);
             }
         }
     }
-    const model = await loadModel(models, parseModelOption(modelName), undefined, accessKeyOptions);
-    return await AIGNE.load(path, { models, memories: availableMemories, model });
+    const model = await loadModel(parseModelOption(modelName), undefined, credential);
+    return await AIGNE.load(path, { loadModel, memories: availableMemories, model });
 }

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

@@ -4,8 +4,8 @@ import { dirname, isAbsolute, join } from "node:path";
 import { isatty } from "node:tty";
 import { promisify } from "node:util";
 import { exists } from "@aigne/agent-library/utils/fs.js";
+import { availableModels, loadModel } from "@aigne/aigne-hub";
 import { AIAgent, AIGNE, DEFAULT_OUTPUT_KEY, readAllString, UserAgent, } from "@aigne/core";
-import { loadModel } from "@aigne/core/loader/index.js";
 import { getLevelFromEnv, LogLevel, logger } from "@aigne/core/utils/logger.js";
 import { flat, isEmpty, tryOrThrow } from "@aigne/core/utils/type-utils.js";
 import chalk from "chalk";
@@ -13,7 +13,6 @@ import { parse } from "yaml";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { ZodError, ZodObject, z } from "zod";
-import { availableModels } from "../constants.js";
 import { TerminalTracer } from "../tracer/terminal.js";
 import { DEFAULT_CHAT_INPUT_KEY, runChatLoopInTerminal, } from "./run-chat-loop.js";
 export const createRunAIGNECommand = (yargs) => yargs
@@ -24,7 +23,12 @@ export const createRunAIGNECommand = (yargs) => yargs
 })
     .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) => i.name.toLowerCase().replace(/ChatModel$/i, ""))
+        .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",
 })
@@ -129,7 +133,7 @@ export async function runWithAIGNE(agentCreator, { argv = process.argv, chatLoop
         if (options.logLevel) {
             logger.level = options.logLevel;
         }
-        const model = await loadModel(availableModels(), {
+        const model = await loadModel({
             ...parseModelOption(options.model),
             temperature: options.temperature,
             topP: options.topP,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/cli",
-  "version": "1.29.0",
+  "version": "1.30.1",
   "description": "cli for AIGNE framework",
   "publishConfig": {
     "access": "public"
@@ -70,20 +70,13 @@
     "yaml": "^2.8.0",
     "yargs": "^18.0.0",
     "zod": "^3.25.67",
-    "@aigne/agent-library": "^1.21.8",
-    "@aigne/aigne-hub": "^0.3.2",
-    "@aigne/anthropic": "^0.10.4",
-    "@aigne/bedrock": "^0.8.8",
-    "@aigne/core": "^1.41.0",
-    "@aigne/deepseek": "^0.7.8",
-    "@aigne/agentic-memory": "^1.0.8",
-    "@aigne/default-memory": "^1.0.8",
-    "@aigne/gemini": "^0.8.8",
-    "@aigne/observability-api": "^0.8.2",
-    "@aigne/ollama": "^0.7.8",
-    "@aigne/open-router": "^0.7.8",
-    "@aigne/openai": "^0.10.8",
-    "@aigne/xai": "^0.7.8"
+    "@aigne/aigne-hub": "^0.4.1",
+    "@aigne/agent-library": "^1.21.10",
+    "@aigne/openai": "^0.10.10",
+    "@aigne/default-memory": "^1.0.10",
+    "@aigne/agentic-memory": "^1.0.10",
+    "@aigne/observability-api": "^0.9.0",
+    "@aigne/core": "^1.43.0"
   },
   "devDependencies": {
     "@types/archiver": "^6.0.3",