@aigne/core 1.73.0-beta → 1.74.0-beta

package/dist/agents/image-agent.cjs

@@ -0,0 +1,74 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_utils_type_utils = require('../utils/type-utils.cjs');
+const require_agent = require('./agent.cjs');
+const require_model = require('./model.cjs');
+const require_prompt_builder = require('../prompt/prompt-builder.cjs');
+const require_loader_schema = require('../loader/schema.cjs');
+const require_image_model = require('./image-model.cjs');
+let zod = require("zod");
+zod = require_rolldown_runtime.__toESM(zod);
+
+//#region src/agents/image-agent.ts
+const imageAgentOptionsSchema = require_agent.agentOptionsSchema.extend({
+	instructions: zod.default.union([zod.default.string(), zod.default.custom()]),
+	outputFileType: require_model.fileTypeSchema.optional()
+});
+var ImageAgent = class ImageAgent extends require_agent.Agent {
+	tag = "ImageAgent";
+	static schema({ filepath }) {
+		const instructionsSchema = require_loader_schema.getInstructionsSchema({ filepath });
+		return require_loader_schema.camelizeSchema(zod.default.object({
+			instructions: instructionsSchema,
+			inputFileKey: require_loader_schema.optionalize(zod.default.string())
+		}));
+	}
+	static async load(options) {
+		const valid = await ImageAgent.schema({ filepath: options.filepath }).parseAsync(options.parsed);
+		return new ImageAgent({
+			...options.parsed,
+			...valid,
+			instructions: require_loader_schema.instructionsToPromptBuilder(valid.instructions)
+		});
+	}
+	static from(options) {
+		return new ImageAgent(options);
+	}
+	constructor(options) {
+		super({
+			...options,
+			outputSchema: require_image_model.imageModelOutputSchema
+		});
+		require_utils_type_utils.checkArguments("ImageAgent", imageAgentOptionsSchema, options);
+		this.instructions = typeof options.instructions === "string" ? require_prompt_builder.PromptBuilder.from(options.instructions) : options.instructions;
+		this.inputFileKey = options.inputFileKey;
+		this.outputFileType = options.outputFileType;
+	}
+	instructions;
+	inputFileKey;
+	outputFileType;
+	async process(input, options) {
+		const imageModel = this.imageModel || options.imageModel || options.context.imageModel;
+		if (!imageModel) throw new Error("image model is required to run ImageAgent");
+		const modelOptions = await imageModel.getModelOptions(input, options);
+		const { prompt, image } = await this.instructions.buildPrompt({
+			...options,
+			input,
+			inputFileKey: this.inputFileKey
+		});
+		const n = input.n || modelOptions?.n;
+		return await this.invokeChildAgent(imageModel, {
+			n: n && typeof n === "number" ? n : void 0,
+			modelOptions,
+			prompt,
+			image,
+			outputFileType: this.outputFileType
+		}, {
+			...options,
+			streaming: false
+		});
+	}
+};
+
+//#endregion
+exports.ImageAgent = ImageAgent;
+exports.imageAgentOptionsSchema = imageAgentOptionsSchema;

package/dist/agents/image-agent.d.cts

@@ -0,0 +1,44 @@
+import { FileType } from "./model.cjs";
+import { ImageModelOutput } from "./image-model.cjs";
+import { Agent, AgentInvokeOptions, AgentOptions, Message } from "./agent.cjs";
+import { PromptBuilder } from "../prompt/prompt-builder.cjs";
+import { Instructions } from "../loader/schema.cjs";
+import z$1, { ZodObject, ZodType } from "zod";
+
+//#region src/agents/image-agent.d.ts
+interface ImageAgentOptions<I extends Message = any, O extends ImageModelOutput = any> extends Omit<AgentOptions<I, O>, "outputSchema"> {
+  instructions: string | PromptBuilder;
+  inputFileKey?: string;
+  outputFileType?: FileType;
+}
+declare const imageAgentOptionsSchema: ZodObject<{ [key in keyof ImageAgentOptions]: ZodType<ImageAgentOptions[key]> }>;
+declare class ImageAgent<I extends Message = any, O extends ImageModelOutput = any> extends Agent<I, O> {
+  tag: string;
+  static schema({
+    filepath
+  }: {
+    filepath: string;
+  }): z$1.ZodObject<{
+    instructions: z$1.ZodType<Instructions, z$1.ZodTypeDef, Instructions>;
+    inputFileKey: z$1.ZodType<string | undefined, z$1.ZodTypeDef, string | undefined>;
+  }, "strip", z$1.ZodTypeAny, {
+    instructions: Instructions;
+    inputFileKey?: string | undefined;
+  }, {
+    instructions: Instructions;
+    inputFileKey?: string | undefined;
+  }>;
+  static load<I extends Message = any, O extends Message = any>(options: {
+    filepath: string;
+    parsed: object;
+  }): Promise<Agent<I, O>>;
+  static from<I extends Message = any, O extends ImageModelOutput = any>(options: ImageAgentOptions<I, O>): ImageAgent<I, O>;
+  constructor(options: ImageAgentOptions<I, O>);
+  instructions: PromptBuilder;
+  inputFileKey?: string;
+  outputFileType?: FileType;
+  process(input: I, options: AgentInvokeOptions): Promise<O>;
+}
+//#endregion
+export { ImageAgent, ImageAgentOptions, imageAgentOptionsSchema };
+//# sourceMappingURL=image-agent.d.cts.map

