@aigne/core 1.0.17 → 1.1.0-beta.2

package/lib/cjs/definitions/data-schema.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.schemaToDataType = schemaToDataType;
-const nanoid_1 = require("nanoid");
-const ordered_map_1 = require("../utils/ordered-map");
-function schemaToDataType(dataType) {
-    return ordered_map_1.OrderedRecord.fromArray(Object.entries(dataType).map(([name, schema]) => {
-        const base = {
-            ...schema,
-            id: (0, nanoid_1.nanoid)(),
-            name,
-        };
-        switch (schema.type) {
-            case "string":
-                return {
-                    ...base,
-                    type: "string",
-                };
-            case "number":
-                return {
-                    ...base,
-                    type: "number",
-                };
-            case "boolean":
-                return {
-                    ...base,
-                    type: "boolean",
-                };
-            case "object":
-                return {
-                    ...base,
-                    type: "object",
-                    properties: schema.properties && schemaToDataType(schema.properties),
-                };
-            case "array":
-                return {
-                    ...base,
-                    type: "array",
-                    items: schema.items &&
-                        ordered_map_1.OrderedRecord.find(schemaToDataType({ items: schema.items }), (i) => i.name === "items"),
-                };
-            default: {
-                throw new Error(`Unknown data type: ${schema.type}`);
-            }
-        }
-    }));
-}

package/lib/cjs/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/cjs/definitions/data-type.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toRunnableMemories = toRunnableMemories;
-const nanoid_1 = require("nanoid");
-const utils_1 = require("../utils");
-function toRunnableMemories(agentName, inputs, memories) {
-    return utils_1.OrderedRecord.fromArray(Object.entries(memories).map(([name, { memory, query, options }]) => {
-        const queryFromVariable = query?.fromVariable
-            ? utils_1.OrderedRecord.find(inputs, (j) => j.name === query.fromVariable)
-            : null;
-        if (query?.fromVariable && !queryFromVariable)
-            throw new Error(`LLMAgent ${agentName} -> Memory ${name} -> Query variable ${query.fromVariable.toString()} not found`);
-        return {
-            id: name || (0, nanoid_1.nanoid)(),
-            name,
-            memory,
-            query: queryFromVariable
-                ? { from: "variable", fromVariableId: queryFromVariable.id }
-                : undefined,
-            options,
-        };
-    }));
-}

package/lib/cjs/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/cjs/definitions/open-api.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.preloadCreatorsToPreloads = preloadCreatorsToPreloads;
-const is_non_nullable_1 = require("../utils/is-non-nullable");
-const ordered_map_1 = require("../utils/ordered-map");
-function preloadCreatorsToPreloads(inputs, creators) {
-    return ordered_map_1.OrderedRecord.fromArray(Object.entries(creators ?? {}).map(([name, preload]) => {
-        const p = preload((runnable, input, options) => ({
-            ...options,
-            runnable,
-            input,
-        }));
-        const input = Object.fromEntries(ordered_map_1.OrderedRecord.map(p.runnable.definition.inputs, (i) => {
-            if (!i.name)
-                return null;
-            const bind = p.input?.[i.name];
-            if (!bind)
-                return null;
-            if (bind.from !== "input")
-                throw new Error(`Unsupported bind from ${bind.from} in preloads`);
-            const from = ordered_map_1.OrderedRecord.find(inputs, (i) => i.name === bind.fromInput);
-            if (!from)
-                throw new Error(`Input ${bind.fromInput} not found`);
-            return [i.id, { ...bind, fromInput: from.id }];
-        }).filter(is_non_nullable_1.isNonNullable));
-        return {
-            id: name,
-            name,
-            description: p.description,
-            runnable: { id: p.runnable.id },
-            input,
-        };
-    }));
-}

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

@@ -1,62 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FunctionAgent = void 0;
-const nanoid_1 = require("nanoid");
-const tsyringe_1 = require("tsyringe");
-const agent_1 = require("./agent");
-const constants_1 = require("./constants");
-const data_schema_1 = require("./definitions/data-schema");
-const memory_1 = require("./definitions/memory");
-const preload_1 = require("./definitions/preload");
-let FunctionAgent = class FunctionAgent extends agent_1.Agent {
-    definition;
-    static create = create;
-    constructor(definition, context) {
-        super(definition, context);
-        this.definition = definition;
-    }
-    async process(input, options) {
-        const { definition: { function: func }, context, } = this;
-        if (!func)
-            throw new Error("Function is required");
-        if (!context)
-            throw new Error("Context is required");
-        return await func(input, { ...options, context });
-    }
-};
-exports.FunctionAgent = FunctionAgent;
-exports.FunctionAgent = FunctionAgent = __decorate([
-    (0, tsyringe_1.injectable)(),
-    __param(0, (0, tsyringe_1.inject)(constants_1.TYPES.definition)),
-    __param(1, (0, tsyringe_1.inject)(constants_1.TYPES.context)),
-    __metadata("design:paramtypes", [Object, Object])
-], FunctionAgent);
-function create(options) {
-    const agentId = options.name || (0, nanoid_1.nanoid)();
-    const inputs = (0, data_schema_1.schemaToDataType)(options.inputs);
-    const outputs = (0, data_schema_1.schemaToDataType)(options.outputs);
-    const preloads = (0, preload_1.preloadCreatorsToPreloads)(inputs, options.preloads);
-    const memories = (0, memory_1.toRunnableMemories)(agentId, inputs, options.memories || {});
-    return new FunctionAgent({
-        id: agentId,
-        name: options.name,
-        type: "function_agent",
-        inputs,
-        outputs,
-        preloads,
-        memories,
-        function: options.function,
-    }, options.context);
-}

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

