@aigne/cli 1.59.0-beta.3 → 1.59.0-beta.31

package/dist/commands/aigne.js

@@ -8,6 +8,7 @@ import { createEvalCommand } from "./eval.js";
 import { createHubCommand } from "./hub.js";
 import { createObservabilityCommand } from "./observe.js";
 import { createRunCommand } from "./run.js";
+import { createRunSkillCommand } from "./run-skill.js";
 import { createServeMCPCommand } from "./serve-mcp.js";
 import { createTestCommand } from "./test.js";
 export function createAIGNECommand(options) {
@@ -17,6 +18,7 @@ export function createAIGNECommand(options) {
         .version(AIGNE_CLI_VERSION)
         // default command: when user runs `aigne` without subcommand, behave like `aigne run`
         .command(createRunCommand(options))
+        .command(createRunSkillCommand())
         .command(createEvalCommand(options))
         .command(createTestCommand(options))
         .command(createCreateCommand())

package/dist/commands/app/agent.d.ts

@@ -10,10 +10,10 @@ export declare const serveMcpCommandModule: ({ aigne, name, }: {
     port?: number;
     pathname: string;
 }>;
-export declare const agentCommandModule: ({ aigne, agent, chat, }: {
+export declare const agentCommandModule: ({ aigne, agent, interactive, }: {
     aigne: AIGNE;
     agent: Agent;
-    chat?: boolean;
+    interactive?: boolean;
 }) => CommandModule<unknown, AgentRunCommonOptions>;
 export declare const cliAgentCommandModule: ({ aigne, cliAgent, }: {
     aigne: AIGNE;

package/dist/commands/app/agent.js

@@ -1,5 +1,7 @@
 import assert from "node:assert";
+import { DEFAULT_USER_ID } from "@aigne/cli/constants.js";
 import { logger } from "@aigne/core/utils/logger.js";
+import { v7 } from "@aigne/uuid";
 import { runAgentWithAIGNE } from "../../utils/run-with-aigne.js";
 import { parseAgentInput, withAgentInputSchema, } from "../../utils/yargs.js";
 import { serveMCPServerFromDir } from "../serve-mcp.js";
@@ -30,7 +32,7 @@ export const serveMcpCommandModule = ({ aigne, name, }) => ({
         });
     },
 });
-export const agentCommandModule = ({ aigne, agent, chat, }) => {
+export const agentCommandModule = ({ aigne, agent, interactive, }) => {
     return {
         command: agent.name,
         aliases: agent.alias || [],
@@ -38,7 +40,9 @@ export const agentCommandModule = ({ aigne, agent, chat, }) => {
         builder: async (yargs) => {
             return withAgentInputSchema(yargs, {
                 inputSchema: agent.inputSchema,
-                optionalInputs: chat && "inputKey" in agent && typeof agent.inputKey === "string" ? [agent.inputKey] : [],
+                optionalInputs: interactive && "inputKey" in agent && typeof agent.inputKey === "string"
+                    ? [agent.inputKey]
+                    : [],
             });
         },
         handler: async (options) => {
@@ -47,7 +51,7 @@ export const agentCommandModule = ({ aigne, agent, chat, }) => {
             await invokeAgent({
                 aigne,
                 agent,
-                input: { ...options, chat: chat ?? options.chat },
+                input: { ...options, interactive: interactive ?? options.interactive },
             });
         },
     };
@@ -96,7 +100,9 @@ export async function invokeAgent(options) {
         await runAgentWithAIGNE(aigne, agent, {
             ...options.input,
             input,
-            chat: options.input.chat,
+            interactive: options.input.interactive,
+            sessionId: options.input.sessionId || v7(),
+            userId: DEFAULT_USER_ID,
         });
     }
     finally {

package/dist/commands/app/app.js

@@ -38,7 +38,7 @@ export async function runAppCLI({ appName = process.env.AIGNE_APP_NAME, appPacka
                     ...agentCommandModule({
                         aigne,
                         agent: aigne.cli.chat,
-                        chat: true,
+                        interactive: true,
                     }),
                     command: "$0",
                 });

package/dist/commands/run-skill.d.ts

@@ -0,0 +1,6 @@
+import type { CommandModule } from "yargs";
+import { type AgentRunCommonOptions } from "../utils/yargs.js";
+export declare function createRunSkillCommand(): CommandModule<unknown, {
+    skill?: string[];
+    interactive?: boolean;
+} & AgentRunCommonOptions>;

package/dist/commands/run-skill.js

@@ -0,0 +1,102 @@
+import { basename, resolve } from "node:path";
+import { AFSHistory } from "@aigne/afs-history";
+import { LocalFS } from "@aigne/afs-local-fs";
+import AgentSkillManager from "@aigne/agent-library/agent-skill-manager";
+import AskUserQuestion from "@aigne/agent-library/ask-user-question";
+import BashAgent from "@aigne/agent-library/bash";
+import { AIGNE, FunctionAgent } from "@aigne/core";
+import { z } from "zod";
+import { loadChatModel } from "../utils/aigne-hub/model.js";
+import { withAgentInputSchema } from "../utils/yargs.js";
+import { invokeAgent } from "./app/agent.js";
+export function createRunSkillCommand() {
+    return {
+        command: ["run-skill"],
+        describe: "Run Agent Skill for the specified path",
+        builder: async (yargs) => {
+            return withAgentInputSchema(yargs
+                .option("skill", {
+                array: true,
+                type: "string",
+                describe: "Path to the Agent Skill directory",
+            })
+                .option("interactive", {
+                describe: "Run in interactive chat mode",
+                type: "boolean",
+                default: false,
+                alias: ["chat"],
+            })
+                .demandOption("skill"), {
+                inputSchema: z.object({
+                    message: z.string(),
+                }),
+                optionalInputs: ["message"],
+            });
+        },
+        handler: async (options) => {
+            if (!Array.isArray(options.skill) || options.skill.length === 0) {
+                throw new Error("At least one skill path must be provided.");
+            }
+            const model = await loadChatModel({
+                model: options.model || "aignehub/anthropic/claude-sonnet-4-5",
+            });
+            const aigne = new AIGNE({ model });
+            const approvedCmds = new Set();
+            const agent = new AgentSkillManager({
+                inputKey: "message",
+                taskRenderMode: "collapse",
+                skills: [
+                    new BashAgent({
+                        sandbox: false,
+                        permissions: {
+                            defaultMode: "ask",
+                            guard: FunctionAgent.from(async (input, options) => {
+                                if (approvedCmds.has(input.script || "")) {
+                                    return {
+                                        approved: true,
+                                    };
+                                }
+                                const confirm = options.prompts?.confirm;
+                                if (!confirm)
+                                    throw new Error("No confirm prompt available for permission guard.");
+                                const approved = await confirm({ message: `Run command ${input.script}?` });
+                                if (approved && input.script) {
+                                    approvedCmds.add(input.script);
+                                }
+                                return {
+                                    approved,
+                                };
+                            }),
+                        },
+                    }),
+                    new AskUserQuestion(),
+                ],
+                afs: {
+                    modules: [
+                        new AFSHistory({}),
+                        new LocalFS({
+                            name: "workspace",
+                            localPath: process.cwd(),
+                            description: `\
+Current working directory. All temporary files should be written here using absolute AFS paths (e.g., /modules/workspace/temp.py).
+Note: Bash is already running in this directory, so do NOT use 'cd /modules/workspace' in scripts. Use relative paths directly (e.g., python temp.py).`,
+                        }),
+                        ...options.skill.map((path) => new LocalFS({
+                            name: basename(resolve(path)),
+                            localPath: path,
+                            description: "Contains Agent Skills. Use 'Skill' tool to invoke skills from this module.",
+                            agentSkills: true,
+                        })),
+                    ],
+                },
+            });
+            await invokeAgent({
+                aigne,
+                agent,
+                input: {
+                    ...options,
+                },
+            });
+        },
+    };
+}

package/dist/commands/run.d.ts

@@ -5,5 +5,5 @@ export declare function createRunCommand({ aigneFilePath, }?: {
     version?: boolean;
     path?: string;
     entryAgent?: string;
-    chat?: boolean;
+    interactive?: boolean;
 }>;

package/dist/commands/run.js

@@ -38,10 +38,11 @@ export function createRunCommand({ aigneFilePath, } = {}) {
                 alias: "v",
                 describe: "Show version number",
             })
-                .option("chat", {
-                describe: "Run chat loop in terminal",
+                .option("interactive", {
+                describe: "Run in interactive chat mode",
                 type: "boolean",
                 default: false,
+                alias: ["chat"],
             })
                 .help(false)
                 .version(false)
@@ -60,15 +61,16 @@ export function createRunCommand({ aigneFilePath, } = {}) {
                 }
             }
             const path = aigneFilePath || options.path || ".";
-            if (!(await findAIGNEFile(path).catch((error) => {
-                if (options._[0] !== "run") {
-                    yargsInstance?.showHelp();
-                }
-                else {
-                    throw error;
-                }
-                return false;
-            }))) {
+            if (!isUrl(path) &&
+                !(await findAIGNEFile(path).catch((error) => {
+                    if (options._[0] !== "run") {
+                        yargsInstance?.showHelp();
+                    }
+                    else {
+                        throw error;
+                    }
+                    return false;
+                }))) {
                 return;
             }
             // Parse model options for loading application
@@ -81,14 +83,14 @@ export function createRunCommand({ aigneFilePath, } = {}) {
             const subYargs = yargs().scriptName("").usage("aigne run <path> <agent> [...options]");
             if (aigne.cli.chat) {
                 subYargs.command({
-                    ...agentCommandModule({ aigne, agent: aigne.cli.chat, chat: true }),
+                    ...agentCommandModule({ aigne, agent: aigne.cli.chat, interactive: true }),
                     command: "$0",
                 });
             }
             // Allow user to run all of agents in the AIGNE instances
             const allAgents = flat(aigne.agents, aigne.skills, aigne.cli.chat, aigne.mcpServer.agents);
             for (const agent of allAgents) {
-                subYargs.command(agentCommandModule({ aigne, agent, chat: options.chat }));
+                subYargs.command(agentCommandModule({ aigne, agent, interactive: options.interactive }));
             }
             for (const cliAgent of aigne.cli.agents ?? []) {
                 subYargs.command(cliAgentCommandModule({

package/dist/constants.d.ts

@@ -3,3 +3,5 @@ export declare const AIGNE_CLI_VERSION: any;
 export declare const availableMemories: (typeof DefaultMemory)[];
 export declare const AIGNE_HUB_CREDITS_NOT_ENOUGH_ERROR_TYPE = "NOT_ENOUGH";
 export declare const CHAT_MODEL_OPTIONS: string[];
+export declare const DEFAULT_USER_ID = "cli-user";
+export declare const DEFAULT_AFS_EXPLORER_PORT = 9670;

package/dist/constants.js

@@ -17,3 +17,5 @@ export const CHAT_MODEL_OPTIONS = [
     "preferInputFileType",
     "reasoningEffort",
 ];
+export const DEFAULT_USER_ID = "cli-user";
+export const DEFAULT_AFS_EXPLORER_PORT = 9670;

package/dist/tracer/terminal.js

@@ -154,6 +154,7 @@ export class TerminalTracer {
             }
             task.resolve();
         };
+        let retryPromptPromise;
         const onError = async ({ context, agent, error, ...event }) => {
             if ("type" in error && error.type === AIGNE_HUB_CREDITS_NOT_ENOUGH_ERROR_TYPE) {
                 if (!Object.hasOwn(error, CREDITS_ERROR_PROCESSED_FLAG)) {
@@ -168,6 +169,23 @@ export class TerminalTracer {
                     }
                 }
             }
+            if (agent instanceof ChatModel) {
+                retryPromptPromise ??= this.proxiedPrompts
+                    .select({
+                    message: chalk.red(`Error: ${error.message}`),
+                    choices: [
+                        { value: "retry", name: "Retry" },
+                        { value: "exit", name: "Exit" },
+                    ],
+                })
+                    .then((result) => ({ retry: result === "retry" }))
+                    .finally(() => {
+                    retryPromptPromise = undefined;
+                });
+                const { retry } = await retryPromptPromise;
+                if (retry)
+                    return { retry: true };
+            }
             const contextId = context.id;
             const task = this.tasks[contextId];
             if (!task)

package/dist/ui/utils/terminal-input.d.ts

@@ -6,6 +6,7 @@ export declare function terminalInput({ render: r, ...options }?: {
     required?: boolean;
     validate?: (input: string) => string | boolean | Promise<string | boolean>;
     render?: typeof render;
+    clear?: boolean;
 }): Promise<string>;
 export declare function TerminalInput(props: {
     message?: string;

package/dist/ui/utils/terminal-input.js

@@ -12,10 +12,14 @@ export async function terminalInput({ render: r = render, ...options } = {}) {
         process.addListener("SIGINT", handleSigInt);
         const clean = () => process.removeListener("SIGINT", handleSigInt);
         const app = r(_jsx(TerminalInput, { ...options, onSubmit: (value) => {
+                if (options.clear)
+                    app.clear();
                 app.unmount();
                 resolve(value);
                 clean();
             }, onError: (error) => {
+                if (options.clear)
+                    app.clear();
                 app.unmount();
                 reject(error);
                 clean();

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

@@ -9,9 +9,6 @@ export declare function createConnect({ connectUrl, openPage, fetchInterval, ret
 export declare function connectToAIGNEHub(url: string): Promise<{
     apiKey: string;
     url: string;
-} | {
-    apiKey: undefined;
-    url: undefined;
 }>;
 export declare const checkConnectionStatus: (host: string) => Promise<{
     apiKey: any;

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

@@ -3,7 +3,6 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { AIGNE_HUB_BLOCKLET_DID, AIGNE_HUB_URL, getAIGNEHubMountPoint } from "@aigne/aigne-hub";
 import { fetch } from "@aigne/core/utils/fetch.js";
-import { logger } from "@aigne/core/utils/logger.js";
 import inquirer from "inquirer";
 import open from "open";
 import pWaitFor from "p-wait-for";
@@ -38,7 +37,7 @@ export const fetchConfigs = async ({ connectUrl, sessionId, fetchInterval, fetch
     };
 };
 function baseWrapSpinner(_, waiting) {
-    return Promise.resolve(waiting());
+    return 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);
@@ -68,28 +67,22 @@ export async function connectToAIGNEHub(url) {
     const { origin } = 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,
-        };
-        const secretStore = await getSecretStore();
-        await secretStore.setKey(accessKeyOptions.url, accessKeyOptions.apiKey);
-        await secretStore.setDefault(accessKeyOptions.url);
-        return accessKeyOptions;
-    }
-    catch (error) {
-        logger.error("Failed to connect to AIGNE Hub", error.message);
-        return { apiKey: undefined, url: undefined };
-    }
+    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,
+    };
+    const secretStore = await getSecretStore();
+    await secretStore.setKey(accessKeyOptions.url, accessKeyOptions.apiKey);
+    await secretStore.setDefault(accessKeyOptions.url);
+    return accessKeyOptions;
 }
 export const checkConnectionStatus = async (host) => {
     const secretStore = await getSecretStore();

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

@@ -1,5 +1,26 @@
 import crypto from "node:crypto";
-import { AesCrypter } from "@ocap/mcrypto/lib/crypter/aes-legacy.js";
+import AES from "crypto-js/aes.js";
+import encBase64 from "crypto-js/enc-base64.js";
+import encHex from "crypto-js/enc-hex.js";
+import encLatin1 from "crypto-js/enc-latin1.js";
+import encUtf8 from "crypto-js/enc-utf8.js";
+import encUtf16 from "crypto-js/enc-utf16.js";
+const encoders = {
+    latin1: encLatin1,
+    utf8: encUtf8,
+    hex: encHex,
+    utf16: encUtf16,
+    base64: encBase64,
+};
+class AesCrypter {
+    encrypt(message, secret) {
+        const text = typeof message === "string" ? message : JSON.stringify(message);
+        return AES.encrypt(text, secret).toString();
+    }
+    decrypt(cipher, secret, outputEncoding = "utf8") {
+        return AES.decrypt(cipher, secret).toString(encoders[outputEncoding]);
+    }
+}
 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"));

package/dist/utils/aigne-hub/store/index.d.ts

@@ -1,4 +1,5 @@
 import FileStore from "./file.js";
 import KeyringStore from "./keytar.js";
 declare const getSecretStore: () => Promise<FileStore | KeyringStore>;
+export declare const resetSecretStoreCache: () => void;
 export default getSecretStore;

package/dist/utils/aigne-hub/store/index.js

@@ -1,5 +1,5 @@
 import { logger } from "@aigne/core/utils/logger.js";
-import { AIGNE_ENV_FILE } from "../constants.js";
+import { AIGNE_ENV_FILE, isTest } from "../constants.js";
 import FileStore from "./file.js";
 import KeyringStore from "./keytar.js";
 import { migrateFileToKeyring } from "./migrate.js";
@@ -32,9 +32,12 @@ const getSecretStore = async () => {
         cachedSecretStore = await createSecretStore({
             filepath: AIGNE_ENV_FILE,
             serviceName: "aigne-hub",
-            // forceKeytarUnavailable: true,
+            forceKeytarUnavailable: Boolean(isTest),
         });
     }
     return cachedSecretStore;
 };
+export const resetSecretStoreCache = () => {
+    cachedSecretStore = undefined;
+};
 export default getSecretStore;

package/dist/utils/inquirer/checkbox.js

@@ -153,7 +153,6 @@ export default createPrompt((config, done) => {
                 let next = active;
                 do {
                     next = (next + offset + items.length) % items.length;
-                    // biome-ignore lint/style/noNonNullAssertion: we need to access items dynamically
                 } while (!isSelectable(items[next]));
                 setActive(next);
             }

package/dist/utils/listr.d.ts

@@ -1,4 +1,4 @@
-import type { AgentResponseStream, Message } from "@aigne/core";
+import { type AgentResponseStream, type Message } from "@aigne/core";
 import type { PromiseOrValue } from "@aigne/core/utils/type-utils.js";
 import { DefaultRenderer, Listr, type ListrDefaultRendererOptions, ListrLogger, type ListrSimpleRendererOptions, type ListrTaskWrapper, SimpleRenderer, Spinner } from "@aigne/listr2";
 import type { createLogUpdate } from "log-update";
@@ -22,7 +22,9 @@ export declare class AIGNEListr extends Listr<object, typeof AIGNEListrRenderer,
             renderImage?: boolean;
         }) => string | Promise<string>;
     }, ...[task, options, parentTask]: ConstructorParameters<typeof Listr<object, typeof AIGNEListrRenderer, typeof AIGNEListrFallbackRenderer>>);
+    private needLogResult;
     run(stream: () => PromiseOrValue<AgentResponseStream<Message>>): Promise<Message>;
+    private marked;
     private extractStream;
 }
 export interface AIGNEListrRendererOptions extends ListrDefaultRendererOptions {

package/dist/utils/listr.js

@@ -1,8 +1,12 @@
 import { EOL } from "node:os";
 import { format } from "node:util";
+import { isAgentResponseProgress } from "@aigne/core";
 import { LogLevel, logger } from "@aigne/core/utils/logger.js";
 import { mergeAgentResponseChunk } from "@aigne/core/utils/stream-utils.js";
 import { color, DefaultRenderer, figures, Listr, ListrDefaultRendererLogLevels, ListrLogger, SimpleRenderer, Spinner, } from "@aigne/listr2";
+import { markedTerminal } from "@aigne/marked-terminal";
+import chalk from "chalk";
+import { Marked } from "marked";
 import wrap from "wrap-ansi";
 export class AIGNEListr extends Listr {
     myOptions;
@@ -15,13 +19,12 @@ export class AIGNEListr extends Listr {
             getStdoutLogs: () => {
                 return this.logs.splice(0);
             },
-            getBottomBarLogs: (options) => {
-                if (!options?.running)
-                    return [];
-                const r = this.myOptions.formatResult(this.result);
-                if (typeof r !== "string")
-                    throw new Error("Must return a string result for running task");
-                return [r];
+            getBottomBarLogs: (_options) => {
+                // if (!options?.running) return [];
+                // const r = this.myOptions.formatResult(this.result);
+                // if (typeof r !== "string") throw new Error("Must return a string result for running task");
+                // return [r];
+                return [];
             },
         };
         super(task, {
@@ -55,6 +58,7 @@ export class AIGNEListr extends Listr {
         this.myOptions = myOptions;
         this.spinner = new Spinner();
     }
+    needLogResult = true;
     async run(stream) {
         const originalLog = logger.logMessage;
         const originalConsole = { ...console };
@@ -81,7 +85,9 @@ export class AIGNEListr extends Listr {
                     throw this.error;
                 return { ...this.result };
             });
-            console.log(await this.myOptions.formatResult(this.result, { running: false, renderImage: true }));
+            if (this.needLogResult) {
+                console.log(await this.myOptions.formatResult(this.result, { running: false, renderImage: true }));
+            }
             return result;
         }
         finally {
@@ -90,11 +96,56 @@ export class AIGNEListr extends Listr {
             this.spinner.stop();
         }
     }
+    marked = new Marked().use({
+        // marked-terminal does not support code block meta, so we need to strip it
+        walkTokens: (token) => {
+            if (token.type === "code") {
+                if (typeof token.lang === "string") {
+                    token.lang = token.lang.trim().split(/\s+/)[0];
+                }
+            }
+        },
+    }, markedTerminal({ forceHyperLink: false }, {
+        theme: {
+            string: chalk.green,
+        },
+    }));
     async extractStream(stream) {
         try {
             this.result = {};
             for await (const value of stream) {
                 mergeAgentResponseChunk(this.result, value);
+                if (isAgentResponseProgress(value) && value.progress.event === "message") {
+                    const { message } = value.progress;
+                    const rendered = [];
+                    if (message.role === "user" || message.role === "agent") {
+                        if (message.role === "agent" && message.toolCalls) {
+                            for (const call of message.toolCalls) {
+                                rendered.push(`${chalk.bold.gray(`[${call.function.name}]`)} ${chalk.gray(`${JSON.stringify(call.function.arguments).slice(0, 200)}...`)}`);
+                            }
+                        }
+                        else if (typeof message.content === "string") {
+                            rendered.push(this.marked.parse(message.content, { async: false }).trim());
+                        }
+                        else if (Array.isArray(message.content)) {
+                            for (const msg of message.content) {
+                                if (msg.type === "text") {
+                                    if (msg.isThinking) {
+                                        rendered.push(chalk.dim(chalk.grey(chalk.italic(`[Thinking] ${msg.text}`))));
+                                    }
+                                    else {
+                                        rendered.push(this.marked.parse(msg.text, { async: false }).trim());
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    if (rendered.length) {
+                        const prefix = message.role === "user" ? chalk.blue.bold(">") : chalk.green.bold("•");
+                        console.log(`${prefix} ${rendered.join("\n")}\n`);
+                        this.needLogResult = false;
+                    }
+                }
             }
             return this.result;
         }

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

@@ -1,4 +1,4 @@
-import { AIGNE, type ChatModelInputOptions, type ImageModelInputOptions } from "@aigne/core";
+import { AIGNE, type ChatModel, type ChatModelInputOptions, type ImageModelInputOptions } from "@aigne/core";
 import type { AIGNEMetadata } from "@aigne/core/aigne/type.js";
 import type { LoadCredentialOptions } from "./aigne-hub/type.js";
 import type { AgentRunCommonOptions } from "./yargs.js";
@@ -8,6 +8,7 @@ export interface RunOptions extends AgentRunCommonOptions {
     cacheDir?: string;
     aigneHubUrl?: string;
 }
+export declare function printChatModelInfoBox(model: ChatModel, otherLines?: string[]): Promise<void>;
 export declare function loadAIGNE({ path, modelOptions, imageModelOptions, skipModelLoading, metadata, }: {
     path?: string;
     modelOptions?: ChatModelInputOptions & LoadCredentialOptions;