@aigne/core 1.0.17 → 1.1.0-beta.2

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

@@ -1,56 +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 Runnable, type RunnableInput, type RunnableOutput, type RunnableOutputType, type 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 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: 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 = Runnable, RI extends RunnableInput = ExtractRunnableInputType<R>> = {
-    runnable: R;
-    input: MakeNullablePropertyOptional<{
-        [key in keyof RI]: VariableWithPropPath;
-    }>;
-};
-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;
-}>(options: CreateAgentOptions<I, O, State, Preloads, Memories> & {
-    processes: Processes;
-}): 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 = RunnableOutputType & {
-    from: "variable";
-    fromVariableId?: string;
-    fromVariablePropPath?: (string | number)[];
-};
-export type PipelineAgentProcess = {
-    id: string;
-    name?: string;
-    runnable?: {
-        id?: string;
-    };
-    input?: {
-        [inputId: string]: {
-            from: "variable";
-            fromVariableId?: string;
-            fromVariablePropPath?: (string | number | symbol)[];
-        };
-    };
-};
-export {};

package/lib/dts/runnable.d.ts

@@ -1,76 +0,0 @@
-import type { Context, ContextState } from "./context";
-import type { DataType } from "./definitions/data-type";
-import { OrderedRecord } from "./utils/ordered-map";
-export interface RunOptions {
-    stream?: boolean;
-}
-export type RunnableResponse<T> = T | RunnableResponseStream<T>;
-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);
-    get id(): string;
-    get name(): string | undefined;
-    inputs: {
-        [key in keyof I]: DataType;
-    };
-    outputs: {
-        [key in keyof O]: DataType;
-    };
-    abstract run(input: I, options: RunOptions & {
-        stream: true;
-    }): Promise<RunnableResponseStream<O>>;
-    abstract run(input: I, options?: RunOptions & {
-        stream?: false;
-    }): Promise<O>;
-    abstract run(input: I, options?: RunOptions): Promise<RunnableResponse<O>>;
-}
-export interface RunnableDefinition {
-    id: string;
-    type: string;
-    name?: string;
-    description?: string;
-    inputs: OrderedRecord<RunnableInputType>;
-    outputs: OrderedRecord<RunnableOutputType>;
-}
-export type RunnableInputType = DataType;
-export type RunnableOutputType = DataType;
-export interface RunnableResponseDelta<T> {
-    $text?: string;
-    delta?: Partial<T>;
-}
-export interface RunnableResponseProgress {
-    progress: {
-        taskId: string;
-        time: string;
-        agent: {
-            id: string;
-            name?: string;
-            description?: string;
-        };
-        payload: {
-            type: "start";
-            input: {
-                [key: string]: any;
-            };
-        } | {
-            type: "end";
-            output: {
-                [key: string]: any;
-            };
-        };
-    };
-}
-export interface RunnableResponseError {
-    error: {
-        message: string;
-    };
-}
-export type RunnableResponseChunk<T> = RunnableResponseDelta<T> | RunnableResponseProgress;
-export type RunnableResponseChunkWithError<T> = RunnableResponseChunk<T> | RunnableResponseError;
-export declare function isRunnableResponseDelta<T>(chunk: RunnableResponseChunkWithError<T>): chunk is RunnableResponseDelta<T>;
-export declare function isRunnableResponseProgress<T>(chunk: RunnableResponseChunkWithError<T>): chunk is RunnableResponseProgress;
-export declare function isRunnableResponseError<T>(chunk: RunnableResponseChunkWithError<T>): chunk is RunnableResponseError;
-export type RunnableResponseStream<T> = ReadableStream<RunnableResponseChunk<T>>;

package/lib/dts/runtime.d.ts

