@aigne/core 0.4.209 → 0.4.211-beta.1

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/open-api-agent.d.ts

@@ -0,0 +1,55 @@
+import { Agent } from './agent';
+import type { Context, ContextState } from './context';
+import { DataTypeSchema, SchemaMapType } from './definitions/data-type-schema';
+import { CreateRunnableMemory } from './definitions/memory';
+import { AuthConfig, FetchRequest, HTTPMethod, OpenAPIDataType, OpenAPIDataTypeSchema } from './definitions/open-api';
+import { MemorableSearchOutput, MemoryItemWithScore } from './memorable';
+import { RunnableDefinition } from './runnable';
+import { OrderedRecord } from './utils';
+export declare class OpenAPIAgent<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: OpenAPIAgentDefinition;
+    static create: typeof create;
+    constructor(definition: OpenAPIAgentDefinition, context?: Context<State>);
+    process(input: I): Promise<any>;
+    fetch(request: FetchRequest): Promise<any>;
+}
+export interface OpenAPIAgentDefinition extends RunnableDefinition {
+    type: 'open_api_agent';
+    inputs: OrderedRecord<OpenAPIDataType>;
+    url: string;
+    method?: HTTPMethod;
+    auth?: AuthConfig;
+}
+export interface CreateOpenAPIAgentOptions<I extends {
+    [name: string]: OpenAPIDataTypeSchema;
+}, O extends {
+    [name: string]: DataTypeSchema;
+}, Memories extends {
+    [name: string]: CreateRunnableMemory<I>;
+}, State extends ContextState> {
+    context?: Context<State>;
+    id?: string;
+    name?: string;
+    inputs: I;
+    outputs: O;
+    memories?: Memories;
+    url: string;
+    method?: HTTPMethod;
+    auth?: AuthConfig;
+}
+declare function create<I extends {
+    [name: string]: OpenAPIDataTypeSchema;
+}, O extends {
+    [name: string]: DataTypeSchema;
+}, Memories extends {
+    [name: string]: CreateRunnableMemory<I>;
+}, State extends ContextState>({ context, ...options }: CreateOpenAPIAgentOptions<I, O, Memories, State>): OpenAPIAgent<SchemaMapType<I>, SchemaMapType<O>, {
+    [name in keyof Memories]: MemorableSearchOutput<Memories[name]['memory']>;
+}, State>;
+export {};