package/dist/agents/image-agent.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-agent.d.cts","names":[],"sources":["../../src/agents/image-agent.ts"],"mappings":";;;;;;;;UAmBiB,iBAAA,WAA4B,OAAA,kBAAyB,gBAAA,gBAC5D,IAAA,CAAK,YAAA,CAAa,CAAA,EAAG,CAAA;EAAA,YAAA,WACN,aAAA;EAAA,YAAA;EAAA,cAAA,GAIN,QAAA;AAAA;AAAA,cAGN,uBAAA,EAAyB,SAAA,iBACtB,iBAAA,GAAoB,OAAA,CAAQ,iBAAA,CAAkB,GAAA;AAAA,cAMjD,UAAA,WAAqB,OAAA,kBAAyB,gBAAA,gBAAgC,KAAA,CACzF,CAAA,EACA,CAAA;EAAA,GAAA;EAAA,OAAA,OAAA;IAAA;EAAA;IAAA,QAAA;EAAA,IAIgD,GAAA,CAAA,SAAA;IAAA,YAAA,cAAxB,YAAA;;;;;;;;;wBAWa,OAAA,kBAAyB,OAAA,OAAA,CAAA,OAAA;IAAA,QAAA;IAAA,MAAA;EAAA,IAG1D,OAAA,CAAQ,KAAA,CAAM,CAAA,EAAG,CAAA;EAAA,OAAA,IAAA,WAWC,OAAA,kBAAyB,gBAAA,OAAA,CAAA,OAAA,EACpC,iBAAA,CAAkB,CAAA,EAAG,CAAA,IAC7B,UAAA,CAAW,CAAA,EAAG,CAAA;EAAA,YAAA,OAAA,EAII,iBAAA,CAAkB,CAAA,EAAG,CAAA;EAAA,YAAA,EAY5B,aAAA;EAAA,YAAA;EAAA,cAAA,GAIG,QAAA;EAAA,QAAA,KAAA,EAEa,CAAA,EAAA,OAAA,EAAY,kBAAA,GAAqB,OAAA,CAAQ,CAAA;AAAA"}

package/dist/agents/image-agent.d.mts

@@ -0,0 +1,44 @@
+import { FileType } from "./model.mjs";
+import { ImageModelOutput } from "./image-model.mjs";
+import { Agent, AgentInvokeOptions, AgentOptions, Message } from "./agent.mjs";
+import { PromptBuilder } from "../prompt/prompt-builder.mjs";
+import { Instructions } from "../loader/schema.mjs";
+import z, { ZodObject, ZodType } from "zod";
+
+//#region src/agents/image-agent.d.ts
+interface ImageAgentOptions<I extends Message = any, O extends ImageModelOutput = any> extends Omit<AgentOptions<I, O>, "outputSchema"> {
+  instructions: string | PromptBuilder;
+  inputFileKey?: string;
+  outputFileType?: FileType;
+}
+declare const imageAgentOptionsSchema: ZodObject<{ [key in keyof ImageAgentOptions]: ZodType<ImageAgentOptions[key]> }>;
+declare class ImageAgent<I extends Message = any, O extends ImageModelOutput = any> extends Agent<I, O> {
+  tag: string;
+  static schema({
+    filepath
+  }: {
+    filepath: string;
+  }): z.ZodObject<{
+    instructions: z.ZodType<Instructions, z.ZodTypeDef, Instructions>;
+    inputFileKey: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+  }, "strip", z.ZodTypeAny, {
+    instructions: Instructions;
+    inputFileKey?: string | undefined;
+  }, {
+    instructions: Instructions;
+    inputFileKey?: string | undefined;
+  }>;
+  static load<I extends Message = any, O extends Message = any>(options: {
+    filepath: string;
+    parsed: object;
+  }): Promise<Agent<I, O>>;
+  static from<I extends Message = any, O extends ImageModelOutput = any>(options: ImageAgentOptions<I, O>): ImageAgent<I, O>;
+  constructor(options: ImageAgentOptions<I, O>);
+  instructions: PromptBuilder;
+  inputFileKey?: string;
+  outputFileType?: FileType;
+  process(input: I, options: AgentInvokeOptions): Promise<O>;
+}
+//#endregion
+export { ImageAgent, ImageAgentOptions, imageAgentOptionsSchema };
+//# sourceMappingURL=image-agent.d.mts.map

