@aigne/core 0.4.205-0 → 0.4.205

package/lib/types/utils/message-utils.d.ts

@@ -1,2 +1,20 @@
-import { LLMModelInputMessage } from '../llm-model';
+import type { LLMAgentDefinition } from '../llm-agent';
+import type { LLMModelInputMessage } from '../llm-model';
+import type { MemoryItemWithScore } from '../memorable';
 export declare function mergeHistoryMessages(messages: LLMModelInputMessage[], history: LLMModelInputMessage[]): LLMModelInputMessage[];
+export declare function memoriesToMessages(memories: {
+    [name: string]: MemoryItemWithScore[];
+}, { primaryMemoryName }?: {
+    primaryMemoryName?: string;
+}): {
+    primaryMemory: LLMModelInputMessage[];
+    memory: string;
+};
+export declare function prepareMessages(definition: Pick<LLMAgentDefinition, 'messages' | 'memories' | 'primaryMemoryId'>, input: {
+    [name: string]: any;
+}, memories: {
+    [name: string]: MemoryItemWithScore[];
+}): {
+    originalMessages: LLMModelInputMessage[];
+    messagesWithMemory: LLMModelInputMessage[];
+};

package/lib/types/utils/nullable.d.ts

@@ -0,0 +1,7 @@
+export type MakeNullablePropertyOptional<T extends {
+    [key: string]: any;
+}> = {
+    [K in keyof T as Extract<T[K], null | undefined> extends never ? K : never]: T[K];
+} & {
+    [K in keyof T as Extract<T[K], null | undefined> extends never ? never : K]?: T[K];
+};

package/lib/types/utils/ordered-map.d.ts

