@aigne/agent-library 1.10.0 → 1.12.0

package/lib/esm/data-mapper/agents/reviewer.js

@@ -0,0 +1,45 @@
+import { FunctionAgent, UserOutputTopic } from "@aigne/core";
+import { z } from "zod";
+import { applyJsonataWithValidation } from "../tools.js";
+const reviewer = FunctionAgent.from({
+    name: "check_mapping",
+    description: "Check the mapping result",
+    subscribeTopic: ["review_request"],
+    publishTopic: (output) => (output.success ? UserOutputTopic : "mapping_request"),
+    inputSchema: z.object({
+        sourceData: z.string(),
+        jsonata: z.string(),
+        responseSchema: z.string(),
+    }),
+    process: async ({ sourceData, jsonata, responseSchema, }) => {
+        let parsedSourceData = null;
+        let parsedResponseSchema = null;
+        try {
+            parsedSourceData = sourceData ? JSON.parse(sourceData) : null;
+            parsedResponseSchema = responseSchema ? JSON.parse(responseSchema) : null;
+        }
+        catch (parseError) {
+            // input data is not valid JSON, return success
+            return {
+                success: true,
+                data: null,
+                feedback: `JSON parsing failed: ${parseError.message}`,
+            };
+        }
+        const transformation = await applyJsonataWithValidation(parsedSourceData, jsonata, parsedResponseSchema);
+        // if transformation is successful, return success
+        if (transformation.success) {
+            return {
+                success: true,
+                data: transformation.data,
+            };
+        }
+        return {
+            success: transformation.success,
+            data: transformation.data,
+            feedback: transformation.error,
+        };
+    },
+    includeInputInOutput: true,
+});
+export default reviewer;

package/lib/esm/data-mapper/index.d.ts

@@ -0,0 +1,18 @@
+import { type ChatModel } from "@aigne/core";
+export interface TransformInput {
+    responseSchema: string;
+    responseSampleData?: string;
+    sourceData?: string;
+    sourceSchema?: string;
+    instruction?: string;
+    [key: string]: unknown;
+}
+export declare function generateMapping({ input, model, }: {
+    input: TransformInput;
+    model: ChatModel;
+}): Promise<{
+    jsonata: string;
+    confidence: number;
+    confidenceReasoning: string;
+} | null>;
+export { applyJsonata } from "./tools.js";

package/lib/esm/data-mapper/index.js

@@ -0,0 +1,21 @@
+import { AIGNE, UserInputTopic, UserOutputTopic } from "@aigne/core";
+import mapper from "./agents/mapper.js";
+import reviewer from "./agents/reviewer.js";
+import { getSchemaFromData } from "./tools.js";
+export async function generateMapping({ input, model, }) {
+    if (!model)
+        throw new Error("model is required to run data mapper");
+    // if sourceSchema is not provided, generate it from sourceData
+    if (!input.sourceSchema && input.sourceData) {
+        input.sourceSchema = JSON.stringify(getSchemaFromData(JSON.parse(input.sourceData)));
+    }
+    const aigne = new AIGNE({ model, agents: [mapper, reviewer] });
+    aigne.publish(UserInputTopic, input);
+    const { message } = await aigne.subscribe(UserOutputTopic);
+    return {
+        jsonata: message.jsonata || "",
+        confidence: message.confidence || 0,
+        confidenceReasoning: message.confidenceReasoning || "",
+    };
+}
+export { applyJsonata } from "./tools.js";

package/lib/esm/data-mapper/prompts.d.ts

