@aigne/core 1.0.1 → 1.0.2-beta.1

package/lib/dts/agent.d.ts

@@ -0,0 +1,41 @@
+import type { Context, ContextState } from "./context";
+import type { MemoryItemWithScore, MemoryMessage } from "./memorable";
+import { type RunOptions, Runnable, type RunnableResponse, type RunnableResponseChunk, type RunnableResponseStream } from "./runnable";
+export interface AgentProcessOptions<Memories extends {
+    [name: string]: MemoryItemWithScore[];
+}> {
+    memories: Memories;
+}
+export declare abstract class Agent<I extends {
+    [key: string]: any;
+} = {}, O extends {
+    [key: string]: any;
+} = {}, Memories extends {
+    [name: string]: MemoryItemWithScore[];
+} = {}, State extends ContextState = ContextState> extends Runnable<I, O, State> {
+    private getMemoryQuery;
+    /**
+     * Load memories that are defined in the agent definition.
+     * @param input The agent input.
+     * @param context The AIGNE context.
+     * @returns A dictionary of memories, where the key is the memory id or name and the value is an array of memory items.
+     */
+    protected loadMemories(input: I, context?: Context): Promise<Memories>;
+    /**
+     * Update memories by user messages and assistant responses.
+     * @param messages Messages to be added to memories.
+     */
+    protected updateMemories(messages: MemoryMessage[]): Promise<void>;
+    run(input: I, options: RunOptions & {
+        stream: true;
+    }): Promise<RunnableResponseStream<O>>;
+    run(input: I, options?: RunOptions & {
+        stream?: false;
+    }): Promise<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/dts/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const TYPES: {
+    context: symbol;
+    definition: symbol;
+    llmModel: symbol;
+    functionRunner: symbol;
+};
+export declare const StreamTextOutputName = "$text";

package/lib/dts/context.d.ts

@@ -0,0 +1,17 @@
+import type { LLMModelConfiguration } from "./llm-model";
+import type { Runnable, RunnableDefinition } from "./runnable";
+export interface ContextState {
+    userId?: string;
+    sessionId?: string;
+    [key: string]: any;
+}
+export interface ContextConfig {
+    llmModel?: LLMModelConfiguration;
+}
+export interface Context<State extends ContextState = ContextState, Config extends ContextConfig = ContextConfig> {
+    state: State;
+    config: Config;
+    resolve<T extends Runnable>(id: string | RunnableDefinition | T): Promise<T>;
+    register<R extends Array<RunnableDefinition | Runnable> = []>(...definition: R): void;
+    resolveDependency<T>(token: string | symbol): T;
+}

package/lib/dts/definitions/data-type-schema.d.ts

@@ -0,0 +1,42 @@
+import type { MakeNullablePropertyOptional } from "../utils/nullable";
+import { OrderedRecord } from "../utils/ordered-map";
+import type { DataType } from "./data-type";
+export declare function schemaToDataType(dataType: {
+    [name: string]: DataTypeSchema;
+}): OrderedRecord<DataType>;
+export type DataTypeSchema = DataTypeSchemaString | DataTypeSchemaNumber | DataTypeSchemaBoolean | DataTypeSchemaObject | DataTypeSchemaArray;
+export interface DataTypeSchemaBase {
+    description?: string;
+    required?: boolean;
+}
+export interface DataTypeSchemaString extends DataTypeSchemaBase {
+    type: "string";
+}
+export interface DataTypeSchemaNumber extends DataTypeSchemaBase {
+    type: "number";
+}
+export interface DataTypeSchemaBoolean extends DataTypeSchemaBase {
+    type: "boolean";
+}
+export interface DataTypeSchemaObject extends DataTypeSchemaBase {
+    type: "object";
+    properties?: {
+        [key: string]: DataTypeSchema;
+    };
+}
+export interface DataTypeSchemaArray extends DataTypeSchemaBase {
+    type: "array";
+    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<NonNullable<T["properties"]>[K]>;
+}> : T extends DataTypeSchemaArray ? T["items"] extends null | undefined ? SchemaType<{
+    type: "object";
+}>[] : SchemaType<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";
+    required: true;
+    properties: T;
+}>;
+export {};

package/lib/dts/definitions/data-type.d.ts

