@aigne/core 1.51.0 → 1.53.0

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

@@ -30,6 +30,7 @@ export const agentOptionsSchema = z.object({
     skills: z.array(z.union([z.custom(), z.custom()])).optional(),
     disableEvents: z.boolean().optional(),
     memory: z.union([z.custom(), z.array(z.custom())]).optional(),
+    asyncMemoryRecord: z.boolean().optional(),
     maxRetrieveMemoryCount: z.number().optional(),
     hooks: z.union([z.array(hooksSchema), hooksSchema]).optional(),
     guideRails: z.array(z.custom()).optional(),
@@ -83,6 +84,7 @@ export class Agent {
         else if (options.memory) {
             this.memories.push(options.memory);
         }
+        this.asyncMemoryRecord = options.asyncMemoryRecord;
         this.maxRetrieveMemoryCount = options.maxRetrieveMemoryCount;
         this.hooks = flat(options.hooks);
         this.guideRails = options.guideRails;
@@ -91,6 +93,7 @@ export class Agent {
      * List of memories this agent can use
      */
     memories = [];
+    asyncMemoryRecord;
     tag;
     /**
      * Maximum number of memory items to retrieve
@@ -552,7 +555,11 @@ export class Agent {
     async postprocess(input, output, options) {
         this.checkContextStatus(options);
         this.publishToTopics(output, options);
-        await this.recordMemories({ content: [{ input, output: replaceTransferAgentToName(output), source: this.name }] }, options);
+        const memory = this.recordMemories({ content: [{ input, output: replaceTransferAgentToName(output), source: this.name }] }, options).catch((error) => {
+            logger.error(`Agent ${this.name} failed to record memories:`, error);
+        });
+        if (!this.asyncMemoryRecord)
+            await memory;
     }
     async publishToTopics(output, options) {
         const publishTopics = typeof this.publishTopic === "function" ? await this.publishTopic(output) : this.publishTopic;

package/lib/esm/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/esm/agents/chat-model.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { Agent } from "./agent.js";
+import { Agent, } from "./agent.js";
 /**
  * ChatModel is an abstract base class for interacting with Large Language Models (LLMs).
  *
@@ -25,12 +25,16 @@ import { Agent } from "./agent.js";
  */
 export class ChatModel extends Agent {
     tag = "ChatModelAgent";
-    constructor() {
+    constructor(options) {
         super({
+            ...options,
             inputSchema: chatModelInputSchema,
             outputSchema: chatModelOutputSchema,
         });
     }
+    get credential() {
+        return {};
+    }
     /**
      * Indicates whether the model supports parallel tool calls
      *
@@ -213,7 +217,7 @@ const chatModelOutputToolCallSchema = z.object({
         arguments: z.record(z.string(), z.unknown()),
     }),
 });
-const chatModelOutputUsageSchema = z.object({
+export const chatModelOutputUsageSchema = z.object({
     inputTokens: z.number(),
     outputTokens: z.number(),
     aigneHubCredits: z.number().optional(),

package/lib/esm/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/esm/agents/image-agent.js

@@ -0,0 +1,36 @@
+import z from "zod";
+import { PromptBuilder } from "../prompt/prompt-builder.js";
+import { checkArguments } from "../utils/type-utils.js";
+import { Agent, agentOptionsSchema, } from "./agent.js";
+import { imageModelOutputSchema } from "./image-model.js";
+export const imageAgentOptionsSchema = agentOptionsSchema.extend({
+    model: z.custom().optional(),
+    instructions: z.union([z.string(), z.custom()]),
+    modelOptions: z.record(z.any()).optional(),
+});
+export class ImageAgent extends Agent {
+    tag = "ImageAgent";
+    static from(options) {
+        return new ImageAgent(options);
+    }
+    constructor(options) {
+        super({ ...options, outputSchema: imageModelOutputSchema });
+        checkArguments("ImageAgent", imageAgentOptionsSchema, options);
+        this.model = options.model;
+        this.instructions =
+            typeof options.instructions === "string"
+                ? PromptBuilder.from(options.instructions)
+                : options.instructions;
+        this.modelOptions = options.modelOptions;
+    }
+    model;
+    instructions;
+    modelOptions;
+    async process(input, options) {
+        const model = this.model ?? options.context.imageModel;
+        if (!model)
+            throw new Error("image model is required to run ImageAgent");
+        const { prompt } = await this.instructions.buildImagePrompt({ input });
+        return (await options.context.invoke(model, { ...input, ...this.modelOptions, prompt }, { ...options, streaming: false }));
+    }
+}

package/lib/esm/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/esm/agents/image-model.js

@@ -0,0 +1,56 @@
+import { z } from "zod";
+import { Agent, } from "./agent.js";
+import { chatModelOutputUsageSchema } from "./chat-model.js";
+export class ImageModel extends Agent {
+    tag = "ImageModelAgent";
+    constructor(options) {
+        super({
+            inputSchema: imageModelInputSchema,
+            outputSchema: imageModelOutputSchema,
+            ...options,
+        });
+    }
+    get credential() {
+        return {};
+    }
+    async preprocess(input, options) {
+        super.preprocess(input, options);
+        const { limits, usage } = options.context;
+        const usedTokens = usage.outputTokens + usage.inputTokens;
+        if (limits?.maxTokens && usedTokens >= limits.maxTokens) {
+            throw new Error(`Exceeded max tokens ${usedTokens}/${limits.maxTokens}`);
+        }
+    }
+    async postprocess(input, output, options) {
+        super.postprocess(input, output, options);
+        const { usage } = output;
+        if (usage) {
+            options.context.usage.outputTokens += usage.outputTokens;
+            options.context.usage.inputTokens += usage.inputTokens;
+            if (usage.aigneHubCredits)
+                options.context.usage.aigneHubCredits += usage.aigneHubCredits;
+        }
+    }
+}
+export const imageModelInputSchema = z.object({
+    model: z.string().optional(),
+    image: z
+        .union([z.string(), z.array(z.string())])
+        .optional()
+        .describe("Image URL or base64 string(s) used for editing"),
+    prompt: z.string(),
+    n: z.number().int().min(1).optional(),
+    responseFormat: z.enum(["url", "base64"]).optional(),
+});
+export const imageModelOutputSchema = z.object({
+    images: z.array(z.union([
+        z.object({
+            url: z.string(),
+        }),
+        z.object({
+            base64: z.string(),
+        }),
+    ])),
+    usage: chatModelOutputUsageSchema.optional(),
+    model: z.string().optional(),
+});

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

@@ -25,15 +25,13 @@ export class AIGNE {
      * @param options - Options to override the loaded configuration.
      * @returns A fully initialized AIGNE instance with configured agents and skills.
      */
-    static async load(path, options) {
-        const { model, agents = [], skills = [], ...aigne } = await load({ ...options, path });
+    static async load(path, options = {}) {
+        const { agents = [], skills = [], model, imageModel, ...aigne } = await load(path, options);
         return new AIGNE({
             ...aigne,
             ...options,
-            rootDir: aigne.rootDir,
-            model: options?.model || model,
-            name: options?.name || aigne.name || undefined,
-            description: options?.description || aigne.description || undefined,
+            model,
+            imageModel,
             agents: agents.concat(options?.agents ?? []),
             skills: skills.concat(options?.skills ?? []),
         });
@@ -50,6 +48,7 @@ export class AIGNE {
         this.name = options?.name;
         this.description = options?.description;
         this.model = options?.model;
+        this.imageModel = options?.imageModel;
         this.limits = options?.limits;
         this.observer =
             process.env.AIGNE_OBSERVABILITY_DISABLED === "true"
@@ -82,6 +81,10 @@ export class AIGNE {
      * Global model to use for all agents that don't specify their own model.
      */
     model;
+    /**
+     * Optional image model to use for image processing tasks.
+     */
+    imageModel;
     /**
      * Usage limits applied to this AIGNE instance's execution.
      */
@@ -219,6 +222,7 @@ export class AIGNE {
 }
 const aigneOptionsSchema = z.object({
     model: z.custom().optional(),
+    imageModel: z.custom().optional(),
     skills: z.array(z.custom()).optional(),
     agents: z.array(z.custom()).optional(),
     observer: z.custom().optional(),

package/lib/esm/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/esm/aigne/context.js

@@ -55,6 +55,9 @@ export class AIGNEContext {
     get model() {
         return this.internal.model;
     }
+    get imageModel() {
+        return this.internal.imageModel;
+    }
     get skills() {
         return this.internal.skills;
     }
@@ -299,6 +302,9 @@ class AIGNEContextShared {
     get model() {
         return this.parent?.model;
     }
+    get imageModel() {
+        return this.parent?.imageModel;
+    }
     get skills() {
         return this.parent?.skills;
     }