@aigne/core 1.0.9 → 1.0.11

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

@@ -1,7 +1,7 @@
 import { Agent } from "./agent";
 import type { Context } from "./context";
 export type Role = "system" | "user" | "assistant" | "tool";
-export interface LLMModelInputs {
+export type LLMModelInputs = {
     messages: LLMModelInputMessage[];
     responseFormat?: {
         type: "text";
@@ -23,7 +23,7 @@ export interface LLMModelInputs {
         };
     };
     modelOptions?: LLMModelOptions;
-}
+};
 export interface LLMModelInputMessage {
     role: Role;
     content: string | ({
@@ -60,7 +60,7 @@ export interface LLMModelOptions {
     frequencyPenalty?: number;
     presencePenalty?: number;
 }
-export interface LLMModelOutputs {
+export type LLMModelOutputs = {
     $text?: string | null;
     toolCalls?: {
         id?: string;
@@ -70,7 +70,7 @@ export interface LLMModelOutputs {
             arguments?: string;
         };
     }[];
-}
+};
 export declare abstract class LLMModel extends Agent<LLMModelInputs, LLMModelOutputs> {
     constructor(context?: Context);
 }

package/lib/esm/llm-models/openai-llm-model.d.ts

@@ -8,7 +8,9 @@ export declare class OpenaiLLMModel extends LLMModel {
     private client;
     setApiKey(apiKey: string): void;
     process(input: LLMModelInputs): AsyncGenerator<{
-        $text: string | undefined;
+        $text: string;
+        delta?: undefined;
+    } | {
         delta: {
             toolCalls: {
                 id?: string;
@@ -19,5 +21,6 @@ export declare class OpenaiLLMModel extends LLMModel {
                 };
             }[];
         };
+        $text?: undefined;
     }, void, unknown>;
 }

package/lib/esm/llm-models/openai-llm-model.js

@@ -37,22 +37,22 @@ export class OpenaiLLMModel extends LLMModel {
         const toolCalls = [];
         for await (const chunk of res) {
             const choice = chunk.choices?.[0];
-            const calls = choice?.delta.tool_calls?.map((i) => ({
-                id: i.id || nanoid(),
-                type: "function",
-                function: {
-                    name: i.function?.name,
-                    arguments: i.function?.arguments,
-                },
-            }));
-            if (calls?.length) {
-                toolCalls.push(...calls);
+            if (choice?.delta.tool_calls?.length) {
+                for (const call of choice.delta.tool_calls) {
+                    const tool = toolCalls[call.index] ?? { id: call.id || nanoid() };
+                    toolCalls[call.index] = tool;
+                    if (call.type)
+                        tool.type = call.type;
+                    tool.function ??= {};
+                    tool.function.name =
+                        (tool.function.name || "") + (call.function?.name || "");
+                    tool.function.arguments = (tool.function.arguments || "").concat(call.function?.arguments || "");
+                }
             }
-            yield {
-                $text: choice?.delta.content || undefined,
-                delta: { toolCalls },
-            };
+            if (choice?.delta.content)
+                yield { $text: choice.delta.content };
         }
+        yield { delta: { toolCalls } };
     }
 }
 async function contentsFromInputMessages(messages) {

package/lib/esm/memorable.d.ts

@@ -1,8 +1,7 @@
+import type { Context } from "./context";
 import type { LLMModelInputMessage } from "./llm-model";
 import { Runnable } from "./runnable";
-export interface MemoryMetadata {
-    [key: string]: any;
-}
+export type MemoryMetadata = Record<string, unknown>;
 export type MemoryActionItem<T> = {
     event: "add";
     id: string;
@@ -31,7 +30,7 @@ export interface MemoryItem<T> {
     memory: T;
     metadata: MemoryMetadata;
 }
-export interface MemoryItemWithScore<T = any> extends MemoryItem<T> {
+export interface MemoryItemWithScore<T = unknown> extends MemoryItem<T> {
     score: number;
 }
 export type MemoryMessage = LLMModelInputMessage;
@@ -110,13 +109,19 @@ export type MemoryActions<T> = {
 } | {
     action: "delete";
     inputs: {
-        filter: string | string[] | Record<string, any>;
+        filter: string | string[] | Record<string, unknown>;
+    };
+    outputs: {
+        [name: string]: never;
     };
-    outputs: {};
 } | {
     action: "reset";
-    inputs: {};
-    outputs: {};
+    inputs: {
+        [name: string]: never;
+    };
+    outputs: {
+        [name: string]: never;
+    };
 };
 export interface SortItem {
     field: string;
@@ -124,7 +129,7 @@ export interface SortItem {
 }
 export type MemorySortOptions = SortItem | SortItem[];
 export declare abstract class Memorable<T, C = undefined> extends Runnable<MemoryActions<T>, MemoryActions<T>["outputs"]> {
-    constructor();
+    constructor(context?: Context);
     abstract runner?: MemoryRunner<T, C>;
     abstract add(messages: Extract<MemoryActions<T>, {
         action: "add";
@@ -169,15 +174,18 @@ export declare abstract class Memorable<T, C = undefined> extends Runnable<Memor
     }>["outputs"]>;
     abstract reset(): Promise<void>;
 }
-export interface MemoryRunnerInput<C = undefined> {
+export type 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>[]> {
+};
+export type MemoryRunnerOutput<T> = {
+    actions: MemoryActionItem<T>[];
+};
+export declare abstract class MemoryRunner<T, C = undefined> extends Runnable<MemoryRunnerInput<C>, MemoryRunnerOutput<T>> {
     constructor(name: string);
 }
-export type MemorableSearchOutput<T extends Memorable<any>> = Awaited<ReturnType<T["search"]>>["results"];
+export type MemorableSearchOutput<T extends Memorable<unknown>> = Awaited<ReturnType<T["search"]>>["results"];

package/lib/esm/memorable.js

@@ -2,14 +2,14 @@ import { camelCase, startCase } from "lodash";
 import { Runnable } from "./runnable";
 import { OrderedRecord } from "./utils";
 export class Memorable extends Runnable {
-    constructor() {
+    constructor(context) {
         super({
             id: "memory",
             type: "memory",
             name: "Memory",
             inputs: OrderedRecord.fromArray([]),
             outputs: OrderedRecord.fromArray([]),
-        });
+        }, context);
     }
 }
 export class MemoryRunner extends Runnable {

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

@@ -1,55 +1,26 @@
-import { Agent } from "./agent";
+import { Agent, type AgentDefinition, type AgentMemories, type AgentPreloads, type AgentProcessInput, type CreateAgentInputSchema, type CreateAgentMemoriesSchema, type CreateAgentMemoriesType, type CreateAgentOptions, type CreateAgentOutputSchema, type CreateAgentPreloadsSchema, type CreateAgentPreloadsType } 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 { AuthConfig, FetchRequest, HTTPMethod, OpenAPIDataType, OpenAPIDataTypeSchema } from "./definitions/open-api";
-import type { MemorableSearchOutput, MemoryItemWithScore } from "./memorable";
-import type { RunnableDefinition } from "./runnable";
+import { type SchemaToType } from "./definitions/data-schema";
+import type { AuthConfig, FetchRequest, HTTPMethod, OpenAPIDataType } from "./definitions/open-api";
+import type { RunnableInput, RunnableOutput } from "./runnable";
 import type { OrderedRecord } from "./utils";
-export declare class OpenAPIAgent<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> {
+export declare class OpenAPIAgent<I extends RunnableInput = RunnableInput, O extends RunnableOutput = RunnableOutput, State extends ContextState = ContextState, Preloads extends AgentPreloads = AgentPreloads, Memories extends AgentMemories = AgentMemories> extends Agent<I, O, State, Preloads, Memories> {
     definition: OpenAPIAgentDefinition;
     static create: typeof create;
     constructor(definition: OpenAPIAgentDefinition, context?: Context<State>);
-    process(input: I): Promise<O>;
+    process(input: AgentProcessInput<I, Preloads, Memories>): Promise<O>;
     fetch<T>(request: FetchRequest): Promise<T>;
 }
-export interface OpenAPIAgentDefinition extends RunnableDefinition {
+export interface OpenAPIAgentDefinition extends AgentDefinition {
     type: "open_api_agent";
     inputs: OrderedRecord<OpenAPIDataType>;
     url: string;
     method?: HTTPMethod;
     auth?: AuthConfig;
 }
-export interface CreateOpenAPIAgentOptions<I extends {
-    [name: string]: OpenAPIDataTypeSchema;
-}, O extends {
-    [name: string]: DataTypeSchema;
-}, Memories extends {
-    [name: string]: CreateRunnableMemory<I>;
-}, State extends ContextState> {
-    context?: Context<State>;
-    id?: string;
-    name?: string;
-    inputs: I;
-    outputs: O;
-    memories?: Memories;
+declare function create<I extends CreateAgentInputSchema, O extends CreateAgentOutputSchema, State extends ContextState, Preloads extends CreateAgentPreloadsSchema<I>, Memories extends CreateAgentMemoriesSchema<I>>(options: CreateAgentOptions<I, O, State, Preloads, Memories> & {
     url: string;
     method?: HTTPMethod;
     auth?: AuthConfig;
-}
-declare function create<I extends {
-    [name: string]: OpenAPIDataTypeSchema;
-}, O extends {
-    [name: string]: DataTypeSchema;
-}, Memories extends {
-    [name: string]: CreateRunnableMemory<I>;
-}, State extends ContextState>({ context, ...options }: CreateOpenAPIAgentOptions<I, O, Memories, State>): OpenAPIAgent<SchemaMapType<I>, SchemaMapType<O>, {
-    [name in keyof Memories]: MemorableSearchOutput<Memories[name]["memory"]>;
-}, State>;
+}): OpenAPIAgent<SchemaToType<I>, SchemaToType<O>, State, CreateAgentPreloadsType<I, Preloads>, CreateAgentMemoriesType<I, Memories>>;
 export {};

package/lib/esm/open-api-agent.js

@@ -12,9 +12,11 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { nanoid } from "nanoid";
 import { inject, injectable } from "tsyringe";
-import { Agent } from "./agent";
+import { Agent, } from "./agent";
 import { TYPES } from "./constants";
-import { schemaToDataType, } from "./definitions/data-type-schema";
+import { schemaToDataType } from "./definitions/data-schema";
+import { toRunnableMemories } from "./definitions/memory";
+import { preloadCreatorsToPreloads } from "./definitions/preload";
 import { fetchOpenApi } from "./utils/fetch-open-api";
 import { formatOpenAPIRequest } from "./utils/open-api-parameter";
 let OpenAPIAgent = class OpenAPIAgent extends Agent {
@@ -42,18 +44,22 @@ OpenAPIAgent = __decorate([
     __metadata("design:paramtypes", [Object, Object])
 ], OpenAPIAgent);
 export { OpenAPIAgent };
-function create({ context, ...options }) {
-    const agentId = options.id || options.name || nanoid();
+function create(options) {
+    const agentId = options.name || nanoid();
     const inputs = schemaToDataType(options.inputs);
     const outputs = schemaToDataType(options.outputs);
+    const preloads = preloadCreatorsToPreloads(inputs, options.preloads);
+    const memories = toRunnableMemories(agentId, inputs, options.memories || {});
     return new OpenAPIAgent({
         id: agentId,
         name: options.name,
         type: "open_api_agent",
         inputs,
+        preloads,
+        memories,
         outputs,
         url: options.url,
         method: options.method,
         auth: options.auth,
-    }, context);
+    }, options.context);
 }

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

@@ -1,63 +1,40 @@
-import { Agent, type AgentProcessOptions } from "./agent";
+import { Agent, type AgentDefinition, type AgentMemories, type AgentPreloads, type AgentProcessInput, type AgentProcessOptions, type CreateAgentInputSchema, type CreateAgentMemoriesSchema, type CreateAgentMemoriesType, type CreateAgentOptions, type CreateAgentOutputSchema, type CreateAgentPreloadsSchema, type CreateAgentPreloadsType } 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 { Runnable, RunnableDefinition, RunnableOutput, RunnableResponseDelta } from "./runnable";
+import { type SchemaToType } from "./definitions/data-schema";
+import type { Runnable, RunnableInput, RunnableOutput, RunnableOutputType, RunnableResponseDelta } from "./runnable";
 import type { MakeNullablePropertyOptional } from "./utils/nullable";
 import { OrderedRecord } from "./utils/ordered-map";
 import type { ExtractRunnableInputType } from "./utils/runnable-type";
-export declare class PipelineAgent<I extends {
-    [key: string]: any;
-} = {}, O extends {
-    [name: string]: any;
-} = {}, Memories extends {
-    [name: string]: MemoryItemWithScore[];
-} = {}, State extends ContextState = ContextState> extends Agent<I, O, Memories, State> {
+export declare class PipelineAgent<I extends RunnableInput = RunnableInput, O extends RunnableOutput = RunnableOutput, State extends ContextState = ContextState, Preloads extends AgentPreloads = AgentPreloads, Memories extends AgentMemories = AgentMemories> extends Agent<I, O, State, AgentPreloads, Memories> {
     definition: PipelineAgentDefinition;
     static create: typeof create;
     constructor(definition: PipelineAgentDefinition, context?: Context<State>);
-    process(input: I, options: AgentProcessOptions<Memories>): Promise<import("stream/web").ReadableStream<RunnableResponseDelta<O>>>;
+    process(input: AgentProcessInput<I, Preloads, Memories>, options: AgentProcessOptions<Preloads, Memories>): Promise<import("stream/web").ReadableStream<RunnableResponseDelta<O>>>;
 }
 type VariableWithPropPath = {
     fromVariable: string;
     fromVariablePropPath?: (string | number)[];
 };
-export type PipelineAgentProcessParameter<R extends Runnable = any, RI extends {
-    [name: string]: DataTypeSchema;
-} = ExtractRunnableInputType<R>> = {
+export type PipelineAgentProcessParameter<R extends Runnable = Runnable, RI extends RunnableInput = ExtractRunnableInputType<R>> = {
     runnable: R;
     input: MakeNullablePropertyOptional<{
         [key in keyof RI]: VariableWithPropPath;
     }>;
 };
-declare function create<I extends {
-    [name: string]: DataTypeSchema;
-}, O extends {
-    [name: string]: DataTypeSchema & {
-        fromVariable: string;
-        fromVariablePropPath?: string[];
-    };
-}, Memories extends {
-    [name: string]: CreateRunnableMemory<I>;
-}, State extends ContextState, Processes extends {
+declare function create<I extends CreateAgentInputSchema, O extends CreateAgentOutputSchema<{
+    fromVariable: string;
+    fromVariablePropPath?: string[];
+}>, State extends ContextState, Preloads extends CreateAgentPreloadsSchema<I>, Memories extends CreateAgentMemoriesSchema<I>, Processes extends {
     [name: string]: PipelineAgentProcessParameter;
-}>({ context, ...options }: {
-    context: Context<State>;
-    name?: string;
-    inputs: I;
-    outputs: O;
-    memories?: Memories;
+}>(options: CreateAgentOptions<I, O, State, Preloads, Memories> & {
     processes: Processes;
-}): PipelineAgent<SchemaMapType<I>, SchemaMapType<O>, {
-    [name in keyof Memories]: MemorableSearchOutput<Memories[name]["memory"]>;
-}, State>;
-export interface PipelineAgentDefinition extends RunnableDefinition {
+}): PipelineAgent<SchemaToType<I>, SchemaToType<O>, State, CreateAgentPreloadsType<I, Preloads>, CreateAgentMemoriesType<I, Memories>>;
+export interface PipelineAgentDefinition extends AgentDefinition {
     type: "pipeline_agent";
     processes?: OrderedRecord<PipelineAgentProcess>;
     outputs: OrderedRecord<PipelineAgentOutput>;
 }
-export type PipelineAgentOutput = RunnableOutput & {
+export type PipelineAgentOutput = RunnableOutputType & {
     from: "variable";
     fromVariableId?: string;
     fromVariablePropPath?: (string | number)[];

package/lib/esm/pipeline-agent.js

@@ -13,12 +13,13 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 import { get, isNil } from "lodash";
 import { nanoid } from "nanoid";
 import { inject, injectable } from "tsyringe";
-import { Agent } from "./agent";
+import { Agent, } from "./agent";
 import { StreamTextOutputName, TYPES } from "./constants";
-import { schemaToDataType, } from "./definitions/data-type-schema";
-import { toRunnableMemories, } from "./definitions/memory";
-import logger from "./logger";
+import { schemaToDataType } from "./definitions/data-schema";
+import { toRunnableMemories } from "./definitions/memory";
+import { preloadCreatorsToPreloads } from "./definitions/preload";
 import { isNonNullable } from "./utils/is-non-nullable";
+import { logger } from "./utils/logger";
 import { OrderedRecord } from "./utils/ordered-map";
 let PipelineAgent = class PipelineAgent extends Agent {
     definition;
@@ -138,9 +139,10 @@ PipelineAgent = __decorate([
     __metadata("design:paramtypes", [Object, Object])
 ], PipelineAgent);
 export { PipelineAgent };
-function create({ context, ...options }) {
+function create(options) {
     const agentId = options.name || nanoid();
     const inputs = schemaToDataType(options.inputs);
+    const preloads = preloadCreatorsToPreloads(inputs, options.preloads);
     const memories = toRunnableMemories(agentId, inputs, options.memories || {});
     const processes = OrderedRecord.fromArray([]);
     for (const [name, p] of Object.entries(options.processes)) {
@@ -190,8 +192,9 @@ function create({ context, ...options }) {
         name: options.name,
         type: "pipeline_agent",
         inputs,
+        preloads,
         memories,
         outputs,
         processes,
-    }, context);
+    }, options.context);
 }

package/lib/esm/runnable.d.ts

@@ -1,16 +1,13 @@
 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;
 }
 export type RunnableResponse<T> = T | RunnableResponseStream<T>;
-export declare abstract class Runnable<I extends {
-    [name: string]: any;
-} = {}, O extends {
-    [name: string]: any;
-} = {}, State extends ContextState = ContextState> {
+export type RunnableInput = Record<string, any>;
+export type RunnableOutput = Record<string, any>;
+export declare abstract class Runnable<I extends RunnableInput = RunnableInput, O extends RunnableOutput = RunnableOutput, State extends ContextState = ContextState> {
     definition: RunnableDefinition;
     context?: Context<State> | undefined;
     constructor(definition: RunnableDefinition, context?: Context<State> | undefined);
@@ -35,25 +32,11 @@ export interface RunnableDefinition {
     type: string;
     name?: string;
     description?: string;
-    memories?: OrderedRecord<RunnableMemory>;
-    inputs: OrderedRecord<RunnableInput>;
-    outputs: OrderedRecord<RunnableOutput>;
+    inputs: OrderedRecord<RunnableInputType>;
+    outputs: OrderedRecord<RunnableOutputType>;
 }
-export interface RunnableMemory {
-    id: string;
-    name?: string;
-    memory?: Memorable<any>;
-    query?: {
-        from: "variable";
-        fromVariableId?: string;
-        fromVariablePropPath?: string[];
-    };
-    options?: {
-        k?: number;
-    };
-}
-export type RunnableInput = DataType;
-export type RunnableOutput = DataType;
+export type RunnableInputType = DataType;
+export type RunnableOutputType = DataType;
 export interface RunnableResponseDelta<T> {
     $text?: string;
     delta?: Partial<T>;

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

@@ -1,48 +1,20 @@
-import { Agent, type AgentProcessOptions } from "./agent";
+import { Agent, type AgentDefinition, type AgentMemories, type AgentPreloads, type AgentProcessInput, type AgentProcessOptions, type CreateAgentInputSchema, type CreateAgentMemoriesSchema, type CreateAgentMemoriesType, type CreateAgentOptions, type CreateAgentOutputSchema, type CreateAgentPreloadsSchema, type CreateAgentPreloadsType } 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 SchemaToType } from "./definitions/data-schema";
+import type { RunnableInput, RunnableOutput } 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> {
+export declare class SandboxFunctionAgent<I extends RunnableInput = RunnableInput, O extends RunnableOutput = RunnableOutput, State extends ContextState = ContextState, Preloads extends AgentPreloads = AgentPreloads, Memories extends AgentMemories = AgentMemories> extends Agent<I, O, State, Preloads, Memories> {
     definition: SandboxFunctionAgentDefinition;
-    runner?: SandboxFunctionRunner<I, O, Memories, State> | undefined;
+    runner?: SandboxFunctionRunner<I, O, State, Preloads, Memories> | 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>>;
+    constructor(definition: SandboxFunctionAgentDefinition, context?: Context<State>, runner?: SandboxFunctionRunner<I, O, State, Preloads, Memories> | undefined);
+    process(input: AgentProcessInput<I, Preloads, Memories>, options: AgentProcessOptions<Preloads, 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;
+export declare function create<I extends CreateAgentInputSchema, O extends CreateAgentOutputSchema, State extends ContextState, Preloads extends CreateAgentPreloadsSchema<I>, Memories extends CreateAgentMemoriesSchema<I>>(options: CreateAgentOptions<I, O, State, Preloads, 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 {
+}): SandboxFunctionAgent<SchemaToType<I>, SchemaToType<O>, State, CreateAgentPreloadsType<I, Preloads>, CreateAgentMemoriesType<I, Memories>>;
+export interface SandboxFunctionAgentDefinition extends AgentDefinition {
     type: "sandbox_function_agent";
     language?: string;
     code?: string;

package/lib/esm/sandbox-function-agent.js

@@ -12,10 +12,11 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { nanoid } from "nanoid";
 import { inject, injectable } from "tsyringe";
-import { Agent } from "./agent";
+import { Agent, } from "./agent";
 import { TYPES } from "./constants";
-import { schemaToDataType, } from "./definitions/data-type-schema";
-import { toRunnableMemories, } from "./definitions/memory";
+import { schemaToDataType } from "./definitions/data-schema";
+import { toRunnableMemories } from "./definitions/memory";
+import { preloadCreatorsToPreloads } from "./definitions/preload";
 let SandboxFunctionAgent = class SandboxFunctionAgent extends Agent {
     definition;
     runner;
@@ -39,6 +40,7 @@ let SandboxFunctionAgent = class SandboxFunctionAgent extends Agent {
             language,
             code,
             input,
+            preloads: options.preloads,
             memories: options.memories,
             context: { state: context.state },
         }, { stream: true });
@@ -52,10 +54,11 @@ SandboxFunctionAgent = __decorate([
     __metadata("design:paramtypes", [Object, Object, Function])
 ], SandboxFunctionAgent);
 export { SandboxFunctionAgent };
-export function create({ context, ...options }) {
+export function create(options) {
     const agentId = options.name || nanoid();
     const inputs = schemaToDataType(options.inputs);
     const outputs = schemaToDataType(options.outputs);
+    const preloads = preloadCreatorsToPreloads(inputs, options.preloads);
     const memories = toRunnableMemories(agentId, inputs, options.memories ?? {});
     return new SandboxFunctionAgent({
         id: agentId,
@@ -63,8 +66,9 @@ export function create({ context, ...options }) {
         type: "sandbox_function_agent",
         inputs,
         outputs,
+        preloads,
         memories,
         language: options.language,
         code: options.code,
-    }, context);
+    }, options.context);
 }

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

@@ -1,25 +1,16 @@
-import { Agent } from "./agent";
+import { Agent, type AgentMemories, type AgentPreloads } from "./agent";
 import type { Context, ContextState } from "./context";
-import type { MemoryItemWithScore } from "./memorable";
-export interface SandboxFunctionRunnerInput<I extends {
-    [name: string]: any;
-} = {}, Memories extends {
-    [name: string]: MemoryItemWithScore[];
-} = {}, State extends ContextState = ContextState> {
+import type { RunnableInput, RunnableOutput } from "./runnable";
+export type SandboxFunctionRunnerInput<Input extends RunnableInput = RunnableInput, State extends ContextState = ContextState, Preloads extends AgentPreloads = AgentPreloads, Memories extends AgentMemories = AgentMemories> = {
     name: string;
     language?: string;
     code: string;
-    input: I;
+    input: Input;
+    preloads: Preloads;
     memories: Memories;
     context: Pick<Context<State>, "state">;
-}
-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<SandboxFunctionRunnerInput<I, Memories, State>, SandboxFunctionRunnerOutput<O>> {
+};
+export type SandboxFunctionRunnerOutput<Output extends RunnableOutput> = Output;
+export declare abstract class SandboxFunctionRunner<I extends RunnableInput = RunnableInput, O extends RunnableOutput = RunnableOutput, State extends ContextState = ContextState, Preloads extends AgentPreloads = AgentPreloads, Memories extends AgentMemories = AgentMemories> extends Agent<SandboxFunctionRunnerInput<I, State, Preloads, Memories>, SandboxFunctionRunnerOutput<O>> {
     constructor(context?: Context);
 }

package/lib/esm/sandbox-function-runner.js

@@ -1,4 +1,4 @@
-import { Agent } from "./agent";
+import { Agent, } from "./agent";
 import { OrderedRecord } from "./utils";
 export class SandboxFunctionRunner extends Agent {
     constructor(context) {
@@ -12,6 +12,7 @@ export class SandboxFunctionRunner extends Agent {
                 { id: "language", name: "language", type: "string" },
                 { id: "code", name: "code", type: "string", required: true },
                 { id: "input", name: "input", type: "object", required: true },
+                { id: "preloads", name: "preloads", type: "object", required: true },
                 { id: "memories", name: "memories", type: "object", required: true },
                 { id: "context", name: "context", type: "object", required: true },
             ]),

package/lib/esm/utils/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./fetch";
 export * from "./fetch-open-api";
 export * from "./is-non-nullable";
+export * from "./logger";
 export * from "./mustache-utils";
 export * from "./nullable";
 export * from "./omit";

package/lib/esm/utils/index.js

@@ -1,6 +1,7 @@
 export * from "./fetch";
 export * from "./fetch-open-api";
 export * from "./is-non-nullable";
+export * from "./logger";
 export * from "./mustache-utils";
 export * from "./nullable";
 export * from "./omit";

package/lib/esm/utils/logger.d.ts

@@ -0,0 +1,3 @@
+type Logger = Pick<typeof console, "debug" | "info" | "warn" | "error">;
+export declare const logger: Logger;
+export {};