@aigne/core 1.51.0 → 1.53.0

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

@@ -1,51 +1,55 @@
-import type { Camelize } from "camelize-ts";
 import { z } from "zod";
 import { Agent, type AgentOptions } from "../agents/agent.js";
 import type { ChatModel } from "../agents/chat-model.js";
+import type { ImageModel } from "../agents/image-model.js";
 import type { AIGNEOptions } from "../aigne/aigne.js";
 import type { MemoryAgent, MemoryAgentOptions } from "../memory/memory.js";
 import { type PromiseOrValue } from "../utils/type-utils.js";
 export interface LoadOptions {
-    loadModel: (model?: Camelize<z.infer<typeof aigneFileSchema>["model"]>) => PromiseOrValue<ChatModel | undefined>;
     memories?: {
         new (parameters?: MemoryAgentOptions): MemoryAgent;
     }[];
-    path: string;
-    model?: ChatModel;
+    model?: ChatModel | ((model?: z.infer<typeof aigneFileSchema>["chatModel"]) => PromiseOrValue<ChatModel | undefined>);
+    imageModel?: ImageModel | ((model?: z.infer<typeof aigneFileSchema>["imageModel"]) => PromiseOrValue<ImageModel | undefined>);
 }
-export declare function load(options: LoadOptions): Promise<AIGNEOptions>;
+export declare function load(path: string, options?: LoadOptions): Promise<AIGNEOptions>;
 export declare function loadAgent(path: string, options?: LoadOptions, agentOptions?: AgentOptions): Promise<Agent>;
 declare const aigneFileSchema: z.ZodObject<{
     name: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
     description: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
-    model: z.ZodEffects<z.ZodType<string | {
-        name?: string | null | undefined;
-        temperature?: number | null | undefined;
-        topP?: number | null | undefined;
-        frequencyPenalty?: number | null | undefined;
-        presencePenalty?: number | null | undefined;
-        provider?: string | null | undefined;
+    chatModel: z.ZodEffects<z.ZodEffects<z.ZodType<string | {
+        model?: string | undefined;
+        temperature?: number | undefined;
+        topP?: number | undefined;
+        frequencyPenalty?: number | undefined;
+        presencePenalty?: number | undefined;
     } | undefined, z.ZodTypeDef, string | {
-        name?: string | null | undefined;
-        temperature?: number | null | undefined;
-        topP?: number | null | undefined;
-        frequencyPenalty?: number | null | undefined;
-        presencePenalty?: number | null | undefined;
-        provider?: string | null | undefined;
+        model?: string | undefined;
+        temperature?: number | undefined;
+        topP?: number | undefined;
+        frequencyPenalty?: number | undefined;
+        presencePenalty?: number | undefined;
+    } | undefined>, string | {
+        model?: string | undefined;
+        temperature?: number | undefined;
+        topP?: number | undefined;
+        frequencyPenalty?: number | undefined;
+        presencePenalty?: number | undefined;
+    } | undefined, unknown>, {
+        model?: string | undefined;
+        temperature?: number | undefined;
+        topP?: number | undefined;
+        frequencyPenalty?: number | undefined;
+        presencePenalty?: number | undefined;
+    } | undefined, unknown>;
+    imageModel: z.ZodEffects<z.ZodType<string | {
+        model?: string | undefined;
+    } | undefined, z.ZodTypeDef, string | {
+        model?: string | undefined;
     } | undefined>, {
-        name?: string | null | undefined;
-        temperature?: number | null | undefined;
-        topP?: number | null | undefined;
-        frequencyPenalty?: number | null | undefined;
-        presencePenalty?: number | null | undefined;
-        provider?: string | null | undefined;
+        model?: string | undefined;
     } | undefined, string | {
-        name?: string | null | undefined;
-        temperature?: number | null | undefined;
-        topP?: number | null | undefined;
-        frequencyPenalty?: number | null | undefined;
-        presencePenalty?: number | null | undefined;
-        provider?: string | null | undefined;
+        model?: string | undefined;
     } | undefined>;
     agents: z.ZodType<string[] | undefined, z.ZodTypeDef, string[] | undefined>;
     skills: z.ZodType<string[] | undefined, z.ZodTypeDef, string[] | undefined>;
@@ -63,15 +67,17 @@ declare const aigneFileSchema: z.ZodObject<{
     name?: string | undefined;
     description?: string | undefined;
     skills?: string[] | undefined;
-    model?: {
-        name?: string | null | undefined;
-        temperature?: number | null | undefined;
-        topP?: number | null | undefined;
-        frequencyPenalty?: number | null | undefined;
-        presencePenalty?: number | null | undefined;
-        provider?: string | null | undefined;
+    imageModel?: {
+        model?: string | undefined;
     } | undefined;
     agents?: string[] | undefined;
+    chatModel?: {
+        model?: string | undefined;
+        temperature?: number | undefined;
+        topP?: number | undefined;
+        frequencyPenalty?: number | undefined;
+        presencePenalty?: number | undefined;
+    } | undefined;
     mcpServer?: {
         agents?: string[] | undefined;
     } | undefined;
@@ -82,15 +88,11 @@ declare const aigneFileSchema: z.ZodObject<{
     name?: string | undefined;
     description?: string | undefined;
     skills?: string[] | undefined;
-    model?: string | {
-        name?: string | null | undefined;
-        temperature?: number | null | undefined;
-        topP?: number | null | undefined;
-        frequencyPenalty?: number | null | undefined;
-        presencePenalty?: number | null | undefined;
-        provider?: string | null | undefined;
+    imageModel?: string | {
+        model?: string | undefined;
     } | undefined;
     agents?: string[] | undefined;
+    chatModel?: unknown;
     mcpServer?: {
         agents?: string[] | undefined;
     } | undefined;

package/lib/cjs/loader/index.js

@@ -8,6 +8,7 @@ const yaml_1 = require("yaml");
 const zod_1 = require("zod");
 const agent_js_1 = require("../agents/agent.js");
 const ai_agent_js_1 = require("../agents/ai-agent.js");
+const image_agent_js_1 = require("../agents/image-agent.js");
 const mcp_agent_js_1 = require("../agents/mcp-agent.js");
 const team_agent_js_1 = require("../agents/team-agent.js");
 const transform_agent_js_1 = require("../agents/transform-agent.js");
@@ -17,15 +18,18 @@ const agent_js_js_1 = require("./agent-js.js");
 const agent_yaml_js_1 = require("./agent-yaml.js");
 const schema_js_1 = require("./schema.js");
 const AIGNE_FILE_NAME = ["aigne.yaml", "aigne.yml"];
-async function load(options) {
-    const { aigne, rootDir } = await loadAIGNEFile(options.path);
+async function load(path, options = {}) {
+    const { aigne, rootDir } = await loadAIGNEFile(path);
     const allAgentPaths = new Set((0, type_utils_js_1.flat)(aigne.agents, aigne.skills, aigne.mcpServer?.agents, aigne.cli?.agents).map((i) => index_js_1.nodejs.path.join(rootDir, i)));
     const allAgents = Object.fromEntries(await Promise.all(Array.from(allAgentPaths).map(async (path) => [path, await loadAgent(path, options)])));
     const pickAgents = (paths) => paths.map((filename) => allAgents[index_js_1.nodejs.path.join(rootDir, filename)]).filter(type_utils_js_1.isNonNullable);
     return {
         ...aigne,
         rootDir,
-        model: options?.model || (await options.loadModel(aigne.model)),
+        model: typeof options.model === "function" ? await options.model(aigne.chatModel) : options.model,
+        imageModel: typeof options.imageModel === "function"
+            ? await options.imageModel(aigne.imageModel)
+            : options.imageModel,
         agents: pickAgents(aigne.agents ?? []),
         skills: pickAgents(aigne.skills ?? []),
         mcpServer: {
@@ -104,6 +108,14 @@ async function parseAgent(path, agent, options, agentOptions) {
                     prompt_builder_js_1.PromptBuilder.from(agent.instructions, { workingDir: index_js_1.nodejs.path.dirname(path) }),
             });
         }
+        case "image": {
+            return image_agent_js_1.ImageAgent.from({
+                ...baseOptions,
+                instructions: prompt_builder_js_1.PromptBuilder.from(agent.instructions, {
+                    workingDir: index_js_1.nodejs.path.dirname(path),
+                }),
+            });
+        }
         case "mcp": {
             if (agent.url) {
                 return mcp_agent_js_1.MCPAgent.from({
@@ -156,17 +168,28 @@ async function loadMemory(memories, provider, options) {
 const aigneFileSchema = (0, schema_js_1.camelizeSchema)(zod_1.z.object({
     name: (0, schema_js_1.optionalize)(zod_1.z.string()),
     description: (0, schema_js_1.optionalize)(zod_1.z.string()),
-    model: (0, schema_js_1.optionalize)(zod_1.z.union([
+    chatModel: zod_1.z
+        .preprocess((v) => {
+        if (!(0, type_utils_js_1.isRecord)(v))
+            return v;
+        return { ...v, model: v.model || `${v.provider || ""}:${v.name || ""}` };
+    }, (0, schema_js_1.optionalize)(zod_1.z.union([
+        zod_1.z.string(),
+        (0, schema_js_1.camelizeSchema)(zod_1.z.object({
+            model: (0, schema_js_1.optionalize)(zod_1.z.string()),
+            temperature: (0, schema_js_1.optionalize)(zod_1.z.number().min(0).max(2)),
+            topP: (0, schema_js_1.optionalize)(zod_1.z.number().min(0)),
+            frequencyPenalty: (0, schema_js_1.optionalize)(zod_1.z.number().min(-2).max(2)),
+            presencePenalty: (0, schema_js_1.optionalize)(zod_1.z.number().min(-2).max(2)),
+        })),
+    ])))
+        .transform((v) => (typeof v === "string" ? { model: v } : v)),
+    imageModel: (0, schema_js_1.optionalize)(zod_1.z.union([
         zod_1.z.string(),
         (0, schema_js_1.camelizeSchema)(zod_1.z.object({
-            provider: zod_1.z.string().nullish(),
-            name: zod_1.z.string().nullish(),
-            temperature: zod_1.z.number().min(0).max(2).nullish(),
-            topP: zod_1.z.number().min(0).nullish(),
-            frequencyPenalty: zod_1.z.number().min(-2).max(2).nullish(),
-            presencePenalty: zod_1.z.number().min(-2).max(2).nullish(),
+            model: (0, schema_js_1.optionalize)(zod_1.z.string()),
         })),
-    ])).transform((v) => (typeof v === "string" ? { name: v } : v)),
+    ])).transform((v) => (typeof v === "string" ? { model: v } : v)),
     agents: (0, schema_js_1.optionalize)(zod_1.z.array(zod_1.z.string())),
     skills: (0, schema_js_1.optionalize)(zod_1.z.array(zod_1.z.string())),
     mcpServer: (0, schema_js_1.optionalize)(zod_1.z.object({
@@ -180,7 +203,7 @@ async function loadAIGNEFile(path) {
     const file = await findAIGNEFile(path);
     const raw = await (0, type_utils_js_1.tryOrThrow)(() => index_js_1.nodejs.fs.readFile(file, "utf8"), (error) => new Error(`Failed to load aigne.yaml from ${file}: ${error.message}`));
     const json = (0, type_utils_js_1.tryOrThrow)(() => (0, yaml_1.parse)(raw), (error) => new Error(`Failed to parse aigne.yaml from ${file}: ${error.message}`));
-    const aigne = (0, type_utils_js_1.tryOrThrow)(() => aigneFileSchema.parse({ ...json, model: json.model ?? json.chat_model ?? json.chatModel }), (error) => new Error(`Failed to validate aigne.yaml from ${file}: ${error.message}`));
+    const aigne = (0, type_utils_js_1.tryOrThrow)(() => aigneFileSchema.parse(json), (error) => new Error(`Failed to validate aigne.yaml from ${file}: ${error.message}`));
     return { aigne, rootDir: index_js_1.nodejs.path.dirname(file) };
 }
 async function findAIGNEFile(path) {

package/lib/cjs/prompt/prompt-builder.d.ts

@@ -27,6 +27,9 @@ export declare class PromptBuilder {
     build(options: PromptBuildOptions): Promise<ChatModelInput & {
         toolAgents?: Agent[];
     }>;
+    buildImagePrompt(options: Pick<PromptBuildOptions, "input">): Promise<{
+        prompt: string;
+    }>;
     private buildMessages;
     private convertMemoriesToMessages;
     private buildResponseFormat;

package/lib/cjs/prompt/prompt-builder.js

@@ -68,6 +68,14 @@ class PromptBuilder {
             ...this.buildTools(options),
         };
     }
+    async buildImagePrompt(options) {
+        const messages = (await (typeof this.instructions === "string"
+            ? template_js_1.ChatMessagesTemplate.from([template_js_1.SystemMessageTemplate.from(this.instructions)])
+            : this.instructions)?.format(options.input, { workingDir: this.workingDir })) ?? [];
+        return {
+            prompt: messages.map((i) => i.content).join("\n"),
+        };
+    }
     async buildMessages(options) {
         const { input } = options;
         const inputKey = options.agent?.inputKey;

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

@@ -1 +1,7 @@
-export declare function camelize<T>(obj: T, shallow?: boolean): any;
+export type CamelCase<S extends string> = S extends `${infer P1}_${infer P2}${infer P3}` ? `${P1}${Uppercase<P2>}${CamelCase<P3>}` : S;
+export type CamelizeObject<T, S = false> = {
+    [K in keyof T as Uncapitalize<CamelCase<string & K>>]: T[K] extends Date ? T[K] : T[K] extends RegExp ? T[K] : T[K] extends Array<infer U> ? U extends object | undefined ? Array<CamelizeObject<U>> : T[K] : T[K] extends object | undefined ? S extends true ? T[K] : CamelizeObject<T[K]> : T[K];
+};
+export type Camelize<T, S = false> = T extends Array<infer U> ? Array<CamelizeObject<U, S>> : CamelizeObject<T, S>;
+export declare function camelize<T, S extends boolean = false>(obj: T, shallow?: S): T extends string ? string : Camelize<T, S>;
+export declare function snakelize<T, S extends boolean = false>(obj: T, shallow?: S): T extends string ? string : any;

package/lib/cjs/utils/camelize.js

@@ -1,21 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.camelize = camelize;
-const type_utils_js_1 = require("./type-utils.js");
-function camelize(obj, shallow = false) {
-    if (Array.isArray(obj)) {
-        return shallow ? obj : obj.map((item) => camelize(item, false));
-    }
-    if ((0, type_utils_js_1.isRecord)(obj)) {
-        return Object.fromEntries(Object.entries(obj).map(([key, value]) => [
-            camelCase(key),
-            shallow ? value : camelize(value, false),
-        ]));
-    }
-    return obj;
+exports.snakelize = snakelize;
+function camelize(obj, shallow) {
+    return typeof obj === "string" ? camelCase(obj) : walk(obj, shallow, camelCase);
+}
+function snakelize(obj, shallow) {
+    return typeof obj === "string" ? snakeCase(obj) : walk(obj, shallow, snakeCase);
 }
 function camelCase(key) {
-    key = key.replace(/[-_#@$\s]+(.)?/g, (_, char) => char.toUpperCase());
+    key = key.replace(/[_.-](\w|$)/g, (_, char) => char.toUpperCase());
     key = key.charAt(0).toLowerCase() + key.slice(1);
     return key;
 }
+function snakeCase(key) {
+    return key.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
+}
+function walk(obj, shallow = false, transform) {
+    if (!obj || typeof obj !== "object")
+        return obj;
+    if (obj instanceof Date || obj instanceof RegExp)
+        return obj;
+    if (Array.isArray(obj))
+        return obj.map((v) => {
+            if (!shallow) {
+                return walk(v, shallow, transform);
+            }
+            if (typeof v === "object")
+                return walk(v, shallow, transform);
+            return v;
+        });
+    return Object.keys(obj).reduce((res, key) => {
+        const newKey = transform(key);
+        res[newKey] = shallow ? obj[key] : walk(obj[key], shallow, transform);
+        return res;
+    }, {});
+}

package/lib/cjs/utils/type-utils.d.ts

@@ -18,7 +18,7 @@ export declare function unique<T>(arr: T[], key?: (item: T) => unknown): T[];
 export declare function pick<T extends object, K extends keyof T>(obj: T, ...keys: (K | K[])[]): Pick<T, K>;
 export declare function omit<T extends object, K extends keyof T>(obj: T, ...keys: (K | K[])[]): Omit<T, K>;
 export declare function omitDeep<T, K>(obj: T, ...keys: (K | K[])[]): unknown;
-export declare function omitBy<T extends Record<string, unknown>, K extends keyof T>(obj: T, predicate: (value: T[K], key: K) => boolean): Partial<T>;
+export declare function omitBy<T extends object, K extends keyof T>(obj: T, predicate: (value: T[K], key: K) => boolean): Partial<T>;
 export declare function flat<T>(...value: (T | T[])[]): NonNullable<T>[];
 export declare function createAccessorArray<T>(array: T[], accessor: (array: T[], name: string) => T | undefined): T[] & {
     [key: string]: T;

package/lib/dts/agents/agent.d.ts

@@ -116,6 +116,7 @@ export interface AgentOptions<I extends Message = Message, O extends Message = M
      * One or more memory agents this agent can use
      */
     memory?: MemoryAgent | MemoryAgent[];
+    asyncMemoryRecord?: boolean;
     /**
      * Maximum number of memory items to retrieve
      */
@@ -199,6 +200,7 @@ export declare abstract class Agent<I extends Message = any, O extends Message =
      * List of memories this agent can use
      */
     readonly memories: MemoryAgent[];
+    asyncMemoryRecord?: boolean;
     tag?: string;
     /**
      * Maximum number of memory items to retrieve

package/lib/dts/agents/chat-model.d.ts

@@ -1,5 +1,6 @@
+import { z } from "zod";
 import type { PromiseOrValue } from "../utils/type-utils.js";
-import { Agent, type AgentInvokeOptions, type AgentProcessResult, type Message } from "./agent.js";
+import { Agent, type AgentInvokeOptions, type AgentOptions, type AgentProcessResult, type Message } from "./agent.js";
 /**
  * ChatModel is an abstract base class for interacting with Large Language Models (LLMs).
  *
@@ -25,8 +26,8 @@ import { Agent, type AgentInvokeOptions, type AgentProcessResult, type Message }
  */
 export declare abstract class ChatModel extends Agent<ChatModelInput, ChatModelOutput> {
     tag: string;
-    constructor();
-    abstract getCredential(): Promise<{
+    constructor(options?: Omit<AgentOptions<ChatModelInput, ChatModelOutput>, "inputSchema" | "outputSchema">);
+    get credential(): PromiseOrValue<{
         url?: string;
         apiKey?: string;
         model?: string;
@@ -391,3 +392,16 @@ export interface ChatModelOutputUsage {
      */
     aigneHubCredits?: number;
 }
+export declare const chatModelOutputUsageSchema: z.ZodObject<{
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    aigneHubCredits: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    inputTokens: number;
+    outputTokens: number;
+    aigneHubCredits?: number | undefined;
+}, {
+    inputTokens: number;
+    outputTokens: number;
+    aigneHubCredits?: number | undefined;
+}>;

package/lib/dts/agents/image-agent.d.ts

@@ -0,0 +1,21 @@
+import { type ZodObject, type ZodType } from "zod";
+import { PromptBuilder } from "../prompt/prompt-builder.js";
+import { Agent, type AgentInvokeOptions, type AgentOptions, type Message } from "./agent.js";
+import { type ImageModel, type ImageModelOutput } from "./image-model.js";
+export interface ImageAgentOptions<I extends Message = any, O extends ImageModelOutput = any> extends Omit<AgentOptions<I, O>, "outputSchema"> {
+    model?: ImageModel;
+    instructions: string | PromptBuilder;
+    modelOptions?: Record<string, any>;
+}
+export declare const imageAgentOptionsSchema: ZodObject<{
+    [key in keyof ImageAgentOptions]: ZodType<ImageAgentOptions[key]>;
+}>;
+export declare class ImageAgent<I extends Message = any, O extends ImageModelOutput = any> extends Agent<I, O> {
+    tag: string;
+    static from<I extends Message = any, O extends ImageModelOutput = any>(options: ImageAgentOptions<I, O>): ImageAgent<I, O>;
+    constructor(options: ImageAgentOptions<I, O>);
+    model?: ImageModel;
+    instructions: PromptBuilder;
+    modelOptions?: Record<string, any>;
+    process(input: I, options: AgentInvokeOptions): Promise<O>;
+}

package/lib/dts/agents/image-model.d.ts

@@ -0,0 +1,115 @@
+import { z } from "zod";
+import type { PromiseOrValue } from "../utils/type-utils.js";
+import { Agent, type AgentInvokeOptions, type AgentOptions, type AgentProcessResult, type Message } from "./agent.js";
+import { type ChatModelOutputUsage } from "./chat-model.js";
+export interface ImageModelOptions<I extends ImageModelInput = ImageModelInput, O extends ImageModelOutput = ImageModelOutput> extends AgentOptions<I, O> {
+}
+export declare abstract class ImageModel<I extends ImageModelInput = ImageModelInput, O extends ImageModelOutput = ImageModelOutput> extends Agent<I, O> {
+    tag: string;
+    constructor(options?: ImageModelOptions<I, O>);
+    get credential(): PromiseOrValue<{
+        url?: string;
+        apiKey?: string;
+        model?: string;
+    }>;
+    protected preprocess(input: I, options: AgentInvokeOptions): Promise<void>;
+    protected postprocess(input: I, output: O, options: AgentInvokeOptions): Promise<void>;
+    abstract process(input: I, options: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<O>>;
+}
+export interface ImageModelInput extends Message {
+    model?: string;
+    image?: string | string[];
+    prompt: string;
+    n?: number;
+    responseFormat?: "url" | "base64";
+}
+export declare const imageModelInputSchema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    image: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    prompt: z.ZodString;
+    n: z.ZodOptional<z.ZodNumber>;
+    responseFormat: z.ZodOptional<z.ZodEnum<["url", "base64"]>>;
+}, "strip", z.ZodTypeAny, {
+    prompt: string;
+    model?: string | undefined;
+    responseFormat?: "url" | "base64" | undefined;
+    image?: string | string[] | undefined;
+    n?: number | undefined;
+}, {
+    prompt: string;
+    model?: string | undefined;
+    responseFormat?: "url" | "base64" | undefined;
+    image?: string | string[] | undefined;
+    n?: number | undefined;
+}>;
+export interface ImageModelOutput extends Message {
+    images: ImageModelOutputImage[];
+    /**
+     * Token usage statistics
+     */
+    usage?: ChatModelOutputUsage;
+    /**
+     * Model name or version used
+     */
+    model?: string;
+}
+export type ImageModelOutputImage = ImageModelOutputImageUrl | ImageModelOutputImageBase64;
+export interface ImageModelOutputImageUrl {
+    url: string;
+}
+export interface ImageModelOutputImageBase64 {
+    base64: string;
+}
+export declare const imageModelOutputSchema: z.ZodObject<{
+    images: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        url: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+    }, {
+        url: string;
+    }>, z.ZodObject<{
+        base64: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        base64: string;
+    }, {
+        base64: string;
+    }>]>, "many">;
+    usage: z.ZodOptional<z.ZodObject<{
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        aigneHubCredits: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        inputTokens: number;
+        outputTokens: number;
+        aigneHubCredits?: number | undefined;
+    }, {
+        inputTokens: number;
+        outputTokens: number;
+        aigneHubCredits?: number | undefined;
+    }>>;
+    model: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    images: ({
+        url: string;
+    } | {
+        base64: string;
+    })[];
+    model?: string | undefined;
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+        aigneHubCredits?: number | undefined;
+    } | undefined;
+}, {
+    images: ({
+        url: string;
+    } | {
+        base64: string;
+    })[];
+    model?: string | undefined;
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+        aigneHubCredits?: number | undefined;
+    } | undefined;
+}>;

package/lib/dts/aigne/aigne.d.ts

@@ -1,6 +1,7 @@
 import { AIGNEObserver } from "@aigne/observability-api";
 import type { Agent, AgentResponse, AgentResponseStream, Message } from "../agents/agent.js";
 import type { ChatModel } from "../agents/chat-model.js";
+import type { ImageModel } from "../agents/image-model.js";
 import type { UserAgent } from "../agents/user-agent.js";
 import { type LoadOptions } from "../loader/index.js";
 import { AIGNEContext, type Context, type InvokeOptions, type UserContext } from "./context.js";
@@ -27,6 +28,10 @@ export interface AIGNEOptions {
      * Global model to use for all agents not specifying a model.
      */
     model?: ChatModel;
+    /**
+     * Optional image model to use for image processing tasks.
+     */
+    imageModel?: ImageModel;
     /**
      * Skills to use for the AIGNE instance.
      */
@@ -71,7 +76,7 @@ export declare class AIGNE<U extends UserContext = UserContext> {
      * @param options - Options to override the loaded configuration.
      * @returns A fully initialized AIGNE instance with configured agents and skills.
      */
-    static load(path: string, options: AIGNEOptions & Omit<LoadOptions, "path">): Promise<AIGNE>;
+    static load(path: string, options?: Omit<AIGNEOptions, keyof LoadOptions> & LoadOptions): Promise<AIGNE>;
     /**
      * Creates a new AIGNE instance with the specified options.
      *
@@ -94,6 +99,10 @@ export declare class AIGNE<U extends UserContext = UserContext> {
      * Global model to use for all agents that don't specify their own model.
      */
     model?: ChatModel;
+    /**
+     * Optional image model to use for image processing tasks.
+     */
+    imageModel?: ImageModel;
     /**
      * Usage limits applied to this AIGNE instance's execution.
      */

package/lib/dts/aigne/context.d.ts

@@ -3,6 +3,7 @@ import type { Span } from "@opentelemetry/api";
 import { Emitter } from "strict-event-emitter";
 import { type Agent, type AgentHooks, type AgentInvokeOptions, type AgentProcessAsyncGenerator, type AgentResponse, type AgentResponseStream, type Message } from "../agents/agent.js";
 import type { ChatModel } from "../agents/chat-model.js";
+import type { ImageModel } from "../agents/image-model.js";
 import { UserAgent } from "../agents/user-agent.js";
 import type { Memory } from "../memory/memory.js";
 import { type OmitPropertiesFromArrayFirstElement } from "../utils/type-utils.js";
@@ -73,6 +74,7 @@ export interface Context<U extends UserContext = UserContext> extends TypedEvent
     parentId?: string;
     rootId: string;
     model?: ChatModel;
+    imageModel?: ImageModel;
     skills?: Agent[];
     agents: Agent[];
     observer?: AIGNEObserver;
@@ -155,6 +157,7 @@ export declare class AIGNEContext implements Context {
     readonly internal: AIGNEContextShared;
     get messageQueue(): MessageQueue;
     get model(): ChatModel | undefined;
+    get imageModel(): ImageModel<import("../agents/image-model.js").ImageModelInput, import("../agents/image-model.js").ImageModelOutput> | undefined;
     get skills(): Agent<any, any>[] | undefined;
     get agents(): Agent<any, any>[];
     get observer(): AIGNEObserver | undefined;
@@ -187,13 +190,14 @@ export declare class AIGNEContext implements Context {
 declare class AIGNEContextShared {
     private readonly parent?;
     spans: Span[];
-    constructor(parent?: (Pick<Context, "model" | "agents" | "skills" | "limits" | "observer"> & {
+    constructor(parent?: (Pick<Context, "model" | "imageModel" | "agents" | "skills" | "limits" | "observer"> & {
         messageQueue?: MessageQueue;
         events?: Emitter<any>;
     }) | undefined);
     readonly messageQueue: MessageQueue;
     readonly events: Emitter<any>;
     get model(): ChatModel | undefined;
+    get imageModel(): ImageModel<import("../agents/image-model.js").ImageModelInput, import("../agents/image-model.js").ImageModelOutput> | undefined;
     get skills(): Agent<any, any>[] | undefined;
     get agents(): Agent<any, any>[];
     get observer(): AIGNEObserver | undefined;

package/lib/dts/index.d.ts

@@ -2,6 +2,8 @@ export * from "./agents/agent.js";
 export * from "./agents/ai-agent.js";
 export * from "./agents/chat-model.js";
 export * from "./agents/guide-rail-agent.js";
+export * from "./agents/image-agent.js";
+export * from "./agents/image-model.js";
 export * from "./agents/mcp-agent.js";
 export * from "./agents/team-agent.js";
 export * from "./agents/transform-agent.js";

package/lib/dts/loader/agent-yaml.d.ts

@@ -39,6 +39,11 @@ export interface AIAgentSchema extends BaseAgentSchema {
     outputKey?: string;
     toolChoice?: AIAgentToolChoice;
 }
+export interface ImageAgentSchema extends BaseAgentSchema {
+    type: "image";
+    instructions: string;
+    modelOptions?: Record<string, any>;
+}
 export interface MCPAgentSchema extends BaseAgentSchema {
     type: "mcp";
     url?: string;
@@ -64,6 +69,6 @@ export interface FunctionAgentSchema extends BaseAgentSchema {
     type: "function";
     process: FunctionAgentFn;
 }
-export type AgentSchema = AIAgentSchema | MCPAgentSchema | TeamAgentSchema | TransformAgentSchema | FunctionAgentSchema;
+export type AgentSchema = AIAgentSchema | ImageAgentSchema | MCPAgentSchema | TeamAgentSchema | TransformAgentSchema | FunctionAgentSchema;
 export declare function parseAgentFile(path: string, data: object): Promise<AgentSchema>;
 export declare function loadAgentFromYamlFile(path: string): Promise<AgentSchema>;