@@ -0,0 +1,32 @@
+import type { OmitPropsFromUnion } from "../utils/omit";
+import type { OrderedRecord } from "../utils/ordered-map";
+export type DataType = DataTypeString | DataTypeNumber | DataTypeBoolean | DataTypeObject | DataTypeArray;
+export interface DataTypeBase {
+    id: string;
+    name?: string;
+    description?: string;
+    required?: boolean;
+}
+export interface DataTypeString extends DataTypeBase {
+    type: "string";
+    defaultValue?: string;
+    multiline?: boolean;
+}
+export interface DataTypeNumber extends DataTypeBase {
+    type: "number";
+    defaultValue?: number;
+}
+export interface DataTypeBoolean extends DataTypeBase {
+    type: "boolean";
+    defaultValue?: boolean;
+}
+export interface DataTypeObject extends DataTypeBase {
+    type: "object";
+    defaultValue?: object;
+    properties?: OrderedRecord<DataType>;
+}
+export interface DataTypeArray extends DataTypeBase {
+    type: "array";
+    defaultValue?: object[];
+    items?: OmitPropsFromUnion<DataType, "id">;
+}

package/lib/dts/definitions/memory.d.ts

@@ -0,0 +1,40 @@
+import type { Memorable } from "../memorable";
+import type { RunnableInput, RunnableMemory } from "../runnable";
+import { OrderedRecord } from "../utils";
+import type { DataTypeSchema } from "./data-type-schema";
+export interface CreateRunnableMemory<I extends {
+    [key: string]: DataTypeSchema;
+} = {}> {
+    /**
+     * Memory instance to query/store memory.
+     */
+    memory: Memorable<any>;
+    /**
+     * Custom query to retrieve memory, if not provided, all input variables will be used.
+     *
+     * @example
+     * {
+     *   fromVariable: 'question' // question is a string input variable
+     * }
+     */
+    query?: {
+        /**
+         * Variable name from input used to query memory.
+         */
+        fromVariable?: keyof {
+            [key in keyof I as I[key]["type"] extends "string" ? key : never]: any;
+        };
+    };
+    /**
+     * Custom options for memory query.
+     */
+    options?: {
+        /**
+         * Number of memories to retrieve.
+         */
+        k?: number;
+    };
+}
+export declare function toRunnableMemories<I extends {}>(agentName: string, inputs: OrderedRecord<RunnableInput>, memories: {
+    [name: string]: CreateRunnableMemory<I>;
+}): OrderedRecord<RunnableMemory>;

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

@@ -0,0 +1,36 @@
+import type { DataType } from "./data-type";
+import type { DataTypeSchema } from "./data-type-schema";
+export interface BaseAuthConfig {
+    type: "bearer" | "basic";
+    token: string;
+    in?: "header" | "query" | "cookie";
+    /**
+     * The key to use for the token. Default `Authorization` in header and `token` in query and cookie.
+     */
+    key?: string;
+}
+export interface CustomAuthConfig {
+    type: "custom";
+    getValue: () => Promise<AuthResult> | AuthResult;
+}
+export type AuthConfig = BaseAuthConfig | CustomAuthConfig;
+export type AuthType = AuthConfig["type"];
+export type AuthResult = Pick<FetchRequest, "headers" | "query" | "cookies">;
+type HTTPMethodLowercase = "get" | "post" | "put" | "delete" | "patch" | "head" | "options";
+export type HTTPMethod = Uppercase<HTTPMethodLowercase> | Lowercase<HTTPMethodLowercase>;
+export type ParameterLocation = "path" | "query" | "body" | "header" | "cookie";
+export type OpenAPIDataType = DataType & {
+    in?: ParameterLocation;
+};
+export type OpenAPIDataTypeSchema = DataTypeSchema & {
+    in?: ParameterLocation;
+};
+export type FetchRequest = {
+    url: string;
+    method: HTTPMethod;
+    query?: Record<string, string | number | boolean>;
+    headers?: Record<string, string>;
+    cookies?: Record<string, string>;
+    body?: Record<string, any>;
+};
+export {};

package/lib/dts/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 { FunctionRunner } from "./function-runner";
+import type { MemorableSearchOutput, MemoryItemWithScore } from "./memorable";
+import type { 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<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 interface CreateFunctionAgentOptions<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 }: 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;
+}

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