@@ -0,0 +1 @@
+export declare const PROMPT_MAPPING = "You are an AI that generates JSONata mapping expressions to transform source data structures into target structures.\n\nGuidelines for creating JSONata mappings:\n\n1. Source References:\n   - Use exact field paths from the source data, e.g. $.merchant_category\n   - For accessing fields with names containing spaces, use backticks, e.g. $.`merchant category`\n   - Jsonata will automatically extract all the fields from the current context. E.g. if you need all variants from all products, you can use $.products.variants. No need to do nested map reduce operations.\n   - $. The variable with no name refers to the context value at any point in the input JSON hierarchy. E.g. if the current context is products.price, then $.currency is products.price.currency\n   - %. The parent of the current context value. E.g. if the current context is products.variants.size and you want variant name, use %.name\n\n   - When multiple source fields could map to a target, use a maximum of 3 fallbacks:\n     GOOD: source1 ? source1 : source2 ? source2 : source3 ? source3 : 'default'\n     BAD: source1 ? source1 : source1 ? source1 : source1 (repeated fields)\n\n2. Expression Rules:\n   - Avoid unnecessary array/string operations\n   - Each mapping should be clear and concise\n   - Use proper JSONata syntax for coalesce operations\n   - Do not use ~> to execute functions. Use the functions directly with the correct arguments or use $map(arr, $function) to apply a function to each element of an array.\n\n3. Array Handling:\n   - For mapping to an array of objects, use the following patterns:\n     a) When in array scope, use $.{} to map each object:\n        Correct: [$.{\"id\": id, \"name\": name}]\n        Incorrect: [{\"id\": $.id}]\n     b) When outside array scope, include the source path:\n        Correct: [$.items.{\"id\": id, \"name\": name}]\n        Incorrect: [{\"id\": $.items.id}]\n     c) For nested arrays, chain the array operators:\n        Correct: [products.variants.{\"size\": size, \"color\": color}]\n        Incorrect: [products.[{\"size\": variants.size}]]\n     d) You need to use the square brackets [] to map to an array of objects, otherwise it might return an object and fail the validation.\n        Correct: variants: [variants.{\"size\": size, \"color\": color}]\n        Incorrect: variants: variants.{\"size\": variants.size}\n   - For array elements, use JSONata array operators like [0] for first element, [-1] for last element\n   - Square bracket notation [] can be used with predicates, e.g. items[type='book']\n\n4. Field Selection Priority:\n   - Prefer variant-specific fields over general fields (e.g., sizeVariants.description over sizes)\n   - Choose the most specific/detailed field available (e.g., type=\"shelf\" over category=\"furniture\")\n\n5. Filters:\n   - Pay special attention to filter statements in the instruction and the schema description. Add them to the generated jsonata expression.\n     Example: Get me all products with SKU 0406654608 or products: {\"type\": \"array\", description: \"only products with SKU 0406654608\"}\n     Generated jsonata expression: Account.Order.Product[SKU = \"0406654608\"].{\"Description\": Description}\n   - For filtering with arrays, you can use the \"in\" operator. E.g. library.books[\"Steven King\" in authors]\n\n6. Data Integrity:\n   - ONLY use fields that exist in the source data structure\n   - If no matching source field exists, leave the field undefined\n   - Never invent or assume the existence of fields not present in the source data\n\n7. Function Calls:\n   - You may use the following functions if prompted:\n      $string(arg) - Converts argument to string\n      $length(str) - Returns string length\n      $substring(str, start[, length]) - Extracts substring\n      $substringBefore(str, chars) - Gets substring before specified chars\n      $substringAfter(str, chars) - Gets substring after specified chars\n      $uppercase(str) - Converts to uppercase\n      $lowercase(str) - Converts to lowercase\n      $trim(str) - Removes whitespace from both ends\n      $pad(str, width[, char]) - Pads string to specified width\n      $contains(str, substring) - Tests if string contains substring\n      $toMillis(timestamp [, picture]) - Converts ISO 8601 timestamp to milliseconds. E.g. $toMillis(\"2017-11-07T15:07:54.972Z\") => 1510067274972\n      $toDate(str | number) - Converts any timestamp string to valid ISO 8601 date string. E.g. $toDate(\"Oct 15, 2024 12:00:00 AM UTC\") => \"2024-10-15T00:00:00.000Z\", $toDate(1728873600000) => \"2024-10-15T00:00:00.000Z\"\n      $dateMax(arr) - Returns the maximum date of an array of dates. E.g. $dateMax([\"2017-11-07T15:07:54.972Z\", \"Oct 15, 2012 12:00:00 AM UTC\"]) returns \"2017-11-07T15:07:54.972Z\".\n      $dateMin(arr) - Returns the minimum date of an array of dates. E.g. $dateMin($.variants.created_at) returns the minimum created_at date of all variants.\n      $dateDiff(date1, date2, unit: \"seconds\" | \"minutes\" | \"hours\" | \"days\") - Returns the difference between two dates in the specified unit. E.g. $dateDiff($.order.created_at, $.order.updated_at, \"days\") returns the number of days between the order created_at and updated_at.\n      $now([picture [, timezone]]) - Returns current date and time in ISO 8601 format. E.g. $now() => \"2017-05-15T15:12:59.152Z\"\n      $split(str[, separator][, limit]) - Splits string into array\n      $join(array[, separator]) - Joins array elements into string\n      $match(str, pattern[, limit]) - Returns array of regex matches\n      $replace(str, pattern, replacement) - Replaces all occurrences of pattern. E.g. $replace(\"abracadabra\", /a.*?a/, \"*\") returns \"ab*ad*bra\". $replace(\"John Smith\", \"John\", \"Marc\") returns Marc Smith.\n      $number(arg) - Converts an argument to a number.\n      $min(arr) - Returns minimum number of a number array. E.g. $min($map($.variants.price, $number)) returns the minimum price of all variants.\n      $max(arr) - Returns maximum number of a number array. E.g. $max($map($.variants.price, $number)) returns the maximum price of all variants.\n      $count(array) - Returns array length\n      $sort(array[, function]) - Sorts array\n      $distinct(array) - Removes duplicates\n      $map(array, function) - Applies function to each element\n      $filter(array, function) - Filters array based on predicate\n\n- Error handling:\n  - If you get an error like \"is not of a type(s) string/number/object\", try to convert the source field, but also consider that the original field or one of its parent might be null. In this case, add a default value.\n  - If the error is something like \"instance is not of a type(s) object\", make sure you REALLY create the target schema with the correct type.\n  - If the error is something like \"instance is not of a type(s) array or array/null\". In this case, wrap the source selector in an array to ensure it always returns an array. E.g. \"result\": [$.items]\n  - if an object is optional but its fields required, you can add a test and default to {}, but do not set the inner fields to default null.\n\nRemember: The goal is to create valid JSONata expressions that accurately transform the source data structure into the required target structure.";

