@aigne/core 0.4.205-1 → 0.4.206

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

@@ -1,51 +1,57 @@
-import type { Context } from './context';
+import { Agent, AgentProcessOptions } from './agent';
+import type { Context, ContextState } from './context';
 import { DataTypeSchema, SchemaMapType } from './definitions/data-type-schema';
-import { RunOptions, Runnable, RunnableDefinition, RunnableOutput, RunnableResponseStream } from './runnable';
+import { CreateRunnableMemory } from './definitions/memory';
+import { MemorableSearchOutput, MemoryItemWithScore } from './memorable';
+import { Runnable, RunnableDefinition, RunnableOutput, RunnableResponseDelta } from './runnable';
+import { MakeNullablePropertyOptional } from './utils/nullable';
 import { OrderedRecord } from './utils/ordered-map';
+import { ExtractRunnableInputType } from './utils/runnable-type';
 export declare class PipelineAgent<I extends {
     [key: string]: any;
-} = {}, O extends {} = {}> extends Runnable<I, O> {
+} = {}, O extends {
+    [name: string]: any;
+} = {}, Memories extends {
+    [name: string]: MemoryItemWithScore[];
+} = {}, 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[];
-        };
-    }>(options: Parameters<typeof createPipelineAgentDefinition<I, O>>[0]): PipelineAgent<SchemaMapType<I>, SchemaMapType<O>>;
-    constructor(definition: PipelineAgentDefinition, context?: Context);
-    run(input: I, options: RunOptions & {
-        stream: true;
-    }): Promise<RunnableResponseStream<O>>;
-    run(input: I, options?: RunOptions & {
-        stream?: false;
-    }): Promise<O>;
+    static create: typeof create;
+    constructor(definition: PipelineAgentDefinition, context?: Context<State>);
+    process(input: I, options: AgentProcessOptions<Memories>): Promise<ReadableStream<RunnableResponseDelta<O>>>;
 }
-export interface PipelineAgentProcessParameter<I extends {} = {}, O extends {} = {}, R = Runnable<I, O>> {
-    name?: string;
+type VariableWithPropPath = {
+    fromVariable: string;
+    fromVariablePropPath?: (string | number)[];
+};
+export type PipelineAgentProcessParameter<R extends Runnable = any, RI extends {
+    [name: string]: DataTypeSchema;
+} = ExtractRunnableInputType<R>> = {
     runnable: R;
-    input?: {
-        [key: string]: {
-            fromVariable: string;
-            fromVariablePropPath?: string[];
-        } | undefined;
-    };
-}
-export declare function createPipelineAgentDefinition<I extends {
+    input: MakeNullablePropertyOptional<{
+        [key in keyof RI]: VariableWithPropPath;
+    }>;
+};
+declare function create<I extends {
     [name: string]: DataTypeSchema;
 }, O extends {
     [name: string]: DataTypeSchema & {
         fromVariable: string;
         fromVariablePropPath?: string[];
     };
-}>(options: {
-    id?: string;
+}, Memories extends {
+    [name: string]: CreateRunnableMemory<I>;
+}, State extends ContextState, Processes extends {
+    [name: string]: PipelineAgentProcessParameter;
+}>({ context, ...options }: {
+    context: Context<State>;
     name?: string;
     inputs: I;
     outputs: O;
-    processes?: PipelineAgentProcessParameter[];
-}): PipelineAgentDefinition;
+    memories?: Memories;
+    processes: Processes;
+}): 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>;
@@ -66,7 +72,8 @@ export type PipelineAgentProcess = {
         [inputId: string]: {
             from: 'variable';
             fromVariableId?: string;
-            fromVariablePropPath?: (string | number)[];
+            fromVariablePropPath?: (string | number | symbol)[];
         };
     };
 };
+export {};

package/lib/types/runnable.d.ts

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