@@ -0,0 +1,25 @@
+import { Agent } from "./agent";
+import type { Context, ContextState } from "./context";
+import type { MemoryItemWithScore } from "./memorable";
+export interface FunctionRunnerInput<I extends {
+    [name: string]: any;
+} = {}, Memories extends {
+    [name: string]: MemoryItemWithScore[];
+} = {}, State extends ContextState = ContextState> {
+    name: string;
+    language?: string;
+    code: string;
+    input: I;
+    memories: Memories;
+    context: Pick<Context<State>, "state">;
+}
+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/dts/index.d.ts

@@ -0,0 +1,18 @@
+export * from "./utils";
+export * from "./constants";
+export * from "./definitions/data-type";
+export * from "./definitions/data-type-schema";
+export * from "./definitions/open-api";
+export * from "./definitions/memory";
+export * from "./context";
+export * from "./runnable";
+export * from "./agent";
+export * from "./pipeline-agent";
+export * from "./llm-agent";
+export * from "./llm-model";
+export * from "./function-agent";
+export * from "./function-runner";
+export * from "./llm-decision-agent";
+export * from "./local-function-agent";
+export * from "./open-api-agent";
+export * from "./memorable";

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

@@ -0,0 +1,96 @@
+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 { LLMModel, LLMModelInputMessage, LLMModelInputs } from "./llm-model";
+import type { MemorableSearchOutput, MemoryItemWithScore } from "./memorable";
+import type { RunnableDefinition } from "./runnable";
+import { OrderedRecord } from "./utils/ordered-map";
+export declare class LLMAgent<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: LLMAgentDefinition;
+    model?: LLMModel | undefined;
+    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.
+ */
+export interface CreateLLMAgentOptions<I extends {
+    [name: string]: DataTypeSchema;
+}, O extends {
+    [name: string]: DataTypeSchema;
+}, Memories extends {
+    [name: string]: CreateRunnableMemory<I>;
+}, State extends ContextState> {
+    context?: Context<State>;
+    /**
+     * Agent name, used to identify the agent.
+     */
+    name?: string;
+    /**
+     * Input variables for this agent.
+     */
+    inputs: I;
+    /**
+     * Output variables for this agent.
+     */
+    outputs: O;
+    /**
+     * Memories to be used in this agent.
+     */
+    memories?: Memories;
+    /**
+     * Options for LLM chat model.
+     */
+    modelOptions?: LLMModelInputs["modelOptions"];
+    /**
+     * Messages to be passed to LLM chat model.
+     */
+    messages?: LLMModelInputMessage[];
+}
+/**
+ * Create LLMAgent definition.
+ * @param options Options to create LLMAgent.
+ * @returns LLMAgent definition.
+ */
+declare function create<I extends {
+    [name: string]: DataTypeSchema;
+}, O extends {
+    [name: string]: DataTypeSchema;
+}, Memories extends {
+    [name: string]: CreateRunnableMemory<I> & {
+        /**
+         * Whether this memory is primary? Primary memory will be passed as messages to LLM chat model,
+         * otherwise, it will be placed in a system message.
+         *
+         * Only one primary memory is allowed.
+         */
+        primary?: boolean;
+    };
+}, 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/dts/llm-decision-agent.d.ts

