@aigne/core 1.0.17 → 1.1.0-beta.2

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

@@ -1,32 +0,0 @@
-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

@@ -1,53 +0,0 @@
-import type { Memorable } from "../memorable";
-import type { RunnableInputType } from "../runnable";
-import { OrderedRecord } from "../utils";
-import type { DataSchema } from "./data-schema";
-export interface AgentMemory {
-    id: string;
-    name?: string;
-    memory?: Memorable<unknown>;
-    query?: {
-        from: "variable";
-        fromVariableId?: string;
-        fromVariablePropPath?: string[];
-    };
-    options?: {
-        k?: number;
-    };
-}
-export interface CreateRunnableMemory<I extends {
-    [key: string]: DataSchema;
-} = {}> {
-    /**
-     * 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<RunnableInputType>, memories: {
-    [name: string]: CreateRunnableMemory<I>;
-}): OrderedRecord<AgentMemory>;

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

@@ -1,36 +0,0 @@
-import type { DataSchema } from "./data-schema";
-import type { DataType } from "./data-type";
-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";
-    auth: () => 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 = DataSchema & {
-    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, unknown>;
-};
-export {};

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

@@ -1,43 +0,0 @@
-import type { CreateAgentInputSchema, CreateAgentPreloadsSchema } from "../agent";
-import type { Runnable, RunnableInputType } from "../runnable";
-import { OrderedRecord } from "../utils/ordered-map";
-import type { ExtractRunnableInputType } from "../utils/runnable-type";
-import type { UnionToIntersection } from "../utils/union";
-import type { SchemaToType } from "./data-schema";
-export declare function preloadCreatorsToPreloads<I extends CreateAgentInputSchema, C extends CreateAgentPreloadsSchema<I>>(inputs: OrderedRecord<RunnableInputType>, creators?: C): OrderedRecord<AgentPreload>;
-export type PreloadCreator<I extends CreateAgentInputSchema> = (preload: <R extends Runnable, Input extends BindAgentInputs<SchemaToType<I>, R>>(runnable: R, input: Input, options?: {
-    description?: string;
-}) => Readonly<BoundAgent<I, R, Input>>) => ReturnType<typeof preload>;
-export type BindAgentInputs<Vars extends Record<string, unknown>, R extends Runnable> = {
-    [key in keyof ExtractRunnableInputType<R>]: BindAgentInput<Vars, ExtractRunnableInputType<R>[key]>;
-};
-export interface AgentPreload {
-    id: string;
-    name?: string;
-    runnable?: {
-        id: string;
-    };
-    input?: {
-        [inputId: string]: BindAgentInput;
-    };
-}
-export type BindAgentInput<Vars extends Record<string, unknown> = Record<string, unknown>, Input = unknown> = {
-    from: "ai";
-} | {
-    from: "input";
-    fromInput: keyof {
-        [name in keyof Vars as Vars[name] extends Input ? name : never]: name;
-    };
-};
-export interface BoundAgent<Vars extends Record<string, unknown> = Record<string, unknown>, R extends Runnable = Runnable, I extends BindAgentInputs<Vars, R> = BindAgentInputs<Vars, R>> {
-    description?: string;
-    runnable: R;
-    input?: I;
-}
-type PickInputFrom<I, From extends BindAgentInput["from"]> = {
-    [key in keyof I as I[key] extends {
-        from: From;
-    } ? key : never]: I[key];
-};
-export type OmitBoundAgentInput<Case extends BoundAgent, From extends BindAgentInput["from"]> = Omit<UnionToIntersection<ExtractRunnableInputType<Case["runnable"]>, Record<string, never>>, keyof PickInputFrom<Required<UnionToIntersection<NonNullable<Case["input"]>, Record<string, never>>>, From>>;
-export {};

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

@@ -1,23 +0,0 @@
-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 SchemaToType } from "./definitions/data-schema";
-import type { RunnableInput, RunnableOutput, RunnableResponse, RunnableResponseChunk } from "./runnable";
-export declare class FunctionAgent<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: FunctionAgentDefinition<I, O, State, Preloads, Memories>;
-    static create: typeof create;
-    constructor(definition: FunctionAgentDefinition<I, O, State, Preloads, Memories>, context?: Context<State>);
-    process(input: AgentProcessInput<I, Preloads, Memories>, options: AgentProcessOptions<Preloads, Memories>): Promise<AsyncGenerator<RunnableResponseChunk<O>, void, any> | RunnableResponse<O>>;
-}
-export interface FunctionAgentDefinition<I extends RunnableInput, O extends RunnableOutput, State extends ContextState, Preloads extends AgentPreloads, Memories extends AgentMemories> extends AgentDefinition {
-    type: "function_agent";
-    function?: FunctionFuncType<I, O, State, Preloads, Memories>;
-}
-export type FunctionFuncType<I extends RunnableInput, O extends RunnableOutput, State extends ContextState, Preloads extends AgentPreloads, Memories extends AgentMemories> = (input: AgentProcessInput<I, Preloads, Memories>, options: {
-    context: Context<State>;
-    preloads: Preloads;
-    memories: Memories;
-}) => Promise<RunnableResponse<O> | AsyncGenerator<RunnableResponseChunk<O>, void>> | AsyncGenerator<RunnableResponseChunk<O>, void>;
-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> & {
-    function?: FunctionFuncType<SchemaToType<I>, SchemaToType<O>, State, CreateAgentPreloadsType<I, Preloads>, CreateAgentMemoriesType<I, Memories>>;
-}): FunctionAgent<SchemaToType<I>, SchemaToType<O>, State, CreateAgentPreloadsType<I, Preloads>, CreateAgentMemoriesType<I, Memories>>;
-export {};

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

@@ -1,53 +0,0 @@
-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 SchemaToType } from "./definitions/data-schema";
-import type { LLMModel, LLMModelInputMessage, LLMModelInputs } from "./llm-model";
-import { type RunnableInput, type RunnableOutput } from "./runnable";
-import { OrderedRecord } from "./utils/ordered-map";
-export declare class LLMAgent<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: LLMAgentDefinition;
-    model?: LLMModel | undefined;
-    static create: typeof create;
-    constructor(definition: LLMAgentDefinition, context?: Context<State>, model?: LLMModel | undefined);
-    process(input: AgentProcessInput<I, Preloads, Memories>, options: AgentProcessOptions): AsyncGenerator<{
-        $text: string | undefined;
-        delta?: undefined;
-    } | {
-        delta: any;
-        $text?: undefined;
-    }, void, unknown>;
-    private runWithStructuredOutput;
-    private runWithTextOutput;
-}
-export interface LLMAgentDefinition extends AgentDefinition {
-    type: "llm_agent";
-    primaryMemoryId?: string;
-    messages?: OrderedRecord<LLMModelInputMessage & {
-        id: string;
-    }>;
-    modelOptions?: LLMModelInputs["modelOptions"];
-}
-/**
- * Create LLMAgent definition.
- * @param options Options to create LLMAgent.
- * @returns LLMAgent definition.
- */
-declare function create<I extends CreateAgentInputSchema, O extends CreateAgentOutputSchema, State extends ContextState, Preloads extends CreateAgentPreloadsSchema<I>, Memories extends CreateAgentMemoriesSchema<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;
-}>>(options: CreateAgentOptions<I, O, State, Preloads, Memories> & {
-    /**
-     * Options for LLM chat model.
-     */
-    modelOptions?: LLMModelInputs["modelOptions"];
-    /**
-     * Messages to be passed to LLM chat model.
-     */
-    messages?: LLMModelInputMessage[];
-}): LLMAgent<SchemaToType<I>, SchemaToType<O>, State, CreateAgentPreloadsType<I, Preloads>, CreateAgentMemoriesType<I, Memories>>;
-export {};

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

