@aigne/core 1.58.3 → 1.60.0

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

@@ -3,6 +3,10 @@ import { type PromiseOrValue } from "../utils/type-utils.js";
 import { Agent, type AgentInvokeOptions, type AgentOptions, type AgentProcessResult, type AgentResponse, type AgentResponseStream, type Message } from "./agent.js";
 export declare class StructuredOutputError extends Error {
 }
+export interface ChatModelOptions extends Omit<AgentOptions<ChatModelInput, ChatModelOutput>, "model" | "inputSchema" | "outputSchema"> {
+    model?: string;
+    modelOptions?: Omit<ModelOptions, "model">;
+}
 /**
  * ChatModel is an abstract base class for interacting with Large Language Models (LLMs).
  *
@@ -27,8 +31,9 @@ export declare class StructuredOutputError extends Error {
  * {@includeCode ../../test/agents/chat-model.test.ts#example-chat-model-tools}
  */
 export declare abstract class ChatModel extends Agent<ChatModelInput, ChatModelOutput> {
+    options?: ChatModelOptions | undefined;
     tag: string;
-    constructor(options?: Omit<AgentOptions<ChatModelInput, ChatModelOutput>, "inputSchema" | "outputSchema">);
+    constructor(options?: ChatModelOptions | undefined);
     get credential(): PromiseOrValue<{
         url?: string;
         apiKey?: string;
@@ -145,7 +150,7 @@ export interface ChatModelInput extends Message {
     /**
      * Model-specific configuration options
      */
-    modelOptions?: ChatModelOptions;
+    modelOptions?: ModelOptions;
 }
 /**
  * Message role types
@@ -578,7 +583,7 @@ export type Modality = "text" | "image" | "audio";
  *
  * Contains various parameters for controlling model behavior, such as model name, temperature, etc.
  */
-export interface ChatModelOptions {
+export interface ModelOptions {
     /**
      * Model name or version
      */
@@ -604,6 +609,7 @@ export interface ChatModelOptions {
      */
     parallelToolCalls?: boolean;
     modalities?: Modality[];
+    preferFileInputType?: "file" | "url";
 }
 /**
  * Output message format for ChatModel

package/lib/esm/agents/chat-model.js

@@ -36,10 +36,11 @@ export class StructuredOutputError extends Error {
  * {@includeCode ../../test/agents/chat-model.test.ts#example-chat-model-tools}
  */
 export class ChatModel extends Agent {
+    options;
     tag = "ChatModelAgent";
     constructor(options) {
         if (options)
-            checkArguments("ChatModel", agentOptionsSchema, options);
+            checkArguments("ChatModel", chatModelOptionsSchema, options);
         const retryOnError = options?.retryOnError === false
             ? false
             : options?.retryOnError === true
@@ -53,7 +54,9 @@ export class ChatModel extends Agent {
             inputSchema: chatModelInputSchema,
             outputSchema: chatModelOutputSchema,
             retryOnError,
+            model: undefined,
         });
+        this.options = options;
     }
     get credential() {
         return {};
@@ -148,6 +151,18 @@ export class ChatModel extends Agent {
                             mimeType: item.mimeType || ChatModel.getMimeType(item.filename || item.path),
                         };
                     }
+                    if ((input.modelOptions?.preferFileInputType ||
+                        this.options?.modelOptions?.preferFileInputType) !== "url") {
+                        if (item.type === "url") {
+                            return {
+                                ...item,
+                                type: "file",
+                                data: Buffer.from(await (await this.downloadFile(item.url)).arrayBuffer()).toString("base64"),
+                                url: undefined,
+                                mimeType: item.mimeType || ChatModel.getMimeType(item.filename || item.url),
+                            };
+                        }
+                    }
                     return item;
                 })),
             };
@@ -338,7 +353,7 @@ const chatModelInputToolChoiceSchema = z.union([
     z.literal("required"),
     chatModelInputToolSchema,
 ]);