package/lib/esm/data-mapper/prompts.js

@@ -0,0 +1,91 @@
+export const PROMPT_MAPPING = `You are an AI that generates JSONata mapping expressions to transform source data structures into target structures.
+
+Guidelines for creating JSONata mappings:
+
+1. Source References:
+   - Use exact field paths from the source data, e.g. $.merchant_category
+   - For accessing fields with names containing spaces, use backticks, e.g. $.\`merchant category\`
+   - Jsonata will automatically extract all the fields from the current context. E.g. if you need all variants from all products, you can use $.products.variants. No need to do nested map reduce operations.
+   - $. The variable with no name refers to the context value at any point in the input JSON hierarchy. E.g. if the current context is products.price, then $.currency is products.price.currency
+   - %. The parent of the current context value. E.g. if the current context is products.variants.size and you want variant name, use %.name
+
+   - When multiple source fields could map to a target, use a maximum of 3 fallbacks:
+     GOOD: source1 ? source1 : source2 ? source2 : source3 ? source3 : 'default'
+     BAD: source1 ? source1 : source1 ? source1 : source1 (repeated fields)
+
+2. Expression Rules:
+   - Avoid unnecessary array/string operations
+   - Each mapping should be clear and concise
+   - Use proper JSONata syntax for coalesce operations
+   - Do not use ~> to execute functions. Use the functions directly with the correct arguments or use $map(arr, $function) to apply a function to each element of an array.
+
+3. Array Handling:
+   - For mapping to an array of objects, use the following patterns:
+     a) When in array scope, use $.{} to map each object:
+        Correct: [$.{"id": id, "name": name}]
+        Incorrect: [{"id": $.id}]
+     b) When outside array scope, include the source path:
+        Correct: [$.items.{"id": id, "name": name}]
+        Incorrect: [{"id": $.items.id}]
+     c) For nested arrays, chain the array operators:
+        Correct: [products.variants.{"size": size, "color": color}]
+        Incorrect: [products.[{"size": variants.size}]]
+     d) You need to use the square brackets [] to map to an array of objects, otherwise it might return an object and fail the validation.
+        Correct: variants: [variants.{"size": size, "color": color}]
+        Incorrect: variants: variants.{"size": variants.size}
+   - For array elements, use JSONata array operators like [0] for first element, [-1] for last element
+   - Square bracket notation [] can be used with predicates, e.g. items[type='book']
+
+4. Field Selection Priority:
+   - Prefer variant-specific fields over general fields (e.g., sizeVariants.description over sizes)
+   - Choose the most specific/detailed field available (e.g., type="shelf" over category="furniture")
+
+5. Filters:
+   - Pay special attention to filter statements in the instruction and the schema description. Add them to the generated jsonata expression.
+     Example: Get me all products with SKU 0406654608 or products: {"type": "array", description: "only products with SKU 0406654608"}
+     Generated jsonata expression: Account.Order.Product[SKU = "0406654608"].{"Description": Description}
+   - For filtering with arrays, you can use the "in" operator. E.g. library.books["Steven King" in authors]
+
+6. Data Integrity:
+   - ONLY use fields that exist in the source data structure
+   - If no matching source field exists, leave the field undefined
+   - Never invent or assume the existence of fields not present in the source data
+
+7. Function Calls:
+   - You may use the following functions if prompted:
+      $string(arg) - Converts argument to string
+      $length(str) - Returns string length
+      $substring(str, start[, length]) - Extracts substring
+      $substringBefore(str, chars) - Gets substring before specified chars
+      $substringAfter(str, chars) - Gets substring after specified chars
+      $uppercase(str) - Converts to uppercase
+      $lowercase(str) - Converts to lowercase
+      $trim(str) - Removes whitespace from both ends
+      $pad(str, width[, char]) - Pads string to specified width
+      $contains(str, substring) - Tests if string contains substring
+      $toMillis(timestamp [, picture]) - Converts ISO 8601 timestamp to milliseconds. E.g. $toMillis("2017-11-07T15:07:54.972Z") => 1510067274972
+      $toDate(str | number) - Converts any timestamp string to valid ISO 8601 date string. E.g. $toDate("Oct 15, 2024 12:00:00 AM UTC") => "2024-10-15T00:00:00.000Z", $toDate(1728873600000) => "2024-10-15T00:00:00.000Z"
+      $dateMax(arr) - Returns the maximum date of an array of dates. E.g. $dateMax(["2017-11-07T15:07:54.972Z", "Oct 15, 2012 12:00:00 AM UTC"]) returns "2017-11-07T15:07:54.972Z".
+      $dateMin(arr) - Returns the minimum date of an array of dates. E.g. $dateMin($.variants.created_at) returns the minimum created_at date of all variants.
+      $dateDiff(date1, date2, unit: "seconds" | "minutes" | "hours" | "days") - Returns the difference between two dates in the specified unit. E.g. $dateDiff($.order.created_at, $.order.updated_at, "days") returns the number of days between the order created_at and updated_at.
+      $now([picture [, timezone]]) - Returns current date and time in ISO 8601 format. E.g. $now() => "2017-05-15T15:12:59.152Z"
+      $split(str[, separator][, limit]) - Splits string into array
+      $join(array[, separator]) - Joins array elements into string
+      $match(str, pattern[, limit]) - Returns array of regex matches
+      $replace(str, pattern, replacement) - Replaces all occurrences of pattern. E.g. $replace("abracadabra", /a.*?a/, "*") returns "ab*ad*bra". $replace("John Smith", "John", "Marc") returns Marc Smith.
+      $number(arg) - Converts an argument to a number.
+      $min(arr) - Returns minimum number of a number array. E.g. $min($map($.variants.price, $number)) returns the minimum price of all variants.
+      $max(arr) - Returns maximum number of a number array. E.g. $max($map($.variants.price, $number)) returns the maximum price of all variants.
+      $count(array) - Returns array length
+      $sort(array[, function]) - Sorts array
+      $distinct(array) - Removes duplicates
+      $map(array, function) - Applies function to each element
+      $filter(array, function) - Filters array based on predicate
+
+- Error handling:
+  - If you get an error like "is not of a type(s) string/number/object", try to convert the source field, but also consider that the original field or one of its parent might be null. In this case, add a default value.
+  - If the error is something like "instance is not of a type(s) object", make sure you REALLY create the target schema with the correct type.
+  - If the error is something like "instance is not of a type(s) array or array/null". In this case, wrap the source selector in an array to ensure it always returns an array. E.g. "result": [$.items]
+  - if an object is optional but its fields required, you can add a test and default to {}, but do not set the inner fields to default null.
+
+Remember: The goal is to create valid JSONata expressions that accurately transform the source data structure into the required target structure.`;