package/dist/agents/image-agent.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-agent.d.mts","names":[],"sources":["../../src/agents/image-agent.ts"],"mappings":";;;;;;;;UAmBiB,iBAAA,WAA4B,OAAA,kBAAyB,gBAAA,gBAC5D,IAAA,CAAK,YAAA,CAAa,CAAA,EAAG,CAAA;EAAA,YAAA,WACN,aAAA;EAAA,YAAA;EAAA,cAAA,GAIN,QAAA;AAAA;AAAA,cAGN,uBAAA,EAAyB,SAAA,iBACtB,iBAAA,GAAoB,OAAA,CAAQ,iBAAA,CAAkB,GAAA;AAAA,cAMjD,UAAA,WAAqB,OAAA,kBAAyB,gBAAA,gBAAgC,KAAA,CACzF,CAAA,EACA,CAAA;EAAA,GAAA;EAAA,OAAA,OAAA;IAAA;EAAA;IAAA,QAAA;EAAA,IAIgD,CAAA,CAAA,SAAA;IAAA,YAAA,YAAxB,YAAA;;;;;;;;;wBAWa,OAAA,kBAAyB,OAAA,OAAA,CAAA,OAAA;IAAA,QAAA;IAAA,MAAA;EAAA,IAG1D,OAAA,CAAQ,KAAA,CAAM,CAAA,EAAG,CAAA;EAAA,OAAA,IAAA,WAWC,OAAA,kBAAyB,gBAAA,OAAA,CAAA,OAAA,EACpC,iBAAA,CAAkB,CAAA,EAAG,CAAA,IAC7B,UAAA,CAAW,CAAA,EAAG,CAAA;EAAA,YAAA,OAAA,EAII,iBAAA,CAAkB,CAAA,EAAG,CAAA;EAAA,YAAA,EAY5B,aAAA;EAAA,YAAA;EAAA,cAAA,GAIG,QAAA;EAAA,QAAA,KAAA,EAEa,CAAA,EAAA,OAAA,EAAY,kBAAA,GAAqB,OAAA,CAAQ,CAAA;AAAA"}

package/dist/agents/image-agent.mjs

@@ -0,0 +1,72 @@
+import { checkArguments } from "../utils/type-utils.mjs";
+import { Agent, agentOptionsSchema } from "./agent.mjs";
+import { fileTypeSchema } from "./model.mjs";
+import { PromptBuilder } from "../prompt/prompt-builder.mjs";
+import { camelizeSchema, getInstructionsSchema, instructionsToPromptBuilder, optionalize } from "../loader/schema.mjs";
+import { imageModelOutputSchema } from "./image-model.mjs";
+import z from "zod";
+
+//#region src/agents/image-agent.ts
+const imageAgentOptionsSchema = agentOptionsSchema.extend({
+	instructions: z.union([z.string(), z.custom()]),
+	outputFileType: fileTypeSchema.optional()
+});
+var ImageAgent = class ImageAgent extends Agent {
+	tag = "ImageAgent";
+	static schema({ filepath }) {
+		const instructionsSchema = getInstructionsSchema({ filepath });
+		return camelizeSchema(z.object({
+			instructions: instructionsSchema,
+			inputFileKey: optionalize(z.string())
+		}));
+	}
+	static async load(options) {
+		const valid = await ImageAgent.schema({ filepath: options.filepath }).parseAsync(options.parsed);
+		return new ImageAgent({
+			...options.parsed,
+			...valid,
+			instructions: instructionsToPromptBuilder(valid.instructions)
+		});
+	}
+	static from(options) {
+		return new ImageAgent(options);
+	}
+	constructor(options) {
+		super({
+			...options,
+			outputSchema: imageModelOutputSchema
+		});
+		checkArguments("ImageAgent", imageAgentOptionsSchema, options);
+		this.instructions = typeof options.instructions === "string" ? PromptBuilder.from(options.instructions) : options.instructions;
+		this.inputFileKey = options.inputFileKey;
+		this.outputFileType = options.outputFileType;
+	}
+	instructions;
+	inputFileKey;
+	outputFileType;
+	async process(input, options) {
+		const imageModel = this.imageModel || options.imageModel || options.context.imageModel;
+		if (!imageModel) throw new Error("image model is required to run ImageAgent");
+		const modelOptions = await imageModel.getModelOptions(input, options);
+		const { prompt, image } = await this.instructions.buildPrompt({
+			...options,
+			input,
+			inputFileKey: this.inputFileKey
+		});
+		const n = input.n || modelOptions?.n;
+		return await this.invokeChildAgent(imageModel, {
+			n: n && typeof n === "number" ? n : void 0,
+			modelOptions,
+			prompt,
+			image,
+			outputFileType: this.outputFileType
+		}, {
+			...options,
+			streaming: false
+		});
+	}
+};
+
+//#endregion
+export { ImageAgent, imageAgentOptionsSchema };
+//# sourceMappingURL=image-agent.mjs.map

