@aigne/cli 1.49.0-beta.8 → 1.49.0-beta.9

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## [1.49.0-beta.9](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.49.0-beta.8...cli-v1.49.0-beta.9) (2025-09-26)
+
+
+### Features
+
+* **cli:** add `--beta` `--target-version` `--force` options for `upgrade` command ([#555](https://github.com/AIGNE-io/aigne-framework/issues/555)) ([f9f0471](https://github.com/AIGNE-io/aigne-framework/commit/f9f04719020cca00bc3adbe8169c42422201df49))
+
+
+### Bug Fixes
+
+* **blocklet:** observability blocklet start failure ([#554](https://github.com/AIGNE-io/aigne-framework/issues/554)) ([8431d4d](https://github.com/AIGNE-io/aigne-framework/commit/8431d4d89a4b96f735f23e774e9545bbe1fd811c))
+* **blocklet:** observability blocklet start failure ([#554](https://github.com/AIGNE-io/aigne-framework/issues/554)) ([8431d4d](https://github.com/AIGNE-io/aigne-framework/commit/8431d4d89a4b96f735f23e774e9545bbe1fd811c))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/agent-library bumped to 1.21.46-beta.9
+    * @aigne/agentic-memory bumped to 1.0.46-beta.9
+    * @aigne/aigne-hub bumped to 0.10.0-beta.9
+    * @aigne/core bumped to 1.61.0-beta.8
+    * @aigne/default-memory bumped to 1.2.9-beta.9
+    * @aigne/observability-api bumped to 0.11.0-beta.1
+    * @aigne/openai bumped to 0.16.0-beta.9
+  * devDependencies
+    * @aigne/test-utils bumped to 0.5.53-beta.8
+
 ## [1.49.0-beta.8](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.49.0-beta.7...cli-v1.49.0-beta.8) (2025-09-26)
 
 

package/dist/commands/app.d.ts

@@ -1,27 +1,42 @@
-import type { Agent, AIGNE, Message } from "@aigne/core";
 import type { CommandModule } from "yargs";
+import { type LoadAIGNEInChildProcessResult } from "../utils/workers/run-aigne-in-child-process.js";
+import type { AgentInChildProcess } from "../utils/workers/run-aigne-in-child-process-worker.js";
 import { type AgentRunCommonOptions } from "../utils/yargs.js";
 export declare function createAppCommands(): CommandModule[];
 export declare const agentCommandModule: ({ dir, agent, }: {
     dir: string;
-    agent: Agent;
+    agent: AgentInChildProcess;
 }) => CommandModule<unknown, AgentRunCommonOptions>;
-export declare function invokeCLIAgentFromDir(options: {
-    dir: string;
-    agent: string;
-    input: Message & AgentRunCommonOptions;
-}): Promise<void>;
-export declare function loadApplication({ name, dir, forceUpgrade, }: {
-    name: string;
-    dir?: string;
-    forceUpgrade?: boolean;
-}): Promise<{
-    aigne: AIGNE;
+interface LoadApplicationOptions {
+    packageName: string;
     dir: string;
+    install?: boolean;
+}
+interface LoadApplicationResult {
+    aigne: LoadAIGNEInChildProcessResult;
     version: string;
     isCache?: boolean;
+}
+export declare function loadApplication(options: LoadApplicationOptions & {
+    install: true;
+}): Promise<LoadApplicationResult>;
+export declare function loadApplication(options: LoadApplicationOptions & {
+    install?: false;
+}): Promise<LoadApplicationResult | null>;
+export declare function installApp({ dir, packageName, beta, version, }: {
+    dir: string;
+    packageName: string;
+    beta?: boolean;
+    version?: string;
+}): Promise<{
+    url: string;
+    version: string;
 }>;
-export declare function getNpmTgzInfo(name: string): Promise<{
+export declare function getNpmTgzInfo(name: string, { version, beta }?: {
+    version?: string;
+    beta?: boolean;
+}): Promise<{
     version: string;
-    url: any;
+    url: string;
 }>;
+export {};

package/dist/commands/app.js

@@ -1,16 +1,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 { join } from "node:path";
 import { logger } from "@aigne/core/utils/logger.js";
+import { jsonSchemaToZod } from "@aigne/json-schema-to-zod";
 import { Listr, PRESET_TIMER } from "@aigne/listr2";
 import { joinURL } from "ufo";
 import { downloadAndExtract } from "../utils/download.js";
-import { loadAIGNE } from "../utils/load-aigne.js";
-import { runAgentWithAIGNE } from "../utils/run-with-aigne.js";
-import { safeLoadAIGNE } from "../utils/workers/load-aigne.js";
-import { parseAgentInput, withAgentInputSchema, } from "../utils/yargs.js";
+import { runAIGNEInChildProcess, } from "../utils/workers/run-aigne-in-child-process.js";
+import { withAgentInputSchema } from "../utils/yargs.js";
 import { serveMCPServerFromDir } from "./serve-mcp.js";
 const NPM_PACKAGE_CACHE_TIME_MS = 1000 * 60 * 60 * 24; // 1 day
 /**
@@ -23,11 +21,13 @@ function shouldUseBetaApps() {
 const builtinApps = [
     {
         name: "doc-smith",
+        packageName: "@aigne/doc-smith",
         describe: "Generate and maintain project docs — powered by agents.",
         aliases: ["docsmith", "doc"],
     },
     {
         name: "web-smith",
+        packageName: "@aigne/web-smith",
         describe: "Generate and maintain project website pages — powered by agents.",
         aliases: ["websmith", "web"],
     },
@@ -38,30 +38,28 @@ export function createAppCommands() {
         describe: app.describe,
         aliases: app.aliases,
         builder: async (yargs) => {
-            const { aigne, dir, version, isCache } = await loadApplication({
-                name: app.name,
-            });
-            yargs
-                .option("model", {
-                type: "string",
-                description: "Model to use for the application, example: openai:gpt-4.1 or google:gemini-2.5-flash",
-            })
-                .command(serveMcpCommandModule({ name: app.name, dir }))
-                .command(upgradeCommandModule({
-                name: app.name,
+            const dir = join(homedir(), ".aigne", "registry.npmjs.org", app.packageName);
+            const { aigne, version } = await loadApplication({
                 dir,
-                isLatest: !isCache,
-                version,
-            }));
-            if (aigne.cli.chat) {
+                packageName: app.packageName,
+                install: true,
+            });
+            if (aigne.cli?.chat) {
                 yargs.command({
                     ...agentCommandModule({ dir, agent: aigne.cli.chat }),
                     command: "$0",
                 });
             }
-            for (const agent of aigne.cli.agents) {
+            for (const agent of aigne.cli?.agents ?? []) {
                 yargs.command(agentCommandModule({ dir, agent }));
             }
+            yargs
+                .option("model", {
+                type: "string",
+                description: "Model to use for the application, example: openai:gpt-4.1 or google:gemini-2.5-flash",
+            })
+                .command(serveMcpCommandModule({ name: app.name, dir }))
+                .command(upgradeCommandModule({ packageName: app.packageName, dir }));
             yargs.version(`${app.name} v${version}`).alias("version", "v");
             return yargs.demandCommand();
         },
@@ -92,18 +90,39 @@ const serveMcpCommandModule = ({ name, dir, }) => ({
         await serveMCPServerFromDir({ ...options, dir });
     },
 });
-const upgradeCommandModule = ({ name, dir, isLatest, version, }) => ({
+const upgradeCommandModule = ({ packageName, dir, }) => ({
     command: "upgrade",
-    describe: `Upgrade ${name} to the latest version`,
-    handler: async () => {
-        if (!isLatest) {
-            const result = await loadApplication({ name, dir, forceUpgrade: true });
-            if (version !== result.version) {
-                console.log(`\n✅ Upgraded ${name} to version ${result.version}`);
-                return;
-            }
+    describe: `Upgrade ${packageName} to the latest version`,
+    builder: (argv) => {
+        return argv
+            .option("beta", {
+            type: "boolean",
+            describe: "Use beta versions if available",
+        })
+            .option("target-version", {
+            type: "string",
+            describe: "Specify a version to upgrade to (default is latest)",
+            alias: ["to", "target"],
+        })
+            .option("force", {
+            type: "boolean",
+            describe: "Force upgrade even if already at latest version",
+            default: false,
+        });
+    },
+    handler: async ({ beta, targetVersion, force }) => {
+        beta ??= shouldUseBetaApps();
+        let app = await loadApplication({ packageName, dir });
+        const npm = await getNpmTgzInfo(packageName, { beta, version: targetVersion });
+        if (!app || force || npm.version !== app.version) {
+            if (force)
+                await rm(dir, { force: true, recursive: true });
+            await installApp({ packageName, dir, beta, version: targetVersion });
+            app = await loadApplication({ dir, packageName, install: true });
+            console.log(`\n✅ Upgraded ${packageName} to version ${app.version}`);
+            return;
         }
-        console.log(`\n✅ ${name} is already at the latest version (${version})`);
+        console.log(`\n✅ ${packageName} is already at the latest version (${app.version})`);
     },
 });
 export const agentCommandModule = ({ dir, agent, }) => {
@@ -111,76 +130,76 @@ export const agentCommandModule = ({ dir, agent, }) => {
         command: agent.name,
         aliases: agent.alias || [],
         describe: agent.description || "",
-        builder: async (yargs) => withAgentInputSchema(yargs, agent),
+        builder: async (yargs) => {
+            return withAgentInputSchema(yargs, { inputSchema: jsonSchemaToZod(agent.inputSchema) });
+        },
         handler: async (options) => {
             if (options.logLevel)
                 logger.level = options.logLevel;
-            await invokeCLIAgentFromDir({ dir, agent: agent.name, input: options });
+            await runAIGNEInChildProcess("invokeCLIAgentFromDir", {
+                dir,
+                agent: agent.name,
+                input: options,
+            });
             process.exit(0);
         },
     };
 };
-export async function invokeCLIAgentFromDir(options) {
-    const aigne = await loadAIGNE({
-        path: options.dir,
-        modelOptions: options.input,
-    });
-    try {
-        const { chat } = aigne.cli;
-        const agent = chat && chat.name === options.agent
-            ? chat
-            : aigne.cli.agents[options.agent] ||
-                aigne.agents[options.agent] ||
-                aigne.skills[options.agent] ||
-                aigne.mcpServer.agents[options.agent];
-        assert(agent, `Agent ${options.agent} not found in ${options.dir}`);
-        const input = await parseAgentInput(options.input, agent);
-        await runAgentWithAIGNE(aigne, agent, {
-            ...options.input,
-            input,
-            chat: agent === chat || options.input.chat,
-        });
-    }
-    finally {
-        await aigne.shutdown();
-    }
-}
-export async function loadApplication({ name, dir, forceUpgrade = false, }) {
-    name = `@aigne/${name}`;
-    dir ??= join(homedir(), ".aigne", "registry.npmjs.org", name);
-    let check = forceUpgrade ? undefined : await isInstallationAvailable(dir);
-    if (check?.available) {
-        const aigne = await safeLoadAIGNE(dir).catch((error) => {
-            console.warn(`⚠️ Failed to load ${name}, trying to reinstall:`, error.message);
+export async function loadApplication(options) {
+    const { dir, packageName } = options;
+    const check = await checkInstallation(dir);
+    if (check && !check.expired) {
+        const aigne = await runAIGNEInChildProcess("loadAIGNE", dir).catch((error) => {
+            console.warn(`⚠️ Failed to load ${packageName}, trying to reinstall:`, error.message);
         });
         if (aigne) {
-            return {
-                aigne,
-                dir,
-                version: check.version,
-                isCache: true,
-            };
+            return { aigne, version: check.version, isCache: true };
         }
-        check = undefined;
     }
-    const result = await new Listr([
+    if (!options.install)
+        return null;
+    const result = await installApp({ dir, packageName, beta: check?.version?.includes("beta") });
+    return {
+        aigne: await runAIGNEInChildProcess("loadAIGNE", dir),
+        version: result.version,
+    };
+}
+async function readInstallationMetadata(dir) {
+    return safeParseJSON(await readFile(join(dir, ".aigne-cli.json"), "utf-8").catch(() => "{}"));
+}
+async function writeInstallationMetadata(dir, metadata) {
+    await writeFile(join(dir, ".aigne-cli.json"), JSON.stringify(metadata, null, 2));
+}
+async function checkInstallation(dir, { cacheTimeMs = NPM_PACKAGE_CACHE_TIME_MS } = {}) {
+    const s = await stat(join(dir, "package.json")).catch(() => null);
+    if (!s)
+        return null;
+    const version = safeParseJSON(await readFile(join(dir, "package.json"), "utf-8"))?.version;
+    if (!version)
+        return null;
+    const installedAt = (await readInstallationMetadata(dir))?.installedAt;
+    if (!installedAt)
+        return null;
+    const now = Date.now();
+    const expired = now - installedAt > cacheTimeMs;
+    return { version, expired };
+}
+export async function installApp({ dir, packageName, beta, version, }) {
+    return await new Listr([
         {
-            title: `Fetching ${name} metadata`,
+            title: `Fetching ${packageName} metadata`,
             task: async (ctx, task) => {
-                const info = await getNpmTgzInfo(name);
-                Object.assign(ctx, info);
-                const useBeta = shouldUseBetaApps();
-                if (useBeta && ctx.version.includes("beta")) {
-                    task.title = `Fetching ${name} metadata (using beta version)`;
+                if (beta) {
+                    task.title = `Fetching ${packageName} metadata (using beta version)`;
                 }
+                const info = await getNpmTgzInfo(packageName, { beta, version });
+                Object.assign(ctx, info);
             },
         },
         {
-            title: `Downloading ${name}`,
-            skip: (ctx) => ctx.version === check?.version,
+            title: `Downloading ${packageName}`,
             task: async (ctx, task) => {
-                task.title = `Downloading ${name}(v${ctx.version})`;
-                await rm(dir, { force: true, recursive: true });
+                task.title = `Downloading ${packageName} (v${ctx.version})`;
                 await mkdir(dir, { recursive: true });
                 await downloadAndExtract(ctx.url, dir, { strip: 1 });
             },
@@ -195,6 +214,7 @@ export async function loadApplication({ name, dir, forceUpgrade = false, }) {
                             task.output = last;
                     },
                 });
+                await writeInstallationMetadata(dir, { installedAt: Date.now() });
             },
         },
     ], {
@@ -204,25 +224,6 @@ export async function loadApplication({ name, dir, forceUpgrade = false, }) {
             timer: PRESET_TIMER,
         },
     }).run();
-    return {
-        aigne: await safeLoadAIGNE(dir),
-        dir,
-        version: result.version,
-    };
-}
-async function isInstallationAvailable(dir, { cacheTimeMs = NPM_PACKAGE_CACHE_TIME_MS } = {}) {
-    const s = await stat(join(dir, "package.json")).catch(() => null);
-    if (!s)
-        return null;
-    const version = safeParseJSON(await readFile(join(dir, "package.json"), "utf-8"))?.version;
-    if (!version)
-        return null;
-    const installedAt = safeParseJSON(await readFile(join(dir, ".aigne-cli.json"), "utf-8").catch(() => "{}"))?.installedAt;
-    if (!installedAt)
-        return null;
-    const now = Date.now();
-    const available = installedAt ? now - installedAt < cacheTimeMs : false;
-    return { version, available };
 }
 async function installDependencies(dir, { log } = {}) {
     await new Promise((resolve, reject) => {
@@ -250,16 +251,20 @@ async function installDependencies(dir, { log } = {}) {
             }
         });
     });
-    await writeFile(join(dir, ".aigne-cli.json"), JSON.stringify({ installedAt: Date.now() }, null, 2));
 }
-export async function getNpmTgzInfo(name) {
+export async function getNpmTgzInfo(name, { version, beta } = {}) {
     const res = await fetch(joinURL("https://registry.npmjs.org", name));
     if (!res.ok)
         throw new Error(`Failed to fetch package info for ${name}: ${res.statusText}`);
     const data = await res.json();
-    const useBeta = shouldUseBetaApps();
     let targetVersion;
-    if (useBeta && data["dist-tags"].beta) {
+    if (version) {
+        if (!data.versions[version]) {
+            throw new Error(`Version ${version} of package ${name} not found`);
+        }
+        targetVersion = version;
+    }
+    else if (beta && data["dist-tags"].beta) {
         // Use beta version if available and beta flag is set
         targetVersion = data["dist-tags"].beta;
     }

package/dist/utils/evaluation/reporter.js

@@ -21,6 +21,33 @@ const chars = {
     "right-mid": borderColor("┤"),
     middle: borderColor("│"),
 };
+const MAX_CELL_LENGTH = 300;
+function renderPagedTable(list, { maxCols = 6, chars }) {
+    if (!list.length)
+        return [];
+    const tables = [];
+    const head = list[0]?.map((h) => h.header) ?? [];
+    const widths = list[0]?.map((h) => h.width ?? 20) ?? [];
+    for (let i = 0; i < head.length; i += maxCols) {
+        const subHead = head.slice(i, i + maxCols);
+        const subWidths = widths.slice(i, i + maxCols);
+        const table = new Table({
+            head: subHead,
+            colWidths: subWidths,
+            wordWrap: true,
+            chars,
+        });
+        for (const row of list) {
+            table.push(row
+                .slice(i, i + maxCols)
+                .map((h) => String(h.value).length > MAX_CELL_LENGTH
+                ? `${String(h.value).slice(0, MAX_CELL_LENGTH)}...`
+                : h.value));
+        }
+        tables.push(table.toString());
+    }
+    return tables;
+}
 export class BaseReporter {
     name = "base";
     async report(_report) {
@@ -43,7 +70,6 @@ export class BaseReporter {
                     width: 40,
                     value: r.expected ? JSON.stringify(r.expected) : "-",
                 },
-                { header: "Error", key: "Error", width: 20, value: r.error ?? "-" },
                 {
                     header: "Evaluations",
                     key: "Evaluations",
@@ -56,6 +82,7 @@ export class BaseReporter {
                     width: 20,
                     value: r.evaluations.map((e) => `${e.rating}`).join(", "),
                 },
+                { header: "Error", key: "Error", width: 20, value: r.error ?? "-" },
                 {
                     header: "Reason",
                     key: "Reason",
@@ -140,18 +167,10 @@ export class ConsoleReporter extends BaseReporter {
         if (!list.length)
             return;
         console.log("\n=== 📋 Detailed Results ===");
-        const head = list[0]?.map((h) => h.header) ?? [];
-        const colWidths = list[0]?.map((h) => h.width) ?? [];
-        const detailTable = new Table({
-            head,
-            colWidths,
-            wordWrap: true,
-            chars,
-        });
-        for (const r of list) {
-            detailTable.push(r.map((h) => h.value));
+        const pages = renderPagedTable(list, { maxCols: 5, chars });
+        for (const page of pages) {
+            console.log(page);
         }
-        console.log(detailTable.toString());
         const failed = report.results.filter((r) => r.error);
         if (failed.length) {
             console.log(chalk.red("\n=== ❌ Failed Cases ==="));

package/dist/utils/workers/run-aigne-in-child-process-worker.d.ts

@@ -0,0 +1,21 @@
+import { type Agent, AIGNE, type Message } from "@aigne/core";
+import { type AgentRunCommonOptions } from "../yargs.js";
+export interface AgentInChildProcess extends Pick<Agent, "name" | "description" | "alias"> {
+    inputSchema: object;
+    outputSchema: object;
+}
+export declare function loadAIGNEInChildProcess(...args: Parameters<typeof AIGNE.load>): Promise<{
+    agents?: AgentInChildProcess[];
+    cli?: {
+        chat?: AgentInChildProcess;
+        agents?: AgentInChildProcess[];
+    };
+    mcpServer?: {
+        agents?: AgentInChildProcess[];
+    };
+}>;
+export declare function invokeCLIAgentFromDirInChildProcess(options: {
+    dir: string;
+    agent: string;
+    input: Message & AgentRunCommonOptions;
+}): Promise<void>;

package/dist/utils/workers/run-aigne-in-child-process-worker.js

@@ -0,0 +1,81 @@
+import assert from "node:assert";
+import { AIGNE } from "@aigne/core";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { loadAIGNE } from "../load-aigne.js";
+import { runAgentWithAIGNE } from "../run-with-aigne.js";
+import { parseAgentInput } from "../yargs.js";
+const METHODS = {
+    loadAIGNE: loadAIGNEInChildProcess,
+    invokeCLIAgentFromDir: invokeCLIAgentFromDirInChildProcess,
+};
+process.on("message", async ({ method, args }) => {
+    const send = (message) => new Promise((resolve, reject) => {
+        assert(process.send);
+        process.send(message, undefined, undefined, (error) => {
+            if (error)
+                reject(error);
+            else
+                resolve(true);
+        });
+    });
+    try {
+        const handler = METHODS[method];
+        if (!handler)
+            throw new Error(`Unknown method: ${method}`);
+        const result = await handler(...args);
+        await send({ method, result });
+    }
+    catch (error) {
+        await send({ method, error: { message: error.message } });
+    }
+    finally {
+        process.exit(0);
+    }
+});
+function serializeAgent(agent) {
+    return {
+        name: agent.name,
+        description: agent.description,
+        alias: agent.alias,
+        inputSchema: zodToJsonSchema(agent.inputSchema),
+        outputSchema: zodToJsonSchema(agent.outputSchema),
+    };
+}
+export async function loadAIGNEInChildProcess(...args) {
+    const aigne = await AIGNE.load(...args);
+    return {
+        agents: aigne.agents.map(serializeAgent),
+        cli: {
+            chat: aigne.cli.chat ? serializeAgent(aigne.cli.chat) : undefined,
+            agents: aigne.cli.agents.map(serializeAgent),
+        },
+        mcpServer: {
+            agents: aigne.mcpServer.agents.map(serializeAgent),
+        },
+    };
+}
+export async function invokeCLIAgentFromDirInChildProcess(options) {
+    const aigne = await loadAIGNE({
+        path: options.dir,
+        modelOptions: options.input,
+    });
+    try {
+        const { chat } = aigne.cli;
+        const agent = chat && chat.name === options.agent
+            ? chat
+            : aigne.cli.agents[options.agent] ||
+                aigne.agents[options.agent] ||
+                aigne.skills[options.agent] ||
+                aigne.mcpServer.agents[options.agent];
+        assert(agent, `Agent ${options.agent} not found in ${options.dir}`);
+        const input = await parseAgentInput(options.input, agent);
+        await runAgentWithAIGNE(aigne, agent, {
+            ...options.input,
+            input,
+            chat: agent === chat || options.input.chat,
+        });
+    }
+    finally {
+        await aigne.shutdown();
+    }
+}

package/dist/utils/workers/run-aigne-in-child-process.d.ts

@@ -0,0 +1,7 @@
+import type { invokeCLIAgentFromDirInChildProcess, loadAIGNEInChildProcess } from "./run-aigne-in-child-process-worker.js";
+export type LoadAIGNEInChildProcessResult = Awaited<ReturnType<typeof loadAIGNEInChildProcess>>;
+export interface ChildProcessAIGNEMethods {
+    loadAIGNE: typeof loadAIGNEInChildProcess;
+    invokeCLIAgentFromDir: typeof invokeCLIAgentFromDirInChildProcess;
+}
+export declare function runAIGNEInChildProcess<M extends keyof ChildProcessAIGNEMethods>(method: M, ...args: Parameters<ChildProcessAIGNEMethods[M]>): Promise<ReturnType<ChildProcessAIGNEMethods[M]>>;

package/dist/utils/workers/run-aigne-in-child-process.js

@@ -0,0 +1,20 @@
+import { fork } from "node:child_process";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+export async function runAIGNEInChildProcess(method, ...args) {
+    return await new Promise((resolve, reject) => {
+        const child = fork(join(dirname(fileURLToPath(import.meta.url)), "./run-aigne-in-child-process-worker.js"));
+        child.on("message", (event) => {
+            if (event.method !== method)
+                reject(new Error(`Unknown method: ${event.method} expected: ${method}`));
+            else if (event.error)
+                reject(new Error(`Failed to execute ${method}: ${event.error.message}`));
+            else
+                resolve(event.result);
+        });
+        child.on("exit", (code) => {
+            reject(new Error(`Child process exited with code ${code}`));
+        });
+        child.send({ method, args });
+    });
+}

package/dist/utils/yargs.d.ts

@@ -50,7 +50,7 @@ export declare function inferZodType(type: ZodType, opts?: {
     array?: boolean;
     optional?: boolean;
 };
-export declare function withAgentInputSchema(yargs: Argv, agent: Agent): Argv<{
+export declare function withAgentInputSchema(yargs: Argv, agent: Pick<Agent, "inputSchema">): Argv<{
     chat: boolean;
 } & {
     model: string | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/cli",
-  "version": "1.49.0-beta.8",
+  "version": "1.49.0-beta.9",
   "description": "Your command center for agent development",
   "publishConfig": {
     "access": "public"
@@ -45,6 +45,7 @@
     }
   },
   "dependencies": {
+    "@aigne/json-schema-to-zod": "^1.3.3",
     "@aigne/listr2": "^1.0.10",
     "@aigne/marked-terminal": "^7.3.2",
     "@fast-csv/format": "^5.0.5",
@@ -82,13 +83,14 @@
     "yargs": "^18.0.0",
     "yoctocolors-cjs": "^2.1.3",
     "zod": "^3.25.67",
-    "@aigne/agent-library": "^1.21.46-beta.8",
-    "@aigne/agentic-memory": "^1.0.46-beta.8",
-    "@aigne/core": "^1.61.0-beta.7",
-    "@aigne/aigne-hub": "^0.10.0-beta.8",
-    "@aigne/default-memory": "^1.2.9-beta.8",
-    "@aigne/observability-api": "^0.11.0-beta",
-    "@aigne/openai": "^0.16.0-beta.8"
+    "zod-to-json-schema": "^3.24.6",
+    "@aigne/agent-library": "^1.21.46-beta.9",
+    "@aigne/core": "^1.61.0-beta.8",
+    "@aigne/aigne-hub": "^0.10.0-beta.9",
+    "@aigne/agentic-memory": "^1.0.46-beta.9",
+    "@aigne/default-memory": "^1.2.9-beta.9",
+    "@aigne/observability-api": "^0.11.0-beta.1",
+    "@aigne/openai": "^0.16.0-beta.9"
   },
   "devDependencies": {
     "@inquirer/testing": "^2.1.50",
@@ -105,7 +107,7 @@
     "rimraf": "^6.0.1",
     "typescript": "^5.9.2",
     "ufo": "^1.6.1",
-    "@aigne/test-utils": "^0.5.53-beta.7"
+    "@aigne/test-utils": "^0.5.53-beta.8"
   },
   "scripts": {
     "lint": "tsc --noEmit",

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

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

package/dist/utils/workers/load-aigne-worker.js

@@ -1,13 +0,0 @@
-import { AIGNE } from "@aigne/core";
-process.on("message", async ({ method, args }) => {
-    try {
-        if (method !== "AIGNE.load")
-            throw new Error(`Unknown method: ${method}`);
-        await AIGNE.load(...args);
-        process.send?.({ method, status: "success" });
-    }
-    catch (error) {
-        process.send?.({ method, status: "error", message: error.message });
-    }
-    process.exit(0);
-});

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

@@ -1,2 +0,0 @@
-import { AIGNE } from "@aigne/core";
-export declare function safeLoadAIGNE(...args: Parameters<typeof AIGNE.load>): Promise<ReturnType<typeof AIGNE.load>>;

package/dist/utils/workers/load-aigne.js

@@ -1,27 +0,0 @@
-import { fork } from "node:child_process";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { AIGNE } from "@aigne/core";
-export async function safeLoadAIGNE(...args) {
-    await new Promise((resolve, reject) => {
-        const child = fork(join(dirname(fileURLToPath(import.meta.url)), "./load-aigne-worker.js"), {
-            timeout: 600e3,
-        });
-        child.on("message", ({ method, message, status }) => {
-            if (method !== "AIGNE.load")
-                reject(new Error(`Unknown method: ${method}`));
-            else if (status === "error")
-                reject(new Error(`Failed to load AIGNE: ${message}`));
-            else if (status === "success")
-                resolve();
-        });
-        child.on("exit", (code) => {
-            if (code !== 0)
-                reject(new Error(`Child process exited with code ${code}`));
-            else
-                resolve();
-        });
-        child.send({ method: "AIGNE.load", args });
-    });
-    return AIGNE.load(...args);
-}