@@ -1,53 +0,0 @@
-import { Agent, type AgentDefinition, type AgentMemories, type AgentPreloads, type AgentProcessInput, type AgentProcessOptions, type CreateAgentMemoriesSchema, type CreateAgentMemoriesType, type CreateAgentOptions, type CreateAgentPreloadsSchema, type CreateAgentPreloadsType } from "./agent";
-import type { Context, ContextState } from "./context";
-import type { TypeToSchema } from "./definitions/data-schema";
-import type { BindAgentInput, BoundAgent, OmitBoundAgentInput } from "./definitions/preload";
-import type { LLMAgentDefinition } from "./llm-agent";
-import type { LLMModel, LLMModelInputMessage, LLMModelInputs } from "./llm-model";
-import type { RunnableInput, RunnableOutput } from "./runnable";
-import { OrderedRecord } from "./utils";
-import type { ExtractRunnableInputTypeIntersection, ExtractRunnableOutputType } from "./utils/runnable-type";
-export declare class LLMDecisionAgent<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: LLMDecisionAgentDefinition;
-    model?: LLMModel | undefined;
-    static create: typeof create;
-    constructor(definition: LLMDecisionAgentDefinition, context?: Context<State>, model?: LLMModel | undefined);
-    process(input: AgentProcessInput<I, Preloads, Memories>, options: AgentProcessOptions<Preloads, Memories>): Promise<import("./runnable").RunnableResponse<O>>;
-}
-declare function create<Case extends BoundAgent, InputType extends ExtractRunnableInputTypeIntersection<Case["runnable"]>, OutputType extends ExtractRunnableOutputType<Case["runnable"]>, State extends ContextState, Preloads extends CreateAgentPreloadsSchema<TypeToSchema<InputType>>, Memories extends CreateAgentMemoriesSchema<TypeToSchema<InputType>, {
-    /**
-     * 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;
-}>>(options: Omit<CreateAgentOptions<never, never, State, Preloads, Memories>, "inputs" | "outputs"> & {
-    cases: {
-        [name: string]: Case;
-    };
-    /**
-     * Options for LLM chat model.
-     */
-    modelOptions?: LLMModelInputs["modelOptions"];
-    /**
-     * Messages to be passed to LLM chat model.
-     */
-    messages?: LLMModelInputMessage[];
-}): LLMDecisionAgent<OmitBoundAgentInput<Case, "ai">, OutputType, State, CreateAgentPreloadsType<TypeToSchema<InputType>, Preloads>, CreateAgentMemoriesType<TypeToSchema<InputType>, Memories>>;
-export interface LLMDecisionAgentDefinition extends AgentDefinition, Pick<LLMAgentDefinition, "modelOptions" | "messages" | "primaryMemoryId"> {
-    type: "llm_decision_agent";
-    cases?: OrderedRecord<LLMDecisionCase>;
-}
-export interface LLMDecisionCase {
-    id: string;
-    name?: string;
-    description?: string;
-    runnable?: {
-        id?: string;
-    };
-    input?: {
-        [inputId: string]: BindAgentInput;
-    };
-}
-export {};

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