@@ -0,0 +1,73 @@
+import { Agent, type AgentProcessOptions } from "./agent";
+import type { Context, ContextState } from "./context";
+import type { DataTypeSchema } from "./definitions/data-type-schema";
+import { type CreateRunnableMemory } from "./definitions/memory";
+import type { CreateLLMAgentOptions, LLMAgentDefinition } from "./llm-agent";
+import type { LLMModel } from "./llm-model";
+import type { MemorableSearchOutput, MemoryItemWithScore } from "./memorable";
+import type { Runnable, RunnableDefinition } from "./runnable";
+import { OrderedRecord } from "./utils";
+import type { ExtractRunnableInputType, ExtractRunnableOutputType } from "./utils/runnable-type";
+import type { UnionToIntersection } from "./utils/union";
+export declare class LLMDecisionAgent<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: LLMDecisionAgentDefinition;
+    model?: LLMModel | undefined;
+    static create: typeof create;
+    constructor(definition: LLMDecisionAgentDefinition, context?: Context<State>, model?: LLMModel | undefined);
+    process(input: I, options: AgentProcessOptions<Memories>): Promise<import("./runnable").RunnableResponse<O>>;
+}
+export interface DecisionAgentCaseParameter<R extends Runnable = Runnable> {
+    description?: string;
+    runnable: R;
+}
+/**
+ * Options to create LLMDecisionAgent.
+ */
+export interface CreateLLMDecisionAgentOptions<Case extends DecisionAgentCaseParameter, I extends UnionToIntersection<ExtractRunnableInputType<Case["runnable"]>, {
+    [name: string]: DataTypeSchema;
+}>, O extends UnionToIntersection<ExtractRunnableOutputType<Case["runnable"]>, {
+    [name: string]: DataTypeSchema;
+}>, Memories extends {
+    [name: string]: CreateRunnableMemory<I>;
+}, State extends ContextState> extends Pick<CreateLLMAgentOptions<I, O, Memories, State>, "name" | "memories" | "messages" | "modelOptions"> {
+    context: Context<State>;
+    cases: {
+        [name: string]: Case;
+    };
+}
+declare function create<Case extends DecisionAgentCaseParameter, I extends UnionToIntersection<ExtractRunnableInputType<Case["runnable"]>, {
+    [name: string]: DataTypeSchema;
+}>, O extends UnionToIntersection<ExtractRunnableOutputType<Case["runnable"]>, {
+    [name: string]: DataTypeSchema;
+}>, Memories extends {
+    [name: string]: CreateRunnableMemory<I> & {
+        /**
+         * Whether this memory is primary? Primary memory will be passed as messages to LLM chat model,
+         * otherwise, it will be placed in a system message.
+         *
+         * Only one primary memory is allowed.
+         */
+        primary?: boolean;
+    };
+}, 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>;
+}
+export interface LLMDecisionCase {
+    id: string;
+    name?: string;
+    description?: string;
+    runnable?: {
+        id?: string;
+    };
+}
+export {};

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

@@ -0,0 +1,80 @@
+import { Agent } from "./agent";
+import type { Context } from "./context";
+export type Role = "system" | "user" | "assistant" | "tool";
+export interface LLMModelInputs {
+    messages: LLMModelInputMessage[];
+    responseFormat?: {
+        type: "text";
+    } | {
+        type: "json_schema";
+        jsonSchema: {
+            name: string;
+            description?: string;
+            schema: object;
+            strict?: boolean;
+        };
+    };
+    tools?: LLMModelInputTool[];
+    toolChoice?: "auto" | "none" | "required" | {
+        type: "function";
+        function: {
+            name: string;
+            description?: string;
+        };
+    };
+    modelOptions?: LLMModelOptions;
+}
+export interface LLMModelInputMessage {
+    role: Role;
+    content: string | ({
+        type: "text";
+        text: string;
+    } | {
+        type: "image_url";
+        imageUrl: {
+            url: string;
+        };
+    })[];
+    toolCalls?: {
+        id: string;
+        type: "function";
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }[];
+    toolCallId?: string;
+}
+export interface LLMModelInputTool {
+    type: "function";
+    function: {
+        name: string;
+        description?: string;
+        parameters: object;
+    };
+}
+export interface LLMModelOptions {
+    model?: string;
+    temperature?: number;
+    topP?: number;
+    frequencyPenalty?: number;
+    presencePenalty?: number;
+}
+export interface LLMModelOutputs {
+    $text?: string | null;
+    toolCalls?: {
+        id?: string;
+        type?: "function";
+        function?: {
+            name?: string;
+            arguments?: string;
+        };
+    }[];
+}
+export declare abstract class LLMModel extends Agent<LLMModelInputs, LLMModelOutputs> {
+    constructor(context?: Context);
+}
+export interface LLMModelConfiguration {
+    default?: Partial<LLMModelOptions>;
+    override?: Partial<LLMModelOptions>;
+}

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

@@ -0,0 +1,64 @@
+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/logger.d.ts

@@ -0,0 +1,2 @@
+declare const logger: Console;
+export default logger;