@aigne/core 1.0.3 → 1.0.4

package/lib/cjs/index.d.ts

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

package/lib/cjs/index.js

@@ -14,21 +14,24 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./utils"), exports);
+__exportStar(require("./agent"), exports);
 __exportStar(require("./constants"), exports);
+__exportStar(require("./context"), exports);
 __exportStar(require("./definitions/data-type"), exports);
 __exportStar(require("./definitions/data-type-schema"), exports);
-__exportStar(require("./definitions/open-api"), exports);
 __exportStar(require("./definitions/memory"), exports);
-__exportStar(require("./context"), exports);
-__exportStar(require("./runnable"), exports);
-__exportStar(require("./agent"), exports);
-__exportStar(require("./pipeline-agent"), exports);
-__exportStar(require("./llm-agent"), exports);
-__exportStar(require("./llm-model"), exports);
+__exportStar(require("./definitions/open-api"), exports);
 __exportStar(require("./function-agent"), exports);
 __exportStar(require("./function-runner"), exports);
+__exportStar(require("./llm-agent"), exports);
 __exportStar(require("./llm-decision-agent"), exports);
+__exportStar(require("./llm-model"), exports);
+__exportStar(require("./llm-models/gemini-llm-model"), exports);
+__exportStar(require("./llm-models/openai-llm-model"), exports);
 __exportStar(require("./local-function-agent"), exports);
-__exportStar(require("./open-api-agent"), exports);
 __exportStar(require("./memorable"), exports);
+__exportStar(require("./open-api-agent"), exports);
+__exportStar(require("./pipeline-agent"), exports);
+__exportStar(require("./runnable"), exports);
+__exportStar(require("./runtime"), exports);
+__exportStar(require("./utils"), exports);

package/lib/cjs/llm-models/gemini-llm-model.d.ts

