@aigne/core 1.18.6 → 1.20.1

package/lib/cjs/aigne/context.js

@@ -11,7 +11,7 @@ const zod_1 = require("zod");
 const agent_js_1 = require("../agents/agent.js");
 const types_js_1 = require("../agents/types.js");
 const user_agent_js_1 = require("../agents/user-agent.js");
-const prompt_builder_js_1 = require("../prompt/prompt-builder.js");
+const event_stream_js_1 = require("../utils/event-stream.js");
 const promise_js_1 = require("../utils/promise.js");
 const stream_utils_js_1 = require("../utils/stream-utils.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
@@ -86,38 +86,54 @@ class AIGNEContext {
             });
         }
         const newContext = this.newContext();
-        const msg = (0, prompt_builder_js_1.createMessage)(message);
-        return Promise.resolve(newContext.internal.invoke(agent, msg, newContext, options)).then(async (response) => {
+        return Promise.resolve(newContext.internal.invoke(agent, message, newContext, options)).then(async (response) => {
             if (!options?.streaming) {
-                const { __activeAgent__: activeAgent, ...output } = await (0, stream_utils_js_1.agentResponseStreamToObject)(response);
+                let { __activeAgent__: activeAgent, ...output } = await (0, stream_utils_js_1.agentResponseStreamToObject)(response);
+                output = await this.onInvocationResult(output, options);
                 if (options?.returnActiveAgent) {
                     return [output, activeAgent];
                 }
                 return output;
             }
             const activeAgentPromise = (0, promise_js_1.promiseWithResolvers)();
-            const stream = (0, stream_utils_js_1.onAgentResponseStreamEnd)((0, stream_utils_js_1.asyncGeneratorToReadableStream)(response), async ({ __activeAgent__: activeAgent }) => {
-                activeAgentPromise.resolve(activeAgent);
-            }, {
-                processChunk(chunk) {
-                    if (chunk.delta.json) {
+            const stream = (0, stream_utils_js_1.onAgentResponseStreamEnd)((0, stream_utils_js_1.asyncGeneratorToReadableStream)(response), {
+                onChunk(chunk) {
+                    if ((0, agent_js_1.isAgentResponseDelta)(chunk) && chunk.delta.json) {
                         return {
                             ...chunk,
                             delta: {
                                 ...chunk.delta,
-                                json: (0, type_utils_js_1.omitBy)(chunk.delta.json, (_, k) => k === "__activeAgent__"),
+                                json: (0, type_utils_js_1.omit)(chunk.delta.json, "__activeAgent__"),
                             },
                         };
                     }
-                    return chunk;
+                },
+                onResult: async (output) => {
+                    activeAgentPromise.resolve(output.__activeAgent__);
+                    return await this.onInvocationResult(output, options);
                 },
             });
+            const finalStream = !options.returnProgressChunks
+                ? stream
+                : (0, stream_utils_js_1.mergeReadableStreams)(stream, new event_stream_js_1.AgentResponseProgressStream(newContext));
             if (options.returnActiveAgent) {
-                return [stream, activeAgentPromise.promise];
+                return [finalStream, activeAgentPromise.promise];
             }
-            return stream;
+            return finalStream;
         });
     });
+    async onInvocationResult(output, options) {
+        if (!options?.returnMetadata) {
+            return output;
+        }
+        return {
+            ...output,
+            $meta: {
+                ...output.$meta,
+                usage: this.usage,
+            },
+        };
+    }
     publish = ((topic, payload, options) => {
         if (options?.userContext) {
             Object.assign(this.userContext, options.userContext);
@@ -171,7 +187,6 @@ class AIGNEContextShared {
         this.memories = overrides?.memories ?? [];
     }
     messageQueue;
-    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
     events = new strict_event_emitter_1.Emitter();
     get model() {
         return this.parent?.model;
@@ -205,44 +220,54 @@ class AIGNEContextShared {
         return withAbortSignal(this.abortController.signal, new Error("AIGNEContext is timeout"), () => this.invokeAgent(agent, input, context, options));
     }
     async *invokeAgent(agent, input, context, options) {
-        let activeAgent = agent;
-        for (;;) {
-            const result = {};
-            if (options?.sourceAgent && activeAgent !== options.sourceAgent) {
-                options.sourceAgent.hooks.onHandoff?.({
-                    context,
-                    source: options.sourceAgent,
-                    target: activeAgent,
-                    input,
-                });
-            }
-            const stream = await activeAgent.invoke(input, { ...options, context, streaming: true });
-            for await (const value of stream) {
-                if (value.delta.json) {
-                    value.delta.json = omitExistsProperties(result, value.delta.json);
-                    Object.assign(result, value.delta.json);
+        const startedAt = Date.now();
+        try {
+            let activeAgent = agent;
+            for (;;) {
+                const result = {};
+                if (options?.sourceAgent && activeAgent !== options.sourceAgent) {
+                    options.sourceAgent.hooks.onHandoff?.({
+                        context,
+                        source: options.sourceAgent,
+                        target: activeAgent,
+                        input,
+                    });
                 }
-                delete value.delta.json?.[types_js_1.transferAgentOutputKey];
-                if ((0, agent_js_1.isEmptyChunk)(value))
-                    continue;
-                yield value;
-            }
-            if (!options?.disableTransfer) {
-                const transferToAgent = (0, types_js_1.isTransferAgentOutput)(result)
-                    ? result[types_js_1.transferAgentOutputKey].agent
-                    : undefined;
-                if (transferToAgent) {
-                    activeAgent = transferToAgent;
-                    continue;
+                const stream = await activeAgent.invoke(input, { ...options, context, streaming: true });
+                for await (const value of stream) {
+                    if ((0, agent_js_1.isAgentResponseDelta)(value)) {
+                        if (value.delta.json) {
+                            value.delta.json = omitExistsProperties(result, value.delta.json);
+                            Object.assign(result, value.delta.json);
+                        }
+                        delete value.delta.json?.[types_js_1.transferAgentOutputKey];
+                    }
+                    if ((0, agent_js_1.isEmptyChunk)(value))
+                        continue;
+                    yield value;
+                }
+                if (!options?.disableTransfer) {
+                    const transferToAgent = (0, types_js_1.isTransferAgentOutput)(result)
+                        ? result[types_js_1.transferAgentOutputKey].agent
+                        : undefined;
+                    if (transferToAgent) {
+                        activeAgent = transferToAgent;
+                        continue;
+                    }
                 }
+                break;
             }
-            break;
+            yield {
+                delta: {
+                    json: { __activeAgent__: activeAgent },
+                },
+            };
+        }
+        finally {
+            const endedAt = Date.now();
+            const duration = endedAt - startedAt;
+            this.usage.duration += duration;
         }
-        yield {
-            delta: {
-                json: { __activeAgent__: activeAgent },
-            },
-        };
     }
 }
 function omitExistsProperties(result, { ...delta }) {

package/lib/cjs/aigne/message-queue.d.ts

@@ -21,7 +21,7 @@ export interface MessagePayload {
 /**
  * @hidden
  */
-export declare function toMessagePayload(payload: Omit<MessagePayload, "context"> | string | Message, options?: Partial<Pick<MessagePayload, "role" | "source">>): Omit<MessagePayload, "context">;
+export declare function toMessagePayload(payload: Omit<MessagePayload, "context"> | Message, options?: Partial<Pick<MessagePayload, "role" | "source">>): Omit<MessagePayload, "context">;
 /**
  * @hidden
  */

package/lib/cjs/aigne/message-queue.js

@@ -4,7 +4,6 @@ exports.MessageQueue = exports.UserOutputTopic = exports.UserInputTopic = void 0
 exports.toMessagePayload = toMessagePayload;
 const strict_event_emitter_1 = require("strict-event-emitter");
 const zod_1 = require("zod");
-const prompt_builder_js_1 = require("../prompt/prompt-builder.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 /**
  * @hidden
@@ -28,12 +27,12 @@ function isMessagePayload(payload) {
  */
 function toMessagePayload(payload, options) {
     if (isMessagePayload(payload)) {
-        return { ...payload, message: (0, prompt_builder_js_1.createMessage)(payload.message), ...options };
+        return { ...payload, ...options };
     }
     return {
         role: options?.role || "user",
         source: options?.source,
-        message: (0, prompt_builder_js_1.createMessage)(payload),
+        message: payload,
     };
 }
 /**

package/lib/cjs/aigne/usage.d.ts

@@ -5,6 +5,7 @@ export interface ContextUsage {
     inputTokens: number;
     outputTokens: number;
     agentCalls: number;
+    duration: number;
 }
 /**
  * @hidden

package/lib/cjs/aigne/usage.js

@@ -9,5 +9,6 @@ function newEmptyContextUsage() {
         inputTokens: 0,
         outputTokens: 0,
         agentCalls: 0,
+        duration: 0,
     };
 }

package/lib/cjs/loader/agent-yaml.d.ts

@@ -5,11 +5,11 @@ export declare function loadAgentFromYamlFile(path: string): Promise<{
     name: string;
     description?: string | undefined;
     skills?: string[] | undefined;
-    instructions?: string | undefined;
     memory?: true | {
         provider: string;
         subscribeTopic?: string[] | undefined;
     } | undefined;
+    instructions?: string | undefined;
     inputSchema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
         [x: string]: any;
     }, {
@@ -20,6 +20,7 @@ export declare function loadAgentFromYamlFile(path: string): Promise<{
     }, {
         [x: string]: any;
     }> | undefined;
+    inputKey?: string | undefined;
     outputKey?: string | undefined;
     toolChoice?: AIAgentToolChoice | undefined;
 } | {

package/lib/cjs/loader/agent-yaml.js

@@ -21,6 +21,10 @@ const agentFileSchema = zod_1.z.discriminatedUnion("type", [
             .string()
             .nullish()
             .transform((v) => v ?? undefined),
+        input_key: zod_1.z
+            .string()
+            .nullish()
+            .transform((v) => v ?? undefined),
         input_schema: schema_js_1.inputOutputSchema
             .nullish()
             .transform((v) => (v ? (0, json_schema_to_zod_1.jsonSchemaToZod)(v) : undefined)),

package/lib/cjs/prompt/prompt-builder.d.ts

@@ -3,33 +3,19 @@ import { Agent, type AgentInvokeOptions, type Message } from "../agents/agent.js
 import type { AIAgent } from "../agents/ai-agent.js";
 import type { ChatModel, ChatModelInput } from "../agents/chat-model.js";
 import { ChatMessagesTemplate } from "./template.js";
-export declare const MESSAGE_KEY = "$message";
-export declare function createMessage<V extends Message>(message: string, variables?: V): {
-    [MESSAGE_KEY]: string;
-} & typeof variables;
-export declare function createMessage<I extends Message, V extends Message>(message: I, variables?: V): I & typeof variables;
-export declare function createMessage<I extends Message, V extends Message>(message: string | I, variables?: V): ({
-    [MESSAGE_KEY]: string;
-} | I) & typeof variables;
-export declare function getMessage(input: Message): string | undefined;
 export interface PromptBuilderOptions {
     instructions?: string | ChatMessagesTemplate;
 }
 export interface PromptBuildOptions extends Pick<AgentInvokeOptions, "context"> {
-    agent?: AIAgent;
+    agent?: AIAgent<any, any, any>;
     input?: Message;
     model?: ChatModel;
     outputSchema?: Agent["outputSchema"];
 }
 export declare class PromptBuilder {
-    static from(instructions: string): PromptBuilder;
-    static from(instructions: GetPromptResult): PromptBuilder;
-    static from(instructions: {
-        path: string;
-    }): Promise<PromptBuilder>;
     static from(instructions: string | {
         path: string;
-    } | GetPromptResult): PromptBuilder | Promise<PromptBuilder>;
+    } | GetPromptResult): PromptBuilder;
     private static fromFile;
     private static fromMCPPromptResult;
     constructor(options?: PromptBuilderOptions);

package/lib/cjs/prompt/prompt-builder.js

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PromptBuilder = exports.MESSAGE_KEY = void 0;
-exports.createMessage = createMessage;
-exports.getMessage = getMessage;
+exports.PromptBuilder = void 0;
 const index_js_1 = require("@aigne/platform-helpers/nodejs/index.js");
 const yaml_1 = require("yaml");
 const zod_1 = require("zod");
@@ -11,20 +9,6 @@ const json_schema_js_1 = require("../utils/json-schema.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const memory_message_template_js_1 = require("./prompts/memory-message-template.js");
 const template_js_1 = require("./template.js");
-exports.MESSAGE_KEY = "$message";
-function createMessage(message, variables) {
-    return (typeof message === "string"
-        ? { [exports.MESSAGE_KEY]: message, ...variables }
-        : { ...message, ...variables });
-}
-function getMessage(input) {
-    const userInputMessage = input[exports.MESSAGE_KEY];
-    if (typeof userInputMessage === "string")
-        return userInputMessage;
-    if (!(0, type_utils_js_1.isNil)(userInputMessage))
-        return JSON.stringify(userInputMessage);
-    return undefined;
-}
 class PromptBuilder {
     static from(instructions) {
         if (typeof instructions === "string")
@@ -35,8 +19,8 @@ class PromptBuilder {
             return PromptBuilder.fromFile(instructions.path);
         throw new Error(`Invalid instructions ${instructions}`);
     }
-    static async fromFile(path) {
-        const text = await index_js_1.nodejs.fs.readFile(path, "utf-8");
+    static fromFile(path) {
+        const text = index_js_1.nodejs.fsSync.readFileSync(path, "utf-8");
         return PromptBuilder.from(text);
     }
     static fromMCPPromptResult(result) {
@@ -80,22 +64,25 @@ class PromptBuilder {
     }
     async buildMessages(options) {
         const { input } = options;
+        const inputKey = options.agent?.inputKey;
+        const message = inputKey && typeof input?.[inputKey] === "string" ? input[inputKey] : undefined;
         const messages = (typeof this.instructions === "string"
             ? template_js_1.ChatMessagesTemplate.from([template_js_1.SystemMessageTemplate.from(this.instructions)])
             : this.instructions)?.format(options.input) ?? [];
         const memories = [];
-        if (options.agent) {
-            memories.push(...(await options.agent.retrieveMemories({ search: options.input }, options)));
+        if (options.agent?.inputKey) {
+            memories.push(...(await options.agent.retrieveMemories({ search: message }, options)));
         }
         if (options.context.memories?.length) {
             memories.push(...options.context.memories);
         }
         if (memories.length)
             messages.push(...this.convertMemoriesToMessages(memories, options));
-        const content = input && getMessage(input);
-        // add user input if it's not the same as the last message
-        if (content && messages.at(-1)?.content !== content) {
-            messages.push({ role: "user", content });
+        if (message) {
+            messages.push({
+                role: "user",
+                content: message,
+            });
         }
         return messages;
     }

package/lib/cjs/utils/event-stream.d.ts

@@ -1,4 +1,5 @@
-import type { AgentResponseChunk, AgentResponseStream, Message } from "../agents/agent.js";
+import { type AgentResponseChunk, type AgentResponseProgress, type AgentResponseStream, type Message } from "../agents/agent.js";
+import type { Context } from "../aigne/context.js";
 export declare class EventStreamParser<T> extends TransformStream<string, T | Error> {
     constructor();
 }
@@ -9,3 +10,6 @@ export declare class AgentResponseStreamParser<O extends Message> extends Transf
 export declare class AgentResponseStreamSSE<O extends Message> extends ReadableStream<string> {
     constructor(stream: AgentResponseStream<O>);
 }
+export declare class AgentResponseProgressStream extends ReadableStream<AgentResponseProgress> {
+    constructor(context: Context);
+}

package/lib/cjs/utils/event-stream.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentResponseStreamSSE = exports.AgentResponseStreamParser = exports.EventStreamParser = void 0;
+exports.AgentResponseProgressStream = exports.AgentResponseStreamSSE = exports.AgentResponseStreamParser = exports.EventStreamParser = void 0;
 const eventsource_parser_1 = require("eventsource-parser");
 const immer_1 = require("immer");
+const agent_js_1 = require("../agents/agent.js");
 const type_utils_js_1 = require("./type-utils.js");
 class EventStreamParser extends TransformStream {
     constructor() {
@@ -15,11 +16,16 @@ class EventStreamParser extends TransformStream {
                             controller.enqueue(new Error(`Parse response chunk json error: ${e.message} ${event.data}`));
                         });
                         if (json) {
-                            if (event.event === "error") {
-                                controller.enqueue(new Error(json.message));
-                            }
-                            else {
-                                controller.enqueue(json);
+                            switch (event.event) {
+                                case "error":
+                                    controller.enqueue(new Error(json.message));
+                                    break;
+                                default: {
+                                    if (!event.event)
+                                        controller.enqueue(json);
+                                    else
+                                        console.warn(`Unknown event type: ${event.event}`, event.data);
+                                }
                             }
                         }
                     },
@@ -42,25 +48,35 @@ class AgentResponseStreamParser extends TransformStream {
                     controller.terminate();
                     return;
                 }
-                this.json = (0, immer_1.produce)(this.json, (draft) => {
-                    if (chunk.delta.json)
-                        Object.assign(draft, chunk.delta.json);
-                    if (chunk.delta.text) {
-                        for (const [key, text] of Object.entries(chunk.delta.text)) {
-                            const original = draft[key];
-                            const t = (original || "") + (text || "");
-                            if (t)
-                                Object.assign(draft, { [key]: t });
+                if ((0, agent_js_1.isAgentResponseDelta)(chunk)) {
+                    this.json = (0, immer_1.produce)(this.json, (draft) => {
+                        if (chunk.delta.json)
+                            Object.assign(draft, chunk.delta.json);
+                        if (chunk.delta.text) {
+                            for (const [key, text] of Object.entries(chunk.delta.text)) {
+                                const original = draft[key];
+                                const t = (original || "") + (text || "");
+                                if (t)
+                                    Object.assign(draft, { [key]: t });
+                            }
                         }
+                    });
+                    controller.enqueue({
+                        ...chunk,
+                        delta: {
+                            ...chunk.delta,
+                            json: this.json,
+                        },
+                    });
+                }
+                else if ((0, agent_js_1.isAgentResponseProgress)(chunk)) {
+                    if (chunk.progress.event === "agentFailed") {
+                        const { name, message } = chunk.progress.error;
+                        chunk.progress.error = new Error(message);
+                        chunk.progress.error.name = name;
                     }
-                });
-                controller.enqueue({
-                    ...chunk,
-                    delta: {
-                        ...chunk.delta,
-                        json: this.json,
-                    },
-                });
+                    controller.enqueue(chunk);
+                }
             },
         });
     }
@@ -78,6 +94,14 @@ class AgentResponseStreamSSE extends ReadableStream {
                         controller.close();
                         return;
                     }
+                    if ((0, agent_js_1.isAgentResponseProgress)(value)) {
+                        if (value.progress.event === "agentFailed") {
+                            value.progress.error = {
+                                name: value.progress.error.name,
+                                message: value.progress.error.message,
+                            };
+                        }
+                    }
                     controller.enqueue(`data: ${JSON.stringify(value)}\n\n`);
                 }
                 catch (error) {
@@ -89,3 +113,44 @@ class AgentResponseStreamSSE extends ReadableStream {
     }
 }
 exports.AgentResponseStreamSSE = AgentResponseStreamSSE;
+class AgentResponseProgressStream extends ReadableStream {
+    constructor(context) {
+        super({
+            async start(controller) {
+                const writeEvent = (eventName, event) => {
+                    const progress = {
+                        ...event,
+                        event: eventName,
+                        agent: { name: event.agent.name },
+                    };
+                    controller.enqueue({ progress });
+                };
+                const close = () => {
+                    context.off("agentStarted", onAgentStarted);
+                    context.off("agentSucceed", onAgentSucceed);
+                    context.off("agentFailed", onAgentFailed);
+                    controller.close();
+                };
+                const onAgentStarted = (event) => {
+                    writeEvent("agentStarted", event);
+                };
+                const onAgentSucceed = (event) => {
+                    writeEvent("agentSucceed", event);
+                    if (event.contextId === context.id) {
+                        close();
+                    }
+                };
+                const onAgentFailed = (event) => {
+                    writeEvent("agentFailed", event);
+                    if (event.contextId === context.id) {
+                        close();
+                    }
+                };
+                context.on("agentStarted", onAgentStarted);
+                context.on("agentSucceed", onAgentSucceed);
+                context.on("agentFailed", onAgentFailed);
+            },
+        });
+    }
+}
+exports.AgentResponseProgressStream = AgentResponseProgressStream;

package/lib/cjs/utils/stream-utils.d.ts

@@ -1,15 +1,15 @@
 import { type AgentProcessAsyncGenerator, type AgentResponseChunk, type AgentResponseStream, type Message } from "../agents/agent.js";
-import type { MESSAGE_KEY } from "../prompt/prompt-builder.js";
 import { type PromiseOrValue } from "./type-utils.js";
 import "./stream-polyfill.js";
 export declare function objectToAgentResponseStream<T extends Message>(json: T): AgentResponseStream<T>;
 export declare function mergeAgentResponseChunk<T extends Message>(output: T, chunk: AgentResponseChunk<T>): T;
 export declare function agentResponseStreamToObject<T extends Message>(stream: AgentResponseStream<T> | AgentProcessAsyncGenerator<T>): Promise<T>;
 export declare function asyncGeneratorToReadableStream<T extends Message>(generator: AgentProcessAsyncGenerator<T>): AgentResponseStream<T>;
-export declare function onAgentResponseStreamEnd<T extends Message>(stream: AgentResponseStream<T>, callback: (result: T) => PromiseOrValue<Partial<T> | void>, options?: {
-    errorCallback?: (error: Error) => PromiseOrValue<Error>;
-    processChunk?: (chunk: AgentResponseChunk<T>) => AgentResponseChunk<T>;
-}): ReadableStream<any>;
+export declare function onAgentResponseStreamEnd<T extends Message>(stream: AgentResponseStream<T>, options?: {
+    onChunk?: (chunk: AgentResponseChunk<T>) => PromiseOrValue<AgentResponseChunk<T> | undefined | void>;
+    onResult?: (result: T) => PromiseOrValue<Partial<T> | undefined | void>;
+    onError?: (error: Error) => PromiseOrValue<Error>;
+}): AgentResponseStream<T>;
 export declare function isAsyncGenerator<T extends AsyncGenerator>(value: AsyncGenerator | unknown): value is T;
 export declare function arrayToAgentProcessAsyncGenerator<T extends Message>(chunks: (AgentResponseChunk<T> | Error)[], result?: Partial<T>): AgentProcessAsyncGenerator<T>;
 export declare function arrayToReadableStream<T>(chunks: (T | Error)[]): ReadableStream<T>;
@@ -17,8 +17,10 @@ export declare function readableStreamToArray<T>(stream: ReadableStream<T>, opti
     catchError: true;
 }): Promise<(T | Error)[]>;
 export declare function readableStreamToArray<T>(stream: ReadableStream<T>, options?: {
-    catchError?: false;
+    catchError?: boolean;
 }): Promise<T[]>;
-export declare function stringToAgentResponseStream(str: string, key?: "text" | typeof MESSAGE_KEY | string): AgentResponseStream<Message>;
+export declare function stringToAgentResponseStream(str: string, key?: "text" | string): AgentResponseStream<Message>;
 export declare function toReadableStream(stream: NodeJS.ReadStream): ReadableStream<Uint8Array<ArrayBufferLike>>;
 export declare function readAllString(stream: NodeJS.ReadStream | ReadableStream): Promise<string>;
+export declare function mergeReadableStreams<T1, T2>(s1: ReadableStream<T1>, s2: ReadableStream<T2>): ReadableStream<T1 | T2>;
+export declare function mergeReadableStreams(...streams: ReadableStream<any>[]): ReadableStream<any>;