@@ -1,64 +0,0 @@
-import { type DependencyContainer } from "tsyringe";
-import type { constructor as Constructor } from "tsyringe/dist/typings/types";
-import type { Context, ContextState } from "./context";
-import type { LLMModel, LLMModelConfiguration } from "./llm-model";
-import type { Memorable } from "./memorable";
-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 {
-    llmModel?: LLMModelConfiguration;
-}
-export interface RuntimeOptions<Agents extends {
-    [name: string]: Runnable;
-}, State extends ContextState> {
-    id?: string;
-    name?: string;
-    config?: RuntimeConfiguration;
-    state?: State;
-    agents?: Agents;
-    historyManager?: Memorable<{
-        input: object;
-        output: object;
-    }>;
-    llmModel?: LLMModel | Constructor<LLMModel>;
-    sandboxFunctionRunner?: SandboxFunctionRunner | Constructor<SandboxFunctionRunner>;
-}
-export declare class Runtime<Agents extends {
-    [name: string]: Runnable;
-} = {}, State extends ContextState = ContextState> implements Context<State> {
-    constructor(options?: RuntimeOptions<Agents, State>);
-    protected inner: RuntimeInner<Agents, State>;
-    get options(): RuntimeOptions<Agents, State>;
-    get id(): string;
-    get name(): string | undefined;
-    get historyManager(): Memorable<{
-        input: object;
-        output: object;
-    }, Record<string, any>> | undefined;
-    config: RuntimeConfiguration;
-    state: State;
-    agents: Agents;
-    private container;
-    setup(config: DeepPartial<RuntimeConfiguration>): void;
-    register<R extends Array<RunnableDefinition | Runnable> = []>(...runnables: R): void;
-    private resolveSync;
-    resolve<T extends Runnable>(id: string | RunnableDefinition | T): Promise<T>;
-    resolveDependency<T>(token: string | symbol): T;
-    copy<State extends ContextState = ContextState>(options: Pick<RuntimeOptions<Agents, State>, "state" | "config">): Runtime<Agents, State>;
-}
-declare class RuntimeInner<Agents extends {
-    [name: string]: Runnable;
-} = {}, State extends ContextState = ContextState> {
-    options: RuntimeOptions<Agents, State>;
-    constructor(options: RuntimeOptions<Agents, State>);
-    readonly id: string;
-    readonly name?: string;
-    config: RuntimeConfiguration;
-    state: State;
-    container: DependencyContainer;
-    runnableDefinitions: OrderedRecord<RunnableDefinition>;
-    registerDependency<T>(token: string | symbol, dependency: Constructor<T> | T): void;
-}
-export {};

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

@@ -1,21 +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 } from "./runnable";
-import type { SandboxFunctionRunner } from "./sandbox-function-runner";
-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, State, Preloads, Memories> | undefined;
-    static create: typeof create;
-    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 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;
-}): 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/dts/sandbox-function-runner.d.ts

@@ -1,16 +0,0 @@
-import { Agent, type AgentMemories, type AgentPreloads } from "./agent";
-import type { Context, ContextState } from "./context";
-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: Input;
-    preloads: Preloads;
-    memories: Memories;
-    context: Pick<Context<State>, "state">;
-};
-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/dts/utils/constants.d.ts

@@ -1 +0,0 @@
-export declare const FETCH_TIMEOUT: number;

package/lib/dts/utils/fetch-open-api.d.ts

@@ -1,2 +0,0 @@
-import type { FetchRequest } from "../definitions/open-api";
-export declare function fetchOpenApi<T>(request: FetchRequest): Promise<T>;

package/lib/dts/utils/fetch.d.ts

@@ -1 +0,0 @@
-export declare function checkFetchResponse(result: Response): Promise<Response>;

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

@@ -1,12 +0,0 @@
-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";
-export * from "./open-api-parameter";
-export * from "./ordered-map";
-export * from "./partial";
-export * from "./stream-utils";
-export * from "./union";

package/lib/dts/utils/is-non-nullable.d.ts

@@ -1,2 +0,0 @@
-export declare function isNonNullable<T>(value: T): value is NonNullable<T>;
-export declare function isPropsNonNullable<T, K extends keyof T>(...props: (K | K[])[]): (value: T) => value is T & Required<Pick<T, K>>;

package/lib/dts/utils/message-utils.d.ts

