@aigne/core 1.29.1 → 1.32.0

package/lib/esm/prompt/template.js

@@ -1,5 +1,12 @@
-import Mustache from "mustache";
+import { nodejs } from "@aigne/platform-helpers/nodejs/index.js";
+import nunjucks from "nunjucks";
 import { z } from "zod";
+import { isNil } from "../utils/type-utils.js";
+nunjucks.runtime.suppressValue = (v) => {
+    if (isNil(v))
+        return "";
+    return typeof v === "object" ? JSON.stringify(v) : v;
+};
 export class PromptTemplate {
     template;
     static from(template) {
@@ -8,12 +15,42 @@ export class PromptTemplate {
     constructor(template) {
         this.template = template;
     }
-    format(variables) {
-        return Mustache.render(this.template, variables, undefined, {
-            escape: (v) => {
-                return typeof v === "object" ? JSON.stringify(v) : v;
-            },
+    async format(variables = {}, options) {
+        let env = new nunjucks.Environment();
+        if (options?.workingDir) {
+            env = new nunjucks.Environment(new CustomLoader({ workingDir: options.workingDir }));
+        }
+        return new Promise((resolve, reject) => env.renderString(this.template, variables, (err, res) => {
+            if (err || !res) {
+                reject(err || new Error(`Failed to render template: ${this.template}`));
+            }
+            else {
+                resolve(res);
+            }
+        }));
+    }
+}
+export class CustomLoader extends nunjucks.Loader {
+    options;
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    async = true;
+    getSource(name, callback) {
+        let result = null;
+        nodejs.fs.readFile(nodejs.path.join(this.options.workingDir, name), "utf-8").then((content) => {
+            result = {
+                src: content,
+                path: name,
+                noCache: true,
+            };
+            callback(null, result);
+        }, (error) => {
+            callback(error, null);
         });
+        // nunjucks expects return LoaderSource synchronously, but we handle it asynchronously.
+        return result;
     }
 }
 export class ChatMessageTemplate {
@@ -25,17 +62,17 @@ export class ChatMessageTemplate {
         this.content = content;
         this.name = name;
     }
-    format(variables) {
+    async format(variables, options) {
         let { content } = this;
         if (Array.isArray(content)) {
-            content = content.map((i) => {
+            content = await Promise.all(content.map(async (i) => {
                 if (i.type === "text")
-                    return { ...i, text: PromptTemplate.from(i.text).format(variables) };
+                    return { ...i, text: await PromptTemplate.from(i.text).format(variables, options) };
                 return i;
-            });
+            }));
         }
         else if (typeof content === "string") {
-            content = PromptTemplate.from(content).format(variables);
+            content = await PromptTemplate.from(content).format(variables, options);
         }
         return {
             role: this.role,
@@ -63,9 +100,9 @@ export class AgentMessageTemplate extends ChatMessageTemplate {
         super("agent", content, name);
         this.toolCalls = toolCalls;
     }
-    format(variables) {
+    async format(variables, options) {
         return {
-            ...super.format(variables),
+            ...(await super.format(variables, options)),
             toolCalls: this.toolCalls,
         };
     }
@@ -81,9 +118,9 @@ export class ToolMessageTemplate extends ChatMessageTemplate {
             : JSON.stringify(content, (_, value) => typeof value === "bigint" ? value.toString() : value), name);
         this.toolCallId = toolCallId;
     }
-    format(variables) {
+    async format(variables, options) {
         return {
-            ...super.format(variables),
+            ...(await super.format(variables, options)),
             toolCallId: this.toolCallId,
         };
     }
@@ -96,8 +133,8 @@ export class ChatMessagesTemplate {
     constructor(messages) {
         this.messages = messages;
     }
-    format(variables) {
-        return this.messages.map((message) => message.format(variables));
+    async format(variables, options) {
+        return Promise.all(this.messages.map((message) => message.format(variables, options)));
     }
 }
 const systemChatMessageSchema = z.object({

package/lib/esm/utils/mcp-utils.d.ts

@@ -1,4 +1,4 @@
-import { type ListPromptsResult, type ListResourceTemplatesResult, type ListResourcesResult, type ListToolsResult } from "@modelcontextprotocol/sdk/types.js";
+import { type ListPromptsResult, type ListResourcesResult, type ListResourceTemplatesResult, type ListToolsResult } from "@modelcontextprotocol/sdk/types.js";
 import { type MCPBaseOptions, MCPPrompt, MCPResource, MCPTool } from "../agents/mcp-agent.js";
 export declare function toolFromMCPTool(tool: ListToolsResult["tools"][number], options: MCPBaseOptions): MCPTool;
 export declare function promptFromMCPPrompt(prompt: ListPromptsResult["prompts"][number], options: MCPBaseOptions): MCPPrompt;

package/lib/esm/utils/stream-utils.js

@@ -1,8 +1,11 @@
 import equal from "fast-deep-equal";
 import { isAgentResponseDelta, isEmptyChunk, } from "../agents/agent.js";
-import { omitBy } from "./type-utils.js";
+import { isRecord, omitBy } from "./type-utils.js";
 import "./stream-polyfill.js";
 export function objectToAgentResponseStream(json) {
+    if (!isRecord(json)) {
+        throw new Error(`expect to return a record type such as {result: ...}, but got (${typeof json}): ${json}`);
+    }
     return new ReadableStream({
         pull(controller) {
             controller.enqueue({ delta: { json } });

package/lib/esm/utils/structured-stream-extractor.d.ts

@@ -0,0 +1,14 @@
+import { type AgentResponseChunk } from "../agents/agent.js";
+import type { ChatModelOutput } from "../agents/chat-model.js";
+export declare class ExtractMetadataTransform extends TransformStream<AgentResponseChunk<ChatModelOutput>, AgentResponseChunk<ChatModelOutput & {
+    metadata?: string;
+}>> {
+    private buffer;
+    private cursor;
+    private state;
+    constructor({ start, end, parse, }: {
+        start: string;
+        end: string;
+        parse: (raw: string) => object;
+    });
+}

package/lib/esm/utils/structured-stream-extractor.js

@@ -0,0 +1,56 @@
+import { isAgentResponseDelta } from "../agents/agent.js";
+export class ExtractMetadataTransform extends TransformStream {
+    buffer = "";
+    cursor = 0;
+    state = "none";
+    constructor({ start, end, parse, }) {
+        super({
+            transform: async (chunk, controller) => {
+                if (isAgentResponseDelta(chunk) && chunk.delta.text?.text) {
+                    const text = chunk.delta.text.text;
+                    this.buffer += text;
+                    for (;;) {
+                        if (this.state === "none") {
+                            const found = findMatchIndex(this.buffer, this.cursor, start);
+                            if (found.start > this.cursor) {
+                                const text = this.buffer.slice(this.cursor, found.start);
+                                this.cursor = found.start;
+                                controller.enqueue({ delta: { text: { text } } });
+                            }
+                            if (found.end) {
+                                this.state = "start";
+                                this.cursor = found.end;
+                            }
+                        }
+                        if (this.state === "start") {
+                            const found = findMatchIndex(this.buffer, this.cursor, end);
+                            if (found.end) {
+                                const metadata = this.buffer.slice(this.cursor, found.start);
+                                const json = parse(metadata);
+                                controller.enqueue({ delta: { json: { json } } });
+                                this.state = "none";
+                                this.cursor = found.end;
+                                continue;
+                            }
+                        }
+                        break;
+                    }
+                    return;
+                }
+                controller.enqueue(chunk);
+            },
+        });
+    }
+}
+function findMatchIndex(str, position, match) {
+    const i = str.indexOf(match, position);
+    if (i >= 0)
+        return { start: i, end: i + match.length };
+    for (let i = match.length - 1; i > 0; i--) {
+        const m = match.slice(0, i);
+        if (str.endsWith(m)) {
+            return { start: str.length - m.length };
+        }
+    }
+    return { start: str.length };
+}

package/lib/esm/utils/type-utils.d.ts

@@ -19,7 +19,7 @@ export declare function pick<T extends object, K extends keyof T>(obj: T, ...key
 export declare function omit<T extends object, K extends keyof T>(obj: T, ...keys: (K | K[])[]): Omit<T, K>;
 export declare function omitDeep<T, K>(obj: T, ...keys: (K | K[])[]): unknown;
 export declare function omitBy<T extends Record<string, unknown>, K extends keyof T>(obj: T, predicate: (value: T[K], key: K) => boolean): Partial<T>;
-export declare function orArrayToArray<T>(value?: T | T[]): T[];
+export declare function flat<T>(value?: T | T[]): T[];
 export declare function createAccessorArray<T>(array: T[], accessor: (array: T[], name: string) => T | undefined): T[] & {
     [key: string]: T;
 };

package/lib/esm/utils/type-utils.js

@@ -37,7 +37,7 @@ export function duplicates(arr, key = (item) => item) {
 export function remove(arr, remove) {
     const removed = [];
     for (let i = 0; i < arr.length; i++) {
-        // biome-ignore lint/style/noNonNullAssertion: <explanation>
+        // biome-ignore lint/style/noNonNullAssertion: false positive
         const item = arr[i];
         if ((Array.isArray(remove) && remove.includes(item)) ||
             (typeof remove === "function" && remove(item))) {
@@ -84,7 +84,7 @@ export function omitBy(obj, predicate) {
         return !predicate(value, k);
     }));
 }
-export function orArrayToArray(value) {
+export function flat(value) {
     if (isNil(value))
         return [];
     return Array.isArray(value) ? value : [value];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/core",
-  "version": "1.29.1",
+  "version": "1.32.0",
   "description": "AIGNE core library for building AI-powered applications",
   "publishConfig": {
     "access": "public"
@@ -63,35 +63,37 @@
   },
   "dependencies": {
     "@aigne/json-schema-to-zod": "^1.3.3",
-    "@modelcontextprotocol/sdk": "^1.11.0",
+    "@modelcontextprotocol/sdk": "^1.13.3",
     "@types/debug": "^4.1.12",
     "camelize-ts": "^3.0.0",
     "content-type": "^1.0.5",
-    "debug": "^4.4.0",
-    "eventsource-parser": "^3.0.1",
+    "debug": "^4.4.1",
+    "eventsource-parser": "^3.0.3",
     "fast-deep-equal": "^3.1.3",
     "immer": "^10.1.1",
     "jsonata": "^2.0.6",
     "mustache": "^4.2.0",
     "nanoid": "^5.1.5",
+    "nunjucks": "^3.2.4",
     "p-retry": "^6.2.1",
     "raw-body": "^3.0.0",
     "strict-event-emitter": "^0.5.1",
     "ufo": "^1.6.1",
     "uuid": "^11.1.0",
-    "yaml": "^2.7.1",
-    "zod": "^3.24.4",
-    "zod-to-json-schema": "^3.24.5",
-    "@aigne/platform-helpers": "^0.1.2",
-    "@aigne/observability-api": "^0.3.3"
+    "yaml": "^2.8.0",
+    "zod": "^3.25.67",
+    "zod-to-json-schema": "^3.24.6",
+    "@aigne/observability-api": "^0.6.0",
+    "@aigne/platform-helpers": "^0.3.0"
   },
   "devDependencies": {
-    "@types/bun": "^1.2.12",
-    "@types/compression": "^1.7.5",
-    "@types/content-type": "^1.1.8",
-    "@types/express": "^5.0.1",
+    "@types/bun": "^1.2.17",
+    "@types/compression": "^1.8.1",
+    "@types/content-type": "^1.1.9",
+    "@types/express": "^5.0.3",
     "@types/mustache": "^4.2.6",
-    "@types/node": "^22.15.15",
+    "@types/node": "^24.0.10",
+    "@types/nunjucks": "^3.2.6",
     "compression": "^1.8.0",
     "detect-port": "^2.1.0",
     "express": "^5.1.0",