@aigne/core 0.4.204 → 0.4.205-1

package/lib/types/local-function-agent.d.ts

@@ -1,38 +1,69 @@
-import type { Context } from './context';
-import { DataTypeSchema, SchemaMapType } from './data-type-schema';
-import { RunOptions, Runnable, RunnableDefinition, RunnableResponse, RunnableResponseStream } from './runnable';
-export declare class LocalFunctionAgent<I extends {} = {}, O extends {} = {}, State = {}> extends Runnable<I, O> {
-    definition: LocalFunctionAgentDefinition<I, O, State>;
-    context?: Context<State> | undefined;
+import { Agent, AgentProcessOptions } from './agent';
+import type { Context, ContextState } from './context';
+import { DataTypeSchema, SchemaMapType } from './definitions/data-type-schema';
+import { CreateRunnableMemory } from './definitions/memory';
+import { MemorableSearchOutput, MemoryItemWithScore } from './memorable';
+import { RunnableDefinition, RunnableResponse, RunnableResponseStream } from './runnable';
+export declare class LocalFunctionAgent<I extends {
+    [name: string]: any;
+} = {}, O extends {
+    [name: string]: any;
+} = {}, Memories extends {
+    [name: string]: MemoryItemWithScore[];
+} = {}, State extends ContextState = ContextState> extends Agent<I, O, Memories, State> {
+    definition: LocalFunctionAgentDefinition<I, O, Memories, State>;
     static create<I extends {
         [name: string]: DataTypeSchema;
     }, O extends {
         [name: string]: DataTypeSchema;
-    }, State = {}>(options: Parameters<typeof createLocalFunctionAgentDefinition<I, O, State>>[0]): LocalFunctionAgent<SchemaMapType<I>, SchemaMapType<O>, State>;
-    constructor(definition: LocalFunctionAgentDefinition<I, O, State>, context?: Context<State> | undefined);
-    run(input: I, options: RunOptions & {
+    }, Memories extends {
+        [name: string]: CreateRunnableMemory<I>;
+    }, State extends ContextState = ContextState>(options: Parameters<typeof createLocalFunctionAgentDefinition<I, O, Memories, State>>[0]): LocalFunctionAgent<SchemaMapType<I>, SchemaMapType<O>, {
+        [name in keyof Memories]: MemorableSearchOutput<Memories[name]['memory']>;
+    }, State>;
+    constructor(definition: LocalFunctionAgentDefinition<I, O, Memories, State>, context?: Context<State>);
+    process(input: I, options: AgentProcessOptions<Memories> & {
         stream: true;
     }): Promise<RunnableResponseStream<O>>;
-    run(input: I, options?: RunOptions & {
+    process(input: I, options: AgentProcessOptions<Memories> & {
         stream?: false;
     }): Promise<O>;
 }
-export declare function createLocalFunctionAgentDefinition<I extends {
+export interface CreateLocalFunctionAgentOptions<I extends {
     [name: string]: DataTypeSchema;
 }, O extends {
     [name: string]: DataTypeSchema;
-}, State = {}>(options: {
-    id?: string;
+}, Memories extends {
+    [name: string]: CreateRunnableMemory<I>;
+}, State extends ContextState = ContextState> {
     name?: string;
     inputs: I;
     outputs: O;
-    function?: (input: SchemaMapType<I>, options: {
+    memories?: Memories;
+    function?: LocalFunctionFuncType<SchemaMapType<I>, SchemaMapType<O>, {
+        [key in keyof Memories]: MemorableSearchOutput<Memories[key]['memory']>;
+    }, State>;
+}
+export declare function createLocalFunctionAgentDefinition<I extends {
+    [name: string]: DataTypeSchema;
+}, O extends {
+    [name: string]: DataTypeSchema;
+}, Memories extends {
+    [name: string]: CreateRunnableMemory<I>;
+}, State extends ContextState = ContextState>(options: CreateLocalFunctionAgentOptions<I, O, Memories, State>): LocalFunctionAgentDefinition<SchemaMapType<I>, SchemaMapType<O>, {
+    [key in keyof Memories]: MemorableSearchOutput<Memories[key]['memory']>;
+}, State>;
+export interface LocalFunctionFuncType<I extends {} = {}, O extends {} = {}, Memories extends {
+    [name: string]: MemoryItemWithScore[];
+} = {}, State extends ContextState = ContextState> {
+    (input: I, options: {
+        memories: Memories;
         context: Context<State>;
-    }) => Promise<RunnableResponse<SchemaMapType<O>>>;
-}): LocalFunctionAgentDefinition<SchemaMapType<I>, SchemaMapType<O>, State>;
-export interface LocalFunctionAgentDefinition<I extends {} = {}, O extends {} = {}, State = {}> extends RunnableDefinition {
+    }): Promise<RunnableResponse<O>>;
+}
+export interface LocalFunctionAgentDefinition<I extends {} = {}, O extends {} = {}, Memories extends {
+    [name: string]: MemoryItemWithScore[];
+} = {}, State extends ContextState = ContextState> extends RunnableDefinition {
     type: 'local_function_agent';
-    function?: (input: I, options: {
-        context: Context<State>;
-    }) => Promise<RunnableResponse<O>>;
+    function?: LocalFunctionFuncType<I, O, Memories, State>;
 }

package/lib/types/memorable.d.ts

@@ -0,0 +1,183 @@
+import { LLMModelInputMessage } from './llm-model';
+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 = any> extends MemoryItem<T> {
+    score: number;
+}
+export type MemoryMessage = LLMModelInputMessage;
+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 Memorable<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);
+}
+export type MemorableSearchOutput<T extends Memorable<any>> = Awaited<ReturnType<T['search']>>['results'];

package/lib/types/pipeline-agent.d.ts

@@ -1,12 +1,11 @@
 import type { Context } from './context';
-import { DataTypeSchema, SchemaMapType } from './data-type-schema';
+import { DataTypeSchema, SchemaMapType } from './definitions/data-type-schema';
 import { RunOptions, Runnable, RunnableDefinition, RunnableOutput, RunnableResponseStream } from './runnable';
 import { OrderedRecord } from './utils/ordered-map';
 export declare class PipelineAgent<I extends {
     [key: string]: any;
 } = {}, O extends {} = {}> extends Runnable<I, O> {
     definition: PipelineAgentDefinition;
-    context?: Context | undefined;
     static create<I extends {
         [name: string]: DataTypeSchema;
     }, O extends {
@@ -15,7 +14,7 @@ export declare class PipelineAgent<I extends {
             fromVariablePropPath?: string[];
         };
     }>(options: Parameters<typeof createPipelineAgentDefinition<I, O>>[0]): PipelineAgent<SchemaMapType<I>, SchemaMapType<O>>;
-    constructor(definition: PipelineAgentDefinition, context?: Context | undefined);
+    constructor(definition: PipelineAgentDefinition, context?: Context);
     run(input: I, options: RunOptions & {
         stream: true;
     }): Promise<RunnableResponseStream<O>>;

package/lib/types/runnable.d.ts

@@ -1,12 +1,19 @@
+import { Context, ContextState } from './context';
 import { DataType } from './data-type';
+import { Memorable } from './memorable';
 import { OrderedRecord } from './utils/ordered-map';
 export interface RunOptions {
     stream?: boolean;
 }
 export type RunnableResponse<T> = T | RunnableResponseStream<T>;
-export declare abstract class Runnable<I extends {} = {}, O extends {} = {}> {
+export declare abstract class Runnable<I extends {
+    [name: string]: any;
+} = {}, O extends {
+    [name: string]: any;
+} = {}, State extends ContextState = ContextState> {
     definition: RunnableDefinition;
-    constructor(definition: RunnableDefinition);
+    context?: Context<State> | undefined;
+    constructor(definition: RunnableDefinition, context?: Context<State> | undefined);
     get id(): string;
     get name(): string | undefined;
     inputs: {
@@ -28,9 +35,23 @@ export interface RunnableDefinition {
     type: string;
     name?: string;
     description?: string;
+    memories?: OrderedRecord<RunnableMemory>;
     inputs: OrderedRecord<RunnableInput>;
     outputs: OrderedRecord<RunnableOutput>;
 }
+export interface RunnableMemory {
+    id: string;
+    name?: string;
+    memory?: Memorable<any>;
+    query?: {
+        from: 'variable';
+        fromVariableId?: string;
+        fromVariablePropPath?: string[];
+    };
+    options?: {
+        k?: number;
+    };
+}
 export type RunnableInput = DataType;
 export type RunnableOutput = DataType;
 export interface RunnableResponseDelta<T> {