@@ -1,20 +0,0 @@
-import type { LLMAgentDefinition } from "../llm-agent";
-import type { LLMModelInputMessage } from "../llm-model";
-import type { MemoryItemWithScore } from "../memorable";
-export declare function mergeHistoryMessages(messages: LLMModelInputMessage[], history: LLMModelInputMessage[]): LLMModelInputMessage[];
-export declare function memoriesToMessages(memories: {
-    [name: string]: MemoryItemWithScore[];
-}, { primaryMemoryName }?: {
-    primaryMemoryName?: string;
-}): {
-    primaryMemory: LLMModelInputMessage[];
-    memory: string;
-};
-export declare function prepareMessages(definition: Pick<LLMAgentDefinition, "messages" | "memories" | "primaryMemoryId">, input: {
-    [name: string]: unknown;
-}, memories: {
-    [name: string]: MemoryItemWithScore[];
-}): {
-    originalMessages: LLMModelInputMessage[];
-    messagesWithMemory: LLMModelInputMessage[];
-};

package/lib/dts/utils/mustache-utils.d.ts

@@ -1,3 +0,0 @@
-export declare function renderMessage(template: string, variables?: {
-    [key: string]: any;
-}): string;

package/lib/dts/utils/nullable.d.ts

@@ -1,7 +0,0 @@
-export type MakeNullablePropertyOptional<T extends {
-    [key: string]: any;
-}> = {
-    [K in keyof T as Extract<T[K], null | undefined> extends never ? K : never]: T[K];
-} & {
-    [K in keyof T as Extract<T[K], null | undefined> extends never ? never : K]?: T[K];
-};

package/lib/dts/utils/omit.d.ts

@@ -1 +0,0 @@
-export type OmitPropsFromUnion<T, K extends string | number | symbol> = T extends any ? Omit<T, K> : never;

package/lib/dts/utils/open-api-parameter.d.ts

@@ -1,7 +0,0 @@
-import type { AuthConfig, FetchRequest, HTTPMethod } from "../definitions/open-api";
-import type { OpenAPIAgentDefinition } from "../open-api-agent";
-export declare function formatOpenAPIRequest(api: {
-    url: string;
-    method: HTTPMethod;
-    auth?: AuthConfig;
-}, inputs: OpenAPIAgentDefinition["inputs"], input: Record<string, any>): Promise<FetchRequest>;

package/lib/dts/utils/ordered-map.d.ts

@@ -1,37 +0,0 @@
-export type OrderedRecord<T extends {
-    id: string;
-}> = Record<string, T> & {
-    $indexes: string[];
-};
-export declare namespace OrderedRecord {
-    function iterator<T extends {
-        id: string;
-    }>(record?: OrderedRecord<T>): IterableIterator<T>;
-    function map<O, T extends {
-        id: string;
-    }>(record: OrderedRecord<T> | undefined, fn: (value: T, index: number) => O): O[];
-    function toArray<T extends {
-        id: string;
-    }>(record: OrderedRecord<T> | undefined): T[];
-    function fromArray<T extends {
-        id: string;
-    }>(array?: T[]): OrderedRecord<T>;
-    function find<T extends {
-        id: string;
-    }>(record: OrderedRecord<T> | undefined, predicate: (value: T, index: number) => boolean): T | undefined;
-    function filter<T extends {
-        id: string;
-    }>(record: OrderedRecord<T> | undefined, predicate: (value: T, index: number) => boolean): T[];
-    function at<T extends {
-        id: string;
-    }>(record: OrderedRecord<T> | undefined, index: number): T | undefined;
-    function push<T extends {
-        id: string;
-    }>(record: OrderedRecord<T>, ...items: T[]): OrderedRecord<T>;
-    function merge<T extends {
-        id: string;
-    }>(...records: OrderedRecord<T>[]): OrderedRecord<T>;
-    function pushOrUpdate<T extends {
-        id: string;
-    }>(record: OrderedRecord<T>, ...items: T[]): OrderedRecord<T>;
-}

package/lib/dts/utils/partial.d.ts

@@ -1,3 +0,0 @@
-export type DeepPartial<T> = T extends object ? {
-    [P in keyof T]?: DeepPartial<T[P]>;
-} : T;

package/lib/dts/utils/runnable-type.d.ts

@@ -1,5 +0,0 @@
-import type { Runnable, RunnableInput, RunnableOutput, RunnableResponseStream } from "../runnable";
-import type { UnionToIntersection } from "./union";
-export type ExtractRunnableInputType<T> = T extends Runnable<infer I, RunnableOutput> ? I : never;
-export type ExtractRunnableOutputType<T> = T extends Runnable<RunnableInput, infer O> ? Exclude<O, RunnableResponseStream<unknown>> : never;
-export type ExtractRunnableInputTypeIntersection<T> = UnionToIntersection<ExtractRunnableInputType<T>, Record<string, unknown>>;

