@aigne/cli 1.11.7 → 1.12.0

package/CHANGELOG.md

@@ -1,5 +1,69 @@
 # Changelog
 
+## [1.12.0](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.11.9...cli-v1.12.0) (2025-06-20)
+
+
+### Features
+
+* **cli:** support pass named input to agent by --input-xxx ([#167](https://github.com/AIGNE-io/aigne-framework/issues/167)) ([cda5bb6](https://github.com/AIGNE-io/aigne-framework/commit/cda5bb6baab680787de1a042664fe34c17a84bb1))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/agent-library bumped to 1.14.0
+    * @aigne/anthropic bumped to 0.3.3
+    * @aigne/bedrock bumped to 0.3.3
+    * @aigne/core bumped to 1.21.0
+    * @aigne/deepseek bumped to 0.3.3
+    * @aigne/gemini bumped to 0.3.3
+    * @aigne/ollama bumped to 0.3.3
+    * @aigne/open-router bumped to 0.3.3
+    * @aigne/openai bumped to 0.3.3
+    * @aigne/xai bumped to 0.3.3
+
+## [1.11.9](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.11.8...cli-v1.11.9) (2025-06-19)
+
+
+### Bug Fixes
+
+* use `inputKey` instead of implicit $message for AIAgent ([#165](https://github.com/AIGNE-io/aigne-framework/issues/165)) ([8b6e589](https://github.com/AIGNE-io/aigne-framework/commit/8b6e5896bba8209fd2eecb0f5b9263618bffdaf8))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/agent-library bumped to 1.13.2
+    * @aigne/anthropic bumped to 0.3.2
+    * @aigne/bedrock bumped to 0.3.2
+    * @aigne/core bumped to 1.20.1
+    * @aigne/deepseek bumped to 0.3.2
+    * @aigne/gemini bumped to 0.3.2
+    * @aigne/ollama bumped to 0.3.2
+    * @aigne/open-router bumped to 0.3.2
+    * @aigne/openai bumped to 0.3.2
+    * @aigne/xai bumped to 0.3.2
+
+## [1.11.8](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.11.7...cli-v1.11.8) (2025-06-17)
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/agent-library bumped to 1.13.1
+    * @aigne/anthropic bumped to 0.3.1
+    * @aigne/bedrock bumped to 0.3.1
+    * @aigne/core bumped to 1.20.0
+    * @aigne/deepseek bumped to 0.3.1
+    * @aigne/gemini bumped to 0.3.1
+    * @aigne/ollama bumped to 0.3.1
+    * @aigne/open-router bumped to 0.3.1
+    * @aigne/openai bumped to 0.3.1
+    * @aigne/xai bumped to 0.3.1
+
 ## [1.11.7](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.11.6...cli-v1.11.7) (2025-06-16)
 
 

package/dist/commands/run.js

@@ -10,14 +10,15 @@ import { Listr, PRESET_TIMER } from "@aigne/listr2";
 import { availableMemories, availableModels } from "../constants.js";
 import { isV1Package, toAIGNEPackage } from "../utils/agent-v1.js";
 import { downloadAndExtract } from "../utils/download.js";
-import { createRunAIGNECommand, parseModelOption, runAgentWithAIGNE, } from "../utils/run-with-aigne.js";
+import { createRunAIGNECommand, parseAgentInputByCommander, parseModelOption, runAgentWithAIGNE, } from "../utils/run-with-aigne.js";
 export function createRunCommand() {
     return createRunAIGNECommand()
         .description("Run AIGNE from the specified agent")
-        .argument("[path]", "Path to the agents directory or URL to aigne project", ".")
+        .option("--url, --path <path_or_url>", "Path to the agents directory or URL to aigne project", ".")
         .option("--entry-agent <entry-agent>", "Name of the agent to run (defaults to the first agent found)")
         .option("--cache-dir <dir>", "Directory to download the package to (defaults to the ~/.aigne/xxx)")
-        .action(async (path, options) => {
+        .action(async (options) => {
+        const { path } = options;
         if (options.logLevel)
             logger.level = options.logLevel;
         const { cacheDir, dir } = prepareDirs(path, options);
@@ -78,8 +79,9 @@ export function createRunCommand() {
         }).run();
         assert(aigne);
         assert(agent);
+        const input = await parseAgentInputByCommander(agent, options);
         try {
-            await runAgentWithAIGNE(aigne, agent, { ...options });
+            await runAgentWithAIGNE(aigne, agent, { ...options, input });
         }
         finally {
             await aigne.shutdown();

package/dist/tracer/terminal.d.ts

@@ -4,6 +4,7 @@ import { type Listr } from "@aigne/listr2";
 import { type AIGNEListrTaskWrapper } from "../utils/listr.js";
 export interface TerminalTracerOptions {
     printRequest?: boolean;
+    outputKey?: string;
 }
 export declare class TerminalTracer {
     readonly context: Context;
@@ -24,8 +25,9 @@ export declare class TerminalTracer {
         time?: boolean;
     }): string;
     private marked;
-    formatRequest(_context: Context, m?: Message): string | undefined;
-    formatResult(context: Context, m?: Message): string;
+    get outputKey(): string;
+    formatRequest(agent: Agent, _context: Context, m?: Message): string | undefined;
+    formatResult(agent: Agent, context: Context, m?: Message): string;
 }
 type Task = ReturnType<typeof promiseWithResolvers<void>> & {
     listr: ReturnType<typeof promiseWithResolvers<{

package/dist/tracer/terminal.js

@@ -1,9 +1,9 @@
 import { EOL } from "node:os";
 import { inspect } from "node:util";
-import { ChatModel, MESSAGE_KEY, } from "@aigne/core";
+import { AIAgent, ChatModel, DEFAULT_OUTPUT_KEY, } from "@aigne/core";
 import { LogLevel, logger } from "@aigne/core/utils/logger.js";
 import { promiseWithResolvers } from "@aigne/core/utils/promise.js";
-import { omitBy } from "@aigne/core/utils/type-utils.js";
+import { omit } from "@aigne/core/utils/type-utils.js";
 import { figures } from "@aigne/listr2";
 import { markedTerminal } from "@aigne/marked-terminal";
 import chalk from "chalk";
@@ -21,8 +21,8 @@ export class TerminalTracer {
     async run(agent, input) {
         const context = this.context.newContext({ reset: true });
         const listr = new AIGNEListr({
-            formatRequest: () => this.options.printRequest ? this.formatRequest(context, input) : undefined,
-            formatResult: (result) => [this.formatResult(context, result)].filter(Boolean),
+            formatRequest: () => this.options.printRequest ? this.formatRequest(agent, context, input) : undefined,
+            formatResult: (result) => [this.formatResult(agent, context, result)].filter(Boolean),
         }, [], { concurrent: true });
         const onAgentStarted = async ({ contextId, parentContextId, agent, timestamp, }) => {
             const task = {
@@ -121,27 +121,44 @@ export class TerminalTracer {
             title += ` ${this.formatTimeUsage(task.startTime, task.endTime)}`;
         return title;
     }
-    marked = new Marked().use(markedTerminal({ forceHyperLink: false }));
-    formatRequest(_context, m = {}) {
+    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 }));
+    get outputKey() {
+        return this.options.outputKey || DEFAULT_OUTPUT_KEY;
+    }
+    formatRequest(agent, _context, m = {}) {
         if (!logger.enabled(LogLevel.INFO))
             return;
         const prefix = `${chalk.grey(figures.pointer)} 💬 `;
-        const msg = m[MESSAGE_KEY];
-        const message = omitBy(m, (_, k) => k === MESSAGE_KEY);
+        const inputKey = agent instanceof AIAgent ? agent.inputKey : undefined;
+        const msg = inputKey ? m[inputKey] : undefined;
+        const message = inputKey ? omit(m, inputKey) : m;
         const text = msg && typeof msg === "string" ? this.marked.parse(msg, { async: false }).trim() : undefined;
         const json = Object.keys(message).length > 0 ? inspect(message, { colors: true }) : undefined;
         return [prefix, [text, json].filter(Boolean).join(EOL)].join(" ");
     }
-    formatResult(context, m = {}) {
+    formatResult(agent, context, m = {}) {
+        const { isTTY } = process.stdout;
+        const outputKey = agent instanceof AIAgent ? agent.outputKey : undefined;
         const prefix = logger.enabled(LogLevel.INFO)
             ? `${chalk.grey(figures.tick)} 🤖 ${this.formatTokenUsage(context.usage)}`
             : null;
-        const msg = m[MESSAGE_KEY];
-        const message = omitBy(m, (_, k) => k === MESSAGE_KEY);
-        const text = msg && typeof msg === "string" ? this.marked.parse(msg, { async: false }).trim() : undefined;
-        const json = Object.keys(message).length > 0
-            ? inspect(message, { colors: process.stdout.isTTY })
+        const msg = outputKey ? m[outputKey] : undefined;
+        const message = outputKey ? omit(m, outputKey) : m;
+        const text = msg && typeof msg === "string"
+            ? isTTY
+                ? this.marked.parse(msg, { async: false }).trim()
+                : msg
             : undefined;
+        const json = Object.keys(message).length > 0 ? inspect(message, { colors: isTTY }) : undefined;
         return [prefix, text, json].filter(Boolean).join(EOL);
     }
 }

package/dist/utils/run-chat-loop.d.ts

@@ -1,4 +1,5 @@
-import { type Message, type UserAgent } from "@aigne/core";
+import type { Message, UserAgent } from "@aigne/core";
+export declare const DEFAULT_CHAT_INPUT_KEY = "message";
 export interface ChatLoopOptions {
     initialCall?: Message | string;
     welcome?: string;
@@ -6,4 +7,4 @@ export interface ChatLoopOptions {
     inputKey?: string;
     skipLoop?: boolean;
 }
-export declare function runChatLoopInTerminal(userAgent: UserAgent, options?: ChatLoopOptions): Promise<void>;
+export declare function runChatLoopInTerminal(userAgent: UserAgent<any, any>, options?: ChatLoopOptions): Promise<void>;

package/dist/utils/run-chat-loop.js

@@ -1,6 +1,6 @@
-import { createMessage } from "@aigne/core";
 import inquirer from "inquirer";
 import { TerminalTracer } from "../tracer/terminal.js";
+export const DEFAULT_CHAT_INPUT_KEY = "message";
 export async function runChatLoopInTerminal(userAgent, options = {}) {
     const { initialCall = process.env.INITIAL_CALL, skipLoop = process.env.SKIP_LOOP === "true" } = options;
     let prompt;
@@ -43,9 +43,7 @@ export async function runChatLoopInTerminal(userAgent, options = {}) {
 }
 async function callAgent(userAgent, input, options) {
     const tracer = new TerminalTracer(userAgent.context);
-    await tracer.run(userAgent, options.inputKey && typeof input === "string"
-        ? { [options.inputKey]: input }
-        : createMessage(input));
+    await tracer.run(userAgent, typeof input === "string" ? { [options.inputKey || DEFAULT_CHAT_INPUT_KEY]: input } : input);
 }
 const COMMANDS = {
     "/exit": () => ({ exit: true }),

package/dist/utils/run-with-aigne.d.ts

@@ -1,4 +1,4 @@
-import { AIGNE, type Agent, type ChatModelOptions } from "@aigne/core";
+import { AIGNE, type Agent, type ChatModelOptions, type Message } from "@aigne/core";
 import { LogLevel } from "@aigne/core/utils/logger.js";
 import { type PromiseOrValue } from "@aigne/core/utils/type-utils.js";
 import { Command } from "commander";
@@ -10,23 +10,32 @@ export interface RunAIGNECommandOptions {
     topP?: number;
     presencePenalty?: number;
     frequencyPenalty?: number;
-    input?: string;
+    input?: string[];
+    format?: "text" | "json" | "yaml";
+    output?: string;
     logLevel?: LogLevel;
+    force?: boolean;
 }
 export declare const createRunAIGNECommand: (name?: string) => Command;
+export declare function parseAgentInputByCommander(agent: Agent, options?: RunAIGNECommandOptions & {
+    inputKey?: string;
+    argv?: string[];
+}): Promise<Message>;
 export declare const parseModelOption: (model?: string) => {
     provider: string | undefined;
     name: string | undefined;
 };
-export declare function runWithAIGNE(agentCreator: ((aigne: AIGNE) => PromiseOrValue<Agent>) | Agent, { argv, chatLoopOptions, modelOptions, }?: {
+export declare function runWithAIGNE(agentCreator: ((aigne: AIGNE) => PromiseOrValue<Agent>) | Agent, { argv, chatLoopOptions, modelOptions, outputKey, }?: {
     argv?: typeof process.argv;
     chatLoopOptions?: ChatLoopOptions;
     modelOptions?: ChatModelOptions;
+    outputKey?: string;
 }): Promise<void>;
-export declare function runAgentWithAIGNE(aigne: AIGNE, agent: Agent, { chatLoopOptions, modelOptions, ...options }?: {
+export declare function runAgentWithAIGNE(aigne: AIGNE, agent: Agent, { outputKey, chatLoopOptions, modelOptions, ...options }?: {
+    outputKey?: string;
     chatLoopOptions?: ChatLoopOptions;
     modelOptions?: ChatModelOptions;
-} & RunAIGNECommandOptions): Promise<{
-    result: import("@aigne/core").Message;
-    context: import("@aigne/core").Context<import("@aigne/core").UserContext>;
+    input?: Message;
+} & Omit<RunAIGNECommandOptions, "input">): Promise<{
+    result: Message;
 } | undefined>;

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

@@ -1,18 +1,24 @@
+import assert from "node:assert";
 import { fstat } from "node:fs";
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join } from "node:path";
 import { isatty } from "node:tty";
 import { promisify } from "node:util";
-import { AIGNE, UserAgent, createMessage } from "@aigne/core";
+import { exists } from "@aigne/agent-library/utils/fs.js";
+import { AIGNE, DEFAULT_OUTPUT_KEY, UserAgent, readAllString, } from "@aigne/core";
 import { loadModel } from "@aigne/core/loader/index.js";
 import { LogLevel, getLevelFromEnv, logger } from "@aigne/core/utils/logger.js";
-import { readAllString } from "@aigne/core/utils/stream-utils.js";
-import { tryOrThrow } from "@aigne/core/utils/type-utils.js";
+import { isEmpty, isNonNullable, tryOrThrow, } from "@aigne/core/utils/type-utils.js";
 import { Command } from "commander";
 import PrettyError from "pretty-error";
-import { ZodError, z } from "zod";
+import { parse } from "yaml";
+import { ZodError, ZodObject, z } from "zod";
 import { availableModels } from "../constants.js";
 import { TerminalTracer } from "../tracer/terminal.js";
-import { runChatLoopInTerminal } from "./run-chat-loop.js";
+import { DEFAULT_CHAT_INPUT_KEY, runChatLoopInTerminal, } from "./run-chat-loop.js";
 export const createRunAIGNECommand = (name = "run") => new Command(name)
+    .allowUnknownOption(true)
+    .allowExcessArguments(true)
     .description("Run agent with AIGNE in terminal")
     .option("--chat", "Run chat loop in terminal", false)
     .option("--model <provider[:model]>", `AI model to use in format 'provider[:model]' where model is optional. Examples: 'openai' or 'openai:gpt-4o-mini'. Available providers: ${availableModels.map((i) => i.name.toLowerCase().replace(/ChatModel$/i, "")).join(", ")} (default: openai)`)
@@ -20,13 +26,73 @@ export const createRunAIGNECommand = (name = "run") => new Command(name)
     .option("--top-p <top-p>", "Top P (nucleus sampling) parameter for the model (controls diversity). Range: 0.0-1.0", customZodError("--top-p", (s) => z.coerce.number().min(0).max(1).parse(s)))
     .option("--presence-penalty <presence-penalty>", "Presence penalty for the model (penalizes repeating the same tokens). Range: -2.0 to 2.0", customZodError("--presence-penalty", (s) => z.coerce.number().min(-2).max(2).parse(s)))
     .option("--frequency-penalty <frequency-penalty>", "Frequency penalty for the model (penalizes frequency of token usage). Range: -2.0 to 2.0", customZodError("--frequency-penalty", (s) => z.coerce.number().min(-2).max(2).parse(s)))
-    .option("--input -i <input>", "Input to the agent")
+    .option("--input -i <input...>", "Input to the agent, use @<file> to read from a file")
+    .option("--format <format>", "Input format for the agent (available: text, json, yaml default: text)")
+    .option("--output -o <output>", "Output file to save the result (default: stdout)")
+    .option("--output-key <output-key>", "Key in the result to save to the output file", DEFAULT_OUTPUT_KEY)
+    .option("--force", "Truncate the output file if it exists, and create directory if the output path is not exists", false)
     .option("--log-level <level>", `Log level for detailed debugging information. Values: ${Object.values(LogLevel).join(", ")}`, customZodError("--log-level", (s) => z.nativeEnum(LogLevel).parse(s)), getLevelFromEnv(logger.options.ns) || LogLevel.INFO);
+export async function parseAgentInputByCommander(agent, options = {}) {
+    const cmd = new Command()
+        .description(`Run agent ${agent.name} with AIGNE`)
+        .allowUnknownOption(true)
+        .allowExcessArguments(true);
+    const inputSchemaShape = agent.inputSchema instanceof ZodObject ? Object.keys(agent.inputSchema.shape) : [];
+    for (const option of inputSchemaShape) {
+        cmd.option(`--input-${option} <${option}>`);
+    }
+    const input = await new Promise((resolve, reject) => {
+        cmd
+            .action(async (agentInputOptions) => {
+            try {
+                const input = Object.fromEntries((await Promise.all(Object.entries(agentInputOptions).map(async ([key, value]) => {
+                    let k = key.replace(/^input/, "");
+                    k = k.charAt(0).toLowerCase() + k.slice(1);
+                    if (!k)
+                        return null;
+                    if (typeof value === "string" && value.startsWith("@")) {
+                        value = await readFile(value.slice(1), "utf8");
+                    }
+                    return [k, value];
+                }))).filter(isNonNullable));
+                resolve(input);
+            }
+            catch (error) {
+                reject(error);
+            }
+        })
+            .parseAsync(options.argv ?? process.argv)
+            .catch((error) => reject(error));
+    });
+    const rawInput = options.input ||
+        (isatty(process.stdin.fd) || !(await stdinHasData())
+            ? null
+            : [await readAllString(process.stdin)]);
+    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 });
+            }
+        }
+    }
+    return input;
+}
 export const parseModelOption = (model) => {
     const { provider, name } = model?.match(/(?<provider>[^:]+)(:(?<name>(\S+)))?/)?.groups ?? {};
     return { provider, name };
 };
-export async function runWithAIGNE(agentCreator, { argv = process.argv, chatLoopOptions, modelOptions, } = {}) {
+export async function runWithAIGNE(agentCreator, { argv = process.argv, chatLoopOptions, modelOptions, outputKey, } = {}) {
     await createRunAIGNECommand()
         .showHelpAfterError(true)
         .showSuggestionAfterError(true)
@@ -44,7 +110,20 @@ export async function runWithAIGNE(agentCreator, { argv = process.argv, chatLoop
         const aigne = new AIGNE({ model });
         try {
             const agent = typeof agentCreator === "function" ? await agentCreator(aigne) : agentCreator;
-            await runAgentWithAIGNE(aigne, agent, { ...options, chatLoopOptions, modelOptions });
+            const input = await parseAgentInputByCommander(agent, {
+                ...options,
+                inputKey: chatLoopOptions?.inputKey,
+            });
+            if (isEmpty(input)) {
+                Object.assign(input, chatLoopOptions?.initialCall || chatLoopOptions?.defaultQuestion);
+            }
+            await runAgentWithAIGNE(aigne, agent, {
+                ...options,
+                outputKey,
+                chatLoopOptions,
+                modelOptions,
+                input,
+            });
         }
         finally {
             await aigne.shutdown();
@@ -59,7 +138,24 @@ export async function runWithAIGNE(agentCreator, { argv = process.argv, chatLoop
 function customZodError(label, fn) {
     return ((...args) => tryOrThrow(() => fn(...args), (e) => new Error(`${label} ${e instanceof ZodError ? e.issues[0]?.message : e.message}`)));
 }
-export async function runAgentWithAIGNE(aigne, agent, { chatLoopOptions, modelOptions, ...options } = {}) {
+export async function runAgentWithAIGNE(aigne, agent, { outputKey, chatLoopOptions, modelOptions, ...options } = {}) {
+    if (options.output) {
+        const outputPath = isAbsolute(options.output)
+            ? options.output
+            : join(process.cwd(), options.output);
+        if (await exists(outputPath)) {
+            const s = await stat(outputPath);
+            if (!s.isFile())
+                throw new Error(`Output path ${outputPath} is not a file`);
+            if (s.size > 0 && !options.force) {
+                throw new Error(`Output file ${outputPath} already exists. Use --force to overwrite.`);
+            }
+        }
+        else {
+            await mkdir(dirname(outputPath), { recursive: true });
+        }
+        await writeFile(outputPath, "", "utf8");
+    }
     if (options.chat) {
         if (!isatty(process.stdout.fd)) {
             throw new Error("--chat mode requires a TTY terminal");
@@ -70,19 +166,20 @@ export async function runAgentWithAIGNE(aigne, agent, { chatLoopOptions, modelOp
         });
         return;
     }
-    const input = options.input ||
-        (isatty(process.stdin.fd) || !(await stdinHasData())
-            ? null
-            : await readAllString(process.stdin)) ||
-        chatLoopOptions?.initialCall ||
-        chatLoopOptions?.defaultQuestion ||
-        {};
     const tracer = new TerminalTracer(aigne.newContext(), {
         printRequest: logger.enabled(LogLevel.INFO),
+        outputKey,
     });
-    return await tracer.run(agent, chatLoopOptions?.inputKey && typeof input === "string"
-        ? { [chatLoopOptions.inputKey]: input }
-        : createMessage(input));
+    assert(options.input);
+    const { result } = await tracer.run(agent, options.input);
+    if (options.output) {
+        const message = result[outputKey || DEFAULT_OUTPUT_KEY];
+        const content = typeof message === "string" ? message : JSON.stringify(result, null, 2);
+        const path = isAbsolute(options.output) ? options.output : join(process.cwd(), options.output);
+        await mkdir(dirname(path), { recursive: true });
+        await writeFile(path, content, "utf8");
+    }
+    return { result };
 }
 async function stdinHasData() {
     const stats = await promisify(fstat)(0);

package/dist/utils/serve-mcp.js

@@ -1,4 +1,4 @@
-import { getMessage } from "@aigne/core";
+import { AIAgent } from "@aigne/core";
 import { promiseWithResolvers } from "@aigne/core/utils/promise.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
@@ -82,7 +82,8 @@ export function createMcpServer(aigne) {
                 content: [
                     {
                         type: "text",
-                        text: getMessage(result) || JSON.stringify(result),
+                        text: (agent instanceof AIAgent && result[agent.outputKey]) ||
+                            JSON.stringify(result),
                     },
                 ],
             };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/cli",
-  "version": "1.11.7",
+  "version": "1.12.0",
   "description": "cli for AIGNE framework",
   "publishConfig": {
     "access": "public"
@@ -49,17 +49,18 @@
     "pretty-error": "^4.0.0",
     "tar": "^7.4.3",
     "wrap-ansi": "^9.0.0",
+    "yaml": "^2.7.1",
     "zod": "^3.24.4",
-    "@aigne/agent-library": "^1.13.0",
-    "@aigne/bedrock": "^0.3.0",
-    "@aigne/core": "^1.19.0",
-    "@aigne/deepseek": "^0.3.0",
-    "@aigne/open-router": "^0.3.0",
-    "@aigne/anthropic": "^0.3.0",
-    "@aigne/ollama": "^0.3.0",
-    "@aigne/openai": "^0.3.0",
-    "@aigne/gemini": "^0.3.0",
-    "@aigne/xai": "^0.3.0"
+    "@aigne/agent-library": "^1.14.0",
+    "@aigne/anthropic": "^0.3.3",
+    "@aigne/bedrock": "^0.3.3",
+    "@aigne/deepseek": "^0.3.3",
+    "@aigne/core": "^1.21.0",
+    "@aigne/ollama": "^0.3.3",
+    "@aigne/gemini": "^0.3.3",
+    "@aigne/open-router": "^0.3.3",
+    "@aigne/xai": "^0.3.3",
+    "@aigne/openai": "^0.3.3"
   },
   "devDependencies": {
     "@types/archiver": "^6.0.3",

package/templates/default/chat.yaml

@@ -3,6 +3,7 @@ description: Chat agent
 instructions: |
   You are a helpful assistant that can answer questions and provide information on a wide range of topics.
   Your goal is to assist users in finding the information they need and to engage in friendly conversation.
+input_key: message
 memory: true
 tools:
   - sandbox.js