package/lib/esm/data-mapper/tools.d.ts

@@ -0,0 +1,17 @@
+import jsonata from "jsonata";
+import type { Schema } from "jsonschema";
+export interface TransformResult {
+    success: boolean;
+    data?: unknown;
+    error?: string;
+}
+/**
+ * Extract JSON Schema from data
+ * @param data Any data
+ * @returns JSON Schema or null
+ */
+export declare function getSchemaFromData(data: unknown): unknown;
+export declare function applyJsonataWithValidation(data: unknown, expr: string, schema: unknown): Promise<TransformResult>;
+export declare function applyJsonata(data: unknown, expr: string): Promise<unknown>;
+export declare function extendJsonata(expr: string): jsonata.Expression;
+export declare function addNullableToOptional(schema: Schema): Schema;

package/lib/esm/data-mapper/tools.js

@@ -0,0 +1,167 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import jsonata from "jsonata";
+import { Validator } from "jsonschema";
+import toJsonSchema from "to-json-schema";
+/**
+ * Extract JSON Schema from data
+ * @param data Any data
+ * @returns JSON Schema or null
+ */
+export function getSchemaFromData(data) {
+    if (!data)
+        return null;
+    return toJsonSchema(data);
+}
+export async function applyJsonataWithValidation(data, expr, schema) {
+    try {
+        const result = await applyJsonata(data, expr);
+        if (result === null ||
+            result === undefined ||
+            (Array.isArray(result) && result.length === 0) ||
+            (typeof result === "object" && Object.keys(result).length === 0)) {
+            return { success: false, error: "Result is empty" };
+        }
+        const validator = new Validator();
+        const optionalSchema = addNullableToOptional(schema);
+        const validation = validator.validate(result, optionalSchema);
+        if (!validation.valid) {
+            return {
+                success: false,
+                error: validation.errors
+                    .map((e) => `${e.stack}. Source: ${e.instance ? JSON.stringify(e.instance) : "undefined"}`)
+                    .join("\n")
+                    .slice(0, 5000),
+            };
+        }
+        return { success: true, data: result };
+    }
+    catch (error) {
+        return { success: false, error: `Validation failed: ${error.message}` };
+    }
+}
+export async function applyJsonata(data, expr) {
+    try {
+        const expression = extendJsonata(expr);
+        const result = await expression.evaluate(data);
+        return result;
+    }
+    catch (error) {
+        throw new Error(`JSONata evaluation failed for expression "${expr}": ${error.message}`);
+    }
+}
+export function extendJsonata(expr) {
+    const expression = jsonata(expr);
+    expression.registerFunction("max", (arr) => {
+        if (Array.isArray(arr)) {
+            return Math.max(...arr.map(Number).filter((n) => !Number.isNaN(n)));
+        }
+        return arr;
+    });
+    expression.registerFunction("min", (arr) => {
+        if (Array.isArray(arr)) {
+            return Math.min(...arr.map(Number).filter((n) => !Number.isNaN(n)));
+        }
+        return arr;
+    });
+    expression.registerFunction("number", (value) => Number.parseFloat(value));
+    expression.registerFunction("substring", (str, start, end) => String(str).substring(start, end));
+    expression.registerFunction("replace", (obj, pattern, replacement) => {
+        if (Array.isArray(obj)) {
+            return obj.map((item) => String(item).replace(pattern, replacement));
+        }
+        if (typeof obj === "object") {
+            return Object.fromEntries(Object.entries(obj || {}).map(([key, value]) => [
+                key,
+                String(value).replace(pattern, replacement),
+            ]));
+        }
+        return String(obj).replace(pattern, replacement);
+    });
+    expression.registerFunction("toDate", (date) => {
+        try {
+            // Handle numeric timestamps (milliseconds or seconds)
+            if (typeof date === "number" || /^\d+$/.test(date)) {
+                const timestamp = typeof date === "number" ? date : Number.parseInt(date, 10);
+                // If timestamp is in seconds (typically 10 digits), convert to milliseconds
+                const millisTimestamp = timestamp < 10000000000 ? timestamp * 1000 : timestamp;
+                return new Date(millisTimestamp).toISOString();
+            }
+            // Handle date strings in MM/DD/YYYY format
+            const match = String(date).match(/^(\d{2})\/(\d{2})\/(\d{4})(?:\s+(\d{2}):(\d{2}):(\d{2}))?$/);
+            if (match) {
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                const [_, month, day, year, hours = "00", minutes = "00", seconds = "00"] = match;
+                const isoDate = `${year}-${month}-${day}T${hours}:${minutes}:${seconds}.000Z`;
+                return new Date(isoDate).toISOString();
+            }
+            // Default case: try standard Date parsing
+            return new Date(date).toISOString();
+        }
+        catch (e) {
+            throw new Error(`Invalid date: ${e.message}`);
+        }
+    });
+    expression.registerFunction("dateMax", (dates) => dates.reduce((max, curr) => (new Date(max) > new Date(curr) ? max : curr)));
+    expression.registerFunction("dateMin", (dates) => dates.reduce((min, curr) => (new Date(min) < new Date(curr) ? min : curr)));
+    expression.registerFunction("dateDiff", (date1, date2, unit = "days") => {
+        const d1 = new Date(date1);
+        const d2 = new Date(date2);
+        const diff = Math.abs(d1.getTime() - d2.getTime());
+        switch (unit.toLowerCase()) {
+            case "seconds":
+                return Math.floor(diff / 1000);
+            case "minutes":
+                return Math.floor(diff / (1000 * 60));
+            case "hours":
+                return Math.floor(diff / (1000 * 60 * 60));
+            case "days":
+                return Math.floor(diff / (1000 * 60 * 60 * 24));
+            default:
+                return diff; // milliseconds
+        }
+    });
+    return expression;
+}
+export function addNullableToOptional(schema) {
+    if (!schema || typeof schema !== "object")
+        return schema;
+    const newSchema = { ...schema };
+    if (schema.type === "object" && schema.properties) {
+        const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+        newSchema.properties = Object.entries(schema.properties).reduce((acc, [key, value]) => ({
+            // biome-ignore lint/performance/noAccumulatingSpread: <explanation>
+            ...acc,
+            [key]: !required.has(key) ? makeNullable(value) : addNullableToOptional(value),
+        }), {});
+    }
+    if (schema.type === "array" && schema.items) {
+        newSchema.items = addNullableToOptional(schema.items);
+    }
+    return newSchema;
+}
+// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+function makeNullable(schema) {
+    if (!schema || typeof schema !== "object")
+        return schema;
+    const newSchema = { ...schema };
+    if (Array.isArray(schema.type)) {
+        if (!schema.type.includes("null")) {
+            newSchema.type = [...schema.type, "null"];
+        }
+    }
+    else if (schema.type) {
+        newSchema.type = [schema.type, "null"];
+    }
+    // Recursively process nested properties
+    if (schema.properties) {
+        newSchema.properties = Object.entries(schema.properties).reduce((acc, [key, value]) => ({
+            // biome-ignore lint/performance/noAccumulatingSpread: <explanation>
+            ...acc,
+            [key]: makeNullable(value),
+        }), {});
+    }
+    if (schema.items) {
+        newSchema.items = makeNullable(schema.items);
+    }
+    return newSchema;
+}

