@aigne/core 0.4.207 → 0.4.208-beta.2

package/lib/types/constants.d.ts

@@ -2,7 +2,6 @@ export declare const TYPES: {
     context: symbol;
     definition: symbol;
     llmModel: symbol;
-    llmModelConfiguration: symbol;
     functionRunner: symbol;
 };
 export declare const StreamTextOutputName = "$text";

package/lib/types/context.d.ts

@@ -1,10 +1,15 @@
+import { LLMModelConfiguration } from './llm-model';
 import { Runnable, RunnableDefinition } from './runnable';
 export interface ContextState {
     userId?: string;
     sessionId?: string;
 }
-export interface Context<State extends ContextState = ContextState> {
+export interface ContextConfig {
+    llmModel?: LLMModelConfiguration;
+}
+export interface Context<State extends ContextState = ContextState, Config extends ContextConfig = ContextConfig> {
     state: State;
+    config: Config;
     resolve<T extends Runnable>(id: string | RunnableDefinition): Promise<T>;
     register<R extends Array<RunnableDefinition | Runnable> = []>(...definition: R): void;
     resolveDependency<T>(token: string | symbol): T;

package/lib/types/data-type-schema.d.ts

@@ -0,0 +1,46 @@
+import { DataType } from './data-type';
+import { OrderedRecord } from './utils';
+export declare function schemaToDataType(dataType: {
+    [name: string]: DataTypeSchema;
+}): OrderedRecord<DataType>;
+export type DataTypeSchema = DataTypeSchemaString | DataTypeSchemaNumber | DataTypeSchemaBoolean | DataTypeSchemaObject | DataTypeSchemaArray;
+export interface DataTypeSchemaBase {
+    description?: string;
+    required?: boolean;
+}
+export interface DataTypeSchemaString extends DataTypeSchemaBase {
+    type: 'string';
+}
+export interface DataTypeSchemaNumber extends DataTypeSchemaBase {
+    type: 'number';
+}
+export interface DataTypeSchemaBoolean extends DataTypeSchemaBase {
+    type: 'boolean';
+}
+export interface DataTypeSchemaObject extends DataTypeSchemaBase {
+    type: 'object';
+    properties: {
+        [key: string]: DataTypeSchema;
+    };
+}
+export interface DataTypeSchemaArray extends DataTypeSchemaBase {
+    type: 'array';
+    items: DataTypeSchema;
+}
+type SchemaTypeInner<T extends DataTypeSchema> = T extends DataTypeSchemaString ? string : T extends DataTypeSchemaNumber ? number : T extends DataTypeSchemaBoolean ? boolean : T extends DataTypeSchemaObject ? MakeNullablePropertyOptional<{
+    [K in keyof T['properties']]: SchemaType<T['properties'][K]>;
+}> : T extends DataTypeSchemaArray ? SchemaType<T['items']>[] : never;
+export type SchemaType<T extends DataTypeSchema> = T['required'] extends true ? SchemaTypeInner<T> : SchemaTypeInner<T> | undefined | null;
+export type SchemaMapType<T extends Record<string, DataTypeSchema>> = SchemaType<{
+    type: 'object';
+    required: true;
+    properties: T;
+}>;
+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];
+};
+export {};

package/lib/types/data-type.d.ts

@@ -0,0 +1,32 @@
+import { OmitPropsFromUnion } from './utils/omit';
+import { OrderedRecord } from './utils/ordered-map';
+export type DataType = DataTypeString | DataTypeNumber | DataTypeBoolean | DataTypeObject | DataTypeArray;
+export interface DataTypeBase {
+    id: string;
+    name?: string;
+    description?: string;
+    required?: boolean;
+}
+export interface DataTypeString extends DataTypeBase {
+    type: 'string';
+    defaultValue?: string;
+    multiline?: boolean;
+}
+export interface DataTypeNumber extends DataTypeBase {
+    type: 'number';
+    defaultValue?: number;
+}
+export interface DataTypeBoolean extends DataTypeBase {
+    type: 'boolean';
+    defaultValue?: boolean;
+}
+export interface DataTypeObject extends DataTypeBase {
+    type: 'object';
+    defaultValue?: object;
+    properties?: OrderedRecord<DataType>;
+}
+export interface DataTypeArray extends DataTypeBase {
+    type: 'array';
+    defaultValue?: object[];
+    items?: OmitPropsFromUnion<DataType, 'id'>;
+}

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);
+}