@aigne/cli 1.36.4 → 1.38.0

package/CHANGELOG.md

@@ -1,5 +1,64 @@
 # 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)
+
+
+### Features
+
+* **cli:** add support for array inputs in CLI arguments ([#378](https://github.com/AIGNE-io/aigne-framework/issues/378)) ([827ae11](https://github.com/AIGNE-io/aigne-framework/commit/827ae112de8d1a2e997b272b759090b6e5b8d395))
+* **cli:** support hide or collapse task for agents in CLI ([#381](https://github.com/AIGNE-io/aigne-framework/issues/381)) ([05b372d](https://github.com/AIGNE-io/aigne-framework/commit/05b372d431a862f7cdfa2a90bb4b7b2379bf97ab))
+
+
+### Bug Fixes
+
+* **cli:** only log API requests at info level and above ([#376](https://github.com/AIGNE-io/aigne-framework/issues/376)) ([03fc4d9](https://github.com/AIGNE-io/aigne-framework/commit/03fc4d9aad6e81aeae3b2eb02a62f7acade3bd77))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/agent-library bumped to 1.21.22
+    * @aigne/agentic-memory bumped to 1.0.22
+    * @aigne/aigne-hub bumped to 0.6.4
+    * @aigne/core bumped to 1.51.0
+    * @aigne/default-memory bumped to 1.1.4
+    * @aigne/openai bumped to 0.11.4
+
 ## [1.36.4](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.36.3...cli-v1.36.4) (2025-08-16)
 
 

package/dist/commands/app.js

@@ -2,18 +2,14 @@ import assert from "node:assert";
 import { spawn } from "node:child_process";
 import { mkdir, readFile, rm, 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 { join } from "node:path";
+import { AIGNE } from "@aigne/core";
 import { Listr, PRESET_TIMER } from "@aigne/listr2";
 import { joinURL } from "ufo";
-import { parse } from "yaml";
-import { ZodBoolean, ZodNumber, ZodObject, ZodString, ZodType } from "zod";
 import { downloadAndExtract } from "../utils/download.js";
 import { loadAIGNE } from "../utils/load-aigne.js";
-import { runAgentWithAIGNE, stdinHasData } from "../utils/run-with-aigne.js";
+import { runAgentWithAIGNE } from "../utils/run-with-aigne.js";
+import { parseAgentInput, withAgentInputSchema } from "../utils/yargs.js";
 import { serveMCPServerFromDir } from "./serve-mcp.js";
 const NPM_PACKAGE_CACHE_TIME_MS = 1000 * 60 * 60 * 24; // 1 day
 const builtinApps = [
@@ -85,120 +81,38 @@ const upgradeCommandModule = ({ name, dir, isLatest, version, }) => ({
     },
 });
 const agentCommandModule = ({ dir, agent, }) => {
-    const inputSchema = agent.inputSchema instanceof ZodObject ? agent.inputSchema.shape : {};
     return {
         command: agent.name,
         aliases: agent.alias || [],
         describe: agent.description || "",
-        builder: (yargs) => {
-            for (const [option, config] of Object.entries(inputSchema)) {
-                const innerType = innerZodType(config);
-                yargs.option(option, {
-                    // TODO: support more types
-                    type: innerType instanceof ZodBoolean
-                        ? "boolean"
-                        : innerType instanceof ZodNumber
-                            ? "number"
-                            : "string",
-                    description: config.description,
-                });
-                if (!(config.isNullable() || config.isOptional())) {
-                    yargs.demandOption(option);
-                }
-            }
-            return yargs
-                .option("input", {
-                type: "array",
-                description: "Input to the agent, use @<file> to read from a file",
-                alias: ["i"],
-            })
-                .option("format", {
-                type: "string",
-                description: 'Input format, can be "json" or "yaml"',
-                choices: ["json", "yaml"],
-            });
-        },
+        builder: async (yargs) => withAgentInputSchema(yargs, agent),
         handler: async (input) => {
             await invokeCLIAgentFromDir({ dir, agent: agent.name, input });
         },
     };
 };
-function innerZodType(type) {
-    if ("innerType" in type._def && type._def.innerType instanceof ZodType) {
-        return innerZodType(type._def.innerType);
-    }
-    return type;
-}
 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];
         assert(agent, `Agent ${options.agent} not found in ${options.dir}`);
-        const inputSchema = agent.inputSchema instanceof ZodObject ? agent.inputSchema.shape : {};
-        const input = Object.fromEntries(await Promise.all(Object.entries(pick(options.input, Object.keys(inputSchema))).map(async ([key, val]) => {
-            if (typeof val === "string" && val.startsWith("@")) {
-                const schema = inputSchema[key];
-                val = await readFileAsInput(val, {
-                    format: schema instanceof ZodString ? "raw" : undefined,
-                });
-            }
-            return [key, val];
-        })));
-        const rawInput = options.input.input ||
-            (isatty(process.stdin.fd) || !(await stdinHasData())
-                ? null
-                : [await readAllString(process.stdin)].filter(Boolean));
-        if (rawInput) {
-            for (const raw of rawInput) {
-                const parsed = raw.startsWith("@")
-                    ? await readFileAsInput(raw, { format: options.input.format })
-                    : raw;
-                if (typeof parsed !== "string") {
-                    Object.assign(input, parsed);
-                }
-                else {
-                    const inputKey = agent instanceof AIAgent ? agent.inputKey : undefined;
-                    if (inputKey) {
-                        Object.assign(input, { [inputKey]: parsed });
-                    }
-                }
-            }
-        }
+        const input = await parseAgentInput(options.input, agent);
         await runAgentWithAIGNE(aigne, agent, { input });
     }
     finally {
         await aigne.shutdown();
     }
 }
-async function readFileAsInput(value, { format } = {}) {
-    if (value.startsWith("@")) {
-        const ext = extname(value);
-        value = await readFile(value.slice(1), "utf8");
-        if (!format) {
-            if (ext === ".json")
-                format = "json";
-            else if (ext === ".yaml" || ext === ".yml")
-                format = "yaml";
-        }
-    }
-    if (format === "json") {
-        return JSON.parse(value);
-    }
-    else if (format === "yaml") {
-        return parse(value);
-    }
-    return value;
-}
 export async function loadApplication({ name, dir, forceUpgrade = false, }) {
     name = `@aigne/${name}`;
     dir ??= join(homedir(), ".aigne", "registry.npmjs.org", name);
     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,
@@ -241,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/tracer/terminal.d.ts

@@ -45,6 +45,8 @@ type Task = ReturnType<typeof promiseWithResolvers<void>> & {
         subtask: Listr;
         taskWrapper: AIGNEListrTaskWrapper;
     }>>;
+    agent: Agent;
+    input: Message;
     startTime?: number;
     endTime?: number;
     usage?: Partial<ContextUsage>;

package/dist/tracer/terminal.js

@@ -1,6 +1,6 @@
 import { EOL } from "node:os";
 import { inspect } from "node:util";
-import { AIAgent, ChatModel, DEFAULT_OUTPUT_KEY, UserAgent, } from "@aigne/core";
+import { AIAgent, ChatModel, DEFAULT_OUTPUT_KEY, mergeContextUsage, newEmptyContextUsage, UserAgent, } from "@aigne/core";
 import { promiseWithResolvers } from "@aigne/core/utils/promise.js";
 import { flat, omit } from "@aigne/core/utils/type-utils.js";
 import { figures } from "@aigne/listr2";
@@ -28,13 +28,39 @@ export class TerminalTracer {
             formatResult: (result, options) => [this.formatResult(agent, context, result, options)].filter(Boolean),
         }, [], { concurrent: true });
         this.listr = listr;
+        const collapsedMap = new Map();
+        const hideContextIds = new Set();
         const onStart = async ({ context, agent, ...event }) => {
             if (agent instanceof UserAgent)
                 return;
+            if (agent.taskRenderMode === "hide") {
+                hideContextIds.add(context.id);
+                return;
+            }
+            else if (agent.taskRenderMode === "collapse") {
+                collapsedMap.set(context.id, {
+                    ancestor: { contextId: context.id },
+                    usage: newEmptyContextUsage(),
+                    models: new Set(),
+                });
+            }
+            if (context.parentId) {
+                if (hideContextIds.has(context.parentId)) {
+                    hideContextIds.add(context.id);
+                    return;
+                }
+                const collapsed = collapsedMap.get(context.parentId);
+                if (collapsed) {
+                    collapsedMap.set(context.id, collapsed);
+                    return;
+                }
+            }
             const contextId = context.id;
             const parentContextId = context.parentId;
             const task = {
                 ...promiseWithResolvers(),
+                agent,
+                input: event.input,
                 listr: promiseWithResolvers(),
                 startTime: Date.now(),
             };
@@ -66,6 +92,34 @@ export class TerminalTracer {
         const onSuccess = async ({ context, agent, output, ...event }) => {
             const contextId = context.id;
             const parentContextId = context.parentId;
+            const collapsed = collapsedMap.get(contextId);
+            if (collapsed) {
+                if (agent instanceof ChatModel) {
+                    const { usage, model } = output;
+                    if (usage)
+                        mergeContextUsage(collapsed.usage, usage);
+                    if (model)
+                        collapsed.models.add(model);
+                }
+                const task = this.tasks[collapsed.ancestor.contextId];
+                if (task) {
+                    task.usage = collapsed.usage;
+                    task.extraTitleMetadata ??= {};
+                    if (collapsed.models.size)
+                        task.extraTitleMetadata.model = [...collapsed.models].join(",");
+                    const { taskWrapper } = await task.listr.promise;
+                    taskWrapper.title = await this.formatTaskTitle(task.agent, {
+                        input: task.input,
+                        task,
+                        usage: Boolean(task.usage.inputTokens || task.usage.outputTokens || task.usage.aigneHubCredits),
+                        time: context.id === collapsed.ancestor.contextId,
+                    });
+                    if (context.id === collapsed.ancestor.contextId) {
+                        task?.resolve();
+                    }
+                    return;
+                }
+            }
             const task = this.tasks[contextId];
             if (!task)
                 return;
@@ -173,6 +227,9 @@ export class TerminalTracer {
         const items = [
             [chalk.yellow(usage.inputTokens), chalk.grey("input tokens")],
             [chalk.cyan(usage.outputTokens), chalk.grey("output tokens")],
+            usage.aigneHubCredits
+                ? [chalk.blue(usage.aigneHubCredits.toFixed()), chalk.grey("AIGNE Hub credits")]
+                : undefined,
             usage.agentCalls ? [chalk.magenta(usage.agentCalls), chalk.grey("agent calls")] : undefined,
         ];
         const content = items.filter((i) => !!i).map((i) => i.join(" "));

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/listr.js

@@ -51,9 +51,11 @@ export class AIGNEListr extends Listr {
         try {
             this.ctx = {};
             this.spinner.start();
-            const request = this.myOptions.formatRequest();
-            if (request)
-                console.log(request);
+            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) => {

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.d.ts

@@ -63,4 +63,3 @@ export declare function runAgentWithAIGNE(aigne: AIGNE, agent: Agent, { outputKe
 } & Omit<RunAIGNECommandOptions, "input">): Promise<{
     result: Message;
 } | undefined>;
-export declare function stdinHasData(): Promise<boolean>;

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

@@ -1,21 +1,19 @@
-import { fstat } from "node:fs";
-import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { mkdir, stat, writeFile } from "node:fs/promises";
 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, parseModelOption } from "@aigne/aigne-hub";
-import { AIAgent, DEFAULT_OUTPUT_KEY, readAllString, UserAgent, } from "@aigne/core";
+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 { flat, 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 { parse } from "yaml";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
-import { ZodError, ZodObject, z } from "zod";
+import { ZodError, z } from "zod";
 import { TerminalTracer } from "../tracer/terminal.js";
 import { loadAIGNE } from "./load-aigne.js";
 import { DEFAULT_CHAT_INPUT_KEY, runChatLoopInTerminal, } from "./run-chat-loop.js";
+import { parseAgentInput, withAgentInputSchema } from "./yargs.js";
 export const createRunAIGNECommand = (yargs) => yargs
     .option("chat", {
     describe: "Run chat loop in terminal",
@@ -80,7 +78,7 @@ export const createRunAIGNECommand = (yargs) => yargs
     .option("log-level", {
     describe: `Log level for detailed debugging information. Values: ${Object.values(LogLevel).join(", ")}`,
     type: "string",
-    default: getLevelFromEnv(logger.options.ns) || LogLevel.INFO,
+    default: getLevelFromEnv(logger.options.ns) || LogLevel.SILENT,
     coerce: customZodError("--log-level", (s) => z.nativeEnum(LogLevel).parse(s)),
 })
     .option("aigne-hub-url", {
@@ -88,38 +86,11 @@ export const createRunAIGNECommand = (yargs) => yargs
     type: "string",
 });
 export async function parseAgentInputByCommander(agent, options = {}) {
-    const inputSchemaShape = flat(agent instanceof AIAgent ? agent.inputKey : undefined, agent.inputSchema instanceof ZodObject ? Object.keys(agent.inputSchema.shape) : []);
-    const parsedInput = await yargs().parseAsync(options.argv ?? process.argv);
-    const input = Object.fromEntries(await Promise.all(inputSchemaShape.map(async (key) => {
-        const k = `input${key.charAt(0).toUpperCase()}${key.slice(1)}`;
-        let value = parsedInput[k];
-        if (typeof value === "string" && value.startsWith("@")) {
-            value = await readFile(value.slice(1), "utf8");
-        }
-        return [key, value];
-    })));
-    const rawInput = options.input ||
-        (isatty(process.stdin.fd) || !(await stdinHasData())
-            ? null
-            : [await readAllString(process.stdin)].filter(Boolean));
-    if (rawInput?.length) {
-        for (let raw of rawInput) {
-            if (raw.startsWith("@")) {
-                raw = await readFile(raw.slice(1), "utf8");
-            }
-            if (options.format === "json") {
-                Object.assign(input, JSON.parse(raw));
-            }
-            else if (options.format === "yaml") {
-                Object.assign(input, parse(raw));
-            }
-            else {
-                Object.assign(input, typeof options.inputKey === "string"
-                    ? { [options.inputKey]: raw }
-                    : { [DEFAULT_CHAT_INPUT_KEY]: raw });
-            }
-        }
-    }
+    const args = await withAgentInputSchema(yargs(), agent)
+        .showHelpOnFail(false)
+        .fail(() => { })
+        .parseAsync(options.argv ?? process.argv);
+    const input = await parseAgentInput({ ...args, input: options.input || args.input }, agent);
     if (isEmpty(input)) {
         const defaultInput = options.defaultInput || process.env.INITIAL_CALL;
         Object.assign(input, typeof defaultInput === "string"
@@ -135,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;
@@ -214,7 +181,3 @@ export async function runAgentWithAIGNE(aigne, agent, { outputKey, chatLoopOptio
     }
     return { result };
 }
-export async function stdinHasData() {
-    const stats = await promisify(fstat)(0);
-    return stats.isFIFO() || stats.isFile();
-}

package/dist/utils/yargs.d.ts

@@ -0,0 +1,20 @@
+import { type Agent, type Message } from "@aigne/core";
+import type { Argv } from "yargs";
+import { ZodType } from "zod";
+export declare function inferZodType(type: ZodType, opts?: {
+    array?: boolean;
+    optional?: boolean;
+}): {
+    type: "string" | "number" | "boolean";
+    array?: boolean;
+    optional?: boolean;
+};
+export declare function withAgentInputSchema(yargs: Argv, agent: Agent): Argv<{
+    input?: string[];
+    format?: "json" | "yaml";
+}>;
+export declare function parseAgentInput(i: Message & {
+    input?: string[];
+    format?: "json" | "yaml";
+}, agent: Agent): Promise<any>;
+export declare function stdinHasData(): Promise<boolean>;

package/dist/utils/yargs.js

@@ -0,0 +1,107 @@
+import { fstat } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { extname } from "node:path";
+import { isatty } from "node:tty";
+import { promisify } from "node:util";
+import { AIAgent, readAllString } from "@aigne/core";
+import { pick } from "@aigne/core/utils/type-utils.js";
+import { parse } from "yaml";
+import { ZodAny, ZodArray, ZodBoolean, ZodNumber, ZodObject, ZodString, ZodType, ZodUnknown, } from "zod";
+export function inferZodType(type, opts = {}) {
+    if (type instanceof ZodUnknown || type instanceof ZodAny) {
+        return { type: "string", optional: true };
+    }
+    opts.optional ??= type.isNullable() || type.isOptional();
+    if ("innerType" in type._def && type._def.innerType instanceof ZodType) {
+        return inferZodType(type._def.innerType, opts);
+    }
+    if (type instanceof ZodArray) {
+        return inferZodType(type.element, { ...opts, array: true });
+    }
+    return {
+        ...opts,
+        array: opts.array || undefined,
+        optional: opts.optional || undefined,
+        type: type instanceof ZodBoolean ? "boolean" : type instanceof ZodNumber ? "number" : "string",
+    };
+}
+export function withAgentInputSchema(yargs, agent) {
+    const inputSchema = agent.inputSchema instanceof ZodObject ? agent.inputSchema.shape : {};
+    for (const [option, config] of Object.entries(inputSchema)) {
+        const type = inferZodType(config);
+        yargs.option(option, {
+            type: type.type,
+            description: config.description,
+            array: type.array,
+        });
+        if (!type.optional) {
+            yargs.demandOption(option);
+        }
+    }
+    return yargs
+        .option("input", {
+        type: "string",
+        array: true,
+        description: "Input to the agent, use @<file> to read from a file",
+        alias: ["i"],
+    })
+        .option("format", {
+        type: "string",
+        description: 'Input format, can be "json" or "yaml"',
+        choices: ["json", "yaml"],
+    });
+}
+export async function parseAgentInput(i, agent) {
+    const inputSchema = agent.inputSchema instanceof ZodObject ? agent.inputSchema.shape : {};
+    const input = Object.fromEntries(await Promise.all(Object.entries(pick(i, Object.keys(inputSchema))).map(async ([key, val]) => {
+        if (typeof val === "string" && val.startsWith("@")) {
+            const schema = inputSchema[key];
+            val = await readFileAsInput(val, {
+                format: schema instanceof ZodString ? "raw" : undefined,
+            });
+        }
+        return [key, val];
+    })));
+    const rawInput = i.input ||
+        (isatty(process.stdin.fd) || !(await stdinHasData())
+            ? null
+            : [await readAllString(process.stdin)].filter(Boolean));
+    if (rawInput) {
+        for (const raw of rawInput) {
+            const parsed = raw.startsWith("@") ? await readFileAsInput(raw, { format: i.format }) : raw;
+            if (typeof parsed !== "string") {
+                Object.assign(input, parsed);
+            }
+            else {
+                const inputKey = agent instanceof AIAgent ? agent.inputKey : undefined;
+                if (inputKey) {
+                    Object.assign(input, { [inputKey]: parsed });
+                }
+            }
+        }
+    }
+    return input;
+}
+async function readFileAsInput(value, { format } = {}) {
+    if (value.startsWith("@")) {
+        const ext = extname(value);
+        value = await readFile(value.slice(1), "utf8");
+        if (!format) {
+            if (ext === ".json")
+                format = "json";
+            else if (ext === ".yaml" || ext === ".yml")
+                format = "yaml";
+        }
+    }
+    if (format === "json") {
+        return JSON.parse(value);
+    }
+    else if (format === "yaml") {
+        return parse(value);
+    }
+    return value;
+}
+export async function stdinHasData() {
+    const stats = await promisify(fstat)(0);
+    return stats.isFIFO() || stats.isFile();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/cli",
-  "version": "1.36.4",
+  "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.21",
-    "@aigne/aigne-hub": "^0.6.3",
-    "@aigne/agentic-memory": "^1.0.21",
-    "@aigne/core": "^1.50.1",
-    "@aigne/default-memory": "^1.1.3",
-    "@aigne/openai": "^0.11.3",
-    "@aigne/observability-api": "^0.9.0"
+    "@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",