@aigne/cli 1.60.0-beta → 1.74.0-beta

package/dist/utils/serve-mcp.js

@@ -1,93 +0,0 @@
-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";
-import express, { json, Router } from "express";
-import { ZodObject } from "zod";
-import { AIGNE_CLI_VERSION } from "../constants.js";
-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: aigne.name || "aigne-mcp-server",
-        version: AIGNE_CLI_VERSION,
-    }, {
-        capabilities: { tools: {} },
-        instructions: aigne.description,
-    });
-    for (const agent of aigne.mcpServer?.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 aigne.invoke(agent, input);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: (agent instanceof AIAgent && result[agent.outputKey]) ||
-                            JSON.stringify(result),
-                    },
-                ],
-            };
-        });
-    }
-    return server;
-}

package/dist/utils/spinner.d.ts

@@ -1 +0,0 @@
-export declare function withSpinner<T>(message: string, fn: () => Promise<T>): Promise<T>;

package/dist/utils/spinner.js

@@ -1,14 +0,0 @@
-import { Spinner } from "@aigne/listr2";
-export async function withSpinner(message, fn) {
-    const spinner = new Spinner();
-    spinner.start(() => {
-        process.stdout.write(`\r\x1b[K${spinner.fetch()} ${message}`);
-    });
-    try {
-        return await fn();
-    }
-    finally {
-        spinner.stop();
-        process.stdout.write("\r\x1b[K"); // Clear the spinner line
-    }
-}

package/dist/utils/string-utils.d.ts

@@ -1 +0,0 @@
-export declare function highlightUrl(str: string): string;

package/dist/utils/string-utils.js

@@ -1,4 +0,0 @@
-import chalk from "chalk";
-export function highlightUrl(str) {
-    return str.replace(/https?:\/\/[^\s]+/g, (url) => chalk.cyan(url));
-}

package/dist/utils/time.d.ts

@@ -1 +0,0 @@
-export declare function parseDuration(duration: number): string;

package/dist/utils/time.js

@@ -1,12 +0,0 @@
-export function parseDuration(duration) {
-    const milliseconds = duration % 1000;
-    const seconds = Math.floor(duration / 1000);
-    const minutes = Math.floor(seconds / 60);
-    const ms = Math.round(milliseconds / 10)
-        .toString()
-        .padStart(2, "0");
-    const s = `${Number.parseFloat(`${seconds % 60}.${ms}`)}s`;
-    if (minutes === 0)
-        return s;
-    return `${minutes}m${s}`;
-}

package/dist/utils/url.d.ts

@@ -1 +0,0 @@
-export declare function isUrl(s: string): boolean;

package/dist/utils/url.js

@@ -1,3 +0,0 @@
-export function isUrl(s) {
-    return /^https?:\/\/\S+/.test(s);
-}

package/dist/utils/yargs.d.ts

@@ -1,94 +0,0 @@
-import { type Agent, type Message } from "@aigne/core";
-import { LogLevel } from "@aigne/core/utils/logger.js";
-import type { Argv } from "yargs";
-import { ZodType } from "zod";
-export type InferArgv<T> = T extends Argv<infer U> ? U : never;
-export declare const withRunAgentCommonOptions: (yargs: Argv) => Argv<{
-    interactive: boolean;
-} & {
-    "session-id": string | undefined;
-} & {
-    model: string | undefined;
-} & {
-    "image-model": string | undefined;
-} & {
-    temperature: number | undefined;
-} & {
-    "top-p": number | undefined;
-} & {
-    "presence-penalty": number | undefined;
-} & {
-    "frequency-penalty": number | undefined;
-} & {
-    input: string[] | undefined;
-} & {
-    "input-file": string[] | undefined;
-} & {
-    format: string | undefined;
-} & {
-    output: string | undefined;
-} & {
-    "output-key": string;
-} & {
-    force: boolean;
-} & {
-    "log-level": LogLevel;
-} & {
-    "aigne-hub-url": string | undefined;
-}>;
-type _AgentRunCommonOptions = Partial<InferArgv<ReturnType<typeof withAgentInputSchema>>>;
-/** Convert literal string types like 'foo-bar' to 'FooBar' */
-type PascalCase<S extends string> = string extends S ? string : S extends `${infer T}-${infer U}` ? `${Capitalize<T>}${PascalCase<U>}` : Capitalize<S>;
-/** Convert literal string types like 'foo-bar' to 'fooBar' */
-type CamelCase<S extends string> = string extends S ? string : S extends `${infer T}-${infer U}` ? `${T}${PascalCase<U>}` : S;
-/** Convert literal string types like 'foo-bar' to 'fooBar', allowing all `PropertyKey` types */
-type CamelCaseKey<K extends PropertyKey> = K extends string ? Exclude<CamelCase<K>, ""> : K;
-export type AgentRunCommonOptions = {
-    [key in keyof _AgentRunCommonOptions as CamelCaseKey<key>]: _AgentRunCommonOptions[key];
-};
-export declare function inferZodType(type: ZodType, opts?: {
-    array?: boolean;
-    optional?: boolean;
-}): {
-    type: "string" | "number" | "boolean";
-    array?: boolean;
-    optional?: boolean;
-};
-export declare function withAgentInputSchema(yargs: Argv, options: Pick<Agent, "inputSchema"> & {
-    optionalInputs?: string[];
-}): Argv<{
-    interactive: boolean;
-} & {
-    "session-id": string | undefined;
-} & {
-    model: string | undefined;
-} & {
-    "image-model": string | undefined;
-} & {
-    temperature: number | undefined;
-} & {
-    "top-p": number | undefined;
-} & {
-    "presence-penalty": number | undefined;
-} & {
-    "frequency-penalty": number | undefined;
-} & {
-    input: string[] | undefined;
-} & {
-    "input-file": string[] | undefined;
-} & {
-    format: string | undefined;
-} & {
-    output: string | undefined;
-} & {
-    "output-key": string;
-} & {
-    force: boolean;
-} & {
-    "log-level": LogLevel;
-} & {
-    "aigne-hub-url": string | undefined;
-}>;
-export declare function parseAgentInput(i: Message & AgentRunCommonOptions, agent: Agent): Promise<any>;
-export declare function stdinHasData(): Promise<boolean>;
-export {};