@@ -1,80 +0,0 @@
-import { Agent } from "./agent";
-import type { Context } from "./context";
-export type Role = "system" | "user" | "assistant" | "tool";
-export type 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 type 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/llm-models/gemini-llm-model.d.ts

@@ -1,24 +0,0 @@
-import { LLMModel, type LLMModelInputs } from "../llm-model";
-export declare class GeminiLLMModel extends LLMModel {
-    private config;
-    constructor(config: {
-        apiKey: string;
-        model: string;
-    });
-    private client;
-    private model;
-    setApiKey(apiKey: string): void;
-    process(input: LLMModelInputs): AsyncGenerator<{
-        $text: string;
-        delta: {
-            toolCalls: {
-                id?: string;
-                type?: "function";
-                function?: {
-                    name?: string;
-                    arguments?: string;
-                };
-            }[];
-        };
-    }, void, unknown>;
-}

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

@@ -1,26 +0,0 @@
-import { LLMModel, type LLMModelInputs } from "../llm-model";
-export declare class OpenaiLLMModel extends LLMModel {
-    private config;
-    constructor(config: {
-        apiKey: string;
-        model: string;
-    });
-    private client;
-    setApiKey(apiKey: string): void;
-    process(input: LLMModelInputs): AsyncGenerator<{
-        $text: string;
-        delta?: undefined;
-    } | {
-        delta: {
-            toolCalls: {
-                id?: string;
-                type?: "function";
-                function?: {
-                    name?: string;
-                    arguments?: string;
-                };
-            }[];
-        };
-        $text?: undefined;
-    }, void, unknown>;
-}

