@aigne/cli 1.60.0-beta → 1.74.0-beta

package/dist/utils/listr.js

@@ -1,265 +0,0 @@
-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;
-    result = {};
-    error;
-    logs = [];
-    spinner;
-    constructor(myOptions, ...[task, options, parentTask]) {
-        const aigneOptions = {
-            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];
-                return [];
-            },
-        };
-        super(task, {
-            ...options,
-            renderer: AIGNEListrRenderer,
-            rendererOptions: {
-                collapseSubtasks: false,
-                icon: {
-                    [ListrDefaultRendererLogLevels.PENDING]: () => this.spinner.fetch(),
-                    [ListrDefaultRendererLogLevels.COMPLETED_WITH_FAILED_SUBTASKS]: figures.cross,
-                },
-                color: {
-                    [ListrDefaultRendererLogLevels.COMPLETED_WITH_FAILED_SUBTASKS]: (m) => m ? color.red(m) : "",
-                },
-                aigne: aigneOptions,
-            },
-            fallbackRenderer: AIGNEListrFallbackRenderer,
-            fallbackRendererOptions: {
-                aigne: aigneOptions,
-                logger: new (class extends ListrLogger {
-                    log(...[level, ...args]) {
-                        // ignore stdout logs if level `INFO` is not enabled
-                        if (!this.options?.toStderr?.includes(level) && !logger.enabled(LogLevel.INFO)) {
-                            return;
-                        }
-                        super.log(level, ...args);
-                    }
-                })(),
-            },
-        }, parentTask);
-        this.myOptions = myOptions;
-        this.spinner = new Spinner();
-    }
-    needLogResult = true;
-    async run(stream) {
-        const originalLog = logger.logMessage;
-        const originalConsole = { ...console };
-        try {
-            this.ctx = {};
-            this.spinner.start();
-            if (logger.enabled(LogLevel.INFO)) {
-                const request = this.myOptions.formatRequest();
-                if (request)
-                    console.log(request);
-            }
-            logger.logMessage = (...args) => this.logs.push(format(...args));
-            for (const method of ["debug", "log", "info", "warn", "error"]) {
-                console[method] = (...args) => {
-                    const renderer = this["renderer"] instanceof AIGNEListrRenderer ? this["renderer"] : undefined;
-                    const msg = format(...args);
-                    renderer ? renderer.log(msg) : this.logs.push(msg);
-                };
-            }
-            const _stream = await stream();
-            this.add({ task: () => this.extractStream(_stream) });
-            const result = await super.run().then(() => {
-                if (this.error)
-                    throw this.error;
-                return { ...this.result };
-            });
-            if (this.needLogResult) {
-                console.log(await this.myOptions.formatResult(this.result, { running: false, renderImage: true }));
-            }
-            return result;
-        }
-        finally {
-            logger.logMessage = originalLog;
-            Object.assign(console, originalConsole);
-            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;
-        }
-        catch (error) {
-            this.error = error;
-            throw error;
-        }
-    }
-}
-export class AIGNEListrRenderer extends DefaultRenderer {
-    static rendererOptions = {
-        ...DefaultRenderer.rendererOptions,
-    };
-    get _updater() {
-        return this["updater"];
-    }
-    get _logger() {
-        return this["logger"];
-    }
-    get _options() {
-        return this["options"];
-    }
-    get _spinner() {
-        return this["spinner"];
-    }
-    update() {
-        if (this.paused || this.ended) {
-            return;
-        }
-        this._updater(this.create({ running: true }));
-    }
-    paused = false;
-    ended = false;
-    end() {
-        this.ended = true;
-        super.end();
-    }
-    async pause() {
-        this.paused = true;
-        this._updater?.clear();
-        this._updater?.done();
-        await new Promise((resolve) => setTimeout(resolve, 100));
-        this._logger.process.release();
-    }
-    async resume() {
-        this._logger.process.hijack();
-        this.paused = false;
-    }
-    log(message) {
-        this._updater?.clear();
-        this._logger.toStdout(message);
-    }
-    isPreviousPrompt = false;
-    create({ running = false, ...options }) {
-        const logs = this._options.aigne?.getStdoutLogs?.();
-        if (logs?.length) {
-            this._updater.clear();
-            this._logger.toStdout(logs.join(EOL));
-        }
-        let buffer = "";
-        const prompt = super["renderPrompt"]();
-        if (prompt.length) {
-            buffer += prompt.join(EOL);
-            this.isPreviousPrompt = true;
-        }
-        // Skip a frame if previous render was a prompt, and reset the flag
-        else if (this.isPreviousPrompt) {
-            this.isPreviousPrompt = false;
-        }
-        else {
-            buffer += super.create({ ...options, prompt: false });
-            const bottomBar = this._options.aigne?.getBottomBarLogs?.({ running });
-            if (bottomBar?.length) {
-                buffer += EOL.repeat(2);
-                const output = [...bottomBar, running ? this._spinner.fetch() : ""]
-                    .map((i) => this._wrap(i))
-                    .join(EOL);
-                // If the task is not running, we show all lines
-                if (!running) {
-                    buffer += output;
-                }
-                // For running tasks, we only show the last few lines
-                else {
-                    const { rows } = process.stdout;
-                    const lines = rows - buffer.split(EOL).length - 2;
-                    buffer += output.split(EOL).slice(-Math.max(4, lines)).join(EOL);
-                }
-            }
-        }
-        return buffer;
-    }
-    _wrap(str) {
-        return wrap(str, process.stdout.columns ?? 80, {
-            hard: true,
-            trim: false,
-        });
-    }
-}
-export class AIGNEListrFallbackRenderer extends SimpleRenderer {
-    static rendererOptions = {
-        ...SimpleRenderer.rendererOptions,
-    };
-    get _logger() {
-        return this["logger"];
-    }
-    get _options() {
-        return this["options"];
-    }
-    end() {
-        const logs = [this._options.aigne?.getStdoutLogs?.(), this._options.aigne?.getBottomBarLogs?.()]
-            .filter(Boolean)
-            .flat()
-            .join(EOL);
-        if (logs)
-            this._logger.toStdout(logs);
-    }
-}

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