@@ -0,0 +1,26 @@
+import { LLMModel, type LLMModelInputs } from "../llm-model";
+export declare class GeminiLLMModel extends LLMModel {
+    config: {
+        apiKey: string;
+        model: string;
+    };
+    constructor(config: {
+        apiKey: string;
+        model: string;
+    });
+    private client;
+    private model;
+    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

@@ -0,0 +1,195 @@
+"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;
+    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

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

package/lib/cjs/llm-models/openai-llm-model.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenaiLLMModel = void 0;
+const nanoid_1 = require("nanoid");
+const openai_1 = __importDefault(require("openai"));
+const llm_model_1 = require("../llm-model");
+const is_non_nullable_1 = require("../utils/is-non-nullable");
+class OpenaiLLMModel extends llm_model_1.LLMModel {
+    config;
+    constructor(config) {
+        super();
+        this.config = config;
+        this.client = new openai_1.default({ apiKey: this.config.apiKey });
+    }
+    client;
+    async *process(input) {
+        const res = await this.client.chat.completions.create({
+            model: this.config.model,
+            temperature: input.modelOptions?.temperature,
+            top_p: input.modelOptions?.topP,
+            frequency_penalty: input.modelOptions?.frequencyPenalty,
+            presence_penalty: input.modelOptions?.presencePenalty,
+            messages: await contentsFromInputMessages(input.messages),
+            tools: toolsFromInputTools(input.tools),
+            tool_choice: input.toolChoice,
+            response_format: input.responseFormat?.type === "json_schema"
+                ? {
+                    type: "json_schema",
+                    json_schema: {
+                        ...input.responseFormat.jsonSchema,
+                        schema: jsonSchemaToOpenAIJsonSchema(input.responseFormat.jsonSchema.schema),
+                    },
+                }
+                : undefined,
+            stream: true,
+        });
+        const toolCalls = [];
+        for await (const chunk of res) {
+            const choice = chunk.choices?.[0];
+            const calls = choice?.delta.tool_calls?.map((i) => ({
+                id: i.id || (0, nanoid_1.nanoid)(),
+                type: "function",
+                function: {
+                    name: i.function?.name,
+                    arguments: i.function?.arguments,
+                },
+            }));
+            if (calls?.length) {
+                toolCalls.push(...calls);
+            }
+            yield {
+                $text: choice?.delta.content || undefined,
+                delta: { toolCalls },
+            };
+        }
+    }
+}
+exports.OpenaiLLMModel = OpenaiLLMModel;
+async function contentsFromInputMessages(messages) {
+    return messages.map((i) => ({
+        role: i.role,
+        content: typeof i.content === "string"
+            ? i.content
+            : i.content
+                .map((c) => {
+                if (c.type === "text") {
+                    return { type: "text", text: c.text };
+                }
+                if (c.type === "image_url") {
+                    return {
+                        type: "image_url",
+                        image_url: { url: c.imageUrl.url },
+                    };
+                }
+            })
+                .filter(is_non_nullable_1.isNonNullable),
+        tool_call_id: i.toolCallId,
+    }));
+}
+function toolsFromInputTools(tools) {
+    return tools?.length
+        ? tools.map((i) => ({
+            type: "function",
+            function: {
+                name: i.function.name,
+                description: i.function.description,
+                parameters: i.function.parameters,
+            },
+        }))
+        : undefined;
+}
+function jsonSchemaToOpenAIJsonSchema(schema) {
+    if (schema?.type === "object") {
+        const { required, properties } = schema;
+        return {
+            ...schema,
+            properties: Object.fromEntries(Object.entries(properties).map(([key, value]) => {
+                const valueSchema = jsonSchemaToOpenAIJsonSchema(value);
+                // NOTE: All fields must be required https://platform.openai.com/docs/guides/structured-outputs/all-fields-must-be-required
+                return [
+                    key,
+                    required?.includes(key)
+                        ? valueSchema
+                        : { anyOf: [valueSchema, { type: ["null"] }] },
+                ];
+            })),
+            required: Object.keys(properties),
+        };
+    }
+    if (schema?.type === "array") {
+        return {
+            ...schema,
+            items: jsonSchemaToOpenAIJsonSchema(schema.items),
+        };
+    }
+    return schema;
+}

package/lib/cjs/runtime.d.ts

@@ -0,0 +1,55 @@
+import { type DependencyContainer } from "tsyringe";
+import type { constructor as Constructor } from "tsyringe/dist/typings/types";
+import type { Context, ContextState } from "./context";
+import type { FunctionRunner } from "./function-runner";
+import type { LLMModel, LLMModelConfiguration } from "./llm-model";
+import { Runnable, type RunnableDefinition } from "./runnable";
+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;
+    llmModel?: LLMModel | Constructor<LLMModel>;
+    functionRunner?: FunctionRunner | Constructor<FunctionRunner>;
+}
+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;
+    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/cjs/runtime.js

