@aigne/core 1.0.16 → 1.1.0-beta.1

package/lib/cjs/llm-decision-agent.js

@@ -1,144 +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.LLMDecisionAgent = void 0;
-const nanoid_1 = require("nanoid");
-const tsyringe_1 = require("tsyringe");
-const agent_1 = require("./agent");
-const constants_1 = require("./constants");
-const memory_1 = require("./definitions/memory");
-const utils_1 = require("./utils");
-const message_utils_1 = require("./utils/message-utils");
-const structured_output_schema_1 = require("./utils/structured-output-schema");
-let LLMDecisionAgent = class LLMDecisionAgent 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, context, model } = this;
-        if (!model)
-            throw new Error("LLM model is required");
-        if (!context)
-            throw new Error("Context is required");
-        const { originalMessages, messagesWithMemory } = (0, message_utils_1.prepareMessages)(definition, input, options.memories);
-        const cases = await Promise.all(utils_1.OrderedRecord.map(definition.cases, async (t) => {
-            if (!t.runnable?.id)
-                throw new Error("Runnable is required");
-            const runnable = await context.resolve(t.runnable.id);
-            // TODO: auto generate name by llm model if needed
-            const name = t.name || runnable.name;
-            if (!name)
-                throw new Error("Case name is required");
-            return { ...t, name, runnable };
-        }));
-        const llmInputs = {
-            messages: messagesWithMemory,
-            modelOptions: definition.modelOptions,
-            tools: cases.map((t) => {
-                // Filter inputs that are bound from AI
-                const inputsFromAI = utils_1.OrderedRecord.fromArray(utils_1.OrderedRecord.filter(t.runnable.definition.inputs, (i) => t.input?.[i.id]?.from === "ai"));
-                const parameters = inputsFromAI.$indexes.length > 0
-                    ? (0, structured_output_schema_1.outputsToJsonSchema)(inputsFromAI)
-                    : {};
-                return {
-                    type: "function",
-                    function: {
-                        name: t.name,
-                        description: t.description,
-                        parameters,
-                    },
-                };
-            }),
-            toolChoice: "required",
-        };
-        const { toolCalls } = await model.run(llmInputs);
-        // TODO: support run multiple calls
-        const { name: functionNameToCall, arguments: args } = toolCalls?.[0]?.function ?? {};
-        if (!functionNameToCall)
-            throw new Error("No any runnable called");
-        const caseToCall = cases.find((i) => i.name === functionNameToCall);
-        if (!caseToCall)
-            throw new Error("Case not found");
-        // Prepare arguments generated by LLM model
-        const llmArgs = args ? JSON.parse(args) : {};
-        // TODO: check result structure and omit undefined values
-        const output = await caseToCall.runnable.run({ ...input, ...llmArgs }, { stream: true });
-        return (0, utils_1.extractOutputsFromRunnableOutput)(output, ({ $text, ...json }) => this.updateMemories([
-            ...originalMessages,
-            {
-                role: "assistant",
-                content: (0, utils_1.renderMessage)("{{$text}}\n{{json}}", { $text, json }).trim(),
-            },
-        ]));
-    }
-};
-exports.LLMDecisionAgent = LLMDecisionAgent;
-exports.LLMDecisionAgent = LLMDecisionAgent = __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])
-], LLMDecisionAgent);
-function create(options) {
-    const agentId = options.name || (0, nanoid_1.nanoid)();
-    const cases = utils_1.OrderedRecord.fromArray(Object.entries(options.cases).map(([name, c]) => {
-        const bindInputs = Object.entries(c.input ?? {});
-        return {
-            id: (0, nanoid_1.nanoid)(),
-            name: name || c.runnable.name,
-            description: c.description,
-            runnable: { id: c.runnable.id },
-            input: Object.fromEntries(bindInputs.map(([inputName, v]) => {
-                const input = c.runnable.definition.inputs[inputName] ||
-                    utils_1.OrderedRecord.find(c.runnable.definition.inputs, (i) => i.name === inputName);
-                if (!input)
-                    throw new Error(`Input ${inputName} not found`);
-                return [input.id, v];
-            })),
-        };
-    }));
-    const inputs = utils_1.OrderedRecord.merge(...Object.values(options.cases).map((i) => i.runnable.definition.inputs));
-    const outputs = utils_1.OrderedRecord.fromArray(utils_1.OrderedRecord.map(utils_1.OrderedRecord.merge(...Object.values(options.cases).map((i) => i.runnable.definition.outputs)), (o) => ({ ...o, required: false })));
-    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 = utils_1.OrderedRecord.fromArray(options.messages?.map((i) => ({
-        id: (0, nanoid_1.nanoid)(),
-        role: i.role,
-        content: i.content,
-    })));
-    return new LLMDecisionAgent({
-        id: agentId,
-        name: options.name,
-        type: "llm_decision_agent",
-        inputs,
-        outputs,
-        messages,
-        primaryMemoryId: primaryMemoryNames?.at(0),
-        memories,
-        modelOptions: options.modelOptions,
-        cases,
-    }, options.context);
-}

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

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LLMModel = void 0;
-const agent_1 = require("./agent");
-const utils_1 = require("./utils");
-class LLMModel extends agent_1.Agent {
-    constructor(context) {
-        super({
-            id: "llm_model",
-            type: "llm_model",
-            name: "LLM Model",
-            description: "Run a LLM model",
-            inputs: utils_1.OrderedRecord.fromArray([
-                { id: "messages", name: "messages", type: "array", required: true },
-                { id: "responseFormat", name: "responseFormat", type: "object" },
-                { id: "tools", name: "tools", type: "array" },
-                { id: "toolChoice", name: "toolChoice", type: "object" },
-                { id: "modelOptions", name: "modelOptions", type: "object" },
-            ]),
-            outputs: utils_1.OrderedRecord.fromArray([
-                { id: "$text", name: "$text", type: "string" },
-                { id: "toolCalls", name: "toolCalls", type: "object" },
-            ]),
-        }, context);
-    }
-}
-exports.LLMModel = LLMModel;