@@ -1,18 +0,0 @@
-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";
-export interface RunOptions extends AgentRunCommonOptions {
-    path: string;
-    entryAgent?: string;
-    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;
-    imageModelOptions?: ImageModelInputOptions & LoadCredentialOptions;
-    skipModelLoading?: boolean;
-    metadata?: AIGNEMetadata;
-}): Promise<AIGNE<import("@aigne/core").UserContext>>;

package/dist/utils/load-aigne.js

@@ -1,80 +0,0 @@
-import { createRequire } from "node:module";
-import { AIGNE, } from "@aigne/core";
-import { isNil, omitBy } from "@aigne/core/utils/type-utils.js";
-import boxen from "boxen";
-import chalk from "chalk";
-import { AIGNE_CLI_VERSION, availableMemories } from "../constants.js";
-import { loadChatModel, loadImageModel, maskApiKey } from "./aigne-hub/model.js";
-import { getUrlOrigin } from "./get-url-origin.js";
-export async function printChatModelInfoBox(model, otherLines) {
-    console.log(`${chalk.grey("TIPS:")} run ${chalk.cyan("aigne observe")} to start the observability server.\n`);
-    const credential = await model.credential;
-    const lines = [`${chalk.cyan("Provider")}: ${chalk.green(model.name.replace("ChatModel", ""))}`];
-    if (credential?.model) {
-        lines.push(`${chalk.cyan("Model")}: ${chalk.green(credential?.model)}`);
-    }
-    if (credential?.url) {
-        lines.push(`${chalk.cyan("API URL")}: ${chalk.green(getUrlOrigin(credential?.url) || "N/A")}`);
-    }
-    if (credential?.apiKey) {
-        lines.push(`${chalk.cyan("API Key")}: ${chalk.green(maskApiKey(credential?.apiKey))}`);
-    }
-    if (otherLines?.length)
-        lines.push(...otherLines);
-    console.log(boxen(lines.join("\n"), { padding: 1, borderStyle: "classic", borderColor: "cyan" }));
-    console.log("");
-}
-export async function loadAIGNE({ path, modelOptions, imageModelOptions, skipModelLoading = false, metadata, }) {
-    let aigne;
-    if (path) {
-        aigne = await AIGNE.load(path, {
-            require: async (modulePath, options) => {
-                if (!options.parent || modulePath.startsWith("@aigne/"))
-                    return import(modulePath);
-                const require = createRequire(options.parent);
-                return require(modulePath);
-            },
-            memories: availableMemories,
-            model: (options) => {
-                if (skipModelLoading)
-                    return undefined;
-                return loadChatModel({
-                    ...options,
-                    ...omitBy(modelOptions ?? {}, (v) => isNil(v)),
-                    model: modelOptions?.model || process.env.MODEL || options?.model,
-                });
-            },
-            imageModel: (options) => {
-                if (skipModelLoading)
-                    return undefined;
-                return loadImageModel({
-                    ...options,
-                    ...omitBy(imageModelOptions ?? {}, (v) => isNil(v)),
-                    model: imageModelOptions?.model || process.env.IMAGE_MODEL || options?.model,
-                });
-            },
-            afs: {
-                availableModules: [
-                    {
-                        module: "history",
-                        load: (options) => import("@aigne/afs-history").then((m) => m.AFSHistory.load(options)),
-                    },
-                    {
-                        module: "local-fs",
-                        alias: ["system-fs"],
-                        load: (options) => import("@aigne/afs-local-fs").then((m) => m.LocalFS.load(options)),
-                    },
-                ],
-            },
-            metadata: { ...metadata, cliVersion: AIGNE_CLI_VERSION },
-        });
-    }
-    else {
-        const chatModel = await loadChatModel({ ...modelOptions });
-        aigne = new AIGNE({
-            model: chatModel,
-            metadata: { ...metadata, cliVersion: AIGNE_CLI_VERSION },
-        });
-    }
-    return aigne;
-}

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

