@aigne/core 0.4.205 → 0.4.206-0

package/lib/types/memory.d.ts

@@ -0,0 +1,184 @@
+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);
+}

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

@@ -1,9 +1,9 @@
 import { Agent, AgentProcessOptions } from './agent';
-import type { Context } from './context';
-import { DataTypeSchema, DataTypeSchemaObject, SchemaMapType } from './definitions/data-type-schema';
+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 { Runnable, RunnableDefinition, RunnableOutput, RunnableResponseStream } from './runnable';
+import { Runnable, RunnableDefinition, RunnableOutput, RunnableResponseDelta } from './runnable';
 import { MakeNullablePropertyOptional } from './utils/nullable';
 import { OrderedRecord } from './utils/ordered-map';
 import { ExtractRunnableInputType } from './utils/runnable-type';
@@ -13,50 +13,25 @@ export declare class PipelineAgent<I extends {
     [name: string]: any;
 } = {}, Memories extends {
     [name: string]: MemoryItemWithScore[];
-} = {}> extends Agent<I, O, Memories> {
+} = {}, State extends ContextState = ContextState> extends Agent<I, O, Memories, State> {
     definition: PipelineAgentDefinition;
-    static create<I extends {
-        [name: string]: DataTypeSchema;
-    }, O extends {
-        [name: string]: DataTypeSchema & {
-            fromVariable: string;
-            fromVariablePropPath?: string[];
-        };
-    }, Memories extends {
-        [name: string]: CreateRunnableMemory<I>;
-    }, Processes extends {
-        [name: string]: PipelineAgentProcessParameter<I>;
-    }>(options: Parameters<typeof createPipelineAgentDefinition<I, O, Memories, Processes>>[0]): PipelineAgent<SchemaMapType<I>, SchemaMapType<O>, {
-        [name in keyof Memories]: MemorableSearchOutput<Memories[name]['memory']>;
-    }>;
-    constructor(definition: PipelineAgentDefinition, context?: Context);
-    process(input: I, options: AgentProcessOptions<Memories> & {
-        stream: true;
-    }): Promise<RunnableResponseStream<O>>;
-    process(input: I, options: AgentProcessOptions<Memories> & {
-        stream?: false;
-    }): Promise<O>;
+    static create: typeof create;
+    constructor(definition: PipelineAgentDefinition, context?: Context<State>);
+    process(input: I, options: AgentProcessOptions<Memories>): Promise<ReadableStream<RunnableResponseDelta<O>>>;
 }
-type VariableWithPropPath<Vars extends {
-    [name: string]: DataTypeSchema;
-}, Var extends keyof Vars = keyof Vars> = {
-    fromVariable: Var;
-    fromVariablePropPath?: VariablePaths<Vars, Var>;
+type VariableWithPropPath = {
+    fromVariable: string;
+    fromVariablePropPath?: (string | number)[];
 };
-type VariablePaths<Vars extends {
-    [name: string]: DataTypeSchema;
-}, Var extends keyof Vars = keyof Vars> = Vars[Var] extends DataTypeSchemaObject ? Array<keyof Vars[Var]['properties']> : never;
-export type PipelineAgentProcessParameter<I extends {
-    [name: string]: DataTypeSchema;
-}, R extends Runnable = any, RI extends {
+export type PipelineAgentProcessParameter<R extends Runnable = any, RI extends {
     [name: string]: DataTypeSchema;
 } = ExtractRunnableInputType<R>> = {
     runnable: R;
     input: MakeNullablePropertyOptional<{
-        [key in keyof RI]: VariableWithPropPath<I>;
+        [key in keyof RI]: VariableWithPropPath;
     }>;
 };
-export interface CreatePipelineAgentOptions<I extends {
+declare function create<I extends {
     [name: string]: DataTypeSchema;
 }, O extends {
     [name: string]: DataTypeSchema & {
@@ -65,27 +40,18 @@ export interface CreatePipelineAgentOptions<I extends {
     };
 }, Memories extends {
     [name: string]: CreateRunnableMemory<I>;
-}, Processes extends {
-    [name: string]: PipelineAgentProcessParameter<I>;
-}> {
+}, State extends ContextState, Processes extends {
+    [name: string]: PipelineAgentProcessParameter;
+}>({ context, ...options }: {
+    context: Context<State>;
     name?: string;
     inputs: I;
     outputs: O;
-    memories: Memories;
+    memories?: Memories;
     processes: Processes;
-}
-export declare function createPipelineAgentDefinition<I extends {
-    [name: string]: DataTypeSchema;
-}, O extends {
-    [name: string]: DataTypeSchema & {
-        fromVariable: string;
-        fromVariablePropPath?: string[];
-    };
-}, Memories extends {
-    [name: string]: CreateRunnableMemory<I>;
-}, Processes extends {
-    [name: string]: PipelineAgentProcessParameter<I>;
-}>(options: CreatePipelineAgentOptions<I, O, Memories, Processes>): PipelineAgentDefinition;
+}): PipelineAgent<SchemaMapType<I>, SchemaMapType<O>, {
+    [name in keyof Memories]: MemorableSearchOutput<Memories[name]['memory']>;
+}, State>;
 export interface PipelineAgentDefinition extends RunnableDefinition {
     type: 'pipeline_agent';
     processes?: OrderedRecord<PipelineAgentProcess>;

package/lib/types/runnable.d.ts

@@ -1,5 +1,5 @@
 import type { Context, ContextState } from './context';
-import type { DataType } from './data-type';
+import type { DataType } from './definitions/data-type';
 import type { Memorable } from './memorable';
 import { OrderedRecord } from './utils/ordered-map';
 export interface RunOptions {