package/lib/esm/default-memory/default-memory-storage/index.d.ts

@@ -0,0 +1,23 @@
+import type { AgentInvokeOptions, Context, Memory } from "@aigne/core";
+import type { PromiseOrValue } from "@aigne/core/utils/type-utils.js";
+import { MemoryStorage } from "../storage.js";
+export interface DefaultMemoryStorageOptions {
+    url?: string;
+    getSessionId?: (context: Context) => PromiseOrValue<string>;
+}
+export declare class DefaultMemoryStorage extends MemoryStorage {
+    options?: DefaultMemoryStorageOptions | undefined;
+    constructor(options?: DefaultMemoryStorageOptions | undefined);
+    private _db;
+    private initSqlite;
+    get db(): Promise<import("drizzle-orm/libsql").LibSQLDatabase<Record<string, never>>>;
+    private convertMemory;
+    search(query: {
+        limit?: number;
+    }, { context }: AgentInvokeOptions): Promise<{
+        result: Memory[];
+    }>;
+    create(memory: Pick<Memory, "content">, { context }: AgentInvokeOptions): Promise<{
+        result: Memory;
+    }>;
+}

package/lib/esm/default-memory/default-memory-storage/index.js

@@ -0,0 +1,61 @@
+import { initDatabase } from "@aigne/sqlite";
+import { desc, eq, isNull } from "drizzle-orm";
+import { MemoryStorage } from "../storage.js";
+import { migrate } from "./migrate.js";
+import { Memories } from "./models/memory.js";
+const DEFAULT_MAX_MEMORY_COUNT = 10;
+export class DefaultMemoryStorage extends MemoryStorage {
+    options;
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    _db;
+    async initSqlite() {
+        const db = await initDatabase({ url: this.options?.url });
+        await migrate(db);
+        return db;
+    }
+    get db() {
+        this._db ??= this.initSqlite();
+        return this._db;
+    }
+    convertMemory(m) {
+        return {
+            id: m.id,
+            sessionId: m.sessionId,
+            content: m.content,
+            createdAt: m.createdAt.toISOString(),
+        };
+    }
+    async search(query, { context }) {
+        const { limit = DEFAULT_MAX_MEMORY_COUNT } = query;
+        const sessionId = (await this.options?.getSessionId?.(context)) ?? null;
+        const db = await this.db;
+        const memories = await db
+            .select()
+            .from(Memories)
+            .where(sessionId ? eq(Memories.sessionId, sessionId) : isNull(Memories.sessionId))
+            .orderBy(desc(Memories.id))
+            .limit(limit)
+            .execute();
+        return {
+            result: memories.reverse().map(this.convertMemory),
+        };
+    }
+    async create(memory, { context }) {
+        const sessionId = (await this.options?.getSessionId?.(context)) ?? null;
+        const db = await this.db;
+        const [result] = await db
+            .insert(Memories)
+            .values({
+            ...memory,
+            sessionId,
+        })
+            .returning()
+            .execute();
+        if (!result)
+            throw new Error("Failed to create memory");
+        return { result: this.convertMemory(result) };
+    }
+}