package/lib/cjs/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/cjs/llm-models/gemini-llm-model.js

@@ -1,199 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GeminiLLMModel = void 0;
-const generative_ai_1 = require("@google/generative-ai");
-const nanoid_1 = require("nanoid");
-const llm_model_1 = require("../llm-model");
-const is_non_nullable_1 = require("../utils/is-non-nullable");
-class GeminiLLMModel extends llm_model_1.LLMModel {
-    config;
-    constructor(config) {
-        super();
-        this.config = config;
-        this.client = new generative_ai_1.GoogleGenerativeAI(this.config.apiKey);
-        this.model = this.client.getGenerativeModel({ model: this.config.model });
-    }
-    client;
-    model;
-    setApiKey(apiKey) {
-        this.client = new generative_ai_1.GoogleGenerativeAI(apiKey);
-        this.model = this.client.getGenerativeModel({ model: this.config.model });
-    }
-    async *process(input) {
-        const res = await this.model.generateContentStream({
-            contents: await contentsFromInputMessages(input.messages),
-            tools: toolsFromInputTools(input.tools),
-            toolConfig: toolConfigFromInputToolChoice(input.toolChoice),
-            generationConfig: generationConfigFromInput(input),
-        });
-        const toolCalls = [];
-        for await (const chunk of res.stream) {
-            const choice = chunk.candidates?.[0];
-            if (choice?.content.parts) {
-                const calls = choice.content.parts
-                    .filter((i) => typeof i.functionCall === "object")
-                    .map((i) => ({
-                    id: (0, nanoid_1.nanoid)(),
-                    type: "function",
-                    function: {
-                        name: i.functionCall.name,
-                        arguments: JSON.stringify(i.functionCall.args),
-                    },
-                }));
-                if (calls.length) {
-                    toolCalls.push(...calls);
-                }
-                yield {
-                    $text: choice.content.parts
-                        .map((i) => i.text)
-                        .filter(Boolean)
-                        .join(""),
-                    delta: { toolCalls },
-                };
-            }
-            else if (chunk.promptFeedback?.blockReason) {
-                const { blockReason, blockReasonMessage } = chunk.promptFeedback;
-                throw new Error(["PROMPT_BLOCKED", blockReason, blockReasonMessage]
-                    .filter(Boolean)
-                    .join(" "));
-            }
-        }
-    }
-}
-exports.GeminiLLMModel = GeminiLLMModel;
-async function contentsFromInputMessages(messages) {
-    const contents = [];
-    let prevMsg;
-    while (messages.length) {
-        const message = messages.shift();
-        if (!prevMsg || message.role !== prevMsg.role) {
-            prevMsg = {
-                role: message.role === "assistant" ? "model" : "user",
-                parts: [],
-            };
-            contents.push(prevMsg);
-        }
-        if (typeof message.content === "string") {
-            prevMsg.parts.push({ text: message.content });
-        }
-        else if (Array.isArray(message.content)) {
-            const res = await Promise.all(message.content.map(resolveContent));
-            prevMsg.parts.push(...res.filter(is_non_nullable_1.isNonNullable));
-        }
-    }
-    return contents;
-}
-async function resolveContent(content) {
-    if (typeof content === "string")
-        return { text: content };
-    if (content.type === "text" && content.text) {
-        return { text: content.text };
-    }
-    if (content.type === "image_url") {
-        const url = content.imageUrl.url;
-        return { fileData: { mimeType: "image/jpeg", fileUri: url } };
-    }
-    return undefined;
-}
-function parameterSchemaToFunctionDeclarationSchema(schema) {
-    if (schema.type === "object") {
-        return {
-            type: generative_ai_1.SchemaType.OBJECT,
-            description: schema.description,
-            properties: Object.fromEntries(Object.entries(schema.properties).map(([key, s]) => [
-                key,
-                openAISchemaToGeminiSchema(s),
-            ])),
-            required: schema.required,
-        };
-    }
-    throw new Error(`Unsupported schema type ${schema.type}`);
-}
-function generationConfigFromInput(input) {
-    const jsonSchema = input.responseFormat?.type === "json_schema"
-        ? input.responseFormat.jsonSchema
-        : undefined;
-    return {
-        temperature: input.modelOptions?.temperature,
-        topP: input.modelOptions?.topP,
-        frequencyPenalty: input.modelOptions?.frequencyPenalty,
-        presencePenalty: input.modelOptions?.presencePenalty,
-        responseMimeType: jsonSchema ? "application/json" : undefined,
-        responseSchema: jsonSchema
-            ? openAISchemaToGeminiSchema(jsonSchema)
-            : undefined,
-    };
-}
-function toolConfigFromInputToolChoice(toolChoice) {
-    if (!toolChoice)
-        return undefined;
-    const selectedToolFunctionName = typeof toolChoice === "object" ? toolChoice.function.name : undefined;
-    return !toolChoice
-        ? undefined
-        : {
-            functionCallingConfig: {
-                mode: toolChoice === "required" || selectedToolFunctionName
-                    ? generative_ai_1.FunctionCallingMode.ANY
-                    : toolChoice === "none"
-                        ? generative_ai_1.FunctionCallingMode.NONE
-                        : generative_ai_1.FunctionCallingMode.AUTO,
-                allowedFunctionNames: selectedToolFunctionName
-                    ? [selectedToolFunctionName]
-                    : undefined,
-            },
-        };
-}
-function toolsFromInputTools(tools) {
-    return tools?.length
-        ? [
-            {
-                functionDeclarations: tools.map((i) => ({
-                    name: i.function.name,
-                    description: i.function.description,
-                    parameters: !i.function.parameters ||
-                        Object.keys(i.function.parameters).length === 0
-                        ? undefined
-                        : parameterSchemaToFunctionDeclarationSchema(i.function.parameters),
-                })),
-            },
-        ]
-        : undefined;
-}
-function openAISchemaToGeminiSchema(schema) {
-    if (schema.type === "string") {
-        return {
-            type: generative_ai_1.SchemaType.STRING,
-            description: schema.description,
-        };
-    }
-    if (schema.type === "number") {
-        return {
-            type: generative_ai_1.SchemaType.NUMBER,
-            description: schema.description,
-        };
-    }
-    if (schema.type === "boolean") {
-        return {
-            type: generative_ai_1.SchemaType.BOOLEAN,
-            description: schema.description,
-        };
-    }
-    if (schema.type === "object") {
-        return {
-            type: generative_ai_1.SchemaType.OBJECT,
-            description: schema.description,
-            properties: Object.fromEntries(Object.entries(schema.properties).map(([key, s]) => [
-                key,
-                openAISchemaToGeminiSchema(s),
-            ])),
-            required: schema.required,
-        };
-    }
-    if (schema.type === "array") {
-        return {
-            type: generative_ai_1.SchemaType.ARRAY,
-            items: openAISchemaToGeminiSchema(schema.items),
-        };
-    }
-    throw new Error(`Unsupported schema type ${schema.type}`);
-}

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