package/dist/agents/image-agent.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-agent.mjs","names":[],"sources":["../../src/agents/image-agent.ts"],"sourcesContent":["import z, { type ZodObject, type ZodType } from \"zod\";\nimport {\n  camelizeSchema,\n  getInstructionsSchema,\n  instructionsToPromptBuilder,\n  optionalize,\n} from \"../loader/schema.js\";\nimport { PromptBuilder } from \"../prompt/prompt-builder.js\";\nimport { checkArguments } from \"../utils/type-utils.js\";\nimport {\n  Agent,\n  type AgentInvokeOptions,\n  type AgentOptions,\n  agentOptionsSchema,\n  type Message,\n} from \"./agent.js\";\nimport { type ImageModelOutput, imageModelOutputSchema } from \"./image-model.js\";\nimport { type FileType, fileTypeSchema } from \"./model.js\";\n\nexport interface ImageAgentOptions<I extends Message = any, O extends ImageModelOutput = any>\n  extends Omit<AgentOptions<I, O>, \"outputSchema\"> {\n  instructions: string | PromptBuilder;\n\n  inputFileKey?: string;\n\n  outputFileType?: FileType;\n}\n\nexport const imageAgentOptionsSchema: ZodObject<{\n  [key in keyof ImageAgentOptions]: ZodType<ImageAgentOptions[key]>;\n}> = agentOptionsSchema.extend({\n  instructions: z.union([z.string(), z.custom<PromptBuilder>()]),\n  outputFileType: fileTypeSchema.optional(),\n});\n\nexport class ImageAgent<I extends Message = any, O extends ImageModelOutput = any> extends Agent<\n  I,\n  O\n> {\n  override tag = \"ImageAgent\";\n\n  static schema({ filepath }: { filepath: string }) {\n    const instructionsSchema = getInstructionsSchema({ filepath });\n\n    return camelizeSchema(\n      z.object({\n        instructions: instructionsSchema,\n        inputFileKey: optionalize(z.string()),\n      }),\n    );\n  }\n\n  static override async load<I extends Message = any, O extends Message = any>(options: {\n    filepath: string;\n    parsed: object;\n  }): Promise<Agent<I, O>> {\n    const valid = await ImageAgent.schema({ filepath: options.filepath }).parseAsync(\n      options.parsed,\n    );\n    return new ImageAgent({\n      ...options.parsed,\n      ...valid,\n      instructions: instructionsToPromptBuilder(valid.instructions),\n    }) as any;\n  }\n\n  static from<I extends Message = any, O extends ImageModelOutput = any>(\n    options: ImageAgentOptions<I, O>,\n  ): ImageAgent<I, O> {\n    return new ImageAgent(options);\n  }\n\n  constructor(options: ImageAgentOptions<I, O>) {\n    super({ ...options, outputSchema: imageModelOutputSchema as ZodType<O> });\n    checkArguments(\"ImageAgent\", imageAgentOptionsSchema, options);\n\n    this.instructions =\n      typeof options.instructions === \"string\"\n        ? PromptBuilder.from(options.instructions)\n        : options.instructions;\n    this.inputFileKey = options.inputFileKey;\n    this.outputFileType = options.outputFileType;\n  }\n\n  instructions: PromptBuilder;\n\n  inputFileKey?: string;\n\n  outputFileType?: FileType;\n\n  override async process(input: I, options: AgentInvokeOptions): Promise<O> {\n    const imageModel = this.imageModel || options.imageModel || options.context.imageModel;\n    if (!imageModel) throw new Error(\"image model is required to run ImageAgent\");\n\n    const modelOptions = await imageModel.getModelOptions(input, options);\n\n    const { prompt, image } = await this.instructions.buildPrompt({\n      ...options,\n      input,\n      inputFileKey: this.inputFileKey,\n    });\n\n    const n = input.n || modelOptions?.n;\n    return (await this.invokeChildAgent(\n      imageModel,\n      {\n        n: n && typeof n === \"number\" ? n : undefined,\n        modelOptions,\n        prompt,\n        image,\n        outputFileType: this.outputFileType,\n      },\n      { ...options, streaming: false },\n    )) as O;\n  }\n}\n"],"mappings":";;;;;;;;;AA4BA,MAAa,0BAER,mBAAmB,OAAO;CAC7B,cAAc,EAAE,MAAM,CAAC,EAAE,QAAQ,EAAE,EAAE,QAAuB,CAAC,CAAC;CAC9D,gBAAgB,eAAe,UAAU;CAC1C,CAAC;AAEF,IAAa,aAAb,MAAa,mBAA8E,MAGzF;CACA,AAAS,MAAM;CAEf,OAAO,OAAO,EAAE,YAAkC;EAChD,MAAM,qBAAqB,sBAAsB,EAAE,UAAU,CAAC;AAE9D,SAAO,eACL,EAAE,OAAO;GACP,cAAc;GACd,cAAc,YAAY,EAAE,QAAQ,CAAC;GACtC,CAAC,CACH;;CAGH,aAAsB,KAAuD,SAGpD;EACvB,MAAM,QAAQ,MAAM,WAAW,OAAO,EAAE,UAAU,QAAQ,UAAU,CAAC,CAAC,WACpE,QAAQ,OACT;AACD,SAAO,IAAI,WAAW;GACpB,GAAG,QAAQ;GACX,GAAG;GACH,cAAc,4BAA4B,MAAM,aAAa;GAC9D,CAAC;;CAGJ,OAAO,KACL,SACkB;AAClB,SAAO,IAAI,WAAW,QAAQ;;CAGhC,YAAY,SAAkC;AAC5C,QAAM;GAAE,GAAG;GAAS,cAAc;GAAsC,CAAC;AACzE,iBAAe,cAAc,yBAAyB,QAAQ;AAE9D,OAAK,eACH,OAAO,QAAQ,iBAAiB,WAC5B,cAAc,KAAK,QAAQ,aAAa,GACxC,QAAQ;AACd,OAAK,eAAe,QAAQ;AAC5B,OAAK,iBAAiB,QAAQ;;CAGhC;CAEA;CAEA;CAEA,MAAe,QAAQ,OAAU,SAAyC;EACxE,MAAM,aAAa,KAAK,cAAc,QAAQ,cAAc,QAAQ,QAAQ;AAC5E,MAAI,CAAC,WAAY,OAAM,IAAI,MAAM,4CAA4C;EAE7E,MAAM,eAAe,MAAM,WAAW,gBAAgB,OAAO,QAAQ;EAErE,MAAM,EAAE,QAAQ,UAAU,MAAM,KAAK,aAAa,YAAY;GAC5D,GAAG;GACH;GACA,cAAc,KAAK;GACpB,CAAC;EAEF,MAAM,IAAI,MAAM,KAAK,cAAc;AACnC,SAAQ,MAAM,KAAK,iBACjB,YACA;GACE,GAAG,KAAK,OAAO,MAAM,WAAW,IAAI;GACpC;GACA;GACA;GACA,gBAAgB,KAAK;GACtB,EACD;GAAE,GAAG;GAAS,WAAW;GAAO,CACjC"}