package/lib/esm/default-memory/default-memory-storage/migrate.d.ts

@@ -0,0 +1,3 @@
+import type { LibSQLDatabase } from "drizzle-orm/libsql";
+import type { SqliteRemoteDatabase } from "drizzle-orm/sqlite-proxy";
+export declare function migrate(db: LibSQLDatabase | SqliteRemoteDatabase): Promise<void>;

package/lib/esm/default-memory/default-memory-storage/migrate.js

@@ -0,0 +1,26 @@
+import { sql } from "drizzle-orm/sql";
+import init from "./migrations/001-init.js";
+export async function migrate(db) {
+    const migrations = [init];
+    const migrationsTable = "__drizzle_migrations";
+    const migrationTableCreate = sql `
+    CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
+      id SERIAL PRIMARY KEY,
+      hash text NOT NULL
+    )
+  `;
+    await db.run(migrationTableCreate).execute();
+    const dbMigrations = await db
+        .values(sql `SELECT id, hash FROM ${sql.identifier(migrationsTable)} ORDER BY id DESC LIMIT 1`)
+        .execute();
+    const lastDbMigration = dbMigrations[0];
+    const queriesToRun = [];
+    for (const migration of migrations) {
+        if (!lastDbMigration || lastDbMigration[1] < migration.hash) {
+            queriesToRun.push(...migration.sql, `INSERT INTO \`${migrationsTable}\` ("hash") VALUES('${migration.hash}')`);
+        }
+    }
+    for (const query of queriesToRun) {
+        await db.run(query).execute();
+    }
+}

