@aigne/core 1.72.0 → 1.74.0-beta

package/dist/memory/retriever.d.cts

@@ -0,0 +1,111 @@
+import { PromiseOrValue } from "../utils/type-utils.cjs";
+import { Memory } from "./memory.cjs";
+import { Agent, AgentInvokeOptions, AgentOptions, AgentProcessResult, FunctionAgentFn, Message } from "../agents/agent.cjs";
+import { z } from "zod";
+
+//#region src/memory/retriever.d.ts
+/**
+ * Input for memory retrieval operations.
+ *
+ * This interface defines the parameters that can be used to query and filter
+ * memories when retrieving them from storage.
+ */
+interface MemoryRetrieverInput extends Message {
+  /**
+       * Maximum number of memories to retrieve.
+       * Used for pagination or limiting result set size.
+       */
+  limit?: number;
+  /**
+       * Search term to filter memories by.
+       * How the search is implemented depends on the specific retriever implementation.
+       */
+  search?: string | Message;
+}
+/**
+ * Output from memory retrieval operations.
+ *
+ * This interface represents the result of retrieving memories from storage,
+ * containing an array of memory objects that match the query criteria.
+ */
+interface MemoryRetrieverOutput extends Message {
+  /**
+       * Array of retrieved memory objects.
+       * Each memory includes its ID, content, and creation timestamp.
+       */
+  memories: Memory[];
+}
+/**
+ * @hidden
+ */
+declare const memoryRetrieverInputSchema: z.ZodObject<{
+  limit: z.ZodOptional<z.ZodNumber>;
+  search: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+}, "strip", z.ZodTypeAny, {
+  search?: string | Record<string, unknown> | undefined;
+  limit?: number | undefined;
+}, {
+  search?: string | Record<string, unknown> | undefined;
+  limit?: number | undefined;
+}>;
+/**
+ * @hidden
+ */
+declare const memoryRetrieverOutputSchema: z.ZodObject<{
+  memories: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    content: z.ZodType<{}, z.ZodTypeDef, {}>;
+    createdAt: z.ZodString;
+  }, "strip", z.ZodTypeAny, {
+    content: {};
+    id: string;
+    createdAt: string;
+  }, {
+    content: {};
+    id: string;
+    createdAt: string;
+  }>, "many">;
+}, "strip", z.ZodTypeAny, {
+  memories: {
+    content: {};
+    id: string;
+    createdAt: string;
+  }[];
+}, {
+  memories: {
+    content: {};
+    id: string;
+    createdAt: string;
+  }[];
+}>;
+interface MemoryRetrieverOptions extends Omit<AgentOptions<MemoryRetrieverInput, MemoryRetrieverOutput>, "inputSchema" | "outputSchema"> {
+  process?: FunctionAgentFn<MemoryRetrieverInput, MemoryRetrieverOutput>;
+}
+/**
+ * Abstract base class for agents that retrieve memories from storage.
+ *
+ * The MemoryRetriever serves as a foundation for implementing specific memory
+ * retrieval mechanisms. Implementations of this class are responsible for:
+ *
+ * 1. Querying a memory storage backend to find relevant memories
+ * 2. Filtering memories based on search criteria
+ * 3. Limiting the number of results returned
+ * 4. Potentially implementing sorting, ranking, or relevance-based retrieval
+ *
+ * Custom implementations should extend this class and provide concrete
+ * implementations of the process method to handle the actual retrieval logic.
+ */
+declare class MemoryRetriever extends Agent<MemoryRetrieverInput, MemoryRetrieverOutput> {
+  tag: string;
+  /**
+       * Creates a new MemoryRetriever instance with predefined input and output schemas.
+       *
+       * @param options - Configuration options for the memory retriever agent
+       */
+  constructor(options: MemoryRetrieverOptions);
+  private _process?;
+  process(input: MemoryRetrieverInput, options: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<MemoryRetrieverOutput>>;
+}
+//#endregion
+export { MemoryRetriever, MemoryRetrieverInput, MemoryRetrieverOptions, MemoryRetrieverOutput, memoryRetrieverInputSchema, memoryRetrieverOutputSchema };
+//# sourceMappingURL=retriever.d.cts.map

package/dist/memory/retriever.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retriever.d.cts","names":[],"sources":["../../src/memory/retriever.ts"],"mappings":";;;;;;;AAkBA;AAoBA;AAWA;;;UA/BiB,oBAAA,SAA6B,OAAA;EAAA;AAoB9C;AAWA;;EA/B8C,KAAA;EAAA;AAoB9C;AAWA;;EA/B8C,MAAA,YAW1B,OAAA;AAAA;AAAA;AASpB;AAWA;;;;AApBoB,UASH,qBAAA,SAA8B,OAAA;EAAA;AAW/C;;;EAX+C,QAAA,EAKnC,MAAA;AAAA;AAAA;AAMZ;;AANY,cAMC,0BAAA,EAA0B,CAAA,CAAA,SAAA;EAAA,KAAA;;;;;;;;;;;;cAQ1B,2BAAA,EAA2B,CAAA,CAAA,SAAA;EAAA,QAAA;;;;;;;;;;;;;;;;;;;;;;;;;;UAUvB,sBAAA,SACP,IAAA,CACN,YAAA,CAAa,oBAAA,EAAsB,qBAAA;EAAA,OAAA,GAG3B,eAAA,CAAgB,oBAAA,EAAsB,qBAAA;AAAA;AAAA;;;;AAiBlD;;;;;;;;;;AAjBkD,cAiBrC,eAAA,SAAwB,KAAA,CAAM,oBAAA,EAAsB,qBAAA;EAAA,GAAA;EAAA;;;;;EAAA,YAAA,OAAA,EAQ1C,sBAAA;EAAA,QAAA,QAAA;EAAA,QAAA,KAAA,EAYZ,oBAAA,EAAA,OAAA,EACE,kBAAA,GACR,cAAA,CAAe,kBAAA,CAAmB,qBAAA;AAAA"}

package/dist/memory/retriever.d.mts

@@ -0,0 +1,111 @@
+import { PromiseOrValue } from "../utils/type-utils.mjs";
+import { Memory } from "./memory.mjs";
+import { Agent, AgentInvokeOptions, AgentOptions, AgentProcessResult, FunctionAgentFn, Message } from "../agents/agent.mjs";
+import { z as z$1 } from "zod";
+
+//#region src/memory/retriever.d.ts
+/**
+ * Input for memory retrieval operations.
+ *
+ * This interface defines the parameters that can be used to query and filter
+ * memories when retrieving them from storage.
+ */
+interface MemoryRetrieverInput extends Message {
+  /**
+       * Maximum number of memories to retrieve.
+       * Used for pagination or limiting result set size.
+       */
+  limit?: number;
+  /**
+       * Search term to filter memories by.
+       * How the search is implemented depends on the specific retriever implementation.
+       */
+  search?: string | Message;
+}
+/**
+ * Output from memory retrieval operations.
+ *
+ * This interface represents the result of retrieving memories from storage,
+ * containing an array of memory objects that match the query criteria.
+ */
+interface MemoryRetrieverOutput extends Message {
+  /**
+       * Array of retrieved memory objects.
+       * Each memory includes its ID, content, and creation timestamp.
+       */
+  memories: Memory[];
+}
+/**
+ * @hidden
+ */
+declare const memoryRetrieverInputSchema: z$1.ZodObject<{
+  limit: z$1.ZodOptional<z$1.ZodNumber>;
+  search: z$1.ZodOptional<z$1.ZodUnion<[z$1.ZodString, z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>]>>;
+}, "strip", z$1.ZodTypeAny, {
+  search?: string | Record<string, unknown> | undefined;
+  limit?: number | undefined;
+}, {
+  search?: string | Record<string, unknown> | undefined;
+  limit?: number | undefined;
+}>;
+/**
+ * @hidden
+ */
+declare const memoryRetrieverOutputSchema: z$1.ZodObject<{
+  memories: z$1.ZodArray<z$1.ZodObject<{
+    id: z$1.ZodString;
+    content: z$1.ZodType<{}, z$1.ZodTypeDef, {}>;
+    createdAt: z$1.ZodString;
+  }, "strip", z$1.ZodTypeAny, {
+    content: {};
+    id: string;
+    createdAt: string;
+  }, {
+    content: {};
+    id: string;
+    createdAt: string;
+  }>, "many">;
+}, "strip", z$1.ZodTypeAny, {
+  memories: {
+    content: {};
+    id: string;
+    createdAt: string;
+  }[];
+}, {
+  memories: {
+    content: {};
+    id: string;
+    createdAt: string;
+  }[];
+}>;
+interface MemoryRetrieverOptions extends Omit<AgentOptions<MemoryRetrieverInput, MemoryRetrieverOutput>, "inputSchema" | "outputSchema"> {
+  process?: FunctionAgentFn<MemoryRetrieverInput, MemoryRetrieverOutput>;
+}
+/**
+ * Abstract base class for agents that retrieve memories from storage.
+ *
+ * The MemoryRetriever serves as a foundation for implementing specific memory
+ * retrieval mechanisms. Implementations of this class are responsible for:
+ *
+ * 1. Querying a memory storage backend to find relevant memories
+ * 2. Filtering memories based on search criteria
+ * 3. Limiting the number of results returned
+ * 4. Potentially implementing sorting, ranking, or relevance-based retrieval
+ *
+ * Custom implementations should extend this class and provide concrete
+ * implementations of the process method to handle the actual retrieval logic.
+ */
+declare class MemoryRetriever extends Agent<MemoryRetrieverInput, MemoryRetrieverOutput> {
+  tag: string;
+  /**
+       * Creates a new MemoryRetriever instance with predefined input and output schemas.
+       *
+       * @param options - Configuration options for the memory retriever agent
+       */
+  constructor(options: MemoryRetrieverOptions);
+  private _process?;
+  process(input: MemoryRetrieverInput, options: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<MemoryRetrieverOutput>>;
+}
+//#endregion
+export { MemoryRetriever, MemoryRetrieverInput, MemoryRetrieverOptions, MemoryRetrieverOutput, memoryRetrieverInputSchema, memoryRetrieverOutputSchema };
+//# sourceMappingURL=retriever.d.mts.map

package/dist/memory/retriever.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retriever.d.mts","names":[],"sources":["../../src/memory/retriever.ts"],"mappings":";;;;;;;AAkBA;AAoBA;AAWA;;;UA/BiB,oBAAA,SAA6B,OAAA;EAAA;AAoB9C;AAWA;;EA/B8C,KAAA;EAAA;AAoB9C;AAWA;;EA/B8C,MAAA,YAW1B,OAAA;AAAA;AAAA;AASpB;AAWA;;;;AApBoB,UASH,qBAAA,SAA8B,OAAA;EAAA;AAW/C;;;EAX+C,QAAA,EAKnC,MAAA;AAAA;AAAA;AAMZ;;AANY,cAMC,0BAAA,EAA0B,GAAA,CAAA,SAAA;EAAA,KAAA;;;;;;;;;;;;cAQ1B,2BAAA,EAA2B,GAAA,CAAA,SAAA;EAAA,QAAA;;;;;;;;;;;;;;;;;;;;;;;;;;UAUvB,sBAAA,SACP,IAAA,CACN,YAAA,CAAa,oBAAA,EAAsB,qBAAA;EAAA,OAAA,GAG3B,eAAA,CAAgB,oBAAA,EAAsB,qBAAA;AAAA;AAAA;;;;AAiBlD;;;;;;;;;;AAjBkD,cAiBrC,eAAA,SAAwB,KAAA,CAAM,oBAAA,EAAsB,qBAAA;EAAA,GAAA;EAAA;;;;;EAAA,YAAA,OAAA,EAQ1C,sBAAA;EAAA,QAAA,QAAA;EAAA,QAAA,KAAA,EAYZ,oBAAA,EAAA,OAAA,EACE,kBAAA,GACR,cAAA,CAAe,kBAAA,CAAmB,qBAAA;AAAA"}

package/dist/memory/retriever.mjs

@@ -0,0 +1,58 @@
+import { Agent } from "../agents/agent.mjs";
+import { z as z$1 } from "zod";
+
+//#region src/memory/retriever.ts
+/**
+* @hidden
+*/
+const memoryRetrieverInputSchema = z$1.object({
+	limit: z$1.number().optional(),
+	search: z$1.union([z$1.string(), z$1.record(z$1.string(), z$1.unknown())]).optional()
+});
+/**
+* @hidden
+*/
+const memoryRetrieverOutputSchema = z$1.object({ memories: z$1.array(z$1.object({
+	id: z$1.string(),
+	content: z$1.custom(),
+	createdAt: z$1.string().datetime()
+})) });
+/**
+* Abstract base class for agents that retrieve memories from storage.
+*
+* The MemoryRetriever serves as a foundation for implementing specific memory
+* retrieval mechanisms. Implementations of this class are responsible for:
+*
+* 1. Querying a memory storage backend to find relevant memories
+* 2. Filtering memories based on search criteria
+* 3. Limiting the number of results returned
+* 4. Potentially implementing sorting, ranking, or relevance-based retrieval
+*
+* Custom implementations should extend this class and provide concrete
+* implementations of the process method to handle the actual retrieval logic.
+*/
+var MemoryRetriever = class extends Agent {
+	tag = "MemoryRetrieverAgent";
+	/**
+	* Creates a new MemoryRetriever instance with predefined input and output schemas.
+	*
+	* @param options - Configuration options for the memory retriever agent
+	*/
+	constructor(options) {
+		super({
+			...options,
+			inputSchema: memoryRetrieverInputSchema,
+			outputSchema: memoryRetrieverOutputSchema
+		});
+		this._process = options.process;
+	}
+	_process;
+	process(input, options) {
+		if (!this._process) throw new Error("MemoryRetriever process function is not implemented.");
+		return this._process.apply(this, [input, options]);
+	}
+};
+
+//#endregion
+export { MemoryRetriever, memoryRetrieverInputSchema, memoryRetrieverOutputSchema };
+//# sourceMappingURL=retriever.mjs.map

package/dist/memory/retriever.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"retriever.mjs","names":["z"],"sources":["../../src/memory/retriever.ts"],"sourcesContent":["import { z } from \"zod\";\nimport {\n  Agent,\n  type AgentInvokeOptions,\n  type AgentOptions,\n  type AgentProcessResult,\n  type FunctionAgentFn,\n  type Message,\n} from \"../agents/agent.js\";\nimport type { PromiseOrValue } from \"../utils/type-utils.js\";\nimport type { Memory } from \"./memory.js\";\n\n/**\n * Input for memory retrieval operations.\n *\n * This interface defines the parameters that can be used to query and filter\n * memories when retrieving them from storage.\n */\nexport interface MemoryRetrieverInput extends Message {\n  /**\n   * Maximum number of memories to retrieve.\n   * Used for pagination or limiting result set size.\n   */\n  limit?: number;\n\n  /**\n   * Search term to filter memories by.\n   * How the search is implemented depends on the specific retriever implementation.\n   */\n  search?: string | Message;\n}\n\n/**\n * Output from memory retrieval operations.\n *\n * This interface represents the result of retrieving memories from storage,\n * containing an array of memory objects that match the query criteria.\n */\nexport interface MemoryRetrieverOutput extends Message {\n  /**\n   * Array of retrieved memory objects.\n   * Each memory includes its ID, content, and creation timestamp.\n   */\n  memories: Memory[];\n}\n\n/**\n * @hidden\n */\nexport const memoryRetrieverInputSchema = z.object({\n  limit: z.number().optional(),\n  search: z.union([z.string(), z.record(z.string(), z.unknown())]).optional(),\n});\n\n/**\n * @hidden\n */\nexport const memoryRetrieverOutputSchema = z.object({\n  memories: z.array(\n    z.object({\n      id: z.string(),\n      content: z.custom<NonNullable<unknown>>(),\n      createdAt: z.string().datetime(),\n    }),\n  ),\n});\n\nexport interface MemoryRetrieverOptions\n  extends Omit<\n    AgentOptions<MemoryRetrieverInput, MemoryRetrieverOutput>,\n    \"inputSchema\" | \"outputSchema\"\n  > {\n  process?: FunctionAgentFn<MemoryRetrieverInput, MemoryRetrieverOutput>;\n}\n\n/**\n * Abstract base class for agents that retrieve memories from storage.\n *\n * The MemoryRetriever serves as a foundation for implementing specific memory\n * retrieval mechanisms. Implementations of this class are responsible for:\n *\n * 1. Querying a memory storage backend to find relevant memories\n * 2. Filtering memories based on search criteria\n * 3. Limiting the number of results returned\n * 4. Potentially implementing sorting, ranking, or relevance-based retrieval\n *\n * Custom implementations should extend this class and provide concrete\n * implementations of the process method to handle the actual retrieval logic.\n */\nexport class MemoryRetriever extends Agent<MemoryRetrieverInput, MemoryRetrieverOutput> {\n  override tag = \"MemoryRetrieverAgent\";\n\n  /**\n   * Creates a new MemoryRetriever instance with predefined input and output schemas.\n   *\n   * @param options - Configuration options for the memory retriever agent\n   */\n  constructor(options: MemoryRetrieverOptions) {\n    super({\n      ...options,\n      inputSchema: memoryRetrieverInputSchema,\n      outputSchema: memoryRetrieverOutputSchema,\n    });\n    this._process = options.process;\n  }\n\n  private _process?: FunctionAgentFn<MemoryRetrieverInput, MemoryRetrieverOutput>;\n\n  override process(\n    input: MemoryRetrieverInput,\n    options: AgentInvokeOptions,\n  ): PromiseOrValue<AgentProcessResult<MemoryRetrieverOutput>> {\n    if (!this._process) {\n      throw new Error(\"MemoryRetriever process function is not implemented.\");\n    }\n\n    return this._process.apply(this as any, [input, options]);\n  }\n}\n"],"mappings":";;;;;;;AAiDA,MAAa,6BAA6BA,IAAE,OAAO;CACjD,OAAOA,IAAE,QAAQ,CAAC,UAAU;CAC5B,QAAQA,IAAE,MAAM,CAACA,IAAE,QAAQ,EAAEA,IAAE,OAAOA,IAAE,QAAQ,EAAEA,IAAE,SAAS,CAAC,CAAC,CAAC,CAAC,UAAU;CAC5E,CAAC;;;;AAKF,MAAa,8BAA8BA,IAAE,OAAO,EAClD,UAAUA,IAAE,MACVA,IAAE,OAAO;CACP,IAAIA,IAAE,QAAQ;CACd,SAASA,IAAE,QAA8B;CACzC,WAAWA,IAAE,QAAQ,CAAC,UAAU;CACjC,CAAC,CACH,EACF,CAAC;;;;;;;;;;;;;;;AAwBF,IAAa,kBAAb,cAAqC,MAAmD;CACtF,AAAS,MAAM;;;;;;CAOf,YAAY,SAAiC;AAC3C,QAAM;GACJ,GAAG;GACH,aAAa;GACb,cAAc;GACf,CAAC;AACF,OAAK,WAAW,QAAQ;;CAG1B,AAAQ;CAER,AAAS,QACP,OACA,SAC2D;AAC3D,MAAI,CAAC,KAAK,SACR,OAAM,IAAI,MAAM,uDAAuD;AAGzE,SAAO,KAAK,SAAS,MAAM,MAAa,CAAC,OAAO,QAAQ,CAAC"}