package/lib/dts/utils/stream-utils.d.ts

@@ -1,20 +0,0 @@
-import { type RunnableResponse, type RunnableResponseChunk, type RunnableResponseStream } from "../runnable";
-export declare function objectToRunnableResponseStream<T extends {
-    [key: string]: any;
-}>(obj: T): RunnableResponseStream<T>;
-export declare function runnableResponseStreamToObject<T extends {
-    [key: string]: any;
-}>(stream: RunnableResponseStream<T> | AsyncGenerator<RunnableResponseChunk<T>>): Promise<T>;
-/**
- * Extracts the outputs from a runnable output stream and run the
- * resolve function on the result before the stream closes. It can be
- * used to update the memories of an agent.
- * @param output The runnable output stream or object
- * @param resolve The function to run on the result
- * @returns The runnable output stream or object
- */
-export declare function extractOutputsFromRunnableOutput<T extends {
-    [key: string]: any;
-}>(output: RunnableResponse<T> | AsyncGenerator<RunnableResponseChunk<T>>, resolve: (result: T) => Promise<void> | void): Promise<RunnableResponse<T>>;
-export declare function asyncGeneratorToReadableStream<T>(generator: AsyncGenerator<T>): ReadableStream<T>;
-export declare function isAsyncGenerator<T extends AsyncGenerator>(value: any): value is T;

package/lib/dts/utils/structured-output-schema.d.ts

@@ -1,3 +0,0 @@
-import type { RunnableOutputType } from "../runnable";
-import { OrderedRecord } from "./ordered-map";
-export declare function outputsToJsonSchema(outputs: OrderedRecord<RunnableOutputType>): object;

package/lib/dts/utils/union.d.ts

@@ -1 +0,0 @@
-export type UnionToIntersection<U, O = any> = (U extends any ? (arg: U) => void : never) extends (arg: infer I) => void ? I extends O ? I : never : never;

package/lib/esm/agent.d.ts