@@ -1,140 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LLMAgent = void 0;
-const nanoid_1 = require("nanoid");
-const tsyringe_1 = require("tsyringe");
-const agent_1 = require("./agent");
-const constants_1 = require("./constants");
-const data_schema_1 = require("./definitions/data-schema");
-const memory_1 = require("./definitions/memory");
-const preload_1 = require("./definitions/preload");
-const runnable_1 = require("./runnable");
-const message_utils_1 = require("./utils/message-utils");
-const mustache_utils_1 = require("./utils/mustache-utils");
-const ordered_map_1 = require("./utils/ordered-map");
-const structured_output_schema_1 = require("./utils/structured-output-schema");
-let LLMAgent = class LLMAgent extends agent_1.Agent {
-    definition;
-    model;
-    static create = create;
-    constructor(definition, context, model) {
-        super(definition, context);
-        this.definition = definition;
-        this.model = model;
-        this.model ??= context?.resolveDependency(constants_1.TYPES.llmModel);
-    }
-    async *process(input, options) {
-        const { definition, model } = this;
-        if (!model)
-            throw new Error("LLM model is required");
-        const { originalMessages, messagesWithMemory } = (0, message_utils_1.prepareMessages)(definition, input, options.memories);
-        const llmInputs = {
-            messages: messagesWithMemory,
-            modelOptions: definition.modelOptions,
-        };
-        let $text = "";
-        const hasTextOutput = ordered_map_1.OrderedRecord.find(definition.outputs, (i) => i.name === constants_1.StreamTextOutputName);
-        if (hasTextOutput) {
-            for await (const chunk of await this.runWithTextOutput(llmInputs)) {
-                if ((0, runnable_1.isRunnableResponseDelta)(chunk)) {
-                    $text += chunk.$text || "";
-                    yield { $text: chunk.$text };
-                }
-            }
-        }
-        const json = await this.runWithStructuredOutput(llmInputs);
-        if (json)
-            yield { delta: json };
-        await this.updateMemories([
-            ...originalMessages,
-            {
-                role: "assistant",
-                content: (0, mustache_utils_1.renderMessage)("{{$text}}\n{{json}}", { $text, json }).trim(),
-            },
-        ]);
-    }
-    async runWithStructuredOutput(llmInputs) {
-        const jsonOutputs = ordered_map_1.OrderedRecord.filter(this.definition.outputs, (i) => i.name !== constants_1.StreamTextOutputName);
-        if (!jsonOutputs.length)
-            return null;
-        const schema = (0, structured_output_schema_1.outputsToJsonSchema)(ordered_map_1.OrderedRecord.fromArray(jsonOutputs));
-        const { model } = this;
-        if (!model)
-            throw new Error("LLM model is required");
-        const response = await model.run({
-            ...llmInputs,
-            responseFormat: {
-                type: "json_schema",
-                jsonSchema: {
-                    name: "output",
-                    schema,
-                    strict: true,
-                },
-            },
-        });
-        if (!response.$text)
-            throw new Error("No text in JSON mode response");
-        return JSON.parse(response.$text);
-    }
-    async runWithTextOutput(llmInputs) {
-        const { model } = this;
-        if (!model)
-            throw new Error("LLM model is required");
-        return model.run(llmInputs, { stream: true });
-    }
-};
-exports.LLMAgent = LLMAgent;
-exports.LLMAgent = LLMAgent = __decorate([
-    (0, tsyringe_1.injectable)(),
-    __param(0, (0, tsyringe_1.inject)(constants_1.TYPES.definition)),
-    __param(1, (0, tsyringe_1.inject)(constants_1.TYPES.context)),
-    __param(2, (0, tsyringe_1.inject)(constants_1.TYPES.llmModel)),
-    __metadata("design:paramtypes", [Object, Object, Function])
-], LLMAgent);
-/**
- * Create LLMAgent definition.
- * @param options Options to create LLMAgent.
- * @returns LLMAgent definition.
- */
-function create(options) {
-    const agentId = options.name || (0, nanoid_1.nanoid)();
-    const inputs = (0, data_schema_1.schemaToDataType)(options.inputs);
-    const outputs = (0, data_schema_1.schemaToDataType)(options.outputs);
-    const preloads = (0, preload_1.preloadCreatorsToPreloads)(inputs, options.preloads);
-    const memories = (0, memory_1.toRunnableMemories)(agentId, inputs, options.memories ?? {});
-    const primaryMemoryNames = Object.entries(options.memories ?? {})
-        .filter(([, i]) => i.primary)
-        .map(([name]) => name);
-    if (primaryMemoryNames && primaryMemoryNames.length > 1) {
-        throw new Error("Only one primary memory is allowed");
-    }
-    const messages = ordered_map_1.OrderedRecord.fromArray(options.messages?.map((i) => ({
-        id: (0, nanoid_1.nanoid)(),
-        role: i.role,
-        content: i.content,
-    })));
-    return new LLMAgent({
-        id: agentId,
-        name: options.name,
-        type: "llm_agent",
-        inputs,
-        outputs,
-        preloads,
-        primaryMemoryId: primaryMemoryNames?.at(0),
-        memories,
-        modelOptions: options.modelOptions,
-        messages,
-    }, options.context);
-}

package/lib/cjs/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 {};