@aigne/cli 1.53.1-beta.2 → 1.53.1-beta.3

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

@@ -1,89 +0,0 @@
-import assert from "node:assert";
-import { findCliAgent, mapCliAgent } from "@aigne/core/utils/agent-utils.js";
-import { logger } from "@aigne/core/utils/logger.js";
-import { loadAIGNE } from "../load-aigne.js";
-import { runAgentWithAIGNE } from "../run-with-aigne.js";
-import { parseAgentInput } from "../yargs.js";
-import { serializeAgent, } from "./run-aigne-in-child-process.js";
-const METHODS = {
-    loadAIGNE: loadAIGNEInChildProcess,
-    invokeCLIAgentFromDir: invokeCLIAgentFromDirInChildProcess,
-};
-process.on("message", async ({ method, args, ...options }) => {
-    if (options.logLevel)
-        logger.level = options.logLevel;
-    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: { name: error.name, message: error.message, stack: error.stack },
-        });
-    }
-    finally {
-        process.exit(0);
-    }
-});
-export async function loadAIGNEInChildProcess(options) {
-    const aigne = await loadAIGNE(options);
-    return {
-        agents: aigne.agents.map(serializeAgent),
-        cli: {
-            chat: aigne.cli.chat ? serializeAgent(aigne.cli.chat) : undefined,
-            agents: aigne.cli.agents?.map((item) => mapCliAgent(item, serializeAgent)),
-        },
-        mcpServer: {
-            agents: aigne.mcpServer.agents.map(serializeAgent),
-        },
-    };
-}
-export async function invokeCLIAgentFromDirInChildProcess(options) {
-    const aigne = await loadAIGNE({
-        path: options.dir,
-        modelOptions: options.input,
-        printTips: true,
-        imageModelOptions: { model: options.input.imageModel },
-        metadata: options.metadata,
-    });
-    try {
-        const { chat } = aigne.cli;
-        let agent;
-        if (chat && chat.name === options.agent) {
-            agent = chat;
-        }
-        else if (options.parent) {
-            agent = findCliAgent(aigne.cli, options.parent, options.agent);
-        }
-        else {
-            agent =
-                findCliAgent(aigne.cli, [], 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: options.input.chat,
-        });
-    }
-    finally {
-        await aigne.shutdown();
-    }
-}

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

@@ -1,19 +0,0 @@
-import type { Agent } from "@aigne/core";
-import type { AIGNECLIAgent } from "@aigne/core/aigne/type.js";
-import type { JsonSchema } from "@aigne/json-schema-to-zod";
-import type { invokeCLIAgentFromDirInChildProcess, loadAIGNEInChildProcess } from "./run-aigne-in-child-process-worker.js";
-export type LoadAIGNEInChildProcessResult = Awaited<ReturnType<typeof loadAIGNEInChildProcess>>;
-export interface AgentInChildProcess extends Pick<Agent, "name" | "description" | "alias"> {
-    inputSchema: JsonSchema;
-    outputSchema: JsonSchema;
-}
-export interface CLIAgentInChildProcess extends Omit<AIGNECLIAgent, "agent" | "agents"> {
-    agent?: AgentInChildProcess;
-    agents?: CLIAgentInChildProcess[];
-}
-export declare function serializeAgent(agent: Agent): AgentInChildProcess;
-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

@@ -1,41 +0,0 @@
-import { fork } from "node:child_process";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { logger } from "@aigne/core/utils/logger.js";
-import { zodToJsonSchema } from "zod-to-json-schema";
-export function serializeAgent(agent) {
-    return {
-        name: agent.name,
-        description: agent.description,
-        alias: agent.alias,
-        inputSchema: zodToJsonSchema(agent.inputSchema),
-        outputSchema: zodToJsonSchema(agent.outputSchema),
-    };
-}
-export async function runAIGNEInChildProcess(method, ...args) {
-    return await new Promise((resolve, reject) => {
-        let completed = false;
-        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) {
-                const e = new Error(event.error.message);
-                e.name = event.error.name;
-                e.stack = event.error.stack;
-                reject(e);
-            }
-            else {
-                resolve(event.result);
-            }
-            completed = true;
-        });
-        child.on("exit", (code) => {
-            if (!completed)
-                process.exit(code);
-            reject(new Error(`Child process exited with code ${code}`));
-        });
-        child.send({ method, args, logLevel: logger.level });
-    });
-}