@@ -1,15 +0,0 @@
-import { type Message, type UserAgent } from "@aigne/core";
-export declare const DEFAULT_CHAT_INPUT_KEY = "message";
-export interface ChatLoopOptions {
-    userId?: string;
-    sessionId?: string;
-    initialCall?: Message | string;
-    welcome?: string;
-    defaultQuestion?: string;
-    inputKey?: string;
-    inputFileKey?: string;
-    outputKey?: string;
-    dataOutputKey?: string;
-    input?: Message;
-}
-export declare function runChatLoopInTerminal(userAgent: UserAgent<any, any>, options?: ChatLoopOptions): Promise<void>;

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

@@ -1,87 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { basename } from "node:path";
-import { ChatModel } from "@aigne/core";
-import { isNonNullable, omit } from "@aigne/core/utils/type-utils.js";
-import { TerminalTracer } from "../tracer/terminal.js";
-import { terminalInput } from "../ui/utils/terminal-input.js";
-export const DEFAULT_CHAT_INPUT_KEY = "message";
-export async function runChatLoopInTerminal(userAgent, options = {}) {
-    const { initialCall } = options;
-    if (initialCall) {
-        await callAgent(userAgent, initialCall, options);
-        if (options.input && options.inputFileKey) {
-            options.input = omit(options.input, options.inputFileKey);
-        }
-    }
-    for (let i = 0;; i++) {
-        const question = await terminalInput({
-            message: "💬",
-            default: i === 0 ? options?.defaultQuestion : undefined,
-            clear: true,
-        });
-        if (!question?.trim())
-            continue;
-        const cmd = COMMANDS[question.trim()];
-        if (cmd) {
-            const result = cmd();
-            if (result.message)
-                console.log(result.message);
-            if (result?.exit)
-                break;
-            continue;
-        }
-        const input = {};
-        if (options.inputFileKey) {
-            const { message, files } = await extractFilesFromQuestion(question);
-            input[options.inputKey || DEFAULT_CHAT_INPUT_KEY] = message;
-            input[options.inputFileKey] = files;
-        }
-        else {
-            input[options.inputKey || DEFAULT_CHAT_INPUT_KEY] = question;
-        }
-        await callAgent(userAgent, input, options);
-        if (options.input && options.inputFileKey) {
-            options.input = omit(options.input, options.inputFileKey);
-        }
-    }
-}
-async function extractFilesFromQuestion(question) {
-    const fileRegex = /@\S+/g;
-    const paths = question.match(fileRegex) || [];
-    const files = (await Promise.all(paths.map(async (path) => {
-        const p = path.slice(1);
-        const filename = basename(p);
-        const data = await readFile(p, "base64").catch((error) => {
-            if (error.code === "ENOENT")
-                return null;
-            throw error;
-        });
-        if (!data)
-            return;
-        return {
-            path,
-            file: { type: "file", data, filename, mimeType: await ChatModel.getMimeType(filename) },
-        };
-    }))).filter(isNonNullable);
-    // Remove file paths from question
-    for (const { path } of files) {
-        question = question.replaceAll(path, "");
-    }
-    return { message: question, files: files.map((i) => i.file) };
-}
-async function callAgent(userAgent, input, options) {
-    const tracer = new TerminalTracer(userAgent.context, options);
-    await tracer.run(userAgent, typeof input === "string"
-        ? { ...options.input, [options.inputKey || DEFAULT_CHAT_INPUT_KEY]: input }
-        : { ...options.input, ...input }, { userContext: { sessionId: options.sessionId, userId: options.userId } });
-}
-const COMMANDS = {
-    "/exit": () => ({ exit: true }),
-    "/help": () => ({
-        message: `\
-Commands:
-  /exit - exit the chat loop
-  /help - show this help message
-`,
-    }),
-};

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

