@aigne/cli 1.37.0 → 1.38.0

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## [1.38.0](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.37.1...cli-v1.38.0) (2025-08-20)
+
+
+### Features
+
+* add ImageModel/ImageAgent support ([#383](https://github.com/AIGNE-io/aigne-framework/issues/383)) ([96a2093](https://github.com/AIGNE-io/aigne-framework/commit/96a209368d91d98f47db6de1e404640368a86fa8))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/agent-library bumped to 1.21.24
+    * @aigne/agentic-memory bumped to 1.0.24
+    * @aigne/aigne-hub bumped to 0.6.6
+    * @aigne/core bumped to 1.53.0
+    * @aigne/default-memory bumped to 1.1.6
+    * @aigne/openai bumped to 0.12.0
+
+## [1.37.1](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.37.0...cli-v1.37.1) (2025-08-20)
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/agent-library bumped to 1.21.23
+    * @aigne/agentic-memory bumped to 1.0.23
+    * @aigne/aigne-hub bumped to 0.6.5
+    * @aigne/core bumped to 1.52.0
+    * @aigne/default-memory bumped to 1.1.5
+    * @aigne/observability-api bumped to 0.9.1
+    * @aigne/openai bumped to 0.11.5
+
 ## [1.37.0](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.36.4...cli-v1.37.0) (2025-08-18)
 
 

package/dist/commands/app.js

@@ -3,7 +3,6 @@ import { spawn } from "node:child_process";
 import { mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { loadModel } from "@aigne/aigne-hub";
 import { AIGNE } from "@aigne/core";
 import { Listr, PRESET_TIMER } from "@aigne/listr2";
 import { joinURL } from "ufo";
@@ -95,7 +94,7 @@ const agentCommandModule = ({ dir, agent, }) => {
 export async function invokeCLIAgentFromDir(options) {
     const aigne = await loadAIGNE({
         path: options.dir,
-        options: { model: options.input.model },
+        modelOptions: { model: options.input.model },
     });
     try {
         const agent = aigne.cli.agents[options.agent];
@@ -113,7 +112,7 @@ export async function loadApplication({ name, dir, forceUpgrade = false, }) {
     const check = forceUpgrade ? undefined : await isInstallationAvailable(dir);
     if (check?.available) {
         return {
-            aigne: await AIGNE.load(dir, { loadModel }),
+            aigne: await AIGNE.load(dir),
             dir,
             version: check.version,
             isCache: true,
@@ -156,7 +155,7 @@ export async function loadApplication({ name, dir, forceUpgrade = false, }) {
         },
     }).run();
     return {
-        aigne: await AIGNE.load(dir, { loadModel }),
+        aigne: await AIGNE.load(dir),
         dir,
         version: result.version,
     };

package/dist/commands/hub.js

@@ -1,10 +1,12 @@
 import { existsSync } from "node:fs";
 import { readFile, writeFile } from "node:fs/promises";
-import { AIGNE_ENV_FILE, AIGNE_HUB_URL, connectToAIGNEHub, isTest } from "@aigne/aigne-hub";
+import { AIGNE_HUB_URL } from "@aigne/aigne-hub";
 import chalk from "chalk";
 import Table from "cli-table3";
 import inquirer from "inquirer";
 import { parse, stringify } from "yaml";
+import { AIGNE_ENV_FILE, isTest } from "../utils/aigne-hub/constants.js";
+import { connectToAIGNEHub } from "../utils/aigne-hub/credential.js";
 import { getUserInfo } from "../utils/aigne-hub-user.js";
 import { getUrlOrigin } from "../utils/get-url-origin.js";
 const formatNumber = (balance) => {

package/dist/commands/run.js

@@ -78,12 +78,10 @@ export function createRunCommand({ aigneFilePath, } = {}) {
                         }
                         const aigne = await loadAIGNE({
                             path: dir,
-                            options: {
+                            modelOptions: {
                                 ...options,
                                 model: options.model || process.env.MODEL,
                                 aigneHubUrl: options?.aigneHubUrl,
-                            },
-                            actionOptions: {
                                 inquirerPromptFn: (prompt) => {
                                     if (prompt.type === "input") {
                                         return task

package/dist/commands/serve-mcp.js

@@ -53,7 +53,7 @@ export async function serveMCPServerFromDir(options) {
     const port = options.port || DEFAULT_PORT();
     const aigne = await loadAIGNE({
         path: options.dir,
-        options: { aigneHubUrl: options.aigneHubUrl },
+        modelOptions: { aigneHubUrl: options.aigneHubUrl },
     });
     await serveMCPServer({
         aigne,

package/dist/commands/test.js

@@ -24,7 +24,7 @@ export function createTestCommand({ aigneFilePath, } = {}) {
             const absolutePath = isAbsolute(path) ? path : resolve(process.cwd(), path);
             const aigne = await loadAIGNE({
                 path: absolutePath,
-                options: { aigneHubUrl: options?.aigneHubUrl },
+                modelOptions: { aigneHubUrl: options?.aigneHubUrl },
             });
             assert(aigne.rootDir);
             spawnSync("node", ["--test"], { cwd: aigne.rootDir, stdio: "inherit" });

package/dist/utils/aigne-hub/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const WELLKNOWN_SERVICE_PATH_PREFIX = "/.well-known/service";
+export declare const ACCESS_KEY_SESSION_API = "/api/access-key/session";
+export declare const AIGNE_HUB_PROVIDER = "aignehub";
+export declare const DEFAULT_AIGNE_HUB_PROVIDER_MODEL = "aignehub:openai/gpt-5-mini";
+export declare const isTest: string | boolean;
+export declare const AIGNE_ENV_FILE: string;

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

@@ -0,0 +1,12 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+const ACCESS_KEY_PREFIX = "/api/access-key";
+export const WELLKNOWN_SERVICE_PATH_PREFIX = "/.well-known/service";
+export const ACCESS_KEY_SESSION_API = `${ACCESS_KEY_PREFIX}/session`;
+const DEFAULT_AIGNE_HUB_MODEL = "openai/gpt-5-mini";
+export const AIGNE_HUB_PROVIDER = "aignehub";
+export const DEFAULT_AIGNE_HUB_PROVIDER_MODEL = `${AIGNE_HUB_PROVIDER}:${DEFAULT_AIGNE_HUB_MODEL}`;
+export const isTest = process.env.CI || process.env.NODE_ENV === "test";
+const TEST_AIGNE_ENV_FILE = join(homedir(), ".aigne", "test-aigne-hub-connected.yaml");
+const PROD_AIGNE_ENV_FILE = join(homedir(), ".aigne", "aigne-hub-connected.yaml");
+export const AIGNE_ENV_FILE = isTest ? TEST_AIGNE_ENV_FILE : PROD_AIGNE_ENV_FILE;

package/dist/utils/aigne-hub/credential.d.ts

@@ -0,0 +1,23 @@
+import type { CreateConnectOptions, FetchResult, LoadCredentialOptions } from "./type.js";
+export declare const fetchConfigs: ({ connectUrl, sessionId, fetchInterval, fetchTimeout, }: {
+    connectUrl: string;
+    sessionId: string;
+    fetchInterval: number;
+    fetchTimeout: number;
+}) => Promise<any>;
+export declare function createConnect({ connectUrl, openPage, fetchInterval, retry, source, connectAction, wrapSpinner, closeOnSuccess, intervalFetchConfig, appName, appLogo, }: CreateConnectOptions): Promise<FetchResult>;
+export declare function connectToAIGNEHub(url: string): Promise<{
+    apiKey: string;
+    url: string;
+} | {
+    apiKey: undefined;
+    url: undefined;
+}>;
+export declare const checkConnectionStatus: (host: string) => Promise<{
+    apiKey: any;
+    url: any;
+}>;
+export declare function loadAIGNEHubCredential(options?: LoadCredentialOptions): Promise<{
+    apiKey?: string;
+    url?: string;
+} | undefined>;

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

@@ -0,0 +1,206 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { AIGNE_HUB_BLOCKLET_DID, AIGNE_HUB_URL, getAIGNEHubMountPoint } from "@aigne/aigne-hub";
+import { logger } from "@aigne/core/utils/logger.js";
+import inquirer from "inquirer";
+import open from "open";
+import pWaitFor from "p-wait-for";
+import { joinURL, withQuery } from "ufo";
+import { parse, stringify } from "yaml";
+import { ACCESS_KEY_SESSION_API, AIGNE_ENV_FILE, isTest, WELLKNOWN_SERVICE_PATH_PREFIX, } from "./constants.js";
+import { decrypt, encodeEncryptionKey } from "./crypto.js";
+const request = async (config) => {
+    const headers = {};
+    if (config.requestCount !== undefined) {
+        headers["X-Request-Count"] = config.requestCount.toString();
+    }
+    const response = await fetch(config.url, { method: config.method || "GET", headers });
+    if (!response.ok)
+        throw new Error(`HTTP error! status: ${response.status}`);
+    const data = await response.json();
+    return { data };
+};
+export const fetchConfigs = async ({ connectUrl, sessionId, fetchInterval, fetchTimeout, }) => {
+    const sessionURL = withQuery(joinURL(connectUrl, ACCESS_KEY_SESSION_API), { sid: sessionId });
+    let requestCount = 0;
+    const condition = async () => {
+        const { data: session } = await request({ url: sessionURL, requestCount });
+        requestCount++;
+        return Boolean(session.accessKeyId && session.accessKeySecret);
+    };
+    await pWaitFor(condition, { interval: fetchInterval, timeout: fetchTimeout });
+    const { data: session } = await request({ url: sessionURL, requestCount });
+    await request({ url: sessionURL, method: "DELETE" });
+    return {
+        ...session,
+        accessKeyId: session.accessKeyId,
+        accessKeySecret: decrypt(session.accessKeySecret, session.accessKeyId, session.challenge),
+    };
+};
+function baseWrapSpinner(_, waiting) {
+    return Promise.resolve(waiting());
+}
+export async function createConnect({ connectUrl, openPage, fetchInterval = 3 * 1000, retry = 1500, source = "Blocklet CLI", connectAction = "connect-cli", wrapSpinner = baseWrapSpinner, closeOnSuccess, intervalFetchConfig, appName = "AIGNE CLI", appLogo = "https://www.aigne.io/favicon.ico?imageFilter=resize&w=32", }) {
+    const startSessionURL = joinURL(connectUrl, ACCESS_KEY_SESSION_API);
+    const { data: session } = await request({ url: startSessionURL, method: "POST" });
+    const token = session.id;
+    const pageUrl = withQuery(joinURL(connectUrl, connectAction), {
+        __token__: encodeEncryptionKey(token),
+        source,
+        closeOnSuccess,
+        cli: true,
+        appName: ` ${appName}`,
+        appLogo,
+    });
+    openPage?.(pageUrl);
+    return await wrapSpinner(`Waiting for connection: ${connectUrl}`, async () => {
+        const checkAuthorizeStatus = intervalFetchConfig ?? fetchConfigs;
+        const authorizeStatus = await checkAuthorizeStatus({
+            connectUrl,
+            sessionId: token,
+            fetchTimeout: retry * fetchInterval,
+            fetchInterval: retry,
+        });
+        return authorizeStatus;
+    });
+}
+export async function connectToAIGNEHub(url) {
+    const { origin, host } = new URL(url);
+    const connectUrl = joinURL(origin, WELLKNOWN_SERVICE_PATH_PREFIX);
+    const apiUrl = await getAIGNEHubMountPoint(url, AIGNE_HUB_BLOCKLET_DID);
+    try {
+        const openFn = isTest ? () => { } : open;
+        const result = await createConnect({
+            connectUrl: connectUrl,
+            connectAction: "gen-simple-access-key",
+            source: `@aigne/cli connect to AIGNE hub`,
+            closeOnSuccess: true,
+            openPage: (pageUrl) => openFn(pageUrl),
+        });
+        const accessKeyOptions = {
+            apiKey: result.accessKeySecret,
+            url: apiUrl,
+        };
+        // After redirection, write the AIGNE Hub access token
+        const aigneDir = join(homedir(), ".aigne");
+        if (!existsSync(aigneDir)) {
+            mkdirSync(aigneDir, { recursive: true });
+        }
+        const envs = parse(await readFile(AIGNE_ENV_FILE, "utf8").catch(() => stringify({})));
+        await writeFile(AIGNE_ENV_FILE, stringify({
+            ...envs,
+            [host]: {
+                AIGNE_HUB_API_KEY: accessKeyOptions.apiKey,
+                AIGNE_HUB_API_URL: accessKeyOptions.url,
+            },
+            default: {
+                AIGNE_HUB_API_URL: accessKeyOptions.url,
+            },
+        }));
+        return accessKeyOptions;
+    }
+    catch (error) {
+        logger.error("Failed to connect to AIGNE Hub", error.message);
+        return { apiKey: 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: env.AIGNE_HUB_API_URL,
+    };
+};
+export async function loadAIGNEHubCredential(options) {
+    const isBlocklet = process.env.BLOCKLET_AIGNE_API_URL && process.env.BLOCKLET_AIGNE_API_PROVIDER;
+    if (isBlocklet)
+        return undefined;
+    const aigneDir = join(homedir(), ".aigne");
+    if (!existsSync(aigneDir)) {
+        mkdirSync(aigneDir, { recursive: true });
+    }
+    const envs = parse(await readFile(AIGNE_ENV_FILE, "utf8").catch(() => stringify({})));
+    const inquirerPrompt = (options?.inquirerPromptFn ?? inquirer.prompt);
+    const configUrl = options?.aigneHubUrl || process.env.AIGNE_HUB_API_URL;
+    const url = configUrl || envs?.default?.AIGNE_HUB_API_URL || AIGNE_HUB_URL;
+    const connectUrl = joinURL(new URL(url).origin, WELLKNOWN_SERVICE_PATH_PREFIX);
+    const { host } = new URL(url);
+    let credential = {};
+    try {
+        credential = await checkConnectionStatus(host);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes("login first")) {
+            let aigneHubUrl = connectUrl;
+            if (!configUrl) {
+                const { subscribe } = await inquirerPrompt({
+                    type: "list",
+                    name: "subscribe",
+                    message: "No LLM API Keys or AIGNE Hub connections found. How would you like to proceed?",
+                    choices: [
+                        {
+                            name: "Connect to the Arcblock official AIGNE Hub (recommended, free credits for new users)",
+                            value: "official",
+                        },
+                        connectUrl.includes(AIGNE_HUB_URL)
+                            ? {
+                                name: "Connect to your own AIGNE Hub instance (self-hosted)",
+                                value: "custom",
+                            }
+                            : null,
+                        {
+                            name: "Exit and configure my own LLM API Keys",
+                            value: "manual",
+                        },
+                    ].filter(Boolean),
+                    default: "official",
+                });
+                if (subscribe === "custom") {
+                    const { customUrl } = await inquirerPrompt({
+                        type: "input",
+                        name: "customUrl",
+                        message: "Enter the URL of your AIGNE Hub:",
+                        validate(input) {
+                            try {
+                                const url = new URL(input);
+                                return url.protocol.startsWith("http")
+                                    ? true
+                                    : "Must be a valid URL with http or https";
+                            }
+                            catch {
+                                return "Invalid URL";
+                            }
+                        },
+                    });
+                    aigneHubUrl = customUrl;
+                }
+                else if (subscribe === "manual") {
+                    console.log("You chose to configure your own LLM API Keys. Exiting...");
+                    process.exit(0);
+                }
+            }
+            credential = await connectToAIGNEHub(aigneHubUrl);
+        }
+        else {
+            throw error;
+        }
+    }
+    return credential;
+}

package/dist/utils/aigne-hub/crypto.d.ts

@@ -0,0 +1,4 @@
+export declare const decrypt: (m: string, s: string, i: string) => string;
+export declare const encrypt: (m: string, s: string, i: string) => string;
+export declare const encodeEncryptionKey: (key: string) => string;
+export declare const decodeEncryptionKey: (str: string) => Uint8Array<ArrayBuffer>;

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

@@ -0,0 +1,9 @@
+import crypto from "node:crypto";
+import { AesCrypter } from "@ocap/mcrypto/lib/crypter/aes-legacy.js";
+const aes = new AesCrypter();
+export const decrypt = (m, s, i) => aes.decrypt(m, crypto.pbkdf2Sync(i, s, 256, 32, "sha512").toString("hex"));
+export const encrypt = (m, s, i) => aes.encrypt(m, crypto.pbkdf2Sync(i, s, 256, 32, "sha512").toString("hex"));
+const escapeFn = (str) => str.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+const unescapeFn = (str) => (str + "===".slice((str.length + 3) % 4)).replace(/-/g, "+").replace(/_/g, "/");
+export const encodeEncryptionKey = (key) => escapeFn(Buffer.from(key).toString("base64"));
+export const decodeEncryptionKey = (str) => new Uint8Array(Buffer.from(unescapeFn(str), "base64"));

package/dist/utils/aigne-hub/model.d.ts

@@ -0,0 +1,12 @@
+import type { ChatModel, ChatModelOptions } from "@aigne/core";
+import type { LoadCredentialOptions } from "./type.js";
+export declare function maskApiKey(apiKey?: string): string | undefined;
+export declare const parseModelOption: (model: string) => {
+    provider: string | undefined;
+    model: string | undefined;
+};
+export declare const formatModelName: (model: string, inquirerPrompt: NonNullable<LoadCredentialOptions["inquirerPromptFn"]>) => Promise<{
+    provider: string;
+    model?: string;
+}>;
+export declare function loadChatModel(options?: ChatModelOptions & LoadCredentialOptions): Promise<ChatModel>;

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

@@ -0,0 +1,75 @@
+import { AIGNE_HUB_DEFAULT_MODEL, findModel } from "@aigne/aigne-hub";
+import { flat } from "@aigne/core/utils/type-utils.js";
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { AIGNE_HUB_PROVIDER } from "./constants.js";
+import { loadAIGNEHubCredential } from "./credential.js";
+export function maskApiKey(apiKey) {
+    if (!apiKey || apiKey.length <= 8)
+        return apiKey;
+    const start = apiKey.slice(0, 4);
+    const end = apiKey.slice(-4);
+    return `${start}${"*".repeat(8)}${end}`;
+}
+export const parseModelOption = (model) => {
+    const { provider, name } = model.match(/(?<provider>[^:]*)(:(?<name>.*))?/)?.groups ?? {};
+    return { provider: provider?.replace(/-/g, ""), model: name };
+};
+export const formatModelName = async (model, inquirerPrompt) => {
+    let { provider, model: name } = parseModelOption(model);
+    provider ||= AIGNE_HUB_PROVIDER;
+    const { match, all } = findModel(provider);
+    if (!match)
+        throw new Error(`Unsupported model: ${provider}/${name}, available providers: ${all.map((m) => m.name).join(", ")}`);
+    if (provider.includes(AIGNE_HUB_PROVIDER)) {
+        return { provider, model: name || AIGNE_HUB_DEFAULT_MODEL };
+    }
+    const requireEnvs = flat(match.apiKeyEnvName);
+    if (requireEnvs.some((name) => name && process.env[name])) {
+        return { provider, model: name };
+    }
+    const result = await inquirerPrompt({
+        type: "list",
+        name: "useAigneHub",
+        message: `Seems no API Key configured for ${provider}/${name}, select your preferred way to continue:`,
+        choices: [
+            {
+                name: `Connect to AIGNE Hub to use ${name} (Recommended since free credits available)`,
+                value: true,
+            },
+            {
+                name: `Exit and bring my owner API Key by set ${requireEnvs.join(", ")}`,
+                value: false,
+            },
+        ],
+        default: true,
+    });
+    if (!result.useAigneHub) {
+        console.log(chalk.yellow(`You can use command "export ${requireEnvs[0]}=xxx" to set API Key in your shell. Or you can set environment variables in .env file.`));
+        process.exit(0);
+    }
+    return { provider: AIGNE_HUB_PROVIDER, model: `${provider}/${name}` };
+};
+export async function loadChatModel(options) {
+    const { provider, model } = await formatModelName(options?.model || process.env.MODEL || "", options?.inquirerPromptFn ??
+        inquirer.prompt);
+    const params = {
+        model,
+        temperature: options?.temperature,
+        topP: options?.topP,
+        frequencyPenalty: options?.frequencyPenalty,
+        presencePenalty: options?.presencePenalty,
+    };
+    const { match, all } = findModel(provider);
+    if (!match) {
+        throw new Error(`Unsupported model provider ${provider}, available providers: ${all.map((m) => m.name).join(", ")}`);
+    }
+    const credential = provider.toLowerCase().includes(AIGNE_HUB_PROVIDER)
+        ? await loadAIGNEHubCredential(options)
+        : undefined;
+    return match.create({
+        ...credential,
+        model: params.model,
+        modelOptions: { ...params },
+    });
+}

package/dist/utils/aigne-hub/type.d.ts

@@ -0,0 +1,38 @@
+type InquirerPromptFn = (prompt: {
+    type: string;
+    name: string;
+    message: string;
+    choices: {
+        name: string;
+        value: any;
+    }[];
+    default: any;
+}) => Promise<any>;
+export type LoadCredentialOptions = {
+    aigneHubUrl?: string;
+    inquirerPromptFn?: InquirerPromptFn;
+};
+export type FetchResult = {
+    accessKeyId: string;
+    accessKeySecret: string;
+};
+export type BaseWrapSpinner = (_: string, waiting: () => Promise<FetchResult>) => Promise<FetchResult>;
+export interface CreateConnectOptions {
+    connectUrl: string;
+    openPage?: (url: string) => void;
+    fetchInterval?: number;
+    retry?: number;
+    source?: string;
+    connectAction?: string;
+    appName?: string;
+    appLogo?: string;
+    wrapSpinner?: BaseWrapSpinner;
+    prettyUrl?: (url: string) => string;
+    closeOnSuccess?: boolean;
+    intervalFetchConfig?: (options: {
+        sessionId: string;
+        fetchInterval: number;
+        fetchTimeout: number;
+    }) => Promise<FetchResult>;
+}
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -1,5 +1,5 @@
-import type { LoadCredentialOptions, Model } from "@aigne/aigne-hub";
 import { AIGNE, type ChatModelOptions } from "@aigne/core";
+import type { LoadCredentialOptions } from "./aigne-hub/type.js";
 import type { RunAIGNECommandOptions } from "./run-with-aigne.js";
 export interface RunOptions extends RunAIGNECommandOptions {
     path: string;
@@ -7,12 +7,7 @@ export interface RunOptions extends RunAIGNECommandOptions {
     cacheDir?: string;
     aigneHubUrl?: string;
 }
-export declare function loadAIGNE({ path, options, modelOptions, actionOptions, }: {
+export declare function loadAIGNE({ path, modelOptions, }: {
     path?: string;
-    options?: Model & Pick<RunOptions, "model" | "aigneHubUrl">;
-    modelOptions?: ChatModelOptions;
-    actionOptions?: {
-        inquirerPromptFn?: LoadCredentialOptions["inquirerPromptFn"];
-        runTest?: boolean;
-    };
+    modelOptions?: ChatModelOptions & LoadCredentialOptions;
 }): Promise<AIGNE<import("@aigne/core").UserContext>>;

package/dist/utils/load-aigne.js

@@ -1,24 +1,17 @@
-import { existsSync, mkdirSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { AIGNE_ENV_FILE, checkConnectionStatus, AIGNE_HUB_URL as DEFAULT_AIGNE_HUB_URL, formatModelName, loadModel, maskApiKey, parseModelOption, } from "@aigne/aigne-hub";
 import { AIGNE } from "@aigne/core";
-import { loadAIGNEFile } from "@aigne/core/loader/index.js";
+import { isNil, omitBy } from "@aigne/core/utils/type-utils.js";
+import { OpenAIImageModel } from "@aigne/openai";
 import boxen from "boxen";
 import chalk from "chalk";
-import inquirer from "inquirer";
-import { parse, stringify } from "yaml";
 import { availableMemories } from "../constants.js";
+import { loadChatModel, maskApiKey } from "./aigne-hub/model.js";
 import { getUrlOrigin } from "./get-url-origin.js";
-const isTest = process.env.CI || process.env.NODE_ENV === "test";
-const mockInquirerPrompt = (() => Promise.resolve({ useAigneHub: true }));
 let printed = false;
 async function printChatModelInfoBox(model) {
     if (printed)
         return;
     printed = true;
-    const credential = await model.getCredential();
+    const credential = await model.credential;
     const lines = [`${chalk.cyan("Provider")}: ${chalk.green(model.name.replace("ChatModel", ""))}`];
     if (credential?.model) {
         lines.push(`${chalk.cyan("Model")}: ${chalk.green(credential?.model)}`);
@@ -32,49 +25,22 @@ async function printChatModelInfoBox(model) {
     console.log(boxen(lines.join("\n"), { padding: 1, borderStyle: "classic", borderColor: "cyan" }));
     console.log("");
 }
-async function prepareAIGNEConfig(options, inquirerPromptFn) {
-    const aigneDir = join(homedir(), ".aigne");
-    if (!existsSync(aigneDir)) {
-        mkdirSync(aigneDir, { recursive: true });
-    }
-    const envs = parse(await readFile(AIGNE_ENV_FILE, "utf8").catch(() => stringify({})));
-    const inquirerPrompt = (inquirerPromptFn ?? inquirer.prompt);
-    // get aigne hub url
-    const configUrl = options?.aigneHubUrl || process.env.AIGNE_HUB_API_URL;
-    const AIGNE_HUB_URL = configUrl || envs?.default?.AIGNE_HUB_API_URL || DEFAULT_AIGNE_HUB_URL;
-    const { host } = new URL(AIGNE_HUB_URL);
-    const result = await checkConnectionStatus(host).catch(() => null);
-    const alreadyConnected = Boolean(result?.apiKey);
-    return { AIGNE_HUB_URL, inquirerPrompt: alreadyConnected ? mockInquirerPrompt : inquirerPrompt };
-}
-export async function loadAIGNE({ path, options, modelOptions, actionOptions, }) {
-    const { AIGNE_HUB_URL, inquirerPrompt } = await prepareAIGNEConfig(options, actionOptions?.inquirerPromptFn);
-    const { temperature, topP, presencePenalty, frequencyPenalty } = options || {};
-    let modelName = options?.model || "";
+export async function loadAIGNE({ path, modelOptions, }) {
+    let aigne;
     if (path) {
-        const { aigne } = await loadAIGNEFile(path).catch(() => ({ aigne: null }));
-        const modelFromPath = `${aigne?.model?.provider ?? ""}:${aigne?.model?.name ?? ""}`;
-        modelName = modelName || modelFromPath;
+        aigne = await AIGNE.load(path, {
+            memories: availableMemories,
+            model: (options) => loadChatModel({ ...options, ...omitBy(modelOptions ?? {}, (v) => isNil(v)) }),
+            imageModel: () => new OpenAIImageModel(),
+        });
     }
-    // format model name
-    const formattedModelName = isTest ? modelName : await formatModelName(modelName, inquirerPrompt);
-    if (isTest && path && !actionOptions?.runTest) {
-        const model = await loadModel(parseModelOption(formattedModelName));
-        return await AIGNE.load(path, { loadModel, memories: availableMemories, model });
+    else {
+        const chatModel = await loadChatModel({ ...modelOptions });
+        aigne = new AIGNE({ model: chatModel });
     }
     console.log(`${chalk.grey("TIPS:")} run ${chalk.cyan("aigne observe")} to start the observability server.\n`);
-    const model = await loadModel({
-        ...parseModelOption(formattedModelName),
-        temperature,
-        topP,
-        presencePenalty,
-        frequencyPenalty,
-    }, modelOptions, { aigneHubUrl: AIGNE_HUB_URL, inquirerPromptFn: actionOptions?.inquirerPromptFn });
-    if (model) {
-        await printChatModelInfoBox(model);
-    }
-    if (path) {
-        return await AIGNE.load(path, { loadModel, memories: availableMemories, model });
+    if (aigne.model) {
+        await printChatModelInfoBox(aigne.model);
     }
-    return new AIGNE({ model });
+    return aigne;
 }

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

@@ -2,10 +2,10 @@ import { mkdir, stat, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join } from "node:path";
 import { isatty } from "node:tty";
 import { exists } from "@aigne/agent-library/utils/fs.js";
-import { availableModels, parseModelOption } from "@aigne/aigne-hub";
+import { availableModels } from "@aigne/aigne-hub";
 import { DEFAULT_OUTPUT_KEY, UserAgent, } from "@aigne/core";
 import { getLevelFromEnv, LogLevel, logger } from "@aigne/core/utils/logger.js";
-import { isEmpty, tryOrThrow } from "@aigne/core/utils/type-utils.js";
+import { isEmpty, isNil, omitBy, pick, tryOrThrow, } from "@aigne/core/utils/type-utils.js";
 import chalk from "chalk";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
@@ -106,14 +106,10 @@ export async function runWithAIGNE(agentCreator, { argv = process.argv, chatLoop
             logger.level = options.logLevel;
         }
         const aigne = await loadAIGNE({
-            options: {
-                ...parseModelOption(options.model),
-                temperature: options.temperature,
-                topP: options.topP,
-                presencePenalty: options.presencePenalty,
-                frequencyPenalty: options.frequencyPenalty,
+            modelOptions: {
+                ...modelOptions,
+                ...omitBy(pick(options, "model", "temperature", "topP", "presencePenalty", "frequencyPenalty"), (v) => isNil(v)),
             },
-            modelOptions,
         });
         try {
             const agent = typeof agentCreator === "function" ? await agentCreator(aigne) : agentCreator;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/cli",
-  "version": "1.37.0",
+  "version": "1.38.0",
   "description": "Your command center for agent development",
   "publishConfig": {
     "access": "public"
@@ -51,6 +51,7 @@
     "@inquirer/type": "^3.0.8",
     "@listr2/prompt-adapter-inquirer": "^3.0.1",
     "@modelcontextprotocol/sdk": "^1.15.0",
+    "@ocap/mcrypto": "^1.21.0",
     "@smithy/node-http-handler": "^4.1.0",
     "boxen": "^8.0.1",
     "chalk": "^5.4.1",
@@ -65,20 +66,22 @@
     "log-update": "^6.1.0",
     "marked": "^16.0.0",
     "nunjucks": "^3.2.4",
+    "open": "^10.2.0",
     "openai": "^5.8.3",
+    "p-wait-for": "^5.0.2",
     "prettier": "^3.6.2",
     "tar": "^7.4.3",
     "wrap-ansi": "^9.0.0",
     "yaml": "^2.8.0",
     "yargs": "^18.0.0",
     "zod": "^3.25.67",
-    "@aigne/agent-library": "^1.21.22",
-    "@aigne/aigne-hub": "^0.6.4",
-    "@aigne/agentic-memory": "^1.0.22",
-    "@aigne/core": "^1.51.0",
-    "@aigne/default-memory": "^1.1.4",
-    "@aigne/observability-api": "^0.9.0",
-    "@aigne/openai": "^0.11.4"
+    "@aigne/agent-library": "^1.21.24",
+    "@aigne/agentic-memory": "^1.0.24",
+    "@aigne/aigne-hub": "^0.6.6",
+    "@aigne/core": "^1.53.0",
+    "@aigne/observability-api": "^0.9.1",
+    "@aigne/default-memory": "^1.1.6",
+    "@aigne/openai": "^0.12.0"
   },
   "devDependencies": {
     "@types/archiver": "^6.0.3",