@aigne/core 1.0.4 → 1.0.6

package/lib/cjs/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/cjs/constants.js

@@ -5,6 +5,6 @@ exports.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"),
 };
 exports.StreamTextOutputName = "$text";

package/lib/cjs/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/cjs/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/cjs/function-agent.js

@@ -13,7 +13,6 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FunctionAgent = void 0;
-exports.create = create;
 const nanoid_1 = require("nanoid");
 const tsyringe_1 = require("tsyringe");
 const agent_1 = require("./agent");
@@ -22,30 +21,18 @@ const data_type_schema_1 = require("./definitions/data-type-schema");
 const memory_1 = require("./definitions/memory");
 let FunctionAgent = class FunctionAgent extends agent_1.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(constants_1.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 });
     }
 };
 exports.FunctionAgent = FunctionAgent;
@@ -53,14 +40,13 @@ exports.FunctionAgent = FunctionAgent = __decorate([
     (0, tsyringe_1.injectable)(),
     __param(0, (0, tsyringe_1.inject)(constants_1.TYPES.definition)),
     __param(1, (0, tsyringe_1.inject)(constants_1.TYPES.context)),
-    __param(2, (0, tsyringe_1.inject)(constants_1.TYPES.functionRunner)),
-    __metadata("design:paramtypes", [Object, Object, Function])
+    __metadata("design:paramtypes", [Object, Object])
 ], FunctionAgent);
 function create({ context, ...options }) {
     const agentId = options.name || (0, nanoid_1.nanoid)();
     const inputs = (0, data_type_schema_1.schemaToDataType)(options.inputs);
     const outputs = (0, data_type_schema_1.schemaToDataType)(options.outputs);
-    const memories = (0, memory_1.toRunnableMemories)(agentId, inputs, options.memories ?? {});
+    const memories = (0, memory_1.toRunnableMemories)(agentId, inputs, options.memories || {});
     return new FunctionAgent({
         id: agentId,
         name: options.name,
@@ -68,7 +54,6 @@ function create({ context, ...options }) {
         inputs,
         outputs,
         memories,
-        language: options.language,
-        code: options.code,
+        function: options.function,
     }, context);
 }

package/lib/cjs/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/cjs/index.js

@@ -22,16 +22,16 @@ __exportStar(require("./definitions/data-type-schema"), exports);
 __exportStar(require("./definitions/memory"), exports);
 __exportStar(require("./definitions/open-api"), exports);
 __exportStar(require("./function-agent"), exports);
-__exportStar(require("./function-runner"), exports);
 __exportStar(require("./llm-agent"), exports);
 __exportStar(require("./llm-decision-agent"), exports);
 __exportStar(require("./llm-model"), exports);
 __exportStar(require("./llm-models/gemini-llm-model"), exports);
 __exportStar(require("./llm-models/openai-llm-model"), exports);
-__exportStar(require("./local-function-agent"), exports);
 __exportStar(require("./memorable"), exports);
 __exportStar(require("./open-api-agent"), exports);
 __exportStar(require("./pipeline-agent"), exports);
 __exportStar(require("./runnable"), exports);
 __exportStar(require("./runtime"), exports);
+__exportStar(require("./sandbox-function-agent"), exports);
+__exportStar(require("./sandbox-function-runner"), exports);
 __exportStar(require("./utils"), exports);

package/lib/cjs/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/cjs/runtime.js

@@ -19,10 +19,10 @@ const constants_1 = require("./constants");
 const function_agent_1 = require("./function-agent");
 const llm_agent_1 = require("./llm-agent");
 const llm_decision_agent_1 = require("./llm-decision-agent");
-const local_function_agent_1 = require("./local-function-agent");
 const open_api_agent_1 = require("./open-api-agent");
 const pipeline_agent_1 = require("./pipeline-agent");
 const runnable_1 = require("./runnable");
+const sandbox_function_agent_1 = require("./sandbox-function-agent");
 const ordered_map_1 = require("./utils/ordered-map");
 let Runtime = Runtime_1 = class Runtime {
     constructor(options = {}) {
@@ -114,16 +114,18 @@ class RuntimeInner {
         this.state = options.state || {};
         this.container.register("pipeline_agent", { useClass: pipeline_agent_1.PipelineAgent });
         this.container.register("llm_agent", { useClass: llm_agent_1.LLMAgent });
-        this.container.register("function_agent", { useClass: function_agent_1.FunctionAgent });
+        this.container.register("sandbox_function_agent", {
+            useClass: sandbox_function_agent_1.SandboxFunctionAgent,
+        });
         this.container.register("llm_decision_agent", {
             useClass: llm_decision_agent_1.LLMDecisionAgent,
         });
-        this.container.register("local_function_agent", {
-            useClass: local_function_agent_1.LocalFunctionAgent,
+        this.container.register("function_agent", {
+            useClass: function_agent_1.FunctionAgent,
         });
         this.container.register("open_api_agent", { useClass: open_api_agent_1.OpenAPIAgent });
-        if (options.functionRunner)
-            this.registerDependency(constants_1.TYPES.functionRunner, options.functionRunner);
+        if (options.sandboxFunctionRunner)
+            this.registerDependency(constants_1.TYPES.sandboxFunctionRunner, options.sandboxFunctionRunner);
         if (options.llmModel)
             this.registerDependency(constants_1.TYPES.llmModel, options.llmModel);
     }

package/lib/cjs/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/cjs/{local-function-agent.js → sandbox-function-agent.js}

@@ -12,48 +12,63 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LocalFunctionAgent = void 0;
+exports.SandboxFunctionAgent = void 0;
+exports.create = create;
 const nanoid_1 = require("nanoid");
 const tsyringe_1 = require("tsyringe");
 const agent_1 = require("./agent");
 const constants_1 = require("./constants");
 const data_type_schema_1 = require("./definitions/data-type-schema");
 const memory_1 = require("./definitions/memory");
-let LocalFunctionAgent = class LocalFunctionAgent extends agent_1.Agent {
+let SandboxFunctionAgent = class SandboxFunctionAgent extends agent_1.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(constants_1.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 });
     }
 };
-exports.LocalFunctionAgent = LocalFunctionAgent;
-exports.LocalFunctionAgent = LocalFunctionAgent = __decorate([
+exports.SandboxFunctionAgent = SandboxFunctionAgent;
+exports.SandboxFunctionAgent = SandboxFunctionAgent = __decorate([
     (0, tsyringe_1.injectable)(),
     __param(0, (0, tsyringe_1.inject)(constants_1.TYPES.definition)),
     __param(1, (0, tsyringe_1.inject)(constants_1.TYPES.context)),
-    __metadata("design:paramtypes", [Object, Object])
-], LocalFunctionAgent);
+    __param(2, (0, tsyringe_1.inject)(constants_1.TYPES.sandboxFunctionRunner)),
+    __metadata("design:paramtypes", [Object, Object, Function])
+], SandboxFunctionAgent);
 function create({ context, ...options }) {
     const agentId = options.name || (0, nanoid_1.nanoid)();
     const inputs = (0, data_type_schema_1.schemaToDataType)(options.inputs);
     const outputs = (0, data_type_schema_1.schemaToDataType)(options.outputs);
-    const memories = (0, memory_1.toRunnableMemories)(agentId, inputs, options.memories || {});
-    return new LocalFunctionAgent({
+    const memories = (0, memory_1.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/cjs/{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/cjs/{function-runner.js → sandbox-function-runner.js}

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FunctionRunner = void 0;
+exports.SandboxFunctionRunner = void 0;
 const agent_1 = require("./agent");
 const utils_1 = require("./utils");
-class FunctionRunner extends agent_1.Agent {
+class SandboxFunctionRunner extends agent_1.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: utils_1.OrderedRecord.fromArray([
                 { id: "name", name: "name", type: "string", required: true },
@@ -28,4 +28,4 @@ class FunctionRunner extends agent_1.Agent {
         }, context);
     }
 }
-exports.FunctionRunner = FunctionRunner;
+exports.SandboxFunctionRunner = SandboxFunctionRunner;

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

@@ -27,7 +27,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/lib/dts/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/dts/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/dts/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/dts/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/dts/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/dts/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;
+}