package/dist/agents/image-model.cjs

@@ -0,0 +1,83 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_model = require('./model.cjs');
+const require_chat_model = require('./chat-model.cjs');
+let _aigne_utils_nodejs = require("@aigne/utils/nodejs");
+let zod = require("zod");
+
+//#region src/agents/image-model.ts
+var ImageModel = class ImageModel extends require_model.Model {
+	tag = "ImageModelAgent";
+	constructor(options) {
+		super({
+			inputSchema: imageModelInputSchema,
+			outputSchema: imageModelOutputSchema,
+			...options
+		});
+		this.options = 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}`);
+		if (input.image) input.image = await Promise.all(input.image.map(async (item) => {
+			if (item.type === "local") return {
+				...item,
+				type: "file",
+				data: await _aigne_utils_nodejs.nodejs.fs.readFile(item.path, "base64"),
+				path: void 0,
+				mimeType: item.mimeType || await ImageModel.getMimeType(item.filename || item.path)
+			};
+			if ((input.modelOptions?.preferInputFileType || this.options?.modelOptions?.preferInputFileType) !== "url") {
+				if (item.type === "url") return {
+					...item,
+					type: "file",
+					data: Buffer.from(await (await this.downloadFile(item.url)).arrayBuffer()).toString("base64"),
+					url: void 0,
+					mimeType: item.mimeType || await ImageModel.getMimeType(item.filename || item.url)
+				};
+			}
+			return item;
+		}));
+	}
+	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;
+			if (usage.creditPrefix) options.context.usage.creditPrefix = usage.creditPrefix;
+		}
+	}
+	async processAgentOutput(input, output, options) {
+		if (output.images) {
+			const images = zod.z.array(require_model.fileUnionContentSchema).parse(output.images);
+			output = {
+				...output,
+				images: await Promise.all(images.map((image) => this.transformFileType(input.outputFileType, image)))
+			};
+		}
+		return super.processAgentOutput(input, output, options);
+	}
+};
+const imageModelInputSchema = zod.z.object({
+	prompt: zod.z.string(),
+	image: zod.z.array(require_model.fileUnionContentSchema).optional().describe("Images used for editing"),
+	n: zod.z.number().int().min(1).optional(),
+	outputFileType: require_model.fileTypeSchema.optional(),
+	modelOptions: zod.z.record(zod.z.unknown()).optional()
+});
+const imageModelOutputSchema = zod.z.object({
+	images: zod.z.array(require_model.fileUnionContentSchema),
+	usage: require_chat_model.chatModelOutputUsageSchema.optional(),
+	model: zod.z.string().optional()
+});
+
+//#endregion
+exports.ImageModel = ImageModel;
+exports.imageModelInputSchema = imageModelInputSchema;
+exports.imageModelOutputSchema = imageModelOutputSchema;

package/dist/agents/image-model.d.cts

@@ -0,0 +1,276 @@
+import { PromiseOrValue } from "../utils/type-utils.cjs";
+import { FileType, FileUnionContent, Model } from "./model.cjs";
+import { ChatModelOutputUsage } from "./chat-model.cjs";
+import { GetterSchema } from "./types.cjs";
+import { AgentInvokeOptions, AgentOptions, AgentProcessResult, AgentResponse, AgentResponseStream, Message } from "./agent.cjs";
+import { ZodType, z } from "zod";
+
+//#region src/agents/image-model.d.ts
+interface ImageModelOptions<I extends ImageModelInput = ImageModelInput, O extends ImageModelOutput = ImageModelOutput> extends Omit<AgentOptions<I, O>, "model"> {
+  model?: string;
+  modelOptions?: ImageModelInputOptionsWithGetter;
+}
+declare abstract class ImageModel<I extends ImageModelInput = ImageModelInput, O extends ImageModelOutput = ImageModelOutput> extends Model<I, O> {
+  options?: ImageModelOptions<I, O> | undefined;
+  tag: string;
+  constructor(options?: ImageModelOptions<I, O> | undefined);
+  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>>;
+  protected processAgentOutput(input: I, output: Exclude<AgentResponse<O>, AgentResponseStream<O>>, options: AgentInvokeOptions): Promise<O>;
+}
+type ImageModelInputImage = FileUnionContent[];
+interface ImageModelInput extends Message {
+  prompt: string;
+  image?: ImageModelInputImage;
+  n?: number;
+  outputFileType?: FileType;
+  modelOptions?: ImageModelInputOptions;
+}
+interface ImageModelInputOptions extends Record<string, unknown> {
+  model?: string;
+  preferInputFileType?: "file" | "url";
+}
+type ImageModelInputOptionsWithGetter = GetterSchema<ImageModelInputOptions>;
+declare const imageModelInputSchema: z.ZodObject<{
+  prompt: z.ZodString;
+  image: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    filename: ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    mimeType: ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+  } & {
+    type: z.ZodLiteral<"local">;
+    path: z.ZodString;
+  }, "strip", z.ZodTypeAny, {
+    path: string;
+    type: "local";
+    mimeType?: string | undefined;
+    filename?: string | undefined;
+  }, {
+    path: string;
+    type: "local";
+    mimeType?: string | undefined;
+    filename?: string | undefined;
+  }>, z.ZodObject<{
+    filename: ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    mimeType: ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+  } & {
+    type: z.ZodLiteral<"url">;
+    url: z.ZodString;
+  }, "strip", z.ZodTypeAny, {
+    type: "url";
+    url: string;
+    mimeType?: string | undefined;
+    filename?: string | undefined;
+  }, {
+    type: "url";
+    url: string;
+    mimeType?: string | undefined;
+    filename?: string | undefined;
+  }>, z.ZodObject<{
+    filename: ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    mimeType: ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+  } & {
+    type: z.ZodLiteral<"file">;
+    data: z.ZodString;
+  }, "strip", z.ZodTypeAny, {
+    type: "file";
+    data: string;
+    mimeType?: string | undefined;
+    filename?: string | undefined;
+  }, {
+    type: "file";
+    data: string;
+    mimeType?: string | undefined;
+    filename?: string | undefined;
+  }>]>, "many">>;
+  n: z.ZodOptional<z.ZodNumber>;
+  outputFileType: z.ZodOptional<z.ZodEnum<["local", "file", "url"]>>;
+  modelOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+  prompt: string;
+  image?: ({
+    path: string;
+    type: "local";
+    mimeType?: string | undefined;
+    filename?: string | undefined;
+  } | {
+    type: "url";
+    url: string;
+    mimeType?: string | undefined;
+    filename?: string | undefined;
+  } | {
+    type: "file";
+    data: string;
+    mimeType?: string | undefined;
+    filename?: string | undefined;
+  })[] | undefined;
+  n?: number | undefined;
+  outputFileType?: "local" | "url" | "file" | undefined;
+  modelOptions?: Record<string, unknown> | undefined;
+}, {
+  prompt: string;
+  image?: ({
+    path: string;
+    type: "local";
+    mimeType?: string | undefined;
+    filename?: string | undefined;
+  } | {
+    type: "url";
+    url: string;
+    mimeType?: string | undefined;
+    filename?: string | undefined;
+  } | {
+    type: "file";
+    data: string;
+    mimeType?: string | undefined;
+    filename?: string | undefined;
+  })[] | undefined;
+  n?: number | undefined;
+  outputFileType?: "local" | "url" | "file" | undefined;
+  modelOptions?: Record<string, unknown> | undefined;
+}>;
+interface ImageModelOutput extends Message {
+  images: FileUnionContent[];
+  /**
+       * Token usage statistics
+       */
+  usage?: ChatModelOutputUsage;
+  /**
+       * Model name or version used
+       */
+  model?: string;
+}
+declare const imageModelOutputSchema: z.ZodObject<{
+  images: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    filename: ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    mimeType: ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+  } & {
+    type: z.ZodLiteral<"local">;
+    path: z.ZodString;
+  }, "strip", z.ZodTypeAny, {
+    path: string;
+    type: "local";
+    mimeType?: string | undefined;
+    filename?: string | undefined;
+  }, {
+    path: string;
+    type: "local";
+    mimeType?: string | undefined;
+    filename?: string | undefined;
+  }>, z.ZodObject<{
+    filename: ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    mimeType: ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+  } & {
+    type: z.ZodLiteral<"url">;
+    url: z.ZodString;
+  }, "strip", z.ZodTypeAny, {
+    type: "url";
+    url: string;
+    mimeType?: string | undefined;
+    filename?: string | undefined;
+  }, {
+    type: "url";
+    url: string;
+    mimeType?: string | undefined;
+    filename?: string | undefined;
+  }>, z.ZodObject<{
+    filename: ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    mimeType: ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+  } & {
+    type: z.ZodLiteral<"file">;
+    data: z.ZodString;
+  }, "strip", z.ZodTypeAny, {
+    type: "file";
+    data: string;
+    mimeType?: string | undefined;
+    filename?: string | undefined;
+  }, {
+    type: "file";
+    data: string;
+    mimeType?: string | undefined;
+    filename?: string | undefined;
+  }>]>, "many">;
+  usage: z.ZodOptional<z.ZodObject<{
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    aigneHubCredits: ZodType<number | undefined, z.ZodTypeDef, number | undefined>;
+    cacheCreationInputTokens: ZodType<number | undefined, z.ZodTypeDef, number | undefined>;
+    cacheReadInputTokens: ZodType<number | undefined, z.ZodTypeDef, number | undefined>;
+    creditPrefix: ZodType<"$" | "€" | "¥" | undefined, z.ZodTypeDef, "$" | "€" | "¥" | undefined>;
+  }, "strip", z.ZodTypeAny, {
+    inputTokens: number;
+    outputTokens: number;
+    aigneHubCredits?: number | undefined;
+    cacheCreationInputTokens?: number | undefined;
+    cacheReadInputTokens?: number | undefined;
+    creditPrefix?: "$" | "€" | "¥" | undefined;
+  }, {
+    inputTokens: number;
+    outputTokens: number;
+    aigneHubCredits?: number | undefined;
+    cacheCreationInputTokens?: number | undefined;
+    cacheReadInputTokens?: number | undefined;
+    creditPrefix?: "$" | "€" | "¥" | undefined;
+  }>>;
+  model: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+  images: ({
+    path: string;
+    type: "local";
+    mimeType?: string | undefined;
+    filename?: string | undefined;
+  } | {
+    type: "url";
+    url: string;
+    mimeType?: string | undefined;
+    filename?: string | undefined;
+  } | {
+    type: "file";
+    data: string;
+    mimeType?: string | undefined;
+    filename?: string | undefined;
+  })[];
+  model?: string | undefined;
+  usage?: {
+    inputTokens: number;
+    outputTokens: number;
+    aigneHubCredits?: number | undefined;
+    cacheCreationInputTokens?: number | undefined;
+    cacheReadInputTokens?: number | undefined;
+    creditPrefix?: "$" | "€" | "¥" | undefined;
+  } | undefined;
+}, {
+  images: ({
+    path: string;
+    type: "local";
+    mimeType?: string | undefined;
+    filename?: string | undefined;
+  } | {
+    type: "url";
+    url: string;
+    mimeType?: string | undefined;
+    filename?: string | undefined;
+  } | {
+    type: "file";
+    data: string;
+    mimeType?: string | undefined;
+    filename?: string | undefined;
+  })[];
+  model?: string | undefined;
+  usage?: {
+    inputTokens: number;
+    outputTokens: number;
+    aigneHubCredits?: number | undefined;
+    cacheCreationInputTokens?: number | undefined;
+    cacheReadInputTokens?: number | undefined;
+    creditPrefix?: "$" | "€" | "¥" | undefined;
+  } | undefined;
+}>;
+//#endregion
+export { ImageModel, ImageModelInput, ImageModelInputImage, ImageModelInputOptions, ImageModelInputOptionsWithGetter, ImageModelOptions, ImageModelOutput, imageModelInputSchema, imageModelOutputSchema };
+//# sourceMappingURL=image-model.d.cts.map

package/dist/agents/image-model.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-model.d.cts","names":[],"sources":["../../src/agents/image-model.ts"],"mappings":";;;;;;;;UAqBiB,iBAAA,WACL,eAAA,GAAkB,eAAA,YAClB,gBAAA,GAAmB,gBAAA,UACrB,IAAA,CAAK,YAAA,CAAa,CAAA,EAAG,CAAA;EAAA,KAAA;EAAA,YAAA,GAGd,gCAAA;AAAA;AAAA,uBAGK,UAAA,WACV,eAAA,GAAkB,eAAA,YAClB,gBAAA,GAAmB,gBAAA,UACrB,KAAA,CAAM,CAAA,EAAG,CAAA;EAAA,OAAA,GAGqB,iBAAA,CAAkB,CAAA,EAAG,CAAA;EAAA,GAAA;EAAA,YAAA,OAAA,GAArB,iBAAA,CAAkB,CAAA,EAAG,CAAA;EAAA,IAAA,WAAA,GAQzC,cAAA;IAAA,GAAA;IAAA,MAAA;IAAA,KAAA;EAAA;EAAA,UAAA,WAAA,KAAA,EAQyB,CAAA,EAAA,OAAA,EAAY,kBAAA,GAAqB,OAAA;EAAA,UAAA,YAAA,KAAA,EA8CnE,CAAA,EAAA,MAAA,EACC,CAAA,EAAA,OAAA,EACC,kBAAA,GACR,OAAA;EAAA,SAAA,QAAA,KAAA,EAYM,CAAA,EAAA,OAAA,EACE,kBAAA,GACR,cAAA,CAAe,kBAAA,CAAmB,CAAA;EAAA,UAAA,mBAAA,KAAA,EAG5B,CAAA,EAAA,MAAA,EACC,OAAA,CAAQ,aAAA,CAAc,CAAA,GAAI,mBAAA,CAAoB,CAAA,IAAA,OAAA,EAC7C,kBAAA,GACR,OAAA,CAAQ,CAAA;AAAA;AAAA,KAeD,oBAAA,GAAuB,gBAAA;AAAA,UAElB,eAAA,SAAwB,OAAA;EAAA,MAAA;EAAA,KAAA,GAG/B,oBAAA;EAAA,CAAA;EAAA,cAAA,GAIS,QAAA;EAAA,YAAA,GAEF,sBAAA;AAAA;AAAA,UAGA,sBAAA,SAA+B,MAAA;EAAA,KAAA;EAAA,mBAAA;AAAA;AAAA,KAMpC,gCAAA,GAAmC,YAAA,CAAa,sBAAA;AAAA,cAE/C,qBAAA,EAAqB,CAAA,CAAA,SAAA;EAAA,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAQjB,gBAAA,SAAyB,OAAA;EAAA,MAAA,EAChC,gBAAA;EAAA;;;EAAA,KAAA,GAKA,oBAAA;EAAA;;;EAAA,KAAA;AAAA;AAAA,cAQG,sBAAA,EAAsB,CAAA,CAAA,SAAA;EAAA,MAAA"}