@@ -1,96 +0,0 @@
-import type { Context, ContextState } from "./context";
-import type { DataSchema } from "./definitions/data-schema";
-import type { AgentMemory, CreateRunnableMemory } from "./definitions/memory";
-import type { AgentPreload, BindAgentInputs, BoundAgent, PreloadCreator } from "./definitions/preload";
-import type { MemorableSearchOutput, MemoryItemWithScore, MemoryMessage } from "./memorable";
-import { type RunOptions, Runnable, type RunnableDefinition, type RunnableInput, type RunnableOutput, type RunnableResponse, type RunnableResponseChunk, type RunnableResponseStream } from "./runnable";
-import { OrderedRecord } from "./utils";
-import type { ExtractRunnableOutputType } from "./utils/runnable-type";
-export type AgentPreloads = Record<string, unknown>;
-export type AgentMemories = Record<string, MemoryItemWithScore[]>;
-export declare abstract class Agent<I extends RunnableInput = RunnableInput, O extends RunnableOutput = RunnableOutput, State extends ContextState = ContextState, Preloads extends AgentPreloads = AgentPreloads, Memories extends AgentMemories = AgentMemories> extends Runnable<I, O, State> {
-    definition: AgentDefinition;
-    context?: Context<State> | undefined;
-    constructor(definition: AgentDefinition, context?: Context<State> | undefined);
-    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): Promise<Memories>;
-    /**
-     * Update memories by user messages and assistant responses.
-     * @param messages Messages to be added to memories.
-     */
-    protected updateMemories(messages: MemoryMessage[]): Promise<void>;
-    protected loadPreloads(input: I): Promise<Preloads>;
-    run(input: I, options: RunOptions & {
-        stream: true;
-    }): Promise<RunnableResponseStream<O>>;
-    run(input: I, options?: RunOptions & {
-        stream?: false;
-    }): Promise<O>;
-    private addHistory;
-    /**
-     * Hook that is called before the agent result is returned.
-     * @param _result The agent result.
-     */
-    protected onResult(_result: O): Promise<void>;
-    abstract process(input: AgentProcessInput<I, Preloads, Memories>, options: AgentProcessOptions): Promise<RunnableResponse<O> | AsyncGenerator<RunnableResponseChunk<O>, void>> | AsyncGenerator<RunnableResponseChunk<O>, void>;
-    /**
-     * Bind some inputs to the agent, used for process of `PipelineAgent` or case of `LLMDecisionAgent`.
-     * @param options The bind options.
-     * @returns The bound agent.
-     */
-    bind<Input extends BindAgentInputs<Record<string, never>, typeof this>>(options: {
-        description?: string;
-        input?: Input;
-    }): BoundAgent<Record<string, never>, typeof this, Readonly<Input>>;
-}
-export type AgentProcessOptions<Preloads extends AgentPreloads = AgentPreloads, Memories extends AgentMemories = AgentMemories> = {
-    preloads: Preloads;
-    memories: Memories;
-};
-export type AgentProcessInput<I extends RunnableInput, Preloads extends AgentPreloads, Memories extends AgentMemories> = I & Preloads & Memories;
-export interface AgentDefinition extends RunnableDefinition {
-    preloads?: OrderedRecord<AgentPreload>;
-    memories?: OrderedRecord<AgentMemory>;
-}
-export type CreateAgentInputSchema = Record<string, DataSchema>;
-export type CreateAgentOutputSchema<Extra extends Record<string, unknown> = Record<string, unknown>> = Record<string, DataSchema & Extra>;
-export type CreateAgentPreloadsSchema<I extends CreateAgentInputSchema> = Record<string, PreloadCreator<I>>;
-export type CreateAgentPreloadsType<I extends CreateAgentInputSchema, Preloads extends CreateAgentPreloadsSchema<I>> = {
-    [name in keyof Preloads]: ExtractRunnableOutputType<ReturnType<Preloads[name]>["runnable"]>;
-};
-export type CreateAgentMemoriesSchema<I extends CreateAgentInputSchema, Extras extends Record<string, unknown> = Record<string, unknown>> = Record<string, CreateRunnableMemory<I> & Extras>;
-export type CreateAgentMemoriesType<I extends CreateAgentInputSchema, Memories extends CreateAgentMemoriesSchema<I, Record<string, unknown>>> = {
-    [key in keyof Memories]: MemorableSearchOutput<Memories[key]["memory"]>;
-};
-/**
- * Common options to create Agent.
- */
-export interface CreateAgentOptions<I extends CreateAgentInputSchema, O extends CreateAgentOutputSchema, State extends ContextState, Preloads extends CreateAgentPreloadsSchema<I>, Memories extends CreateAgentMemoriesSchema<I, Record<string, unknown>>> {
-    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;
-    /**
-     * Preload runnables before running this agent. the preloaded data are available in the agent as input variables.
-     */
-    preloads?: Preloads;
-    /**
-     * Memories to be used in this agent.
-     */
-    memories?: Memories;
-}

package/lib/esm/agent.js