@@ -0,0 +1,144 @@
+"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 Runtime_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Runtime = void 0;
+const immer_1 = require("immer");
+const lodash_1 = require("lodash");
+const nanoid_1 = require("nanoid");
+const tsyringe_1 = require("tsyringe");
+const constants_1 = require("./constants");
+const function_agent_1 = require("./function-agent");
+const llm_agent_1 = require("./llm-agent");
+const llm_decision_agent_1 = require("./llm-decision-agent");
+const local_function_agent_1 = require("./local-function-agent");
+const open_api_agent_1 = require("./open-api-agent");
+const pipeline_agent_1 = require("./pipeline-agent");
+const runnable_1 = require("./runnable");
+const ordered_map_1 = require("./utils/ordered-map");
+let Runtime = Runtime_1 = class Runtime {
+    constructor(options = {}) {
+        // support copy inner from a existing runtime, but not expose to public
+        const inner = options.inner;
+        if (inner instanceof RuntimeInner)
+            this.inner = inner;
+        else
+            this.inner = new RuntimeInner(options);
+        this.container = this.inner.container.createChildContainer();
+        this.container.register(constants_1.TYPES.context, { useValue: this });
+        this.config = options.config || { ...this.inner.config };
+        this.state = options.state || { ...this.inner.state };
+    }
+    inner;
+    get options() {
+        return this.inner.options;
+    }
+    get id() {
+        return this.inner.id;
+    }
+    get name() {
+        return this.inner.name;
+    }
+    config;
+    state;
+    agents = new Proxy({}, { get: (_, prop) => this.resolveSync(prop.toString()) });
+    container;
+    setup(config) {
+        this.config = (0, immer_1.produce)(this.config, (draft) => {
+            (0, lodash_1.merge)(draft, config);
+        });
+    }
+    register(...runnables) {
+        for (const runnable of runnables) {
+            ordered_map_1.OrderedRecord.pushOrUpdate(this.inner.runnableDefinitions, runnable instanceof runnable_1.Runnable ? runnable.definition : runnable);
+        }
+    }
+    resolveSync(idOrRunnable) {
+        const runnableId = typeof idOrRunnable === "string" ? idOrRunnable : idOrRunnable.id;
+        // Find runnable definition by id or name
+        let definition = this.inner.runnableDefinitions[runnableId] ??
+            ordered_map_1.OrderedRecord.find(this.inner.runnableDefinitions, (def) => def.name === runnableId);
+        if (!definition) {
+            // extract definition from runnable
+            if (idOrRunnable instanceof runnable_1.Runnable)
+                definition = idOrRunnable.definition;
+            // directly use runnable as definition
+            else if (typeof idOrRunnable === "object")
+                definition = idOrRunnable;
+        }
+        if (definition) {
+            const childContainer = this.container
+                .createChildContainer()
+                .register(constants_1.TYPES.definition, { useValue: definition });
+            const result = childContainer.resolve(definition.type);
+            childContainer.dispose();
+            return result;
+        }
+        throw new Error(`Runnable not found: ${idOrRunnable}`);
+    }
+    async resolve(id) {
+        return this.resolveSync(id);
+    }
+    resolveDependency(token) {
+        return this.container.resolve(token);
+    }
+    copy(options) {
+        const clone = new Runtime_1({
+            ...options,
+            // Copy inner runtime
+            ...{ inner: this.inner },
+        });
+        return clone;
+    }
+};
+exports.Runtime = Runtime;
+exports.Runtime = Runtime = Runtime_1 = __decorate([
+    (0, tsyringe_1.injectable)(),
+    __metadata("design:paramtypes", [Object])
+], Runtime);
+class RuntimeInner {
+    options;
+    constructor(options) {
+        this.options = options;
+        this.name = options.name;
+        this.id = options.id || this.name || (0, nanoid_1.nanoid)();
+        this.config = options.config || {};
+        this.state = options.state || {};
+        this.container.register("pipeline_agent", { useClass: pipeline_agent_1.PipelineAgent });
+        this.container.register("llm_agent", { useClass: llm_agent_1.LLMAgent });
+        this.container.register("function_agent", { useClass: function_agent_1.FunctionAgent });
+        this.container.register("llm_decision_agent", {
+            useClass: llm_decision_agent_1.LLMDecisionAgent,
+        });
+        this.container.register("local_function_agent", {
+            useClass: local_function_agent_1.LocalFunctionAgent,
+        });
+        this.container.register("open_api_agent", { useClass: open_api_agent_1.OpenAPIAgent });
+        if (options.functionRunner)
+            this.registerDependency(constants_1.TYPES.functionRunner, options.functionRunner);
+        if (options.llmModel)
+            this.registerDependency(constants_1.TYPES.llmModel, options.llmModel);
+    }
+    id;
+    name;
+    config;
+    state;
+    container = tsyringe_1.container.createChildContainer();
+    runnableDefinitions = ordered_map_1.OrderedRecord.fromArray([]);
+    registerDependency(token, dependency) {
+        if (typeof dependency === "function")
+            this.container.register(token, {
+                useClass: dependency,
+            });
+        else
+            this.container.register(token, { useValue: dependency });
+    }
+}

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

@@ -6,5 +6,6 @@ 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/cjs/utils/index.js

@@ -22,5 +22,6 @@ __exportStar(require("./nullable"), exports);
 __exportStar(require("./omit"), exports);
 __exportStar(require("./open-api-parameter"), exports);
 __exportStar(require("./ordered-map"), exports);
+__exportStar(require("./partial"), exports);
 __exportStar(require("./stream-utils"), exports);
 __exportStar(require("./union"), exports);

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

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

package/lib/cjs/utils/partial.js

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