@aigne/core 1.0.3 → 1.0.4

package/lib/dts/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/dts/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/dts/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/dts/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/dts/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/dts/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/esm/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/esm/index.js

@@ -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/esm/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/esm/llm-models/gemini-llm-model.js

@@ -0,0 +1,191 @@
+import { FunctionCallingMode, GoogleGenerativeAI, SchemaType, } from "@google/generative-ai";
+import { nanoid } from "nanoid";
+import { LLMModel, } from "../llm-model";
+import { isNonNullable } from "../utils/is-non-nullable";
+export class GeminiLLMModel extends LLMModel {
+    config;
+    constructor(config) {
+        super();
+        this.config = config;
+        this.client = new 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: 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(" "));
+            }
+        }
+    }
+}
+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(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: 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
+                    ? FunctionCallingMode.ANY
+                    : toolChoice === "none"
+                        ? FunctionCallingMode.NONE
+                        : 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: SchemaType.STRING,
+            description: schema.description,
+        };
+    }
+    if (schema.type === "number") {
+        return {
+            type: SchemaType.NUMBER,
+            description: schema.description,
+        };
+    }
+    if (schema.type === "boolean") {
+        return {
+            type: SchemaType.BOOLEAN,
+            description: schema.description,
+        };
+    }
+    if (schema.type === "object") {
+        return {
+            type: 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: SchemaType.ARRAY,
+            items: openAISchemaToGeminiSchema(schema.items),
+        };
+    }
+    throw new Error(`Unsupported schema type ${schema.type}`);
+}

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

@@ -0,0 +1,113 @@
+import { nanoid } from "nanoid";
+import OpenAI from "openai";
+import { LLMModel, } from "../llm-model";
+import { isNonNullable } from "../utils/is-non-nullable";
+export class OpenaiLLMModel extends LLMModel {
+    config;
+    constructor(config) {
+        super();
+        this.config = config;
+        this.client = new OpenAI({ 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 || 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 },
+            };
+        }
+    }
+}
+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(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/esm/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 {};