package/lib/dts/memorable.d.ts

@@ -1,198 +0,0 @@
-import { Agent } from "./agent";
-import type { Context } from "./context";
-import type { LLMModelInputMessage } from "./llm-model";
-import { Runnable } from "./runnable";
-export type MemoryMetadata = Record<string, unknown>;
-export type MemoryActionItem<T> = {
-    event: "add";
-    id: string;
-    memory: T;
-    metadata?: MemoryMetadata;
-} | {
-    event: "update";
-    id: string;
-    memory: T;
-    oldMemory: T;
-    metadata?: MemoryMetadata;
-} | {
-    event: "delete";
-    id: string;
-    memory: T;
-} | {
-    event: "none";
-    memory: T;
-};
-export interface MemoryItem<T> {
-    id: string;
-    userId?: string;
-    sessionId?: string;
-    agentId?: string;
-    createdAt: string;
-    updatedAt: string;
-    memory: T;
-    metadata: MemoryMetadata;
-}
-export interface MemoryItemWithScore<T = unknown> extends MemoryItem<T> {
-    score: number;
-}
-export type MemoryMessage = LLMModelInputMessage;
-export type MemoryActions<T> = {
-    action: "add";
-    inputs: {
-        messages: MemoryMessage[];
-        options?: {
-            userId?: string;
-            sessionId?: string;
-            agentId?: string;
-            metadata?: MemoryMetadata;
-        };
-    };
-    outputs: {
-        results: MemoryActionItem<T>[];
-    };
-} | {
-    action: "search";
-    inputs: {
-        query: string;
-        options?: {
-            k?: number;
-            userId?: string;
-            sessionId?: string;
-            agentId?: string;
-            filter?: MemoryMetadata;
-            sort?: MemorySortOptions;
-        };
-    };
-    outputs: {
-        results: MemoryItemWithScore<T>[];
-    };
-} | {
-    action: "filter";
-    inputs: {
-        options?: {
-            k?: number;
-            userId?: string;
-            sessionId?: string;
-            agentId?: string;
-            filter?: MemoryMetadata;
-            sort?: MemorySortOptions;
-        };
-    };
-    outputs: {
-        results: MemoryItem<T>[];
-    };
-} | {
-    action: "get";
-    inputs: {
-        memoryId: string;
-    };
-    outputs: {
-        result: MemoryItem<T> | null;
-    };
-} | {
-    action: "create";
-    inputs: {
-        memory: T;
-        options?: {
-            userId?: string;
-            sessionId?: string;
-            agentId?: string;
-            metadata?: MemoryMetadata;
-        };
-    };
-    outputs: {
-        result: MemoryItem<T>;
-    };
-} | {
-    action: "update";
-    inputs: {
-        memoryId: string;
-        memory: T;
-    };
-    outputs: {
-        result: MemoryItem<T> | null;
-    };
-} | {
-    action: "delete";
-    inputs: {
-        filter: string | string[] | Record<string, unknown>;
-    };
-    outputs: {
-        [name: string]: never;
-    };
-} | {
-    action: "reset";
-    inputs: {
-        [name: string]: never;
-    };
-    outputs: {
-        [name: string]: never;
-    };
-};
-export interface SortItem {
-    field: string;
-    direction: "asc" | "desc";
-}
-export type MemorySortOptions = SortItem | SortItem[];
-export declare abstract class Memorable<T, C extends Record<string, any> = Record<string, any>> extends Runnable<MemoryActions<T>, MemoryActions<T>["outputs"]> {
-    constructor(context?: Context);
-    abstract runner?: MemoryRunner<T, C>;
-    abstract add(messages: Extract<MemoryActions<T>, {
-        action: "add";
-    }>["inputs"]["messages"], options?: Extract<MemoryActions<T>, {
-        action: "add";
-    }>["inputs"]["options"]): Promise<Extract<MemoryActions<T>, {
-        action: "add";
-    }>["outputs"]>;
-    abstract search(query: Extract<MemoryActions<T>, {
-        action: "search";
-    }>["inputs"]["query"], options?: Extract<MemoryActions<T>, {
-        action: "search";
-    }>["inputs"]["options"]): Promise<Extract<MemoryActions<T>, {
-        action: "search";
-    }>["outputs"]>;
-    abstract filter(options: Extract<MemoryActions<T>, {
-        action: "filter";
-    }>["inputs"]["options"]): Promise<Extract<MemoryActions<T>, {
-        action: "filter";
-    }>["outputs"]>;
-    abstract get(memoryId: Extract<MemoryActions<T>, {
-        action: "get";
-    }>["inputs"]["memoryId"]): Promise<Extract<MemoryActions<T>, {
-        action: "get";
-    }>["outputs"]>;
-    abstract create(memory: Extract<MemoryActions<T>, {
-        action: "create";
-    }>["inputs"]["memory"], options?: Extract<MemoryActions<T>, {
-        action: "create";
-    }>["inputs"]["options"]): Promise<Extract<MemoryActions<T>, {
-        action: "create";
-    }>["outputs"]>;
-    abstract update(memoryId: Extract<MemoryActions<T>, {
-        action: "update";
-    }>["inputs"]["memoryId"], memory: T): Promise<Extract<MemoryActions<T>, {
-        action: "update";
-    }>["outputs"]>;
-    abstract delete(memoryId: Extract<MemoryActions<T>, {
-        action: "delete";
-    }>["inputs"]["filter"]): Promise<Extract<MemoryActions<T>, {
-        action: "delete";
-    }>["outputs"]>;
-    abstract reset(): Promise<void>;
-}
-export type MemoryRunnerInput<C extends Record<string, any> = Record<string, any>> = {
-    messages: MemoryMessage[];
-    userId?: string;
-    sessionId?: string;
-    agentId?: string;
-    metadata?: MemoryMetadata;
-    filter?: MemoryMetadata;
-    customData: C;
-};
-export type MemoryRunnerOutput<T> = {
-    actions: MemoryActionItem<T>[];
-};
-export declare abstract class MemoryRunner<T, C extends Record<string, any> = Record<string, any>> extends Agent<MemoryRunnerInput<C>, MemoryRunnerOutput<T>> {
-    constructor(name: string);
-}
-export type MemorableSearchOutput<T extends Memorable<unknown>> = Awaited<ReturnType<T["search"]>>["results"];

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

@@ -1,26 +0,0 @@
-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 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 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: AgentProcessInput<I, Preloads, Memories>): Promise<O>;
-    fetch<T>(request: FetchRequest): Promise<T>;
-}
-export interface OpenAPIAgentDefinition extends AgentDefinition {
-    type: "open_api_agent";
-    inputs: OrderedRecord<OpenAPIDataType>;
-    url: string;
-    method?: HTTPMethod;
-    auth?: AuthConfig;
-}
-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;
-}): OpenAPIAgent<SchemaToType<I>, SchemaToType<O>, State, CreateAgentPreloadsType<I, Preloads>, CreateAgentMemoriesType<I, Memories>>;
-export {};