@aigne/core 0.4.205 → 0.4.206

package/lib/esm/utils/index.js

@@ -1,4 +1,7 @@
-export * from './ordered-map';
 export * from './is-non-nullable';
-export * from './stream-utils';
 export * from './mustache-utils';
+export * from './nullable';
+export * from './omit';
+export * from './ordered-map';
+export * from './stream-utils';
+export * from './union';

package/lib/esm/utils/stream-utils.js

@@ -28,24 +28,41 @@ export async function runnableResponseStreamToObject(stream) {
  * @returns The runnable output stream or object
  */
 export async function extractOutputsFromRunnableOutput(output, resolve) {
-    if (!(output instanceof ReadableStream)) {
-        await resolve(output);
-        return output;
+    if (output instanceof ReadableStream || isAsyncGenerator(output)) {
+        return new ReadableStream({
+            async start(controller) {
+                try {
+                    const result = {};
+                    let $text = '';
+                    for await (const value of output) {
+                        if (isRunnableResponseDelta(value)) {
+                            controller.enqueue(value);
+                            $text += value.$text || '';
+                            Object.assign(result, value.delta);
+                        }
+                    }
+                    Object.assign(result, { $text: result.$text || $text || undefined });
+                    await resolve(result);
+                }
+                catch (error) {
+                    controller.error(error);
+                }
+                finally {
+                    controller.close();
+                }
+            },
+        });
     }
+    await resolve(output);
+    return output;
+}
+export function asyncGeneratorToReadableStream(generator) {
     return new ReadableStream({
         async start(controller) {
             try {
-                const result = {};
-                let $text = '';
-                for await (const value of output) {
-                    if (isRunnableResponseDelta(value)) {
-                        $text += value.$text || '';
-                        Object.assign(result, value.delta);
-                    }
+                for await (const value of generator) {
+                    controller.enqueue(value);
                 }
-                Object.assign(result, { $text: result.$text || $text || undefined });
-                controller.enqueue({ $text: result.$text, delta: result });
-                await resolve(result);
             }
             catch (error) {
                 controller.error(error);
@@ -56,3 +73,6 @@ export async function extractOutputsFromRunnableOutput(output, resolve) {
         },
     });
 }
+export function isAsyncGenerator(value) {
+    return Symbol.asyncIterator in value;
+}

package/lib/types/agent.d.ts

@@ -1,9 +1,9 @@
 import { Context, ContextState } from './context';
 import { MemoryItemWithScore, MemoryMessage } from './memorable';
-import { RunOptions, Runnable, RunnableResponse, RunnableResponseStream } from './runnable';
+import { RunOptions, Runnable, RunnableResponse, RunnableResponseChunk, RunnableResponseStream } from './runnable';
 export interface AgentProcessOptions<Memories extends {
     [name: string]: MemoryItemWithScore[];
-}> extends RunOptions {
+}> {
     memories: Memories;
 }
 export declare abstract class Agent<I extends {
@@ -32,11 +32,10 @@ export declare abstract class Agent<I extends {
     run(input: I, options?: RunOptions & {
         stream?: false;
     }): Promise<O>;
-    abstract process(input: I, options: AgentProcessOptions<Memories> & {
-        stream: true;
-    }): Promise<RunnableResponseStream<O>>;
-    abstract process(input: I, options: AgentProcessOptions<Memories> & {
-        stream?: false;
-    }): Promise<O>;
-    abstract process(input: I, options: AgentProcessOptions<Memories>): Promise<RunnableResponse<O>>;
+    /**
+     * Hook that is called before the agent result is returned.
+     * @param _result The agent result.
+     */
+    protected onResult(_result: O): Promise<void>;
+    abstract process(input: I, options: AgentProcessOptions<Memories>): Promise<RunnableResponse<O> | AsyncGenerator<RunnableResponseChunk<O>, void>> | AsyncGenerator<RunnableResponseChunk<O>, void>;
 }

package/lib/types/context.d.ts

@@ -6,4 +6,6 @@ export interface ContextState {
 export interface Context<State extends ContextState = ContextState> {
     state: State;
     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/definitions/data-type-schema.d.ts

@@ -1,6 +1,6 @@
-import { DataType } from '../data-type';
 import { OrderedRecord } from '../utils';
 import { MakeNullablePropertyOptional } from '../utils/nullable';
+import { DataType } from './data-type';
 export declare function schemaToDataType(dataType: {
     [name: string]: DataTypeSchema;
 }): OrderedRecord<DataType>;
@@ -20,17 +20,19 @@ export interface DataTypeSchemaBoolean extends DataTypeSchemaBase {
 }
 export interface DataTypeSchemaObject extends DataTypeSchemaBase {
     type: 'object';
-    properties: {
+    properties?: {
         [key: string]: DataTypeSchema;
     };
 }
 export interface DataTypeSchemaArray extends DataTypeSchemaBase {
     type: 'array';
-    items: DataTypeSchema;
+    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;
+    [K in keyof T['properties']]: SchemaType<NonNullable<T['properties']>[K]>;
+}> : T extends DataTypeSchemaArray ? T['items'] extends null | undefined ? SchemaType<{
+    type: 'object';
+}>[] : NonNullable<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';

package/lib/types/{data-type.d.ts → definitions/data-type.d.ts}

@@ -1,5 +1,5 @@
-import { OmitPropsFromUnion } from './utils/omit';
-import { OrderedRecord } from './utils/ordered-map';
+import { OmitPropsFromUnion } from '../utils/omit';
+import { OrderedRecord } from '../utils/ordered-map';
 export type DataType = DataTypeString | DataTypeNumber | DataTypeBoolean | DataTypeObject | DataTypeArray;
 export interface DataTypeBase {
     id: string;

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

@@ -1,34 +1,47 @@
+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 { FunctionRunner } from './function-runner';
-import { RunOptions, Runnable, RunnableDefinition, RunnableResponseStream } from './runnable';
-export declare class FunctionAgent<I extends {} = {}, O extends {} = {}> extends Runnable<I, O> {
+import { MemorableSearchOutput, MemoryItemWithScore } from './memorable';
+import { RunnableDefinition } from './runnable';
+export declare class FunctionAgent<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: FunctionAgentDefinition;
-    runner?: FunctionRunner | undefined;
-    static create<I extends {
-        [name: string]: DataTypeSchema;
-    }, O extends {
-        [name: string]: DataTypeSchema;
-    }>(options: Parameters<typeof createFunctionAgentDefinition<I, O>>[0]): FunctionAgent<SchemaMapType<I>, SchemaMapType<O>>;
-    constructor(definition: FunctionAgentDefinition, runner?: FunctionRunner | undefined);
-    run(input: I, options: RunOptions & {
-        stream: true;
-    }): Promise<RunnableResponseStream<O>>;
-    run(input: I, options?: RunOptions & {
-        stream?: false;
-    }): Promise<O>;
+    runner?: FunctionRunner<I, O, Memories, State> | undefined;
+    static create: typeof create;
+    constructor(definition: FunctionAgentDefinition, context?: Context<State>, runner?: FunctionRunner<I, O, Memories, State> | undefined);
+    process(input: I, options: AgentProcessOptions<Memories>): Promise<import("./runnable").RunnableResponseStream<O>>;
 }
-export declare function createFunctionAgentDefinition<I extends {
+export interface CreateFunctionAgentOptions<I extends {
     [name: string]: DataTypeSchema;
 }, O extends {
     [name: string]: DataTypeSchema;
-}>(options: {
-    id?: string;
+}, Memories extends {
+    [name: string]: CreateRunnableMemory<I>;
+}, State extends ContextState> {
+    context?: Context<State>;
     name?: string;
     inputs: I;
     outputs: O;
-    language: string;
+    memories?: Memories;
+    language?: string;
     code: string;
-}): FunctionAgentDefinition;
+}
+export declare function create<I extends {
+    [name: string]: DataTypeSchema;
+}, O extends {
+    [name: string]: DataTypeSchema;
+}, Memories extends {
+    [name: string]: CreateRunnableMemory<I>;
+}, State extends ContextState>({ context, ...options }: CreateFunctionAgentOptions<I, O, Memories, State>): FunctionAgent<SchemaMapType<I>, SchemaMapType<O>, {
+    [name in keyof Memories]: MemorableSearchOutput<Memories[name]['memory']>;
+}, State>;
 export interface FunctionAgentDefinition extends RunnableDefinition {
     type: 'function_agent';
     language?: string;

package/lib/types/function-runner.d.ts

@@ -1,12 +1,25 @@
-import { Context } from './context';
-import { Runnable } from './runnable';
-export interface FunctionRunnerInputs {
+import { Agent } from './agent';
+import { Context, ContextState } from './context';
+import { MemoryItemWithScore } from './memorable';
+export interface FunctionRunnerInput<I extends {
+    [name: string]: any;
+} = {}, Memories extends {
+    [name: string]: MemoryItemWithScore[];
+} = {}, State extends ContextState = ContextState> {
     name: string;
-    language: string;
+    language?: string;
     code: string;
-    arguments?: object;
+    input: I;
+    memories: Memories;
+    context: Pick<Context<State>, 'state'>;
 }
-export type FunctionRunnerOutputs = object;
-export declare abstract class FunctionRunner extends Runnable<FunctionRunnerInputs, FunctionRunnerOutputs> {
+export type FunctionRunnerOutput<O> = O;
+export declare abstract class FunctionRunner<I extends {
+    [name: string]: any;
+} = {}, O extends {
+    [name: string]: any;
+} = {}, Memories extends {
+    [name: string]: MemoryItemWithScore[];
+} = {}, State extends ContextState = ContextState> extends Agent<FunctionRunnerInput<I, Memories, State>, FunctionRunnerOutput<O>> {
     constructor(context?: Context);
 }

package/lib/types/index.d.ts

@@ -1,6 +1,6 @@
 export * from './utils';
 export * from './constants';
-export * from './data-type';
+export * from './definitions/data-type';
 export * from './definitions/data-type-schema';
 export * from './context';
 export * from './runnable';

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

@@ -1,10 +1,10 @@
 import { Agent, AgentProcessOptions } from './agent';
-import type { Context } from './context';
+import type { Context, ContextState } from './context';
 import { DataTypeSchema, SchemaMapType } from './definitions/data-type-schema';
 import { CreateRunnableMemory } from './definitions/memory';
 import { LLMModel, LLMModelInputMessage, LLMModelInputs } from './llm-model';
 import { MemorableSearchOutput, MemoryItemWithScore } from './memorable';
-import { RunnableDefinition, RunnableResponseStream } from './runnable';
+import { RunnableDefinition } from './runnable';
 import { OrderedRecord } from './utils/ordered-map';
 export declare class LLMAgent<I extends {
     [name: string]: any;
@@ -12,28 +12,29 @@ export declare class LLMAgent<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: LLMAgentDefinition;
     model?: LLMModel | undefined;
-    static create<I extends {
-        [name: string]: DataTypeSchema;
-    }, O extends {
-        [name: string]: DataTypeSchema;
-    }, Memories extends {
-        [name: string]: CreateRunnableMemory<I>;
-    }>(options: Parameters<typeof createLLMAgentDefinition<I, O, Memories>>[0]): LLMAgent<SchemaMapType<I>, SchemaMapType<O>, {
-        [name in keyof Memories]: MemorableSearchOutput<Memories[name]['memory']>;
-    }>;
-    constructor(definition: LLMAgentDefinition, context?: Context, model?: LLMModel | undefined);
-    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: LLMAgentDefinition, context?: Context<State>, model?: LLMModel | undefined);
+    process(input: I, options: AgentProcessOptions<Memories>): AsyncGenerator<{
+        $text: string | undefined;
+        delta?: undefined;
+    } | {
+        delta: any;
+        $text?: undefined;
+    }, void, unknown>;
     private runWithStructuredOutput;
     private runWithTextOutput;
 }
+export interface LLMAgentDefinition extends RunnableDefinition {
+    type: 'llm_agent';
+    primaryMemoryId?: string;
+    messages?: OrderedRecord<LLMModelInputMessage & {
+        id: string;
+    }>;
+    modelOptions?: LLMModelInputs['modelOptions'];
+}
 /**
  * Options to create LLMAgent.
  */
@@ -43,7 +44,8 @@ export interface CreateLLMAgentOptions<I extends {
     [name: string]: DataTypeSchema;
 }, Memories extends {
     [name: string]: CreateRunnableMemory<I>;
-}> {
+}, State extends ContextState> {
+    context?: Context<State>;
     /**
      * Agent name, used to identify the agent.
      */
@@ -74,7 +76,7 @@ export interface CreateLLMAgentOptions<I extends {
  * @param options Options to create LLMAgent.
  * @returns LLMAgent definition.
  */
-export declare function createLLMAgentDefinition<I extends {
+declare function create<I extends {
     [name: string]: DataTypeSchema;
 }, O extends {
     [name: string]: DataTypeSchema;
@@ -88,12 +90,7 @@ export declare function createLLMAgentDefinition<I extends {
          */
         primary?: boolean;
     };
-}>(options: CreateLLMAgentOptions<I, O, Memories>): LLMAgentDefinition;
-export interface LLMAgentDefinition extends RunnableDefinition {
-    type: 'llm_agent';
-    primaryMemoryId?: string;
-    messages?: OrderedRecord<LLMModelInputMessage & {
-        id: string;
-    }>;
-    modelOptions?: LLMModelInputs['modelOptions'];
-}
+}, State extends ContextState>({ context, ...options }: CreateLLMAgentOptions<I, O, Memories, State>): LLMAgent<SchemaMapType<I>, SchemaMapType<O>, {
+    [name in keyof Memories]: MemorableSearchOutput<Memories[name]['memory']>;
+}, State>;
+export {};

package/lib/types/llm-decision-agent.d.ts

@@ -4,11 +4,11 @@ import { DataTypeSchema } from './definitions/data-type-schema';
 import { CreateRunnableMemory } from './definitions/memory';
 import { CreateLLMAgentOptions, LLMAgentDefinition } from './llm-agent';
 import { LLMModel } from './llm-model';
-import { MemoryItemWithScore } from './memorable';
-import { Runnable, RunnableDefinition, RunnableResponseStream } from './runnable';
+import { MemorableSearchOutput, MemoryItemWithScore } from './memorable';
+import { Runnable, RunnableDefinition } from './runnable';
 import { OrderedRecord } from './utils';
 import { ExtractRunnableInputType, ExtractRunnableOutputType } from './utils/runnable-type';
-import { ObjectUnionToIntersection } from './utils/union';
+import { UnionToIntersection } from './utils/union';
 export declare class LLMDecisionAgent<I extends {
     [name: string]: any;
 } = {}, O extends {
@@ -18,20 +18,9 @@ export declare class LLMDecisionAgent<I extends {
 } = {}, State extends ContextState = ContextState> extends Agent<I, O, Memories, State> {
     definition: LLMDecisionAgentDefinition;
     model?: LLMModel | undefined;
-    static create<Case extends DecisionAgentCaseParameter, I extends ObjectUnionToIntersection<ExtractRunnableInputType<Case['runnable']>, {
-        [name: string]: DataTypeSchema;
-    }>, O extends ObjectUnionToIntersection<ExtractRunnableOutputType<Case['runnable']>, {
-        [name: string]: DataTypeSchema;
-    }>, Memories extends {
-        [name: string]: CreateRunnableMemory<I>;
-    }>(options: Parameters<typeof createLLMDecisionAgentDefinition<Case, I, O, Memories>>[0]): LLMDecisionAgent<ObjectUnionToIntersection<ExtractRunnableInputType<Case['runnable']>>, ExtractRunnableOutputType<Case['runnable']>>;
+    static create: typeof create;
     constructor(definition: LLMDecisionAgentDefinition, context?: Context<State>, model?: LLMModel | undefined);
-    process(input: I, options: AgentProcessOptions<Memories> & {
-        stream: true;
-    }): Promise<RunnableResponseStream<O>>;
-    process(input: I, options: AgentProcessOptions<Memories> & {
-        stream?: false;
-    }): Promise<O>;
+    process(input: I, options: AgentProcessOptions<Memories>): Promise<import("./runnable").RunnableResponse<O>>;
 }
 export interface DecisionAgentCaseParameter<R extends Runnable = Runnable> {
     description?: string;
@@ -40,20 +29,21 @@ export interface DecisionAgentCaseParameter<R extends Runnable = Runnable> {
 /**
  * Options to create LLMDecisionAgent.
  */
-export interface CreateLLMDecisionAgentOptions<Case extends DecisionAgentCaseParameter, I extends ObjectUnionToIntersection<ExtractRunnableInputType<Case['runnable']>, {
+export interface CreateLLMDecisionAgentOptions<Case extends DecisionAgentCaseParameter, I extends UnionToIntersection<ExtractRunnableInputType<Case['runnable']>, {
     [name: string]: DataTypeSchema;
-}>, O extends ObjectUnionToIntersection<ExtractRunnableOutputType<Case['runnable']>, {
+}>, O extends UnionToIntersection<ExtractRunnableOutputType<Case['runnable']>, {
     [name: string]: DataTypeSchema;
 }>, Memories extends {
     [name: string]: CreateRunnableMemory<I>;
-}> extends Pick<CreateLLMAgentOptions<I, O, Memories>, 'name' | 'memories' | 'messages' | 'modelOptions'> {
+}, State extends ContextState> extends Pick<CreateLLMAgentOptions<I, O, Memories, State>, 'name' | 'memories' | 'messages' | 'modelOptions'> {
+    context: Context<State>;
     cases: {
         [name: string]: Case;
     };
 }
-export declare function createLLMDecisionAgentDefinition<Case extends DecisionAgentCaseParameter, I extends ObjectUnionToIntersection<ExtractRunnableInputType<Case['runnable']>, {
+declare function create<Case extends DecisionAgentCaseParameter, I extends UnionToIntersection<ExtractRunnableInputType<Case['runnable']>, {
     [name: string]: DataTypeSchema;
-}>, O extends ObjectUnionToIntersection<ExtractRunnableOutputType<Case['runnable']>, {
+}>, O extends UnionToIntersection<ExtractRunnableOutputType<Case['runnable']>, {
     [name: string]: DataTypeSchema;
 }>, Memories extends {
     [name: string]: CreateRunnableMemory<I> & {
@@ -65,7 +55,9 @@ export declare function createLLMDecisionAgentDefinition<Case extends DecisionAg
          */
         primary?: boolean;
     };
-}>(options: CreateLLMDecisionAgentOptions<Case, I, O, Memories>): LLMDecisionAgentDefinition;
+}, State extends ContextState>({ context, ...options }: CreateLLMDecisionAgentOptions<Case, I, O, Memories, State>): LLMDecisionAgent<UnionToIntersection<ExtractRunnableInputType<Case['runnable']>, {}>, ExtractRunnableOutputType<Case['runnable']>, {
+    [name in keyof Memories]: MemorableSearchOutput<Memories[name]['memory']>;
+}, State>;
 export interface LLMDecisionAgentDefinition extends RunnableDefinition, Pick<LLMAgentDefinition, 'modelOptions' | 'messages' | 'primaryMemoryId'> {
     type: 'llm_decision_agent';
     cases?: OrderedRecord<LLMDecisionCase>;
@@ -78,3 +70,4 @@ export interface LLMDecisionCase {
         id?: string;
     };
 }
+export {};

package/lib/types/llm-model.d.ts

@@ -1,5 +1,5 @@
+import { Agent } from './agent';
 import { Context } from './context';
-import { Runnable } from './runnable';
 export type Role = 'system' | 'user' | 'assistant' | 'tool';
 export interface LLMModelInputs {
     messages: LLMModelInputMessage[];
@@ -71,7 +71,7 @@ export interface LLMModelOutputs {
         };
     }[];
 }
-export declare abstract class LLMModel extends Runnable<LLMModelInputs, LLMModelOutputs> {
+export declare abstract class LLMModel extends Agent<LLMModelInputs, LLMModelOutputs> {
     constructor(context?: Context);
 }
 export interface LLMModelConfiguration {

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

@@ -3,7 +3,7 @@ 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';
+import { RunnableDefinition, RunnableResponse, RunnableResponseChunk } from './runnable';
 export declare class LocalFunctionAgent<I extends {
     [name: string]: any;
 } = {}, O extends {
@@ -12,22 +12,31 @@ export declare class LocalFunctionAgent<I 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;
-    }, 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>;
+    static create: typeof create;
     constructor(definition: LocalFunctionAgentDefinition<I, O, Memories, State>, context?: Context<State>);
-    process(input: I, options: AgentProcessOptions<Memories> & {
-        stream: true;
-    }): Promise<RunnableResponseStream<O>>;
-    process(input: I, options: AgentProcessOptions<Memories> & {
-        stream?: false;
-    }): Promise<O>;
+    process(input: I, options: AgentProcessOptions<Memories>): Promise<AsyncGenerator<RunnableResponseChunk<O>, void, any> | RunnableResponse<O>>;
+}
+export interface LocalFunctionAgentDefinition<I extends {
+    [name: string]: any;
+}, O extends {
+    [name: string]: any;
+}, Memories extends {
+    [name: string]: MemoryItemWithScore[];
+}, State extends ContextState> extends RunnableDefinition {
+    type: 'local_function_agent';
+    function?: LocalFunctionFuncType<I, O, Memories, State>;
+}
+export interface LocalFunctionFuncType<I extends {
+    [name: string]: any;
+}, O extends {
+    [name: string]: any;
+}, Memories extends {
+    [name: string]: MemoryItemWithScore[];
+}, State extends ContextState> {
+    (input: I, options: {
+        memories: Memories;
+        context: Context<State>;
+    }): Promise<RunnableResponse<O> | AsyncGenerator<RunnableResponseChunk<O>, void>> | AsyncGenerator<RunnableResponseChunk<O>, void>;
 }
 export interface CreateLocalFunctionAgentOptions<I extends {
     [name: string]: DataTypeSchema;
@@ -35,7 +44,8 @@ export interface CreateLocalFunctionAgentOptions<I extends {
     [name: string]: DataTypeSchema;
 }, Memories extends {
     [name: string]: CreateRunnableMemory<I>;
-}, State extends ContextState = ContextState> {
+}, State extends ContextState> {
+    context?: Context<State>;
     name?: string;
     inputs: I;
     outputs: O;
@@ -44,26 +54,13 @@ export interface CreateLocalFunctionAgentOptions<I extends {
         [key in keyof Memories]: MemorableSearchOutput<Memories[key]['memory']>;
     }, State>;
 }
-export declare function createLocalFunctionAgentDefinition<I extends {
+declare function create<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 extends ContextState>({ context, ...options }: CreateLocalFunctionAgentOptions<I, O, Memories, State>): LocalFunctionAgent<SchemaMapType<I>, SchemaMapType<O>, {
+    [name in keyof Memories]: MemorableSearchOutput<Memories[name]['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<O>>;
-}
-export interface LocalFunctionAgentDefinition<I extends {} = {}, O extends {} = {}, Memories extends {
-    [name: string]: MemoryItemWithScore[];
-} = {}, State extends ContextState = ContextState> extends RunnableDefinition {
-    type: 'local_function_agent';
-    function?: LocalFunctionFuncType<I, O, Memories, State>;
-}
+export {};