package/lib/esm/default-memory/default-memory-storage/migrations/001-init.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    hash: string;
+    sql: string[];
+};
+export default _default;

package/lib/esm/default-memory/default-memory-storage/migrations/001-init.js

@@ -0,0 +1,14 @@
+export default {
+    hash: "001-init",
+    sql: [
+        `\
+CREATE TABLE "Memories" (
+  "id" TEXT NOT NULL PRIMARY KEY,
+  "createdAt" DATETIME NOT NULL,
+  "updatedAt" DATETIME NOT NULL,
+  "sessionId" TEXT,
+  "content" JSON NOT NULL
+)
+`,
+    ],
+};

package/lib/esm/default-memory/default-memory-storage/models/memory.d.ts

@@ -0,0 +1,102 @@
+export declare const Memories: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "Memories";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "Memories";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "createdAt";
+            tableName: "Memories";
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            sqliteColumnBuilderBrand: "SQLiteCustomColumnBuilderBrand";
+        }>;
+        updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "updatedAt";
+            tableName: "Memories";
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            sqliteColumnBuilderBrand: "SQLiteCustomColumnBuilderBrand";
+        }>;
+        sessionId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "sessionId";
+            tableName: "Memories";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        content: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "content";
+            tableName: "Memories";
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: unknown;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            sqliteColumnBuilderBrand: "SQLiteCustomColumnBuilderBrand";
+        }>;
+    };
+    dialect: "sqlite";
+}>;

