@aigne/cli 1.7.0 → 1.8.0

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [1.8.0](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.7.0...cli-v1.8.0) (2025-04-27)
+
+
+### Features
+
+* support TeamAgent and finalize API naming ([#91](https://github.com/AIGNE-io/aigne-framework/issues/91)) ([033d1b6](https://github.com/AIGNE-io/aigne-framework/commit/033d1b6a7dc5460807476abb35a413ba89a2a664))
+
+
+### Bug Fixes
+
+* upgrade to streamable api for serve mcp command ([#98](https://github.com/AIGNE-io/aigne-framework/issues/98)) ([ae32bda](https://github.com/AIGNE-io/aigne-framework/commit/ae32bda20e57c2a2eb8b49fad034b0b2a5ebb15e))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/core bumped to 1.12.0
+
 ## [1.7.0](https://github.com/AIGNE-io/aigne-framework/compare/cli-v1.6.0...cli-v1.7.0) (2025-04-23)
 
 

package/dist/commands/aigne.js

@@ -1,5 +1,5 @@
 import { Command } from "commander";
-import pkg from "../../package.json" with { type: "json" };
+import { AIGNE_CLI_VERSION } from "../constants.js";
 import { asciiLogo } from "../utils/ascii-logo.js";
 import { createCreateCommand } from "./create.js";
 import { createRunCommand } from "./run.js";
@@ -10,7 +10,7 @@ export function createAIGNECommand() {
     return new Command()
         .name("aigne")
         .description("CLI for AIGNE framework")
-        .version(pkg.version)
+        .version(AIGNE_CLI_VERSION)
         .addCommand(createRunCommand())
         .addCommand(createTestCommand())
         .addCommand(createCreateCommand())

package/dist/commands/run.js

@@ -2,7 +2,7 @@ import assert from "node:assert";
 import { cp, mkdir, rm } from "node:fs/promises";
 import { homedir } from "node:os";
 import { isAbsolute, join, resolve } from "node:path";
-import { ExecutionEngine } from "@aigne/core";
+import { AIGNE } from "@aigne/core";
 import { loadModel } from "@aigne/core/loader/index.js";
 import { logger } from "@aigne/core/utils/logger.js";
 import { isNonNullable } from "@aigne/core/utils/type-utils.js";
@@ -24,7 +24,7 @@ export function createRunCommand() {
         if (options.verbose)
             logger.enable("*");
         const { downloadDir, dir } = prepareDirs(path, options);
-        const { engine, agent } = await new Listr([
+        const { aigne, agent } = await new Listr([
             {
                 title: "Prepare environment",
                 task: (_, task) => {
@@ -43,30 +43,30 @@ export function createRunCommand() {
                 },
             },
             {
-                title: "Initialize execution engine",
+                title: "Initialize AIGNE",
                 task: async (ctx) => {
-                    const engine = await runEngine(dir, options);
-                    ctx.engine = engine;
+                    const aigne = await loadAIGNE(dir, options);
+                    ctx.aigne = aigne;
                 },
             },
             {
                 task: (ctx) => {
-                    const { engine } = ctx;
-                    assert(engine);
+                    const { aigne } = ctx;
+                    assert(aigne);
                     let agent;
                     if (options.agent) {
-                        agent = engine.agents[options.agent];
+                        agent = aigne.agents[options.agent];
                         if (!agent) {
                             console.error(`Agent "${options.agent}" not found in ${path}`);
                             console.log("Available agents:");
-                            for (const agent of engine.agents) {
+                            for (const agent of aigne.agents) {
                                 console.log(`- ${agent.name}`);
                             }
                             throw new Error(`Agent "${options.agent}" not found in ${path}`);
                         }
                     }
                     else {
-                        agent = engine.agents[0];
+                        agent = aigne.agents[0];
                         if (!agent)
                             throw new Error(`No agents found in ${path}`);
                     }
@@ -79,23 +79,23 @@ export function createRunCommand() {
                 timer: PRESET_TIMER,
             },
         }).run();
-        assert(engine);
+        assert(aigne);
         assert(agent);
-        const user = engine.call(agent);
+        const user = aigne.invoke(agent);
         await runChatLoopInTerminal(user);
-        await engine.shutdown();
+        await aigne.shutdown();
     })
         .showHelpAfterError(true)
         .showSuggestionAfterError(true);
 }
-async function runEngine(path, options) {
+async function loadAIGNE(path, options) {
     if (options.modelName && !options.modelProvider) {
         throw new Error("please specify --model-provider when using the --model-name option");
     }
     const model = options.modelProvider
         ? await loadModel({ provider: options.modelProvider, name: options.modelName })
         : undefined;
-    return await ExecutionEngine.load({ path, model });
+    return await AIGNE.load({ path, model });
 }
 async function downloadPackage(url, downloadDir) {
     await rm(downloadDir, { recursive: true, force: true });

package/dist/commands/serve.js

@@ -1,5 +1,5 @@
 import { isAbsolute, resolve } from "node:path";
-import { ExecutionEngine } from "@aigne/core";
+import { AIGNE } from "@aigne/core";
 import { tryOrThrow } from "@aigne/core/utils/type-utils.js";
 import { Command } from "commander";
 import { serveMCPServer } from "../utils/serve-mcp.js";
@@ -17,15 +17,23 @@ export function createServeCommand() {
         .description("Serve the agents in the specified directory as a MCP server")
         .argument("[path]", "Path to the agents directory", ".")
         .option("--mcp", "Serve the agents as a MCP server")
+        .option("--host <host>", "Host to run the MCP server on, use 0.0.0.0 to publicly expose the server", "localhost")
         .option("--port <port>", "Port to run the MCP server on", (s) => Number.parseInt(s))
+        .option("--pathname <pathname>", "Pathname to the service", "/mcp")
         .action(async (path, options) => {
         const absolutePath = isAbsolute(path) ? path : resolve(process.cwd(), path);
         const port = options.port || DEFAULT_PORT();
-        const engine = await ExecutionEngine.load({ path: absolutePath });
+        const aigne = await AIGNE.load({ path: absolutePath });
         if (options.mcp)
-            await serveMCPServer({ engine, port });
+            await serveMCPServer({
+                aigne,
+                host: options.host,
+                port,
+                pathname: options.pathname,
+            });
         else
             throw new Error("Default server is not supported yet. Please use --mcp option");
+        console.log(`MCP server is running on http://${options.host}:${port}${options.pathname}`);
     })
         .showHelpAfterError(true)
         .showSuggestionAfterError(true);

package/dist/constants.d.ts

@@ -0,0 +1 @@
+export declare const AIGNE_CLI_VERSION: string;

package/dist/constants.js

@@ -0,0 +1,2 @@
+import pkg from "../package.json" with { type: "json" };
+export const AIGNE_CLI_VERSION = pkg.version;

package/dist/tracer/terminal.d.ts

@@ -1,5 +1,4 @@
-import { type Agent, type Context, MESSAGE_KEY, type Message } from "@aigne/core";
-import type { ContextUsage } from "@aigne/core/execution-engine/usage";
+import { type Agent, type Context, type ContextUsage, MESSAGE_KEY, type Message } from "@aigne/core";
 import { type DefaultRenderer, Listr, type ListrRenderer, type ListrTaskWrapper } from "@aigne/listr2";
 import { promiseWithResolvers } from "../utils/promise-with-resolvers.js";
 export interface TerminalTracerOptions {

package/dist/tracer/terminal.js

@@ -99,7 +99,7 @@ export class TerminalTracer {
         context.on("agentSucceed", onAgentSucceed);
         context.on("agentFailed", onAgentFailed);
         try {
-            const stream = await context.call(agent, input, { streaming: true });
+            const stream = await context.invoke(agent, input, { streaming: true });
             const result = await listr.run(stream);
             return { result, context };
         }
@@ -129,7 +129,7 @@ export class TerminalTracer {
         return chalk.grey(`[${parseDuration(duration)}]`);
     }
     formatTaskTitle(agent, { task, usage, time } = {}) {
-        let title = `call agent ${agent.name}`;
+        let title = `invoke agent ${agent.name}`;
         if (usage && task?.usage)
             title += ` ${this.formatTokenUsage(task.usage, task.extraTitleMetadata)}`;
         if (time && task?.startTime && task.endTime)

package/dist/utils/agent-v1.js

@@ -43,15 +43,15 @@ async function loadAgentV1Package(path) {
     return definition;
 }
 function assistantToAigneV2(agent, project) {
-    const converter = RUNNABLE_MAP[agent.type];
+    const converter = AGENT_MAP[agent.type];
     if (!converter)
-        throw new Error(`Unsupported runnable type: ${agent.type}`);
+        throw new Error(`Unsupported agent type: ${agent.type}`);
     return converter(agent, project);
 }
-const RUNNABLE_MAP = {
+const AGENT_MAP = {
     prompt: (agent) => {
         if (agent.type !== "prompt")
-            throw new Error(`Expected runnable type 'prompt', but got '${agent.type}'`);
+            throw new Error(`Expected agent type 'prompt', but got '${agent.type}'`);
         const obj = {
             name: agent.name || agent.id,
             description: agent.description,
@@ -68,7 +68,7 @@ const RUNNABLE_MAP = {
     },
     function: async (agent) => {
         if (agent.type !== "function")
-            throw new Error(`Expected runnable type 'function', but got '${agent.type}'`);
+            throw new Error(`Expected agent type 'function', but got '${agent.type}'`);
         const inputNames = agent.parameters?.map((i) => i.key).filter(Boolean) ?? [];
         return {
             content: await formatCode(`\
@@ -88,7 +88,7 @@ agent.output_schema = ${JSON.stringify(convertOutputSchema(agent))};
     },
     router: (agent, project) => {
         if (agent.type !== "router")
-            throw new Error(`Expected runnable type 'router', but got '${agent.type}'`);
+            throw new Error(`Expected agent type 'router', but got '${agent.type}'`);
         return {
             content: stringify({
                 name: agent.name || agent.id,
@@ -96,7 +96,7 @@ agent.output_schema = ${JSON.stringify(convertOutputSchema(agent))};
                 instructions: agent.prompt,
                 input_schema: convertInputSchema(agent),
                 output_schema: convertOutputSchema(agent),
-                tools: agent.routes?.map((i) => {
+                skills: agent.routes?.map((i) => {
                     const tool = project.agents.find((j) => j.id === i.id);
                     if (!tool)
                         throw new Error(`Tool ${i.id} not found in project definition`);

package/dist/utils/serve-mcp.d.ts

@@ -1,5 +1,9 @@
-import { type ExecutionEngine } from "@aigne/core";
-export declare function serveMCPServer({ engine, port }: {
-    engine: ExecutionEngine;
+import { type AIGNE } from "@aigne/core";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function serveMCPServer({ pathname, aigne, host, port, }: {
+    pathname?: string;
+    aigne: AIGNE;
+    host?: string;
     port: number;
 }): Promise<import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>>;
+export declare function createMcpServer(aigne: AIGNE): McpServer;

package/dist/utils/serve-mcp.js

@@ -1,23 +1,83 @@
 import { getMessage } from "@aigne/core";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
-import express from "express";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import express, { Router, json } from "express";
 import { ZodObject } from "zod";
+import { AIGNE_CLI_VERSION } from "../constants.js";
 import { promiseWithResolvers } from "./promise-with-resolvers.js";
-export async function serveMCPServer({ engine, port }) {
+export async function serveMCPServer({ pathname = "/mcp", aigne, host = "localhost", port, }) {
+    const app = express();
+    app.use(json());
+    const router = Router();
+    app.use(router);
+    router.post(pathname, async (req, res) => {
+        try {
+            const server = createMcpServer(aigne);
+            const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+            await server.connect(transport);
+            await transport.handleRequest(req, res, req.body);
+            res.on("close", async () => {
+                await transport.close();
+                await server.close();
+            });
+        }
+        catch (error) {
+            console.error("Error handling MCP request:", error);
+            if (!res.headersSent) {
+                res.status(500).json({
+                    jsonrpc: "2.0",
+                    error: {
+                        code: -32603,
+                        message: error.message,
+                    },
+                    id: null,
+                });
+            }
+        }
+    });
+    router.get(pathname, async (_, res) => {
+        res.writeHead(405).end(JSON.stringify({
+            jsonrpc: "2.0",
+            error: {
+                code: -32000,
+                message: "Method not allowed.",
+            },
+            id: null,
+        }));
+    });
+    router.delete(pathname, async (_, res) => {
+        res.writeHead(405).end(JSON.stringify({
+            jsonrpc: "2.0",
+            error: {
+                code: -32000,
+                message: "Method not allowed.",
+            },
+            id: null,
+        }));
+    });
+    const { promise, resolve, reject } = promiseWithResolvers();
+    const httpServer = app.listen(port, host, (error) => {
+        if (error)
+            reject(error);
+        resolve();
+    });
+    await promise;
+    return httpServer;
+}
+export function createMcpServer(aigne) {
     const server = new McpServer({
-        name: engine.name || "aigne-mcp-server",
-        version: "1.0.0",
+        name: aigne.name || "aigne-mcp-server",
+        version: AIGNE_CLI_VERSION,
     }, {
         capabilities: { tools: {} },
-        instructions: engine.description,
+        instructions: aigne.description,
     });
-    for (const agent of engine.agents) {
+    for (const agent of aigne.agents) {
         const schema = agent.inputSchema;
         if (!(schema instanceof ZodObject))
             throw new Error("Agent input schema must be a ZodObject");
         server.tool(agent.name, agent.description || "", schema.shape, async (input) => {
-            const result = await engine.call(agent, input);
+            const result = await aigne.invoke(agent, input);
             return {
                 content: [
                     {
@@ -28,45 +88,5 @@ export async function serveMCPServer({ engine, port }) {
             };
         });
     }
-    const app = express();
-    const transports = {};
-    app.get("/sse", async (req, res) => {
-        const transport = new SSEServerTransport("/messages", res);
-        transports[transport.sessionId] = transport;
-        req.on("close", () => {
-            delete transports[transport.sessionId];
-        });
-        await server.connect(transport);
-    });
-    app.post("/messages", async (req, res) => {
-        const sessionId = req.query.sessionId;
-        const transport = transports[sessionId];
-        if (transport) {
-            await transport.handlePostMessage(req, res);
-        }
-        else {
-            throw new HttpError(400, "No transport found for sessionId");
-        }
-    });
-    app.use(((error, _req, res, _next) => {
-        console.error("handle route error", { error });
-        res
-            .status(error instanceof HttpError ? error.status : 500)
-            .json({ error: { message: error.message } });
-    }));
-    const { promise, resolve, reject } = promiseWithResolvers();
-    const httpServer = app.listen(port, (error) => {
-        if (error)
-            reject(error);
-        resolve();
-    });
-    await promise;
-    return httpServer;
-}
-class HttpError extends Error {
-    status;
-    constructor(status, message) {
-        super(message);
-        this.status = status;
-    }
+    return server;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/cli",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "cli for AIGNE framework",
   "publishConfig": {
     "access": "public"
@@ -50,7 +50,7 @@
     "pretty-error": "^4.0.0",
     "tar": "^7.4.3",
     "zod": "^3.24.2",
-    "@aigne/core": "^1.11.0"
+    "@aigne/core": "^1.12.0"
   },
   "devDependencies": {
     "@types/archiver": "^6.0.3",

package/templates/default/README.md

@@ -5,7 +5,7 @@ This is the default project template for the Aigne framework, providing a basic
 ## Template Structure
 
 - `aigne.yaml` - Project configuration file that defines the chat model used and references to agents
-- `chat.yaml` - Chat agent configuration, including agent instructions and tools used
+- `chat.yaml` - Chat agent configuration, including agent instructions and skills used
 - `sandbox.js` - JavaScript code execution tool for running JavaScript code within conversations
 - `sandbox.test.js` - Test file to verify the functionality of the code execution tool
 

package/templates/default/chat.yaml

@@ -3,8 +3,6 @@ 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.
-memory:
-  subscribeTopic:
-    - chat
+memory: true
 tools:
   - sandbox.js