@@ -28,6 +28,9 @@ export declare namespace OrderedRecord {
     function push<T extends {
         id: string;
     }>(record: OrderedRecord<T>, ...items: T[]): OrderedRecord<T>;
+    function merge<T extends {
+        id: string;
+    }>(...records: OrderedRecord<T>[]): OrderedRecord<T>;
     function pushOrUpdate<T extends {
         id: string;
     }>(record: OrderedRecord<T>, ...items: T[]): OrderedRecord<T>;

package/lib/types/utils/stream-utils.d.ts

@@ -1,7 +1,18 @@
-import { RunnableResponseStream } from '../runnable';
+import { RunnableResponse, RunnableResponseStream } from '../runnable';
 export declare function objectToRunnableResponseStream<T extends {
     [key: string]: any;
 }>(obj: T): RunnableResponseStream<T>;
 export declare function runnableResponseStreamToObject<T extends {
     [key: string]: any;
 }>(stream: RunnableResponseStream<T>): Promise<T>;
+/**
+ * Extracts the outputs from a runnable output stream and run the
+ * resolve function on the result before the stream closes. It can be
+ * used to update the memories of an agent.
+ * @param output The runnable output stream or object
+ * @param resolve The function to run on the result
+ * @returns The runnable output stream or object
+ */
+export declare function extractOutputsFromRunnableOutput<T extends {
+    [key: string]: any;
+}>(output: RunnableResponse<T>, resolve: (result: T) => Promise<void> | void): Promise<typeof output>;

package/lib/types/utils/union.d.ts

@@ -1,2 +1,2 @@
 export type UnionToIntersection<U> = (U extends any ? (arg: U) => void : never) extends (arg: infer I) => void ? I : never;
-export type ObjectUnionToIntersection<T> = UnionToIntersection<T> extends object ? UnionToIntersection<T> : never;
+export type ObjectUnionToIntersection<T, O = object> = UnionToIntersection<T> extends O ? UnionToIntersection<T> : never;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/core",
-  "version": "0.4.205-0",
+  "version": "0.4.205",
   "description": "AIGNE core library",
   "publishConfig": {
     "access": "public"

package/lib/cjs/memory.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemoryRunner = exports.Memory = void 0;
-const lodash_1 = require("lodash");
-const runnable_1 = require("./runnable");
-const utils_1 = require("./utils");
-class Memory extends runnable_1.Runnable {
-    constructor() {
-        super({
-            id: 'memory',
-            type: 'memory',
-            name: 'Memory',
-            inputs: utils_1.OrderedRecord.fromArray([]),
-            outputs: utils_1.OrderedRecord.fromArray([]),
-        });
-    }
-}
-exports.Memory = Memory;
-class MemoryRunner extends runnable_1.Runnable {
-    constructor(name) {
-        const id = `${(0, lodash_1.camelCase)(name)}_runner`;
-        super({
-            id,
-            type: id,
-            name: `${(0, lodash_1.startCase)(name)} Runner`,
-            description: `${(0, lodash_1.startCase)(name)} Runner`,
-            inputs: utils_1.OrderedRecord.fromArray([]),
-            outputs: utils_1.OrderedRecord.fromArray([]),
-        });
-    }
-}
-exports.MemoryRunner = MemoryRunner;

package/lib/esm/memory.js

@@ -1,27 +0,0 @@
-import { camelCase, startCase } from 'lodash';
-import { Runnable } from './runnable';
-import { OrderedRecord } from './utils';
-export class Memory extends Runnable {
-    constructor() {
-        super({
-            id: 'memory',
-            type: 'memory',
-            name: 'Memory',
-            inputs: OrderedRecord.fromArray([]),
-            outputs: OrderedRecord.fromArray([]),
-        });
-    }
-}
-export class MemoryRunner extends Runnable {
-    constructor(name) {
-        const id = `${camelCase(name)}_runner`;
-        super({
-            id,
-            type: id,
-            name: `${startCase(name)} Runner`,
-            description: `${startCase(name)} Runner`,
-            inputs: OrderedRecord.fromArray([]),
-            outputs: OrderedRecord.fromArray([]),
-        });
-    }
-}

package/lib/types/memory.d.ts

@@ -1,184 +0,0 @@
-import { Runnable } from './runnable';
-export interface MemoryMetadata {
-    [key: string]: any;
-}
-export type MemoryActionItem<T> = {
-    event: 'add';
-    id: string;
-    memory: T;
-    metadata?: MemoryMetadata;
-} | {
-    event: 'update';
-    id: string;
-    memory: T;
-    oldMemory: T;
-    metadata?: MemoryMetadata;
-} | {
-    event: 'delete';
-    id: string;
-    memory: T;
-} | {
-    event: 'none';
-    memory: T;
-};
-export interface MemoryItem<T> {
-    id: string;
-    userId?: string;
-    sessionId?: string;
-    createdAt: string;
-    updatedAt: string;
-    memory: T;
-    metadata: MemoryMetadata;
-}
-export interface MemoryItemWithScore<T> extends MemoryItem<T> {
-    score: number;
-}
-export interface MemoryMessage {
-    role: string;
-    content: string;
-}
-export type MemoryActions<T> = {
-    action: 'add';
-    inputs: {
-        messages: MemoryMessage[];
-        options?: {
-            userId?: string;
-            sessionId?: string;
-            metadata?: MemoryMetadata;
-        };
-    };
-    outputs: {
-        results: MemoryActionItem<T>[];
-    };
-} | {
-    action: 'search';
-    inputs: {
-        query: string;
-        options?: {
-            k?: number;
-            userId?: string;
-            sessionId?: string;
-            filter?: MemoryMetadata;
-            sort?: MemorySortOptions;
-        };
-    };
-    outputs: {
-        results: MemoryItemWithScore<T>[];
-    };
-} | {
-    action: 'filter';
-    inputs: {
-        options?: {
-            k?: number;
-            userId?: string;
-            sessionId?: string;
-            filter?: MemoryMetadata;
-            sort?: MemorySortOptions;
-        };
-    };
-    outputs: {
-        results: MemoryItem<T>[];
-    };
-} | {
-    action: 'get';
-    inputs: {
-        memoryId: string;
-    };
-    outputs: {
-        result: MemoryItem<T> | null;
-    };
-} | {
-    action: 'create';
-    inputs: {
-        memory: T;
-        options?: {
-            userId?: string;
-            sessionId?: string;
-            metadata?: MemoryMetadata;
-        };
-    };
-    outputs: {
-        result: MemoryItem<T>;
-    };
-} | {
-    action: 'update';
-    inputs: {
-        memoryId: string;
-        memory: T;
-    };
-    outputs: {
-        result: MemoryItem<T> | null;
-    };
-} | {
-    action: 'delete';
-    inputs: {
-        filter: string | string[] | Record<string, any>;
-    };
-    outputs: {};
-} | {
-    action: 'reset';
-    inputs: {};
-    outputs: {};
-};
-export interface SortItem {
-    field: string;
-    direction: 'asc' | 'desc';
-}
-export type MemorySortOptions = SortItem | SortItem[];
-export declare abstract class Memory<T, C = undefined> extends Runnable<MemoryActions<T>, MemoryActions<T>['outputs']> {
-    constructor();
-    abstract runner?: MemoryRunner<T, C>;
-    abstract add(messages: Extract<MemoryActions<T>, {
-        action: 'add';
-    }>['inputs']['messages'], options?: Extract<MemoryActions<T>, {
-        action: 'add';
-    }>['inputs']['options']): Promise<Extract<MemoryActions<T>, {
-        action: 'add';
-    }>['outputs']>;
-    abstract search(query: Extract<MemoryActions<T>, {
-        action: 'search';
-    }>['inputs']['query'], options?: Extract<MemoryActions<T>, {
-        action: 'search';
-    }>['inputs']['options']): Promise<Extract<MemoryActions<T>, {
-        action: 'search';
-    }>['outputs']>;
-    abstract filter(options: Extract<MemoryActions<T>, {
-        action: 'filter';
-    }>['inputs']['options']): Promise<Extract<MemoryActions<T>, {
-        action: 'filter';
-    }>['outputs']>;
-    abstract get(memoryId: Extract<MemoryActions<T>, {
-        action: 'get';
-    }>['inputs']['memoryId']): Promise<Extract<MemoryActions<T>, {
-        action: 'get';
-    }>['outputs']>;
-    abstract create(memory: Extract<MemoryActions<T>, {
-        action: 'create';
-    }>['inputs']['memory'], options?: Extract<MemoryActions<T>, {
-        action: 'create';
-    }>['inputs']['options']): Promise<Extract<MemoryActions<T>, {
-        action: 'create';
-    }>['outputs']>;
-    abstract update(memoryId: Extract<MemoryActions<T>, {
-        action: 'update';
-    }>['inputs']['memoryId'], memory: T): Promise<Extract<MemoryActions<T>, {
-        action: 'update';
-    }>['outputs']>;
-    abstract delete(memoryId: Extract<MemoryActions<T>, {
-        action: 'delete';
-    }>['inputs']['filter']): Promise<Extract<MemoryActions<T>, {
-        action: 'delete';
-    }>['outputs']>;
-    abstract reset(): Promise<void>;
-}
-export interface MemoryRunnerInput<C = undefined> {
-    messages: MemoryMessage[];
-    userId?: string;
-    sessionId?: string;
-    metadata?: MemoryMetadata;
-    filter?: MemoryMetadata;
-    customData: C;
-}
-export declare abstract class MemoryRunner<T, C = undefined> extends Runnable<MemoryRunnerInput<C>, MemoryActionItem<T>[]> {
-    constructor(name: string);
-}