-const chatModelOptionsSchema = z.object({
+const modelOptionsSchema = z.object({
     model: z.string().optional(),
     temperature: z.number().optional(),
     topP: z.number().optional(),
@@ -347,12 +362,16 @@ const chatModelOptionsSchema = z.object({
     parallelToolCalls: z.boolean().optional().default(true),
     modalities: z.array(z.enum(["text", "image", "audio"])).optional(),
 });
+const chatModelOptionsSchema = agentOptionsSchema.extend({
+    model: z.string().optional(),
+    modelOptions: modelOptionsSchema.optional(),
+});
 const chatModelInputSchema = z.object({
     messages: z.array(chatModelInputMessageSchema),
     responseFormat: chatModelInputResponseFormatSchema.optional(),
     tools: z.array(chatModelInputToolSchema).optional(),
     toolChoice: chatModelInputToolChoiceSchema.optional(),
-    modelOptions: chatModelOptionsSchema.optional(),
+    modelOptions: modelOptionsSchema.optional(),
 });
 export var FileOutputType;
 (function (FileOutputType) {

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

@@ -1,9 +1,8 @@
 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";
+import { 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>;
 }
@@ -14,7 +13,6 @@ export declare class ImageAgent<I extends Message = any, O extends ImageModelOut
     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

@@ -4,7 +4,6 @@ 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(),
 });
@@ -16,21 +15,19 @@ export class ImageAgent extends Agent {
     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)
+        const imageModel = this.imageModel || options.imageModel || options.context.imageModel;
+        if (!imageModel)
             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 }));
+        return (await this.invokeChildAgent(imageModel, { ...input, ...this.modelOptions, prompt }, { ...options, streaming: false }));
     }
 }

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