package/lib/esm/default-memory/default-memory-storage/models/memory.js

@@ -0,0 +1,18 @@
+import { datetime, json } from "@aigne/sqlite/type.js";
+import { sqliteTable, text } from "drizzle-orm/sqlite-core";
+import { v7 } from "uuid";
+export const Memories = sqliteTable("Memories", {
+    id: text("id")
+        .notNull()
+        .primaryKey()
+        .$defaultFn(() => v7()),
+    createdAt: datetime("createdAt")
+        .notNull()
+        .$defaultFn(() => new Date()),
+    updatedAt: datetime("updatedAt")
+        .notNull()
+        .$defaultFn(() => new Date())
+        .$onUpdateFn(() => new Date()),
+    sessionId: text("sessionId"),
+    content: json("content").notNull(),
+});

package/lib/esm/default-memory/index.d.ts

@@ -0,0 +1,10 @@
+import { MemoryAgent, type MemoryAgentOptions } from "@aigne/core";
+import { type DefaultMemoryStorageOptions } from "./default-memory-storage/index.js";
+import { MemoryStorage } from "./storage.js";
+export interface DefaultMemoryOptions extends Partial<MemoryAgentOptions> {
+    storage?: MemoryStorage | DefaultMemoryStorageOptions;
+}
+export declare class DefaultMemory extends MemoryAgent {
+    constructor(options?: DefaultMemoryOptions);
+    storage: MemoryStorage;
+}