package/dist/utils/yargs.js

@@ -1,210 +0,0 @@
-import { fstat } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { basename, extname } from "node:path";
-import { isatty } from "node:tty";
-import { promisify } from "node:util";
-import { availableImageModels, availableModels, } from "@aigne/aigne-hub";
-import { AIAgent, ChatModel, DEFAULT_OUTPUT_KEY, readAllString, } from "@aigne/core";
-import { getLevelFromEnv, LogLevel, logger } from "@aigne/core/utils/logger.js";
-import { flat, pick, tryOrThrow } from "@aigne/core/utils/type-utils.js";
-import { parse } from "yaml";
-import z, { ZodAny, ZodArray, ZodBoolean, ZodError, ZodNumber, ZodObject, ZodString, ZodType, ZodUnknown, } from "zod";
-const MODEL_OPTIONS_GROUP_NAME = "Model Options";
-export const withRunAgentCommonOptions = (yargs) => yargs
-    .option("interactive", {
-    describe: "Run in interactive chat mode",
-    type: "boolean",
-    default: false,
-    alias: ["chat"],
-})
-    .option("session-id", {
-    describe: "Session ID for chat-based agents to maintain context across interactions",
-    type: "string",
-})
-    .option("model", {
-    group: MODEL_OPTIONS_GROUP_NAME,
-    describe: `AI model to use in format 'provider[/model]' where model is optional. Examples: 'openai' or 'openai/gpt-4o-mini'. Available providers: ${formatModelsName(availableModels())} (default: openai)`,
-    type: "string",
-})
-    .option("image-model", {
-    group: MODEL_OPTIONS_GROUP_NAME,
-    describe: `Image model to use in format 'provider[/model]' where model is optional. Examples: 'openai' or 'openai/gpt-image-1'. Available providers: ${formatModelsName(availableImageModels())} (default: openai)`,
-    type: "string",
-})
-    .option("temperature", {
-    group: MODEL_OPTIONS_GROUP_NAME,
-    describe: "Temperature for the model (controls randomness, higher values produce more random outputs). Range: 0.0-2.0",
-    type: "number",
-    coerce: customZodError("--temperature", (s) => z.coerce.number().min(0).max(2).parse(s)),
-})
-    .option("top-p", {
-    group: MODEL_OPTIONS_GROUP_NAME,
-    describe: "Top P (nucleus sampling) parameter for the model (controls diversity). Range: 0.0-1.0",
-    type: "number",
-    coerce: customZodError("--top-p", (s) => z.coerce.number().min(0).max(1).parse(s)),
-})
-    .option("presence-penalty", {
-    group: MODEL_OPTIONS_GROUP_NAME,
-    describe: "Presence penalty for the model (penalizes repeating the same tokens). Range: -2.0 to 2.0",
-    type: "number",
-    coerce: customZodError("--presence-penalty", (s) => z.coerce.number().min(-2).max(2).parse(s)),
-})
-    .option("frequency-penalty", {
-    group: MODEL_OPTIONS_GROUP_NAME,
-    describe: "Frequency penalty for the model (penalizes frequency of token usage). Range: -2.0 to 2.0",
-    type: "number",
-    coerce: customZodError("--frequency-penalty", (s) => z.coerce.number().min(-2).max(2).parse(s)),
-})
-    .option("input", {
-    describe: "Input to the agent, use @<file> to read from a file",
-    type: "string",
-    array: true,
-    alias: "i",
-})
-    .option("input-file", {
-    describe: "Input files to the agent",
-    type: "string",
-    array: true,
-})
-    .option("format", {
-    describe: "Input format for the agent (available: text, json, yaml default: text)",
-    type: "string",
-    choices: ["text", "json", "yaml"],
-})
-    .option("output", {
-    describe: "Output file to save the result (default: stdout)",
-    type: "string",
-    alias: "o",
-})
-    .option("output-key", {
-    describe: "Key in the result to save to the output file",
-    type: "string",
-    default: DEFAULT_OUTPUT_KEY,
-})
-    .option("force", {
-    describe: "Truncate the output file if it exists, and create directory if the output path does not exists",
-    type: "boolean",
-    default: false,
-})
-    .option("log-level", {
-    describe: `Log level for detailed debugging information. Values: ${Object.values(LogLevel).join(", ")}`,
-    type: "string",
-    default: getLevelFromEnv(logger.options.ns) || LogLevel.SILENT,
-    coerce: customZodError("--log-level", (s) => z.nativeEnum(LogLevel).parse(s)),
-})
-    .option("aigne-hub-url", {
-    group: MODEL_OPTIONS_GROUP_NAME,
-    describe: "Custom AIGNE Hub service URL. Used to fetch remote agent definitions or models.",
-    type: "string",
-});
-function formatModelsName(models) {
-    return models
-        .map((i) => {
-        if (typeof i.name === "string") {
-            return i.name.toLowerCase().replace(/ChatModel$/i, "");
-        }
-        return i.name.map((n) => n.toLowerCase().replace(/ChatModel$/i, ""));
-    })
-        .join(", ");
-}
-export function inferZodType(type, opts = {}) {
-    if (type instanceof ZodUnknown || type instanceof ZodAny) {
-        return { type: "string", optional: true };
-    }
-    opts.optional ??= type.isNullable() || type.isOptional();
-    if ("innerType" in type._def && type._def.innerType instanceof ZodType) {
-        return inferZodType(type._def.innerType, opts);
-    }
-    if (type instanceof ZodArray) {
-        return inferZodType(type.element, { ...opts, array: true });
-    }
-    return {
-        ...opts,
-        array: opts.array || undefined,
-        optional: opts.optional || undefined,
-        type: type instanceof ZodBoolean ? "boolean" : type instanceof ZodNumber ? "number" : "string",
-    };
-}
-export function withAgentInputSchema(yargs, options) {
-    const inputSchema = options.inputSchema instanceof ZodObject ? options.inputSchema.shape : {};
-    for (const [option, config] of Object.entries(inputSchema)) {
-        const type = inferZodType(config);
-        yargs.option(option, {
-            group: "Agent Parameters",
-            type: type.type,
-            description: config.description,
-            array: type.array,
-        });
-        if (!type.optional && !options.optionalInputs?.includes(option)) {
-            yargs.demandOption(option);
-        }
-    }
-    return withRunAgentCommonOptions(yargs);
-}
-export async function parseAgentInput(i, agent) {
-    const inputSchema = agent.inputSchema instanceof ZodObject ? agent.inputSchema.shape : {};
-    const input = Object.fromEntries(await Promise.all(Object.entries(pick(i, Object.keys(inputSchema))).map(async ([key, val]) => {
-        if (typeof val === "string" && val.startsWith("@")) {
-            const schema = inputSchema[key];
-            val = await readFileAsInput(val, {
-                format: schema instanceof ZodString ? "raw" : undefined,
-            });
-        }
-        return [key, val];
-    })));
-    if (agent instanceof AIAgent && agent.inputFileKey) {
-        const files = [];
-        for (const file of flat(i.inputFile, i[agent.inputFileKey]) ?? []) {
-            const raw = await readFile(file.replace(/^@/, ""), "base64");
-            const filename = basename(file);
-            const mimeType = (await ChatModel.getMimeType(filename)) || "application/octet-stream";
-            files.push({ type: "file", data: raw, filename, mimeType });
-        }
-        Object.assign(input, { [agent.inputFileKey]: files });
-    }
-    const rawInput = i.input ||
-        (isatty(process.stdin.fd) || !(await stdinHasData())
-            ? null
-            : [await readAllString(process.stdin)].filter(Boolean));
-    if (rawInput) {
-        for (const raw of rawInput) {
-            const parsed = raw.startsWith("@") ? await readFileAsInput(raw, { format: i.format }) : raw;
-            if (typeof parsed !== "string") {
-                Object.assign(input, parsed);
-            }
-            else {
-                const inputKey = agent instanceof AIAgent ? agent.inputKey : undefined;
-                if (inputKey) {
-                    Object.assign(input, { [inputKey]: parsed });
-                }
-            }
-        }
-    }
-    return input;
-}
-async function readFileAsInput(value, { format } = {}) {
-    if (value.startsWith("@")) {
-        const ext = extname(value);
-        value = await readFile(value.slice(1), "utf8");
-        if (!format) {
-            if (ext === ".json")
-                format = "json";
-            else if (ext === ".yaml" || ext === ".yml")
-                format = "yaml";
-        }
-    }
-    if (format === "json") {
-        return JSON.parse(value);
-    }
-    else if (format === "yaml") {
-        return parse(value);
-    }
-    return value;
-}
-export async function stdinHasData() {
-    const stats = await promisify(fstat)(0);
-    return stats.isFIFO() || stats.isFile();
-}
-function customZodError(label, fn) {
-    return ((...args) => tryOrThrow(() => fn(...args), (e) => new Error(`${label} ${e instanceof ZodError ? e.issues[0]?.message : e.message}`)));
-}