@aigne/core 1.0.4 → 1.0.6

package/lib/dts/{function-runner.d.ts → sandbox-function-runner.d.ts}

@@ -1,7 +1,7 @@
 import { Agent } from "./agent";
 import type { Context, ContextState } from "./context";
 import type { MemoryItemWithScore } from "./memorable";
-export interface FunctionRunnerInput<I extends {
+export interface SandboxFunctionRunnerInput<I extends {
     [name: string]: any;
 } = {}, Memories extends {
     [name: string]: MemoryItemWithScore[];
@@ -13,13 +13,13 @@ export interface FunctionRunnerInput<I extends {
     memories: Memories;
     context: Pick<Context<State>, "state">;
 }
-export type FunctionRunnerOutput<O> = O;
-export declare abstract class FunctionRunner<I extends {
+export type SandboxFunctionRunnerOutput<O> = O;
+export declare abstract class SandboxFunctionRunner<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>> {
+} = {}, State extends ContextState = ContextState> extends Agent<SandboxFunctionRunnerInput<I, Memories, State>, SandboxFunctionRunnerOutput<O>> {
     constructor(context?: Context);
 }

package/lib/esm/constants.d.ts

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

package/lib/esm/constants.js

@@ -2,6 +2,6 @@ export const TYPES = {
     context: Symbol.for("AIGNE_CONTEXT"),
     definition: Symbol.for("AIGNE_DEFINITION"),
     llmModel: Symbol.for("AIGNE_LLM_MODEL"),
-    functionRunner: Symbol.for("AIGNE_FUNCTION_RUNNER"),
+    sandboxFunctionRunner: Symbol.for("AIGNE_SANDBOX_FUNCTION_RUNNER"),
 };
 export const StreamTextOutputName = "$text";

package/lib/esm/definitions/open-api.d.ts

@@ -11,7 +11,7 @@ export interface BaseAuthConfig {
 }
 export interface CustomAuthConfig {
     type: "custom";
-    getValue: () => Promise<AuthResult> | AuthResult;
+    auth: () => Promise<AuthResult> | AuthResult;
 }
 export type AuthConfig = BaseAuthConfig | CustomAuthConfig;
 export type AuthType = AuthConfig["type"];

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

@@ -2,9 +2,8 @@ import { Agent, type AgentProcessOptions } from "./agent";
 import type { Context, ContextState } from "./context";
 import { type DataTypeSchema, type SchemaMapType } from "./definitions/data-type-schema";
 import { type CreateRunnableMemory } from "./definitions/memory";
-import type { FunctionRunner } from "./function-runner";
 import type { MemorableSearchOutput, MemoryItemWithScore } from "./memorable";
-import type { RunnableDefinition } from "./runnable";
+import type { RunnableDefinition, RunnableResponse, RunnableResponseChunk } from "./runnable";
 export declare class FunctionAgent<I extends {
     [name: string]: any;
 } = {}, O extends {
@@ -12,12 +11,31 @@ export declare class FunctionAgent<I extends {
 } = {}, Memories extends {
     [name: string]: MemoryItemWithScore[];
 } = {}, State extends ContextState = ContextState> extends Agent<I, O, Memories, State> {
-    definition: FunctionAgentDefinition;
-    runner?: FunctionRunner<I, O, Memories, State> | undefined;
+    definition: FunctionAgentDefinition<I, O, Memories, State>;
     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>>;
+    constructor(definition: FunctionAgentDefinition<I, O, Memories, State>, context?: Context<State>);
+    process(input: I, options: AgentProcessOptions<Memories>): Promise<AsyncGenerator<RunnableResponseChunk<O>, void, any> | RunnableResponse<O>>;
 }
+export interface FunctionAgentDefinition<I extends {
+    [name: string]: any;
+}, O extends {
+    [name: string]: any;
+}, Memories extends {
+    [name: string]: MemoryItemWithScore[];
+}, State extends ContextState> extends RunnableDefinition {
+    type: "function_agent";
+    function?: FunctionFuncType<I, O, Memories, State>;
+}
+export type FunctionFuncType<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 CreateFunctionAgentOptions<I extends {
     [name: string]: DataTypeSchema;
 }, O extends {
@@ -30,10 +48,11 @@ export interface CreateFunctionAgentOptions<I extends {
     inputs: I;
     outputs: O;
     memories?: Memories;
-    language?: string;
-    code: string;
+    function?: FunctionFuncType<SchemaMapType<I>, SchemaMapType<O>, {
+        [key in keyof Memories]: MemorableSearchOutput<Memories[key]["memory"]>;
+    }, State>;
 }
-export declare function create<I extends {
+declare function create<I extends {
     [name: string]: DataTypeSchema;
 }, O extends {
     [name: string]: DataTypeSchema;
@@ -42,8 +61,4 @@ export declare function create<I extends {
 }, 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;
-    code?: string;
-}
+export {};

package/lib/esm/function-agent.js

@@ -18,45 +18,32 @@ import { schemaToDataType, } from "./definitions/data-type-schema";
 import { toRunnableMemories, } from "./definitions/memory";
 let FunctionAgent = class FunctionAgent extends Agent {
     definition;
-    runner;
     static create = create;
-    constructor(definition, context, runner) {
+    constructor(definition, context) {
         super(definition, context);
         this.definition = definition;
-        this.runner = runner;
-        this.runner ??= context?.resolveDependency(TYPES.functionRunner);
     }
     async process(input, options) {
-        const { definition: { language, code, ...definition }, runner, context, } = this;
-        if (!runner)
-            throw new Error("Function runner is required");
-        if (!code)
-            throw new Error("Code is required");
+        const { definition: { function: func }, context, } = this;
+        if (!func)
+            throw new Error("Function is required");
         if (!context)
             throw new Error("Context is required");
-        return await runner.run({
-            name: definition.name || definition.id,
-            language,
-            code,
-            input,
-            memories: options.memories,
-            context: { state: context.state },
-        }, { stream: true });
+        return await func(input, { context, memories: options.memories });
     }
 };
 FunctionAgent = __decorate([
     injectable(),
     __param(0, inject(TYPES.definition)),
     __param(1, inject(TYPES.context)),
-    __param(2, inject(TYPES.functionRunner)),
-    __metadata("design:paramtypes", [Object, Object, Function])
+    __metadata("design:paramtypes", [Object, Object])
 ], FunctionAgent);
 export { FunctionAgent };
-export function create({ context, ...options }) {
+function create({ context, ...options }) {
     const agentId = options.name || nanoid();
     const inputs = schemaToDataType(options.inputs);
     const outputs = schemaToDataType(options.outputs);
-    const memories = toRunnableMemories(agentId, inputs, options.memories ?? {});
+    const memories = toRunnableMemories(agentId, inputs, options.memories || {});
     return new FunctionAgent({
         id: agentId,
         name: options.name,
@@ -64,7 +51,6 @@ export function create({ context, ...options }) {
         inputs,
         outputs,
         memories,
-        language: options.language,
-        code: options.code,
+        function: options.function,
     }, context);
 }

package/lib/esm/index.d.ts

@@ -6,16 +6,16 @@ export * from "./definitions/data-type-schema";
 export * from "./definitions/memory";
 export * from "./definitions/open-api";
 export * from "./function-agent";
-export * from "./function-runner";
 export * from "./llm-agent";
 export * from "./llm-decision-agent";
 export * from "./llm-model";
 export * from "./llm-models/gemini-llm-model";
 export * from "./llm-models/openai-llm-model";
-export * from "./local-function-agent";
 export * from "./memorable";
 export * from "./open-api-agent";
 export * from "./pipeline-agent";
 export * from "./runnable";
 export * from "./runtime";
+export * from "./sandbox-function-agent";
+export * from "./sandbox-function-runner";
 export * from "./utils";

package/lib/esm/index.js

@@ -6,16 +6,16 @@ export * from "./definitions/data-type-schema";
 export * from "./definitions/memory";
 export * from "./definitions/open-api";
 export * from "./function-agent";
-export * from "./function-runner";
 export * from "./llm-agent";
 export * from "./llm-decision-agent";
 export * from "./llm-model";
 export * from "./llm-models/gemini-llm-model";
 export * from "./llm-models/openai-llm-model";
-export * from "./local-function-agent";
 export * from "./memorable";
 export * from "./open-api-agent";
 export * from "./pipeline-agent";
 export * from "./runnable";
 export * from "./runtime";
+export * from "./sandbox-function-agent";
+export * from "./sandbox-function-runner";
 export * from "./utils";

package/lib/esm/runtime.d.ts

@@ -1,9 +1,9 @@
 import { type DependencyContainer } from "tsyringe";
 import type { constructor as Constructor } from "tsyringe/dist/typings/types";
 import type { Context, ContextState } from "./context";
-import type { FunctionRunner } from "./function-runner";
 import type { LLMModel, LLMModelConfiguration } from "./llm-model";
 import { Runnable, type RunnableDefinition } from "./runnable";
+import type { SandboxFunctionRunner } from "./sandbox-function-runner";
 import { OrderedRecord } from "./utils/ordered-map";
 import type { DeepPartial } from "./utils/partial";
 export interface RuntimeConfiguration {
@@ -18,7 +18,7 @@ export interface RuntimeOptions<Agents extends {
     state?: State;
     agents?: Agents;
     llmModel?: LLMModel | Constructor<LLMModel>;
-    functionRunner?: FunctionRunner | Constructor<FunctionRunner>;
+    sandboxFunctionRunner?: SandboxFunctionRunner | Constructor<SandboxFunctionRunner>;
 }
 export declare class Runtime<Agents extends {
     [name: string]: Runnable;

package/lib/esm/runtime.js

@@ -16,10 +16,10 @@ import { TYPES } from "./constants";
 import { FunctionAgent } from "./function-agent";
 import { LLMAgent } from "./llm-agent";
 import { LLMDecisionAgent } from "./llm-decision-agent";
-import { LocalFunctionAgent } from "./local-function-agent";
 import { OpenAPIAgent } from "./open-api-agent";
 import { PipelineAgent } from "./pipeline-agent";
 import { Runnable } from "./runnable";
+import { SandboxFunctionAgent } from "./sandbox-function-agent";
 import { OrderedRecord } from "./utils/ordered-map";
 let Runtime = Runtime_1 = class Runtime {
     constructor(options = {}) {
@@ -111,16 +111,18 @@ class RuntimeInner {
         this.state = options.state || {};
         this.container.register("pipeline_agent", { useClass: PipelineAgent });
         this.container.register("llm_agent", { useClass: LLMAgent });
-        this.container.register("function_agent", { useClass: FunctionAgent });
+        this.container.register("sandbox_function_agent", {
+            useClass: SandboxFunctionAgent,
+        });
         this.container.register("llm_decision_agent", {
             useClass: LLMDecisionAgent,
         });
-        this.container.register("local_function_agent", {
-            useClass: LocalFunctionAgent,
+        this.container.register("function_agent", {
+            useClass: FunctionAgent,
         });
         this.container.register("open_api_agent", { useClass: OpenAPIAgent });
-        if (options.functionRunner)
-            this.registerDependency(TYPES.functionRunner, options.functionRunner);
+        if (options.sandboxFunctionRunner)
+            this.registerDependency(TYPES.sandboxFunctionRunner, options.sandboxFunctionRunner);
         if (options.llmModel)
             this.registerDependency(TYPES.llmModel, options.llmModel);
     }

package/lib/esm/sandbox-function-agent.d.ts

@@ -0,0 +1,49 @@
+import { Agent, type AgentProcessOptions } from "./agent";
+import type { Context, ContextState } from "./context";
+import { type DataTypeSchema, type SchemaMapType } from "./definitions/data-type-schema";
+import { type CreateRunnableMemory } from "./definitions/memory";
+import type { MemorableSearchOutput, MemoryItemWithScore } from "./memorable";
+import type { RunnableDefinition } from "./runnable";
+import type { SandboxFunctionRunner } from "./sandbox-function-runner";
+export declare class SandboxFunctionAgent<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: SandboxFunctionAgentDefinition;
+    runner?: SandboxFunctionRunner<I, O, Memories, State> | undefined;
+    static create: typeof create;
+    constructor(definition: SandboxFunctionAgentDefinition, context?: Context<State>, runner?: SandboxFunctionRunner<I, O, Memories, State> | undefined);
+    process(input: I, options: AgentProcessOptions<Memories>): Promise<import("./runnable").RunnableResponseStream<O>>;
+}
+export interface CreateSandboxFunctionAgentOptions<I extends {
+    [name: string]: DataTypeSchema;
+}, O extends {
+    [name: string]: DataTypeSchema;
+}, Memories extends {
+    [name: string]: CreateRunnableMemory<I>;
+}, State extends ContextState> {
+    context?: Context<State>;
+    name?: string;
+    inputs: I;
+    outputs: O;
+    memories?: Memories;
+    language?: string;
+    code: string;
+}
+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 }: CreateSandboxFunctionAgentOptions<I, O, Memories, State>): SandboxFunctionAgent<SchemaMapType<I>, SchemaMapType<O>, {
+    [name in keyof Memories]: MemorableSearchOutput<Memories[name]["memory"]>;
+}, State>;
+export interface SandboxFunctionAgentDefinition extends RunnableDefinition {
+    type: "sandbox_function_agent";
+    language?: string;
+    code?: string;
+}

package/lib/esm/{local-function-agent.js → sandbox-function-agent.js}

@@ -16,41 +16,55 @@ import { Agent } from "./agent";
 import { TYPES } from "./constants";
 import { schemaToDataType, } from "./definitions/data-type-schema";
 import { toRunnableMemories, } from "./definitions/memory";
-let LocalFunctionAgent = class LocalFunctionAgent extends Agent {
+let SandboxFunctionAgent = class SandboxFunctionAgent extends Agent {
     definition;
+    runner;
     static create = create;
-    constructor(definition, context) {
+    constructor(definition, context, runner) {
         super(definition, context);
         this.definition = definition;
+        this.runner = runner;
+        this.runner ??= context?.resolveDependency(TYPES.sandboxFunctionRunner);
     }
     async process(input, options) {
-        const { definition: { function: func }, context, } = this;
-        if (!func)
-            throw new Error("Function is required");
+        const { definition: { language, code, ...definition }, runner, context, } = this;
+        if (!runner)
+            throw new Error("Sandbox function runner is required");
+        if (!code)
+            throw new Error("Code is required");
         if (!context)
             throw new Error("Context is required");
-        return await func(input, { context, memories: options.memories });
+        return await runner.run({
+            name: definition.name || definition.id,
+            language,
+            code,
+            input,
+            memories: options.memories,
+            context: { state: context.state },
+        }, { stream: true });
     }
 };
-LocalFunctionAgent = __decorate([
+SandboxFunctionAgent = __decorate([
     injectable(),
     __param(0, inject(TYPES.definition)),
     __param(1, inject(TYPES.context)),
-    __metadata("design:paramtypes", [Object, Object])
-], LocalFunctionAgent);
-export { LocalFunctionAgent };
-function create({ context, ...options }) {
+    __param(2, inject(TYPES.sandboxFunctionRunner)),
+    __metadata("design:paramtypes", [Object, Object, Function])
+], SandboxFunctionAgent);
+export { SandboxFunctionAgent };
+export function create({ context, ...options }) {
     const agentId = options.name || nanoid();
     const inputs = schemaToDataType(options.inputs);
     const outputs = schemaToDataType(options.outputs);
-    const memories = toRunnableMemories(agentId, inputs, options.memories || {});
-    return new LocalFunctionAgent({
+    const memories = toRunnableMemories(agentId, inputs, options.memories ?? {});
+    return new SandboxFunctionAgent({
         id: agentId,
         name: options.name,
-        type: "local_function_agent",
+        type: "sandbox_function_agent",
         inputs,
         outputs,
         memories,
-        function: options.function,
+        language: options.language,
+        code: options.code,
     }, context);
 }

package/lib/esm/{function-runner.d.ts → sandbox-function-runner.d.ts}

@@ -1,7 +1,7 @@
 import { Agent } from "./agent";
 import type { Context, ContextState } from "./context";
 import type { MemoryItemWithScore } from "./memorable";
-export interface FunctionRunnerInput<I extends {
+export interface SandboxFunctionRunnerInput<I extends {
     [name: string]: any;
 } = {}, Memories extends {
     [name: string]: MemoryItemWithScore[];
@@ -13,13 +13,13 @@ export interface FunctionRunnerInput<I extends {
     memories: Memories;
     context: Pick<Context<State>, "state">;
 }
-export type FunctionRunnerOutput<O> = O;
-export declare abstract class FunctionRunner<I extends {
+export type SandboxFunctionRunnerOutput<O> = O;
+export declare abstract class SandboxFunctionRunner<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>> {
+} = {}, State extends ContextState = ContextState> extends Agent<SandboxFunctionRunnerInput<I, Memories, State>, SandboxFunctionRunnerOutput<O>> {
     constructor(context?: Context);
 }

package/lib/esm/{function-runner.js → sandbox-function-runner.js}

@@ -1,11 +1,11 @@
 import { Agent } from "./agent";
 import { OrderedRecord } from "./utils";
-export class FunctionRunner extends Agent {
+export class SandboxFunctionRunner extends Agent {
     constructor(context) {
         super({
-            id: "function_runner",
-            type: "function_runner",
-            name: "Function Runner",
+            id: "sandbox_function_runner",
+            type: "sandbox_function_runner",
+            name: "Sandbox Function Runner",
             description: "Run a function",
             inputs: OrderedRecord.fromArray([
                 { id: "name", name: "name", type: "string", required: true },

package/lib/esm/utils/open-api-parameter.js

@@ -21,7 +21,7 @@ async function getAuthParams(auth) {
     if (!auth)
         return {};
     if (auth.type === "custom") {
-        return await auth.getValue();
+        return await auth.auth();
     }
     const { type, key, token } = auth;
     switch (auth.in) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/core",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "AIGNE core library",
   "publishConfig": {
     "access": "public"

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

@@ -1,64 +0,0 @@
-import { Agent, type AgentProcessOptions } from "./agent";
-import type { Context, ContextState } from "./context";
-import { type DataTypeSchema, type SchemaMapType } from "./definitions/data-type-schema";
-import { type CreateRunnableMemory } from "./definitions/memory";
-import type { MemorableSearchOutput, MemoryItemWithScore } from "./memorable";
-import type { RunnableDefinition, RunnableResponse, RunnableResponseChunk } from "./runnable";
-export declare class LocalFunctionAgent<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: LocalFunctionAgentDefinition<I, O, Memories, State>;
-    static create: typeof create;
-    constructor(definition: LocalFunctionAgentDefinition<I, O, Memories, State>, context?: Context<State>);
-    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 type 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;
-}, O extends {
-    [name: string]: DataTypeSchema;
-}, Memories extends {
-    [name: string]: CreateRunnableMemory<I>;
-}, State extends ContextState> {
-    context?: Context<State>;
-    name?: string;
-    inputs: I;
-    outputs: O;
-    memories?: Memories;
-    function?: LocalFunctionFuncType<SchemaMapType<I>, SchemaMapType<O>, {
-        [key in keyof Memories]: MemorableSearchOutput<Memories[key]["memory"]>;
-    }, State>;
-}
-declare function create<I extends {
-    [name: string]: DataTypeSchema;
-}, O extends {
-    [name: string]: DataTypeSchema;
-}, Memories extends {
-    [name: string]: CreateRunnableMemory<I>;
-}, 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 {};

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

@@ -1,64 +0,0 @@
-import { Agent, type AgentProcessOptions } from "./agent";
-import type { Context, ContextState } from "./context";
-import { type DataTypeSchema, type SchemaMapType } from "./definitions/data-type-schema";
-import { type CreateRunnableMemory } from "./definitions/memory";
-import type { MemorableSearchOutput, MemoryItemWithScore } from "./memorable";
-import type { RunnableDefinition, RunnableResponse, RunnableResponseChunk } from "./runnable";
-export declare class LocalFunctionAgent<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: LocalFunctionAgentDefinition<I, O, Memories, State>;
-    static create: typeof create;
-    constructor(definition: LocalFunctionAgentDefinition<I, O, Memories, State>, context?: Context<State>);
-    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 type 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;
-}, O extends {
-    [name: string]: DataTypeSchema;
-}, Memories extends {
-    [name: string]: CreateRunnableMemory<I>;
-}, State extends ContextState> {
-    context?: Context<State>;
-    name?: string;
-    inputs: I;
-    outputs: O;
-    memories?: Memories;
-    function?: LocalFunctionFuncType<SchemaMapType<I>, SchemaMapType<O>, {
-        [key in keyof Memories]: MemorableSearchOutput<Memories[key]["memory"]>;
-    }, State>;
-}
-declare function create<I extends {
-    [name: string]: DataTypeSchema;
-}, O extends {
-    [name: string]: DataTypeSchema;
-}, Memories extends {
-    [name: string]: CreateRunnableMemory<I>;
-}, 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 {};