@@ -1,161 +0,0 @@
-import { Runnable, } from "./runnable";
-import { OrderedRecord, extractOutputsFromRunnableOutput, isAsyncGenerator, isNonNullable, objectToRunnableResponseStream, renderMessage, runnableResponseStreamToObject, } from "./utils";
-import { logger } from "./utils/logger";
-export class Agent extends Runnable {
-    definition;
-    context;
-    constructor(definition, context) {
-        super(definition, context);
-        this.definition = definition;
-        this.context = context;
-    }
-    async getMemoryQuery(input, query) {
-        if (query?.from === "variable") {
-            const i = OrderedRecord.find(this.definition.inputs, (i) => i.id === query.fromVariableId);
-            if (!i)
-                throw new Error(`Input variable ${query.fromVariableId} not found`);
-            const value = i.name ? input[i.name] : undefined;
-            return renderMessage("{{value}}", { value });
-        }
-        return Object.entries(input)
-            .map(([key, value]) => `${key} ${value}`)
-            .join("\n");
-    }
-    /**
-     * 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.
-     */
-    async loadMemories(input) {
-        const { definition: { memories }, context, } = this;
-        if (!memories?.$indexes.length)
-            return {};
-        if (!context)
-            throw new Error("Context is required");
-        const { userId, sessionId } = context.state;
-        return Object.fromEntries((await Promise.all(OrderedRecord.map(memories, async ({ id, name, memory, query, options }) => {
-            if (!name || !memory)
-                return null;
-            const q = await this.getMemoryQuery(input, query);
-            const { results: memories } = await memory.search(q, {
-                ...options,
-                userId,
-                sessionId,
-            });
-            return [
-                [id, memories],
-                [name, memories],
-            ];
-        })))
-            .flat()
-            .filter(isNonNullable));
-    }
-    /**
-     * Update memories by user messages and assistant responses.
-     * @param messages Messages to be added to memories.
-     */
-    async updateMemories(messages) {
-        const { context, definition: { memories }, } = this;
-        if (!context)
-            throw new Error("Context is required");
-        const { userId, sessionId } = context.state ?? {};
-        await Promise.all(OrderedRecord.map(memories, async ({ memory }) => {
-            if (!memory) {
-                logger.warn(`Memory is not defined in agent ${this.name || this.id}`);
-                return;
-            }
-            await memory.add(messages, { userId, sessionId });
-        }));
-    }
-    async loadPreloads(input) {
-        const { context, definition: { preloads }, } = this;
-        if (!preloads?.$indexes.length)
-            return {};
-        if (!context)
-            throw new Error("Context is required");
-        return Object.fromEntries(await Promise.all(OrderedRecord.map(preloads, async (preload) => {
-            if (!preload.runnable?.id)
-                throw new Error("Runnable id in preload is required");
-            const runnable = await context.resolve(preload.runnable.id);
-            const runnableInput = Object.fromEntries(OrderedRecord.map(runnable.definition.inputs, (i) => {
-                if (!i.name)
-                    return null;
-                const bind = preload.input?.[i.id];
-                if (!bind)
-                    return null;
-                if (bind.from !== "input")
-                    throw new Error(`Unsupported bind from ${bind.from}`);
-                const from = this.definition.inputs[bind.fromInput];
-                if (!from)
-                    throw new Error(`Input ${bind.fromInput} not found`);
-                if (!from.name)
-                    return null;
-                const v = input[from.name];
-                return [i.name, v];
-            }).filter(isNonNullable));
-            const result = await runnable.run(runnableInput);
-            return [preload.id, result];
-        })));
-    }
-    async run(input, options) {
-        logger.debug(`AIGNE core: run agent ${this.name || this.id} with`, {
-            input,
-        });
-        const preloads = await this.loadPreloads(input);
-        const memories = await this.loadMemories(input);
-        const processResult = await this.process({ ...input, ...preloads, ...memories }, { preloads, memories });
-        if (options?.stream) {
-            const stream = processResult instanceof ReadableStream ||
-                isAsyncGenerator(processResult)
-                ? processResult
-                : objectToRunnableResponseStream(processResult);
-            return extractOutputsFromRunnableOutput(stream, async (result) => {
-                // TODO: validate result against outputs schema
-                logger.debug(`AIGNE core: run agent ${this.name || this.id} success`, {
-                    result,
-                });
-                await this.addHistory({ input, output: result });
-                await this.onResult(result);
-            });
-        }
-        const result = processResult instanceof ReadableStream
-            ? await runnableResponseStreamToObject(processResult)
-            : Symbol.asyncIterator in processResult
-                ? await runnableResponseStreamToObject(processResult)
-                : processResult;
-        logger.debug(`AIGNE core: run agent ${this.name || this.id} success`, {
-            result,
-        });
-        // TODO: validate result against outputs schema
-        await this.addHistory({ input, output: result });
-        await this.onResult(result);
-        return result;
-    }
-    async addHistory({ input, output }) {
-        await this.context?.historyManager?.create({ input, output }, {
-            userId: this.context?.state.userId,
-            sessionId: this.context?.state.sessionId,
-            agentId: this.id,
-        });
-    }
-    /**
-     * Hook that is called before the agent result is returned.
-     * @param _result The agent result.
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async onResult(_result) {
-        // Override this method to perform additional operations before the result is returned
-    }
-    /**
-     * Bind some inputs to the agent, used for process of `PipelineAgent` or case of `LLMDecisionAgent`.
-     * @param options The bind options.
-     * @returns The bound agent.
-     */
-    bind(options) {
-        return {
-            ...options,
-            runnable: this,
-        };
-    }
-}