@@ -1,27 +0,0 @@
-import { type Agent, type AIGNE, type ChatModelInputOptions, type Message } from "@aigne/core";
-import { type PromiseOrValue } from "@aigne/core/utils/type-utils.js";
-import { type ChatLoopOptions } from "./run-chat-loop.js";
-import { type AgentRunCommonOptions } from "./yargs.js";
-export declare function parseAgentInputByCommander(agent: Agent, options?: AgentRunCommonOptions & {
-    inputKey?: string;
-    argv?: string[];
-    defaultInput?: string | Message;
-}): Promise<Message>;
-export declare function loadAIGNEWithCmdOptions(): Promise<AIGNE<import("@aigne/core").UserContext>>;
-export declare function runWithAIGNE(agentCreator: ((aigne: AIGNE) => PromiseOrValue<Agent>) | Agent, { aigne, argv, chatLoopOptions, modelOptions, outputKey, }?: {
-    aigne?: AIGNE;
-    argv?: typeof process.argv;
-    chatLoopOptions?: ChatLoopOptions;
-    modelOptions?: ChatModelInputOptions;
-    outputKey?: string;
-}): Promise<void>;
-export declare function runAgentWithAIGNE(aigne: AIGNE, agent: Agent, { userId, sessionId, outputKey, outputFileKey, chatLoopOptions, ...options }?: {
-    userId?: string;
-    sessionId?: string;
-    outputKey?: string;
-    outputFileKey?: string;
-    chatLoopOptions?: ChatLoopOptions;
-    input?: Message;
-} & Omit<AgentRunCommonOptions, "input">): Promise<{
-    result: Message;
-} | undefined>;

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

