@aigne/core 1.15.0 → 1.17.0

package/lib/esm/aigne/context.d.ts

@@ -1,7 +1,7 @@
 import EventEmitter from "node:events";
 import { Agent, type AgentInvokeOptions, type AgentProcessAsyncGenerator, type AgentResponse, type AgentResponseStream, type Message } from "../agents/agent.js";
+import type { ChatModel } from "../agents/chat-model.js";
 import { UserAgent } from "../agents/user-agent.js";
-import type { ChatModel } from "../models/chat-model.js";
 import { type OmitPropertiesFromArrayFirstElement } from "../utils/type-utils.js";
 import type { Args, Listener, TypedEventEmitter } from "../utils/typed-event-emtter.js";
 import { type MessagePayload, MessageQueue, type MessageQueueListener, type Unsubscribe } from "./message-queue.js";
@@ -38,19 +38,27 @@ export type ContextEmitEventMap = {
 /**
  * @hidden
  */
-export interface InvokeOptions extends AgentInvokeOptions {
+export interface InvokeOptions<U extends UserContext = UserContext> extends Partial<Omit<AgentInvokeOptions<U>, "context">> {
     returnActiveAgent?: boolean;
     disableTransfer?: boolean;
+    sourceAgent?: Agent;
+    userContext?: U;
 }
 /**
  * @hidden
  */
-export interface Context extends TypedEventEmitter<ContextEventMap, ContextEmitEventMap> {
+export interface UserContext extends Record<string, unknown> {
+}
+/**
+ * @hidden
+ */
+export interface Context<U extends UserContext = UserContext> extends TypedEventEmitter<ContextEventMap, ContextEmitEventMap> {
     model?: ChatModel;
     skills?: Agent[];
     usage: ContextUsage;
     limits?: ContextLimits;
     status?: "normal" | "timeout";
+    userContext: U;
     /**
      * Create a user agent to consistently invoke an agent
      * @param agent Agent to invoke
@@ -91,7 +99,7 @@ export interface Context extends TypedEventEmitter<ContextEventMap, ContextEmitE
      * @param topic topic name, or an array of topic names
      * @param payload message to publish
      */
-    publish(topic: string | string[], payload: Omit<MessagePayload, "context"> | Message | string): void;
+    publish(topic: string | string[], payload: Omit<MessagePayload, "context"> | Message | string, options?: InvokeOptions): void;
     subscribe(topic: string | string[], listener?: undefined): Promise<MessagePayload>;
     subscribe(topic: string | string[], listener: MessageQueueListener): Unsubscribe;
     subscribe(topic: string | string[], listener?: MessageQueueListener): Unsubscribe | Promise<MessagePayload>;
@@ -113,15 +121,17 @@ export interface Context extends TypedEventEmitter<ContextEventMap, ContextEmitE
  * @hidden
  */
 export declare class AIGNEContext implements Context {
-    constructor(parent?: ConstructorParameters<typeof AIGNEContextInternal>[0]);
+    constructor(...[parent, ...args]: ConstructorParameters<typeof AIGNEContextShared>);
     parentId?: string;
     id: string;
-    readonly internal: AIGNEContextInternal;
+    readonly internal: AIGNEContextShared;
     get model(): ChatModel | undefined;
     get skills(): Agent<Message, Message>[] | undefined;
     get limits(): ContextLimits | undefined;
     get status(): "normal" | "timeout";
     get usage(): ContextUsage;
+    get userContext(): Context["userContext"];
+    set userContext(userContext: Context["userContext"]);
     newContext({ reset }?: {
         reset?: boolean;
     }): AIGNEContext;
@@ -134,17 +144,18 @@ export declare class AIGNEContext implements Context {
     once<K extends keyof ContextEventMap>(eventName: K, listener: Listener<K, ContextEventMap>): this;
     off<K extends keyof ContextEventMap>(eventName: K, listener: Listener<K, ContextEventMap>): this;
 }
-declare class AIGNEContextInternal {
+declare class AIGNEContextShared {
     private readonly parent?;
     constructor(parent?: (Pick<Context, "model" | "skills" | "limits"> & {
         messageQueue?: MessageQueue;
-    }) | undefined);
+    }) | undefined, overrides?: Partial<Context>);
     readonly messageQueue: MessageQueue;
     readonly events: EventEmitter<ContextEventMap>;
     get model(): ChatModel | undefined;
     get skills(): Agent<Message, Message>[] | undefined;
     get limits(): ContextLimits | undefined;
     usage: ContextUsage;
+    userContext: Context["userContext"];
     private abortController;
     private timer?;
     private initTimeout;

package/lib/esm/aigne/context.js

@@ -2,7 +2,7 @@ import EventEmitter from "node:events";
 import { v7 } from "uuid";
 import { z } from "zod";
 import { Agent, } from "../agents/agent.js";
-import { isTransferAgentOutput, transferAgentOutputKey } from "../agents/types.js";
+import { isTransferAgentOutput, transferAgentOutputKey, } from "../agents/types.js";
 import { UserAgent } from "../agents/user-agent.js";
 import { createMessage } from "../prompt/prompt-builder.js";
 import { agentResponseStreamToObject, asyncGeneratorToReadableStream, onAgentResponseStreamEnd, } from "../utils/stream-utils.js";
@@ -13,13 +13,13 @@ import { newEmptyContextUsage } from "./usage.js";
  * @hidden
  */
 export class AIGNEContext {
-    constructor(parent) {
+    constructor(...[parent, ...args]) {
         if (parent instanceof AIGNEContext) {
             this.parentId = parent.id;
             this.internal = parent.internal;
         }
         else {
-            this.internal = new AIGNEContextInternal(parent);
+            this.internal = new AIGNEContextShared(parent, ...args);
         }
     }
     parentId;
@@ -40,9 +40,15 @@ export class AIGNEContext {
     get usage() {
         return this.internal.usage;
     }
+    get userContext() {
+        return this.internal.userContext;
+    }
+    set userContext(userContext) {
+        this.internal.userContext = userContext;
+    }
     newContext({ reset } = {}) {
         if (reset)
-            return new AIGNEContext(this.internal);
+            return new AIGNEContext(this, { userContext: {} });
         return new AIGNEContext(this);
     }
     invoke = ((agent, message, options) => {
@@ -51,6 +57,8 @@ export class AIGNEContext {
             message,
             options,
         });
+        if (options?.userContext)
+            Object.assign(this.userContext, options.userContext);
         if (isNil(message)) {
             return UserAgent.from({
                 context: this,
@@ -90,7 +98,9 @@ export class AIGNEContext {
             return stream;
         });
     });
-    publish = ((topic, payload) => {
+    publish = ((topic, payload, options) => {
+        if (options?.userContext)
+            Object.assign(this.userContext, options.userContext);
         return this.internal.messageQueue.publish(topic, {
             ...toMessagePayload(payload),
             context: this,
@@ -125,11 +135,12 @@ export class AIGNEContext {
         return this;
     }
 }
-class AIGNEContextInternal {
+class AIGNEContextShared {
     parent;
-    constructor(parent) {
+    constructor(parent, overrides) {
         this.parent = parent;
         this.messageQueue = this.parent?.messageQueue ?? new MessageQueue();
+        this.userContext = overrides?.userContext ?? {};
     }
     messageQueue;
     events = new EventEmitter();
@@ -143,6 +154,7 @@ class AIGNEContextInternal {
         return this.parent?.limits;
     }
     usage = newEmptyContextUsage();
+    userContext;
     abortController = new AbortController();
     timer;
     initTimeout() {
@@ -167,7 +179,15 @@ class AIGNEContextInternal {
         let output;
         for (;;) {
             const result = {};
-            const stream = await activeAgent.invoke(input, context, { streaming: true });
+            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.text) {
                     yield { delta: { text: value.delta.text } };

package/lib/esm/index.d.ts

@@ -1,10 +1,11 @@
 export * from "./agents/agent.js";
 export * from "./agents/ai-agent.js";
+export * from "./agents/chat-model.js";
+export * from "./agents/guide-rail-agent.js";
 export * from "./agents/mcp-agent.js";
 export * from "./agents/team-agent.js";
 export * from "./agents/types.js";
 export * from "./agents/user-agent.js";
 export * from "./aigne/index.js";
-export * from "./models/chat-model.js";
 export * from "./prompt/prompt-builder.js";
 export * from "./prompt/template.js";

package/lib/esm/index.js

@@ -1,10 +1,11 @@
 export * from "./agents/agent.js";
 export * from "./agents/ai-agent.js";
+export * from "./agents/chat-model.js";
+export * from "./agents/guide-rail-agent.js";
 export * from "./agents/mcp-agent.js";
 export * from "./agents/team-agent.js";
 export * from "./agents/types.js";
 export * from "./agents/user-agent.js";
 export * from "./aigne/index.js";
-export * from "./models/chat-model.js";
 export * from "./prompt/prompt-builder.js";
 export * from "./prompt/template.js";

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

@@ -14,16 +14,16 @@ export declare function loadAgentFromYamlFile(path: string): Promise<{
     }, {
         [x: string]: any;
     }> | undefined;
-    toolChoice?: AIAgentToolChoice | undefined;
     outputSchema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
         [x: string]: any;
     }, {
         [x: string]: any;
     }> | undefined;
     outputKey?: string | undefined;
+    toolChoice?: AIAgentToolChoice | undefined;
 } | {
     type: "mcp";
     url?: string | undefined;
-    command?: string | undefined;
     args?: string[] | undefined;
+    command?: string | undefined;
 }>;

package/lib/esm/loader/index.d.ts

@@ -1,7 +1,14 @@
+import type { Camelize } from "camelize-ts";
 import { z } from "zod";
 import { type Agent } from "../agents/agent.js";
-import type { ChatModel, ChatModelOptions } from "../models/chat-model.js";
+import type { ChatModel, ChatModelOptions } from "../agents/chat-model.js";
 export interface LoadOptions {
+    models: {
+        new (parameters: {
+            model?: string;
+            modelOptions?: ChatModelOptions;
+        }): ChatModel;
+    }[];
     path: string;
 }
 export declare function load(options: LoadOptions): Promise<{
@@ -15,12 +22,12 @@ export declare function load(options: LoadOptions): Promise<{
         temperature?: number | null | undefined;
         provider?: string | null | undefined;
         top_p?: number | null | undefined;
-        frequent_penalty?: number | null | undefined;
+        frequency_penalty?: number | null | undefined;
         presence_penalty?: number | null | undefined;
     } | null | undefined;
 }>;
 export declare function loadAgent(path: string): Promise<Agent>;
-export declare function loadModel(model?: z.infer<typeof aigneFileSchema>["chat_model"], modelOptions?: ChatModelOptions): Promise<ChatModel | undefined>;
+export declare function loadModel(models: LoadOptions["models"], model?: Camelize<z.infer<typeof aigneFileSchema>["chat_model"]>, modelOptions?: ChatModelOptions): Promise<ChatModel | undefined>;
 declare const aigneFileSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -29,35 +36,35 @@ declare const aigneFileSchema: z.ZodObject<{
         name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         temperature: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
         top_p: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        frequent_penalty: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        frequency_penalty: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
         presence_penalty: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
     }, "strip", z.ZodTypeAny, {
         name?: string | null | undefined;
         temperature?: number | null | undefined;
         provider?: string | null | undefined;
         top_p?: number | null | undefined;
-        frequent_penalty?: number | null | undefined;
+        frequency_penalty?: number | null | undefined;
         presence_penalty?: number | null | undefined;
     }, {
         name?: string | null | undefined;
         temperature?: number | null | undefined;
         provider?: string | null | undefined;
         top_p?: number | null | undefined;
-        frequent_penalty?: number | null | undefined;
+        frequency_penalty?: number | null | undefined;
         presence_penalty?: number | null | undefined;
     }>]>>>, {
         name?: string | null | undefined;
         temperature?: number | null | undefined;
         provider?: string | null | undefined;
         top_p?: number | null | undefined;
-        frequent_penalty?: number | null | undefined;
+        frequency_penalty?: number | null | undefined;
         presence_penalty?: number | null | undefined;
     } | null | undefined, string | {
         name?: string | null | undefined;
         temperature?: number | null | undefined;
         provider?: string | null | undefined;
         top_p?: number | null | undefined;
-        frequent_penalty?: number | null | undefined;
+        frequency_penalty?: number | null | undefined;
         presence_penalty?: number | null | undefined;
     } | null | undefined>;
     agents: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
@@ -71,7 +78,7 @@ declare const aigneFileSchema: z.ZodObject<{
         temperature?: number | null | undefined;
         provider?: string | null | undefined;
         top_p?: number | null | undefined;
-        frequent_penalty?: number | null | undefined;
+        frequency_penalty?: number | null | undefined;
         presence_penalty?: number | null | undefined;
     } | null | undefined;
     agents?: string[] | null | undefined;
@@ -84,7 +91,7 @@ declare const aigneFileSchema: z.ZodObject<{
         temperature?: number | null | undefined;
         provider?: string | null | undefined;
         top_p?: number | null | undefined;
-        frequent_penalty?: number | null | undefined;
+        frequency_penalty?: number | null | undefined;
         presence_penalty?: number | null | undefined;
     } | null | undefined;
     agents?: string[] | null | undefined;
@@ -98,7 +105,7 @@ export declare function loadAIGNEFile(path: string): Promise<{
         temperature?: number | null | undefined;
         provider?: string | null | undefined;
         top_p?: number | null | undefined;
-        frequent_penalty?: number | null | undefined;
+        frequency_penalty?: number | null | undefined;
         presence_penalty?: number | null | undefined;
     } | null | undefined;
     agents?: string[] | null | undefined;

package/lib/esm/loader/index.js

@@ -5,14 +5,6 @@ import { z } from "zod";
 import { FunctionAgent } from "../agents/agent.js";
 import { AIAgent } from "../agents/ai-agent.js";
 import { MCPAgent } from "../agents/mcp-agent.js";
-import { BedrockChatModel } from "../models/bedrock-chat-model.js";
-import { ClaudeChatModel } from "../models/claude-chat-model.js";
-import { DeepSeekChatModel } from "../models/deepseek-chat-model.js";
-import { GeminiChatModel } from "../models/gemini-chat-model.js";
-import { OllamaChatModel } from "../models/ollama-chat-model.js";
-import { OpenRouterChatModel } from "../models/open-router-chat-model.js";
-import { OpenAIChatModel } from "../models/openai-chat-model.js";
-import { XAIChatModel } from "../models/xai-chat-model.js";
 import { tryOrThrow } from "../utils/type-utils.js";
 import { loadAgentFromJsFile } from "./agent-js.js";
 import { loadAgentFromYamlFile } from "./agent-yaml.js";
@@ -26,7 +18,7 @@ export async function load(options) {
     const skills = await Promise.all((aigne.skills ?? []).map((filename) => loadAgent(join(rootDir, filename))));
     return {
         ...aigne,
-        model: await loadModel(aigne.chat_model),
+        model: await loadModel(options.models, aigne.chat_model),
         agents,
         skills,
     };
@@ -64,26 +56,15 @@ export async function loadAgent(path) {
 }
 const { MODEL_PROVIDER, MODEL_NAME } = process.env;
 const DEFAULT_MODEL_PROVIDER = "openai";
-const DEFAULT_MODEL_NAME = "gpt-4o-mini";
-export async function loadModel(model, modelOptions) {
+export async function loadModel(models, model, modelOptions) {
     const params = {
-        model: MODEL_NAME ?? model?.name ?? DEFAULT_MODEL_NAME,
+        model: MODEL_NAME ?? model?.name ?? undefined,
         temperature: model?.temperature ?? undefined,
-        topP: model?.top_p ?? undefined,
-        frequencyPenalty: model?.frequent_penalty ?? undefined,
-        presencePenalty: model?.presence_penalty ?? undefined,
+        topP: model?.topP ?? undefined,
+        frequencyPenalty: model?.frequencyPenalty ?? undefined,
+        presencePenalty: model?.presencePenalty ?? undefined,
     };
-    const availableModels = [
-        OpenAIChatModel,
-        ClaudeChatModel,
-        XAIChatModel,
-        GeminiChatModel,
-        DeepSeekChatModel,
-        OpenRouterChatModel,
-        OllamaChatModel,
-        BedrockChatModel,
-    ];
-    const M = availableModels.find((m) => m.name
+    const M = models.find((m) => m.name
         .toLowerCase()
         .includes((MODEL_PROVIDER ?? model?.provider ?? DEFAULT_MODEL_PROVIDER).toLowerCase()));
     if (!M)
@@ -101,7 +82,7 @@ const aigneFileSchema = z.object({
             name: z.string().nullish(),
             temperature: z.number().min(0).max(2).nullish(),
             top_p: z.number().min(0).nullish(),
-            frequent_penalty: z.number().min(-2).max(2).nullish(),
+            frequency_penalty: z.number().min(-2).max(2).nullish(),
             presence_penalty: z.number().min(-2).max(2).nullish(),
         }),
     ])

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

@@ -0,0 +1,30 @@
+import type { AgentInvokeOptions } from "../../../agents/agent.js";
+import "sqlite3";
+import { Sequelize } from "sequelize";
+import type { Context } from "../../../aigne/context.js";
+import type { PromiseOrValue } from "../../../utils/type-utils.js";
+import type { Memory } from "../../memory.js";
+import { MemoryStorage } from "../storage.js";
+export interface DefaultMemoryStorageOptions {
+    path?: string;
+    getSessionId?: (context: Context) => PromiseOrValue<string>;
+}
+export declare class DefaultMemoryStorage extends MemoryStorage {
+    options?: DefaultMemoryStorageOptions | undefined;
+    memories: {
+        [groupId: string]: Memory[];
+    };
+    constructor(options?: DefaultMemoryStorageOptions | undefined);
+    private _models?;
+    private get models();
+    private convertMemory;
+    search(query: {
+        limit?: number;
+    }, { context }: AgentInvokeOptions): Promise<{
+        result: Memory[];
+    }>;
+    create(memory: Pick<Memory, "content">, { context }: AgentInvokeOptions): Promise<{
+        result: Memory;
+    }>;
+}
+export declare function initSequelize(path?: string): Sequelize;

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

@@ -0,0 +1,64 @@
+import "sqlite3";
+import { Sequelize } from "sequelize";
+import { logger } from "../../../utils/logger.js";
+import { MemoryStorage } from "../storage.js";
+import { migrate } from "./migrate.js";
+import { initMemoryModel } from "./models/memory.js";
+const DEFAULT_MAX_MEMORY_COUNT = 10;
+export class DefaultMemoryStorage extends MemoryStorage {
+    options;
+    memories = {};
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    _models;
+    get models() {
+        this._models ??= (async () => {
+            const sequelize = initSequelize(this.options?.path);
+            await migrate(sequelize);
+            return {
+                Memory: initMemoryModel(sequelize),
+            };
+        })();
+        return this._models;
+    }
+    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 { Memory } = await this.models;
+        const memories = await Memory.findAll({
+            where: { sessionId },
+            order: [["id", "DESC"]],
+            limit,
+        });
+        return {
+            result: memories.reverse().map(this.convertMemory),
+        };
+    }
+    async create(memory, { context }) {
+        const sessionId = (await this.options?.getSessionId?.(context)) ?? null;
+        const { Memory } = await this.models;
+        const m = await Memory.create({
+            ...memory,
+            sessionId,
+        });
+        return { result: this.convertMemory(m) };
+    }
+}
+export function initSequelize(path) {
+    const sequelize = new Sequelize({
+        logging: (sql) => logger.debug(sql),
+        storage: path,
+        dialect: "sqlite",
+    });
+    return sequelize;
+}

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

@@ -0,0 +1,7 @@
+import type { Sequelize } from "sequelize";
+import { type MigrateDownOptions, type MigrateUpOptions } from "umzug";
+export declare const migrate: (sequelize: Sequelize, { type, upOptions, downOptions, }?: {
+    type?: "up" | "down";
+    upOptions?: MigrateUpOptions;
+    downOptions?: MigrateDownOptions;
+}) => Promise<void>;

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

@@ -0,0 +1,16 @@
+import { SequelizeStorage, Umzug } from "umzug";
+import * as init from "./migrations/20250523165801-init.js";
+export const migrate = async (sequelize, { type = "up", upOptions, downOptions, } = {}) => {
+    const umzug = new Umzug({
+        migrations: [{ ...init, name: "20241224202701-init" }],
+        context: sequelize.getQueryInterface(),
+        storage: new SequelizeStorage({ sequelize }),
+        logger: console,
+    });
+    if (type === "down") {
+        await umzug.down(downOptions);
+    }
+    else {
+        await umzug.up(upOptions);
+    }
+};

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

@@ -0,0 +1,7 @@
+import { type QueryInterface } from "sequelize";
+export declare const up: ({ context: queryInterface }: {
+    context: QueryInterface;
+}) => Promise<void>;
+export declare const down: ({ context: queryInterface }: {
+    context: QueryInterface;
+}) => Promise<void>;

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

@@ -0,0 +1,28 @@
+import { DataTypes } from "sequelize";
+export const up = async ({ context: queryInterface }) => {
+    await queryInterface.createTable("Memories", {
+        id: {
+            type: DataTypes.STRING,
+            primaryKey: true,
+            allowNull: false,
+        },
+        createdAt: {
+            type: DataTypes.DATE,
+            allowNull: false,
+        },
+        updatedAt: {
+            type: DataTypes.DATE,
+            allowNull: false,
+        },
+        sessionId: {
+            type: DataTypes.STRING,
+        },
+        content: {
+            type: DataTypes.JSON,
+            allowNull: false,
+        },
+    });
+};
+export const down = async ({ context: queryInterface }) => {
+    await queryInterface.dropTable("Memories");
+};

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

@@ -0,0 +1,10 @@
+import { type CreationOptional, type InferAttributes, type InferCreationAttributes, Model } from "sequelize";
+import type { ModelStatic, Sequelize } from "sequelize";
+export interface Memory extends Model<InferAttributes<Memory>, InferCreationAttributes<Memory>> {
+    id: CreationOptional<string>;
+    createdAt: CreationOptional<Date>;
+    updatedAt: CreationOptional<Date>;
+    sessionId?: string | null;
+    content: unknown;
+}
+export declare function initMemoryModel(sequelize: Sequelize): ModelStatic<Memory>;

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

@@ -0,0 +1,29 @@
+import { DataTypes, Model, } from "sequelize";
+import { v7 } from "uuid";
+const nextId = () => v7();
+export function initMemoryModel(sequelize) {
+    return class Memory extends Model {
+    }.init({
+        id: {
+            type: DataTypes.STRING,
+            primaryKey: true,
+            allowNull: false,
+            defaultValue: nextId,
+        },
+        createdAt: {
+            type: DataTypes.DATE,
+            allowNull: false,
+        },
+        updatedAt: {
+            type: DataTypes.DATE,
+            allowNull: false,
+        },
+        sessionId: {
+            type: DataTypes.STRING,
+        },
+        content: {
+            type: DataTypes.JSON,
+            allowNull: false,
+        },
+    }, { sequelize });
+}

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

@@ -0,0 +1,10 @@
+import { MemoryAgent, type MemoryAgentOptions } from "../memory.js";
+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;
+}