@@ -2,7 +2,7 @@ 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 interface ImageModelOptions<I extends ImageModelInput = ImageModelInput, O extends ImageModelOutput = ImageModelOutput> extends Omit<AgentOptions<I, O>, "model"> {
 }
 export declare abstract class ImageModel<I extends ImageModelInput = ImageModelInput, O extends ImageModelOutput = ImageModelOutput> extends Agent<I, O> {
     tag: string;
@@ -32,14 +32,14 @@ export declare const imageModelInputSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     prompt: string;
     model?: string | undefined;
-    responseFormat?: "base64" | "url" | undefined;
     image?: string | string[] | undefined;
+    responseFormat?: "base64" | "url" | undefined;
     n?: number | undefined;
 }, {
     prompt: string;
     model?: string | undefined;
-    responseFormat?: "base64" | "url" | undefined;
     image?: string | string[] | undefined;
+    responseFormat?: "base64" | "url" | undefined;
     n?: number | undefined;
 }>;
 export interface ImageModelOutput extends Message {

package/lib/esm/agents/team-agent.js

@@ -171,7 +171,10 @@ export class TeamAgent extends Agent {
         for (;;) {
             const output = await agentProcessResultToObject(await this._processNonReflection(previousOutput, options));
             Object.assign(previousOutput, output);
-            const reviewOutput = await options.context.invoke(this.reflection.reviewer, previousOutput);
+            const reviewOutput = await this.invokeChildAgent(this.reflection.reviewer, previousOutput, {
+                ...options,
+                streaming: false,
+            });
             Object.assign(previousOutput, reviewOutput);
             const { isApproved } = this.reflection;
             const approved = typeof isApproved === "string" ? reviewOutput[isApproved] : await isApproved(reviewOutput);
@@ -246,7 +249,7 @@ export class TeamAgent extends Agent {
     async *_processSequential(input, options) {
         const output = {};
         for (const agent of this.skills) {
-            const o = await options.context.invoke(agent, { ...input, ...output }, { ...options, streaming: true });
+            const o = await this.invokeChildAgent(agent, { ...input, ...output }, { ...options, streaming: true });
             const isLast = agent === this.skills[this.skills.length - 1];
             for await (const chunk of o) {
                 // Only yield the chunk if it is the last agent in the sequence
@@ -272,7 +275,7 @@ export class TeamAgent extends Agent {
      * @private
      */
     async *_processParallel(input, options) {
-        const streams = await Promise.all(this.skills.map((agent) => options.context.invoke(agent, input, { ...options, streaming: true })));
+        const streams = await Promise.all(this.skills.map((agent) => this.invokeChildAgent(agent, input, { ...options, streaming: true })));
         const read = async (index, reader) => {
             const promise = reader.read();
             return promise.then((result) => ({ ...result, reader, index }));

package/lib/esm/agents/user-agent.js

@@ -32,7 +32,8 @@ export class UserAgent extends Agent {
             return this._process(input, options);
         }
         if (this.activeAgent) {
-            const [output, agent] = await options.context.invoke(this.activeAgent, input, {
+            const [output, agent] = await this.invokeChildAgent(this.activeAgent, input, {
+                ...options,
                 returnActiveAgent: true,
                 streaming: true,
                 // Do not create a new context for the nested agent invocation,

package/lib/esm/aigne/context.js

@@ -347,6 +347,8 @@ class AIGNEContextShared {
                     hooks: options.hooks,
                     context,
                     streaming: true,
+                    model: options.model,
+                    imageModel: options.imageModel,
                 });
                 for await (const value of stream) {
                     if (isAgentResponseDelta(value)) {

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

@@ -1,7 +1,8 @@
-import { type ZodType } from "zod";
+import { type ZodType, z } from "zod";
 import type { AgentHooks, FunctionAgentFn, TaskRenderMode } from "../agents/agent.js";
 import { AIAgentToolChoice } from "../agents/ai-agent.js";
 import { ProcessMode, type ReflectionMode } from "../agents/team-agent.js";
+import { chatModelSchema, imageModelSchema } from "./schema.js";
 export interface HooksSchema {
     priority?: AgentHooks["priority"];
     onStart?: NestAgentSchema;
@@ -20,6 +21,8 @@ export type NestAgentSchema = string | {
 export interface BaseAgentSchema {
     name?: string;
     description?: string;
+    model?: z.infer<typeof chatModelSchema>;
+    imageModel?: z.infer<typeof imageModelSchema>;
     taskTitle?: string;
     taskRenderMode?: TaskRenderMode;
     inputSchema?: ZodType<Record<string, any>>;
@@ -74,5 +77,5 @@ export interface FunctionAgentSchema extends BaseAgentSchema {
     process: FunctionAgentFn;
 }
 export type AgentSchema = AIAgentSchema | ImageAgentSchema | MCPAgentSchema | TeamAgentSchema | TransformAgentSchema | FunctionAgentSchema;
-export declare function parseAgentFile(path: string, data: object): Promise<AgentSchema>;
+export declare function parseAgentFile(path: string, data: any): Promise<AgentSchema>;
 export declare function loadAgentFromYamlFile(path: string): Promise<AgentSchema>;

package/lib/esm/loader/agent-yaml.js

@@ -5,7 +5,7 @@ import { z } from "zod";
 import { AIAgentToolChoice } from "../agents/ai-agent.js";
 import { ProcessMode } from "../agents/team-agent.js";
 import { tryOrThrow } from "../utils/type-utils.js";
-import { camelizeSchema, defaultInputSchema, inputOutputSchema, optionalize } from "./schema.js";
+import { camelizeSchema, chatModelSchema, defaultInputSchema, imageModelSchema, inputOutputSchema, optionalize, } from "./schema.js";
 export async function parseAgentFile(path, data) {
     const agentSchema = z.lazy(() => {
         const nestAgentSchema = z.lazy(() => z.union([
@@ -31,6 +31,8 @@ export async function parseAgentFile(path, data) {
             name: optionalize(z.string()),
             alias: optionalize(z.array(z.string())),
             description: optionalize(z.string()),
+            model: optionalize(chatModelSchema),
+            imageModel: optionalize(imageModelSchema),
             taskTitle: optionalize(z.string()),
             taskRenderMode: optionalize(z.union([z.literal("hide"), z.literal("collapse")])),
             inputSchema: optionalize(inputOutputSchema({ path })).transform((v) => v ? jsonSchemaToZod(v) : undefined),
@@ -114,7 +116,10 @@ export async function parseAgentFile(path, data) {
                 .extend(baseAgentSchema.shape),
         ]));
     });
-    return agentSchema.parseAsync(data);
+    return agentSchema.parseAsync({
+        ...data,
+        model: data.model || data.chatModel || data.chat_model,
+    });
 }
 export async function loadAgentFromYamlFile(path) {
     const raw = await tryOrThrow(() => nodejs.fs.readFile(path, "utf8"), (error) => new Error(`Failed to load agent definition from ${path}: ${error.message}`));

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

@@ -9,7 +9,7 @@ export interface LoadOptions {
     memories?: {
         new (parameters?: MemoryAgentOptions): MemoryAgent;
     }[];
-    model?: ChatModel | ((model?: z.infer<typeof aigneFileSchema>["chatModel"]) => PromiseOrValue<ChatModel | undefined>);
+    model?: ChatModel | ((model?: z.infer<typeof aigneFileSchema>["model"]) => PromiseOrValue<ChatModel | undefined>);
     imageModel?: ImageModel | ((model?: z.infer<typeof aigneFileSchema>["imageModel"]) => PromiseOrValue<ImageModel | undefined>);
     key?: string | number;
 }
@@ -18,38 +18,22 @@ export declare function loadAgent(path: string, options?: LoadOptions, agentOpti
 declare const aigneFileSchema: z.ZodObject<{
     name: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
     description: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
-    chatModel: z.ZodEffects<z.ZodEffects<z.ZodType<string | {
+    model: z.ZodType<{
         model?: string | undefined;
         temperature?: number | undefined;
         topP?: number | undefined;
         frequencyPenalty?: number | undefined;
         presencePenalty?: number | undefined;
-    } | undefined, z.ZodTypeDef, string | {
-        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>, {
+    } | undefined, z.ZodTypeDef, {
         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>, {
+    } | undefined>;
+    imageModel: z.ZodType<{
         model?: string | undefined;
-    } | undefined, string | {
+    } | undefined, z.ZodTypeDef, {
         model?: string | undefined;
     } | undefined>;
     agents: z.ZodType<string[] | undefined, z.ZodTypeDef, string[] | undefined>;
@@ -67,20 +51,20 @@ declare const aigneFileSchema: z.ZodObject<{
         chat?: string | undefined;
     } | undefined>;
 }, "strip", z.ZodTypeAny, {
-    name?: string | undefined;
-    description?: string | undefined;
-    skills?: string[] | undefined;
-    imageModel?: {
-        model?: string | undefined;
-    } | undefined;
-    agents?: string[] | undefined;
-    chatModel?: {
+    model?: {
         model?: string | undefined;
         temperature?: number | undefined;
         topP?: number | undefined;
         frequencyPenalty?: number | undefined;
         presencePenalty?: number | undefined;
     } | undefined;
+    name?: string | undefined;
+    description?: string | undefined;
+    imageModel?: {
+        model?: string | undefined;
+    } | undefined;
+    skills?: string[] | undefined;
+    agents?: string[] | undefined;
     mcpServer?: {
         agents?: string[] | undefined;
     } | undefined;
@@ -89,14 +73,20 @@ declare const aigneFileSchema: z.ZodObject<{
         chat?: string | undefined;
     } | undefined;
 }, {
+    model?: {
+        model?: string | undefined;
+        temperature?: number | undefined;
+        topP?: number | undefined;
+        frequencyPenalty?: number | undefined;
+        presencePenalty?: number | undefined;
+    } | undefined;
     name?: string | undefined;
     description?: string | undefined;
-    skills?: string[] | undefined;
-    imageModel?: string | {
+    imageModel?: {
         model?: string | undefined;
     } | undefined;
+    skills?: string[] | undefined;
     agents?: string[] | undefined;
-    chatModel?: unknown;
     mcpServer?: {
         agents?: string[] | undefined;
     } | undefined;

package/lib/esm/loader/index.js

@@ -8,10 +8,10 @@ import { MCPAgent } from "../agents/mcp-agent.js";
 import { TeamAgent } from "../agents/team-agent.js";
 import { TransformAgent } from "../agents/transform-agent.js";
 import { PromptBuilder } from "../prompt/prompt-builder.js";
-import { flat, isNonNullable, isRecord, tryOrThrow, } from "../utils/type-utils.js";
+import { flat, isNonNullable, tryOrThrow } from "../utils/type-utils.js";
 import { loadAgentFromJsFile } from "./agent-js.js";
 import { loadAgentFromYamlFile } from "./agent-yaml.js";
-import { camelizeSchema, optionalize } from "./schema.js";
+import { camelizeSchema, chatModelSchema, imageModelSchema, optionalize } from "./schema.js";
 const AIGNE_FILE_NAME = ["aigne.yaml", "aigne.yml"];
 export async function load(path, options = {}) {
     options.key ??= Date.now();
@@ -22,7 +22,7 @@ export async function load(path, options = {}) {
     return {
         ...aigne,
         rootDir,
-        model: typeof options.model === "function" ? await options.model(aigne.chatModel) : options.model,
+        model: typeof options.model === "function" ? await options.model(aigne.model) : options.model,
         imageModel: typeof options.imageModel === "function"
             ? await options.imageModel(aigne.imageModel)
             : options.imageModel,
@@ -87,9 +87,17 @@ async function parseAgent(path, agent, options, agentOptions) {
     const memory = "memory" in agent && options?.memories?.length
         ? await loadMemory(options.memories, typeof agent.memory === "object" ? agent.memory.provider : undefined, typeof agent.memory === "object" ? agent.memory : {})
         : undefined;
+    const model = agent.model && typeof options?.model === "function"
+        ? await options.model(agent.model)
+        : undefined;
+    const imageModel = agent.imageModel && typeof options?.imageModel === "function"
+        ? await options.imageModel(agent.imageModel)
+        : undefined;
     const baseOptions = {
         ...agentOptions,
         ...agent,
+        model,
+        imageModel,
         skills,
         memory,
         hooks: [
@@ -170,28 +178,8 @@ async function loadMemory(memories, provider, options) {
 const aigneFileSchema = camelizeSchema(z.object({
     name: optionalize(z.string()),
     description: optionalize(z.string()),
-    chatModel: z
-        .preprocess((v) => {
-        if (!isRecord(v))
-            return v;
-        return { ...v, model: v.model || `${v.provider || ""}:${v.name || ""}` };
-    }, optionalize(z.union([
-        z.string(),
-        camelizeSchema(z.object({
-            model: optionalize(z.string()),
-            temperature: optionalize(z.number().min(0).max(2)),
-            topP: optionalize(z.number().min(0)),
-            frequencyPenalty: optionalize(z.number().min(-2).max(2)),
-            presencePenalty: optionalize(z.number().min(-2).max(2)),
-        })),
-    ])))
-        .transform((v) => (typeof v === "string" ? { model: v } : v)),
-    imageModel: optionalize(z.union([
-        z.string(),
-        camelizeSchema(z.object({
-            model: optionalize(z.string()),
-        })),
-    ])).transform((v) => (typeof v === "string" ? { model: v } : v)),
+    model: optionalize(chatModelSchema),
+    imageModel: optionalize(imageModelSchema),
     agents: optionalize(z.array(z.string())),
     skills: optionalize(z.array(z.string())),
     mcpServer: optionalize(z.object({
@@ -206,7 +194,7 @@ export async function loadAIGNEFile(path) {
     const file = await findAIGNEFile(path);
     const raw = await tryOrThrow(() => nodejs.fs.readFile(file, "utf8"), (error) => new Error(`Failed to load aigne.yaml from ${file}: ${error.message}`));
     const json = tryOrThrow(() => parse(raw), (error) => new Error(`Failed to parse aigne.yaml from ${file}: ${error.message}`));
-    const aigne = tryOrThrow(() => aigneFileSchema.parse(json), (error) => new Error(`Failed to validate aigne.yaml from ${file}: ${error.message}`));
+    const aigne = tryOrThrow(() => aigneFileSchema.parse({ ...json, model: json.model || json.chatModel || json.chat_model }), (error) => new Error(`Failed to validate aigne.yaml from ${file}: ${error.message}`));
     return { aigne, rootDir: nodejs.path.dirname(file) };
 }
 async function findAIGNEFile(path) {

package/lib/esm/loader/schema.d.ts

@@ -29,7 +29,36 @@ export declare const defaultInputSchema: z.ZodRecord<z.ZodString, z.ZodUnion<[z.
 }, {
     $get: string;
 }>, z.ZodUnknown]>>;
+declare const chatModelObjectSchema: z.ZodObject<{
+    model: ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    temperature: ZodType<number | undefined, z.ZodTypeDef, number | undefined>;
+    topP: ZodType<number | undefined, z.ZodTypeDef, number | undefined>;
+    frequencyPenalty: ZodType<number | undefined, z.ZodTypeDef, number | undefined>;
+    presencePenalty: ZodType<number | undefined, z.ZodTypeDef, number | undefined>;
+}, "strip", z.ZodTypeAny, {
+    model?: string | undefined;
+    temperature?: number | undefined;
+    topP?: number | undefined;
+    frequencyPenalty?: number | undefined;
+    presencePenalty?: number | undefined;
+}, {
+    model?: string | undefined;
+    temperature?: number | undefined;
+    topP?: number | undefined;
+    frequencyPenalty?: number | undefined;
+    presencePenalty?: number | undefined;
+}>;
+export declare const chatModelSchema: typeof chatModelObjectSchema;
+declare const imageModelObjectSchema: z.ZodObject<{
+    model: ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+}, "strip", z.ZodTypeAny, {
+    model?: string | undefined;
+}, {
+    model?: string | undefined;
+}>;
+export declare const imageModelSchema: typeof imageModelObjectSchema;
 export declare function optionalize<T>(schema: ZodType<T>): ZodType<T | undefined>;
 export declare function camelizeSchema<T extends ZodType>(schema: T, { shallow }?: {
     shallow?: boolean;
 }): T;
+export {};

package/lib/esm/loader/schema.js

@@ -54,6 +54,26 @@ export const defaultInputSchema = z.record(z.string(), z.union([
     }),
     z.unknown(),
 ]));
+const chatModelObjectSchema = camelizeSchema(z.object({
+    model: optionalize(z.string()),
+    temperature: optionalize(z.number().min(0).max(2)),
+    topP: optionalize(z.number().min(0)),
+    frequencyPenalty: optionalize(z.number().min(-2).max(2)),
+    presencePenalty: optionalize(z.number().min(-2).max(2)),
+}));
+export const chatModelSchema = z
+    .preprocess((v) => {
+    if (!isRecord(v))
+        return v;
+    return { ...v, model: v.model || `${v.provider || ""}:${v.name || ""}` };
+}, z.union([z.string(), chatModelObjectSchema]))
+    .transform((v) => typeof v === "string" ? { model: v } : v);
+const imageModelObjectSchema = camelizeSchema(z.object({
+    model: optionalize(z.string()),
+}));
+export const imageModelSchema = z
+    .union([z.string(), imageModelObjectSchema])
+    .transform((v) => typeof v === "string" ? { model: v } : v);
 export function optionalize(schema) {
     return schema.nullish().transform((v) => v ?? undefined);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/core",
-  "version": "1.58.3",
+  "version": "1.60.0",
   "description": "The functional core of agentic AI",
   "publishConfig": {
     "access": "public"
@@ -92,8 +92,8 @@
     "yaml": "^2.8.0",
     "zod": "^3.25.67",
     "zod-to-json-schema": "^3.24.6",
-    "@aigne/platform-helpers": "^0.6.2",
-    "@aigne/observability-api": "^0.10.2"
+    "@aigne/observability-api": "^0.10.3",
+    "@aigne/platform-helpers": "^0.6.2"
   },
   "devDependencies": {
     "@types/bun": "^1.2.18",