@aigne/core 1.19.0 → 1.20.1

package/lib/esm/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/esm/loader/agent-yaml.js

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

package/lib/esm/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/esm/prompt/prompt-builder.js

@@ -3,23 +3,9 @@ import { stringify } from "yaml";
 import { ZodObject } from "zod";
 import { Agent } from "../agents/agent.js";
 import { outputSchemaToResponseFormatSchema } from "../utils/json-schema.js";
-import { isNil, unique } from "../utils/type-utils.js";
+import { unique } from "../utils/type-utils.js";
 import { MEMORY_MESSAGE_TEMPLATE } from "./prompts/memory-message-template.js";
 import { AgentMessageTemplate, ChatMessagesTemplate, PromptTemplate, SystemMessageTemplate, UserMessageTemplate, } from "./template.js";
-export const MESSAGE_KEY = "$message";
-export function createMessage(message, variables) {
-    return (typeof message === "string"
-        ? { [MESSAGE_KEY]: message, ...variables }
-        : { ...message, ...variables });
-}
-export function getMessage(input) {
-    const userInputMessage = input[MESSAGE_KEY];
-    if (typeof userInputMessage === "string")
-        return userInputMessage;
-    if (!isNil(userInputMessage))
-        return JSON.stringify(userInputMessage);
-    return undefined;
-}
 export class PromptBuilder {
     static from(instructions) {
         if (typeof instructions === "string")
@@ -30,8 +16,8 @@ export class PromptBuilder {
             return PromptBuilder.fromFile(instructions.path);
         throw new Error(`Invalid instructions ${instructions}`);
     }
-    static async fromFile(path) {
-        const text = await nodejs.fs.readFile(path, "utf-8");
+    static fromFile(path) {
+        const text = nodejs.fsSync.readFileSync(path, "utf-8");
         return PromptBuilder.from(text);
     }
     static fromMCPPromptResult(result) {
@@ -75,22 +61,25 @@ export 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"
             ? ChatMessagesTemplate.from([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/esm/utils/stream-utils.d.ts

@@ -1,5 +1,4 @@
 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>;
@@ -20,7 +19,7 @@ export declare function readableStreamToArray<T>(stream: ReadableStream<T>, opti
 export declare function readableStreamToArray<T>(stream: ReadableStream<T>, options?: {
     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>;

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

@@ -16,6 +16,7 @@ export declare function duplicates<T>(arr: T[], key?: (item: T) => unknown): T[]
 export declare function remove<T>(arr: T[], remove: T[] | ((item: T) => boolean)): T[];
 export declare function unique<T>(arr: T[], key?: (item: T) => unknown): T[];
 export declare function omit<T extends Record<string, unknown>, 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 createAccessorArray<T>(array: T[], accessor: (array: T[], name: string) => T | undefined): T[] & {

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

@@ -62,6 +62,18 @@ export function omit(obj, ...keys) {
     const flattenedKeys = new Set(keys.flat());
     return Object.fromEntries(Object.entries(obj).filter(([key]) => !flattenedKeys.has(key)));
 }
+export function omitDeep(obj, ...keys) {
+    if (Array.isArray(obj)) {
+        return obj.map((item) => omitDeep(item, ...keys));
+    }
+    if (isRecord(obj)) {
+        const flattenedKeys = new Set(keys.flat());
+        return Object.fromEntries(Object.entries(obj)
+            .filter(([key]) => !flattenedKeys.has(key))
+            .map(([key, value]) => [key, omitDeep(value, ...keys)]));
+    }
+    return obj;
+}
 export function omitBy(obj, predicate) {
     return Object.fromEntries(Object.entries(obj).filter(([key, value]) => {
         const k = key;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/core",
-  "version": "1.19.0",
+  "version": "1.20.1",
   "description": "AIGNE core library for building AI-powered applications",
   "publishConfig": {
     "access": "public"
@@ -81,7 +81,7 @@
     "yaml": "^2.7.1",
     "zod": "^3.24.4",
     "zod-to-json-schema": "^3.24.5",
-    "@aigne/platform-helpers": "^0.1.1"
+    "@aigne/platform-helpers": "^0.1.2"
   },
   "devDependencies": {
     "@types/bun": "^1.2.12",