@@ -1,157 +0,0 @@
-import { mkdir, stat, writeFile } from "node:fs/promises";
-import { dirname, isAbsolute, join } from "node:path";
-import { isatty } from "node:tty";
-import { fileURLToPath } from "node:url";
-import { startExplorer } from "@aigne/afs-explorer";
-import { exists } from "@aigne/agent-library/utils/fs.js";
-import { AIAgent, DEFAULT_OUTPUT_KEY, UserAgent, } from "@aigne/core";
-import { logger } from "@aigne/core/utils/logger.js";
-import { isEmpty, isNil, omitBy, pick } from "@aigne/core/utils/type-utils.js";
-import { v7 } from "@aigne/uuid";
-import chalk from "chalk";
-import { detect } from "detect-port";
-import yargs from "yargs";
-import { hideBin } from "yargs/helpers";
-import { DEFAULT_AFS_EXPLORER_PORT, DEFAULT_USER_ID } from "../constants.js";
-import { TerminalTracer } from "../tracer/terminal.js";
-import { loadAIGNE, printChatModelInfoBox } from "./load-aigne.js";
-import { DEFAULT_CHAT_INPUT_KEY, runChatLoopInTerminal, } from "./run-chat-loop.js";
-import { parseAgentInput, withAgentInputSchema, withRunAgentCommonOptions, } from "./yargs.js";
-export async function parseAgentInputByCommander(agent, options = {}) {
-    const args = await withAgentInputSchema(yargs(), agent)
-        .showHelpOnFail(false)
-        .fail(() => { })
-        .parseAsync(options.argv ?? process.argv);
-    const input = await parseAgentInput({ ...args, input: options.input || args.input }, agent);
-    if (isEmpty(input)) {
-        const defaultInput = options.defaultInput || process.env.INITIAL_CALL;
-        Object.assign(input, typeof defaultInput === "string"
-            ? {
-                [options?.inputKey ||
-                    (agent instanceof AIAgent ? agent.inputKey : undefined) ||
-                    DEFAULT_CHAT_INPUT_KEY]: defaultInput,
-            }
-            : defaultInput);
-    }
-    return input;
-}
-export async function loadAIGNEWithCmdOptions() {
-    const options = await withRunAgentCommonOptions(yargs())
-        .strict(false)
-        .parseAsync(hideBin(process.argv));
-    return await loadAIGNE({
-        modelOptions: {
-            ...omitBy(pick(options, "model", "temperature", "topP", "presencePenalty", "frequencyPenalty"), (v) => isNil(v)),
-        },
-    });
-}
-export async function runWithAIGNE(agentCreator, { aigne, argv = process.argv, chatLoopOptions, modelOptions, outputKey, } = {}) {
-    await yargs()
-        .command("$0", "Execute an AI agent using the AIGNE framework with specified configuration", (yargs) => withRunAgentCommonOptions(yargs), async (options) => {
-        if (options.logLevel) {
-            logger.level = options.logLevel;
-        }
-        aigne ??= await loadAIGNE({
-            modelOptions: {
-                ...modelOptions,
-                ...omitBy(pick(options, "model", "temperature", "topP", "presencePenalty", "frequencyPenalty"), (v) => isNil(v)),
-            },
-        });
-        let explorerServer;
-        let explorerServerURL;
-        try {
-            const agent = typeof agentCreator === "function" ? await agentCreator(aigne) : agentCreator;
-            const input = await parseAgentInputByCommander(agent, {
-                ...options,
-                inputKey: chatLoopOptions?.inputKey,
-                defaultInput: chatLoopOptions?.initialCall || chatLoopOptions?.defaultQuestion,
-            });
-            if (agent.afs) {
-                const port = await detect(DEFAULT_AFS_EXPLORER_PORT);
-                explorerServer = await startExplorer(agent.afs, {
-                    port,
-                    distPath: dirname(fileURLToPath(import.meta.resolve("@aigne/afs-explorer/index.html"))),
-                });
-                explorerServerURL = `http://localhost:${port}`;
-            }
-            if (aigne.model) {
-                const lines = [];
-                if (explorerServerURL) {
-                    lines.push(`${chalk.cyan("AFS Explorer")}: ${chalk.green(explorerServerURL)}`);
-                }
-                await printChatModelInfoBox(aigne.model, lines);
-            }
-            if (chatLoopOptions?.welcome)
-                console.log(chatLoopOptions.welcome);
-            await runAgentWithAIGNE(aigne, agent, {
-                ...options,
-                outputKey: outputKey || options.outputKey,
-                chatLoopOptions,
-                input,
-                sessionId: chatLoopOptions?.sessionId || v7(),
-                userId: DEFAULT_USER_ID,
-            });
-        }
-        finally {
-            await explorerServer?.stop();
-            await aigne.shutdown();
-        }
-    })
-        .alias("h", "help")
-        .alias("v", "version")
-        .fail((message, error, yargs) => {
-        if (!error)
-            yargs.showHelp();
-        console.error(`\n${message || error?.message}`);
-        process.exit(1);
-    })
-        .parseAsync(hideBin(argv))
-        .catch((error) => {
-        console.error(`${chalk.red("Error:")} ${error.message}`);
-        process.exit(1);
-    });
-}
-export async function runAgentWithAIGNE(aigne, agent, { userId, sessionId, outputKey, outputFileKey, chatLoopOptions, ...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.interactive) {
-        if (!isatty(process.stdout.fd)) {
-            throw new Error("--interactive mode requires a TTY terminal");
-        }
-        const userAgent = agent instanceof UserAgent ? agent : aigne.invoke(agent);
-        await runChatLoopInTerminal(userAgent, {
-            ...chatLoopOptions,
-            outputKey,
-            inputFileKey: agent instanceof AIAgent ? agent.inputFileKey : undefined,
-            input: options.input,
-            sessionId,
-            userId,
-        });
-        return;
-    }
-    const tracer = new TerminalTracer(aigne.newContext(), { outputKey, outputFileKey });
-    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 };
-}

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

@@ -1,9 +0,0 @@
-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;