@polpo-ai/tools 0.6.31 → 0.7.0

package/dist/image-tools.js

@@ -1,49 +1,50 @@
 /**
  * Image & video tools for generation and vision/analysis.
  *
- * Provides agent capabilities to:
- * - Generate images from text prompts (image_generate) — via fal.ai
- * - Generate videos from text prompts (video_generate) — via fal.ai
- * - Analyze/describe images using vision models (image_analyze) — via OpenAI/Anthropic
+ * Architecture: thin wrappers over the Vercel AI SDK v6.
+ *   - image_generate  → `generateImage` against a configurable provider
+ *   - video_generate  → `experimental_generateVideo` against a configurable provider
+ *   - image_analyze   → `generateText` (multimodal) against a configurable provider
  *
- * Architecture: direct fetch() to provider REST APIs — zero vendor SDK dependencies.
+ * Model selection: each tool picks its model in this order:
+ *   1. per-call `model` input parameter (`<provider>/<model>` string),
+ *   2. agent-config default passed to the factory (image/video/vision),
+ *   3. hardcoded fallback constant from @polpo-ai/core.
  *
- * Providers:
- *   Image generation: fal.ai (FLUX models — fal-ai/flux/dev default)
- *   Video generation: fal.ai (Wan 2.2 — fal-ai/wan/v2.2-1.3b/text-to-video default)
- *   Vision/analysis:  openai (gpt-4.1-mini), anthropic (Claude)
- *
- * Credential resolution order (same as email tools):
- *   1. Agent vault (per-agent credentials — e.g. service "fal" with key "key")
- *   2. Environment variables (global fallback)
- *
- * Environment variables (fallback):
- *   FAL_KEY             — fal.ai image/video generation
- *   OPENAI_API_KEY      — openai vision provider
- *   ANTHROPIC_API_KEY   — anthropic vision provider
+ * Provider names are not in the input schema anymore — they ride along
+ * with the model string. Every supported provider has a vault key
+ * convention (fal-ai, openai, anthropic) with an env-var fallback.
  */
 import { resolve, dirname, extname } from "node:path";
 import { Type } from "@sinclair/typebox";
+import { parseModelString, DEFAULT_IMAGE_MODEL, DEFAULT_VIDEO_MODEL, DEFAULT_VISION_MODEL, } from "@polpo-ai/core";
 import { NodeFileSystem } from "./adapters/node-filesystem.js";
 import { resolveAllowedPaths, assertPathAllowed } from "./path-sandbox.js";
-// ─── Constants ───
+import { resolveImageProvider, resolveVideoProvider, resolveVisionProvider, } from "./lib/provider-resolver.js";
 const MAX_IMAGE_SIZE = 20 * 1024 * 1024; // 20 MB
-const DEFAULT_TIMEOUT = 120_000; // 2 min for image generation
-const VIDEO_TIMEOUT = 300_000; // 5 min for video generation
-const FAL_QUEUE_POLL_INTERVAL = 3_000; // 3 sec polling for async queue
-// ─── Helpers ───
 function requireEnv(key) {
     const val = process.env[key];
     if (!val)
         throw new Error(`Missing environment variable: ${key}. Set it before using this tool.`);
     return val;
 }
-/** Resolve fal.ai API key: vault (service "fal-ai", key "key") > FAL_KEY env var. */
-function resolveFalKey(vault) {
-    const fromVault = vault?.getKey("fal-ai", "key");
-    if (fromVault)
-        return fromVault;
-    return requireEnv("FAL_KEY");
+/** Resolve which model to actually use, in priority order. */
+function resolveEffectiveModel(override, configured, fallback) {
+    return parseModelString(override ?? configured ?? fallback);
+}
+/** Vault-key resolution per provider. Throws with a clear message
+ *  when neither vault nor env var has the credential. */
+function resolveProviderKey(provider, vault) {
+    switch (provider) {
+        case "fal":
+            return vault?.getKey("fal-ai", "key") ?? requireEnv("FAL_KEY");
+        case "openai":
+            return vault?.getKey("openai", "key") ?? requireEnv("OPENAI_API_KEY");
+        case "anthropic":
+            return vault?.getKey("anthropic", "key") ?? requireEnv("ANTHROPIC_API_KEY");
+        default:
+            throw new Error(`Unknown provider '${provider}': no credential lookup defined`);
+    }
 }
 function imageMime(ext) {
     const map = {
@@ -58,76 +59,13 @@ function imageMime(ext) {
     };
     return map[ext.toLowerCase()] ?? "image/png";
 }
-/**
- * Submit a request to fal.ai queue and poll until completion.
- * Uses the queue endpoint (POST https://queue.fal.run/<model>) for reliability,
- * then polls the status endpoint until the result is ready.
- */
-async function falQueueRequest(modelId, input, apiKey, timeout, signal) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeout);
-    if (signal)
-        signal.addEventListener("abort", () => controller.abort(), { once: true });
-    try {
-        // Submit to queue
-        const submitResp = await fetch(`https://queue.fal.run/${modelId}`, {
-            method: "POST",
-            headers: {
-                Authorization: `Key ${apiKey}`,
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify(input),
-            signal: controller.signal,
-        });
-        if (!submitResp.ok) {
-            const errText = await submitResp.text();
-            throw new Error(`fal.ai queue submit ${submitResp.status}: ${errText}`);
-        }
-        const queueData = await submitResp.json();
-        const requestId = queueData.request_id;
-        const statusUrl = queueData.status_url ?? `https://queue.fal.run/${modelId}/requests/${requestId}/status`;
-        const responseUrl = queueData.response_url ?? `https://queue.fal.run/${modelId}/requests/${requestId}`;
-        // Poll for completion
-        while (true) {
-            await new Promise(r => setTimeout(r, FAL_QUEUE_POLL_INTERVAL));
-            const statusResp = await fetch(statusUrl, {
-                headers: { Authorization: `Key ${apiKey}` },
-                signal: controller.signal,
-            });
-            if (!statusResp.ok) {
-                throw new Error(`fal.ai status poll ${statusResp.status}`);
-            }
-            const status = await statusResp.json();
-            if (status.status === "COMPLETED") {
-                break;
-            }
-            if (status.status === "FAILED") {
-                throw new Error(`fal.ai request failed: ${status.error ?? "unknown error"}`);
-            }
-            // IN_QUEUE or IN_PROGRESS — keep polling
-        }
-        // Fetch result
-        const resultResp = await fetch(responseUrl, {
-            headers: { Authorization: `Key ${apiKey}` },
-            signal: controller.signal,
-        });
-        if (!resultResp.ok) {
-            const errText = await resultResp.text();
-            throw new Error(`fal.ai result fetch ${resultResp.status}: ${errText}`);
-        }
-        return await resultResp.json();
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}
 // ─── Tool: image_generate ───
 const ImageGenerateSchema = Type.Object({
     prompt: Type.String({ description: "Text prompt describing the image to generate" }),
     path: Type.String({ description: "Output file path (e.g. 'output.png'). Format inferred from extension." }),
     model: Type.Optional(Type.String({
-        description: "fal.ai model ID. Default: 'fal-ai/flux/dev'. " +
-            "Other options: 'fal-ai/flux-pro/v1.1' (higher quality), 'fal-ai/flux/schnell' (faster).",
+        description: "Override the agent's image_model for this call. Format: '<provider>/<model>' " +
+            "(e.g. 'fal/fal-ai/flux/dev', 'fal/fal-ai/flux-pro/v1.1'). When omitted, uses the agent's configured image_model.",
     })),
     size: Type.Optional(Type.String({
         description: "Image size as 'WIDTHxHEIGHT' (e.g. '1024x1024', '1024x768', '768x1024'). Default: '1024x1024'.",
@@ -142,20 +80,21 @@ const ImageGenerateSchema = Type.Object({
         description: "Random seed for reproducible results. Omit for random.",
     })),
 });
-function createGenerateTool(cwd, sandbox, fs, vault) {
+function createGenerateTool(cwd, sandbox, fs, configuredModel, vault) {
     return {
         name: "image_generate",
         label: "Generate Image",
-        description: "Generate an image from a text prompt using fal.ai (FLUX models). " +
+        description: "Generate an image from a text prompt. " +
             "Output format inferred from file extension (png, jpg, webp). " +
-            "Models: fal-ai/flux/dev (default, balanced), fal-ai/flux-pro/v1.1 (best quality), " +
-            "fal-ai/flux/schnell (fastest). Credentials resolved from: agent vault > FAL_KEY env var.",
+            "Model is configured at agent level (image_model) — pass `model` here only to override per-call. " +
+            "Default: fal/fal-ai/flux/dev. Currently supports fal as image provider.",
         parameters: ImageGenerateSchema,
         async execute(_id, params, signal) {
             const filePath = resolve(cwd, params.path);
             assertPathAllowed(filePath, sandbox, "image_generate");
             try {
-                return await generateFal(filePath, params, fs, vault, signal);
+                const parsed = resolveEffectiveModel(params.model, configuredModel, DEFAULT_IMAGE_MODEL);
+                return await generateImageWithSdk(filePath, parsed, params, fs, vault, signal);
             }
             catch (err) {
                 return {
@@ -166,59 +105,51 @@ function createGenerateTool(cwd, sandbox, fs, vault) {
         },
     };
 }
-async function generateFal(filePath, params, fs, vault, signal) {
-    const apiKey = resolveFalKey(vault);
-    const model = params.model ?? "fal-ai/flux/dev";
-    // Parse size into width/height
-    let width = 1024, height = 1024;
-    if (params.size) {
-        const parts = params.size.split("x").map(Number);
-        if (parts.length === 2 && parts[0] > 0 && parts[1] > 0) {
-            width = parts[0];
-            height = parts[1];
-        }
-    }
-    const input = {
-        prompt: params.prompt,
-        image_size: { width, height },
-        num_images: 1,
-    };
+async function generateImageWithSdk(filePath, parsed, params, fs, vault, signal) {
+    const { generateImage } = await import("ai");
+    const apiKey = resolveProviderKey(parsed.provider, vault);
+    const provider = await resolveImageProvider(parsed.provider, apiKey);
+    // fal-specific knobs go through providerOptions; the SDK passes them
+    // through to the model's input untouched.
+    const falOptions = {};
     if (params.num_inference_steps != null)
-        input.num_inference_steps = params.num_inference_steps;
+        falOptions.num_inference_steps = params.num_inference_steps;
     if (params.guidance_scale != null)
-        input.guidance_scale = params.guidance_scale;
-    if (params.seed != null)
-        input.seed = params.seed;
-    const result = await falQueueRequest(model, input, apiKey, DEFAULT_TIMEOUT, signal);
-    // fal.ai FLUX response: { images: [{ url, width, height, content_type }], ... }
-    const images = result.images;
-    if (!images || images.length === 0) {
-        throw new Error("No images in fal.ai response");
+        falOptions.guidance_scale = params.guidance_scale;
+    const result = await generateImage({
+        model: provider.image(parsed.model),
+        prompt: params.prompt,
+        size: params.size,
+        seed: params.seed,
+        providerOptions: parsed.provider === "fal" && Object.keys(falOptions).length
+            ? { fal: falOptions }
+            : undefined,
+        abortSignal: signal,
+    });
+    const bytes = result.image.uint8Array;
+    if (!bytes || bytes.byteLength === 0) {
+        throw new Error("No image bytes in SDK response");
     }
-    const imageUrl = images[0].url;
-    const imgResp = await fetch(imageUrl);
-    if (!imgResp.ok)
-        throw new Error(`Failed to download generated image: ${imgResp.status}`);
-    const buffer = Buffer.from(await imgResp.arrayBuffer());
     if (!fs.writeFileBuffer) {
         throw new Error("FileSystem implementation does not support writeFileBuffer (required for binary writes).");
     }
     await fs.mkdir(dirname(filePath));
-    await fs.writeFileBuffer(filePath, new Uint8Array(buffer));
+    await fs.writeFileBuffer(filePath, bytes);
     const info = [
         `Image saved: ${filePath}`,
-        `Size: ${(buffer.byteLength / 1024).toFixed(1)} KB`,
-        `Model: ${model}`,
-        `Dimensions: ${images[0].width}x${images[0].height}`,
+        `Size: ${(bytes.byteLength / 1024).toFixed(1)} KB`,
+        `Model: ${parsed.provider}/${parsed.model}`,
     ];
+    if (params.size)
+        info.push(`Dimensions: ${params.size}`);
     return {
         content: [{ type: "text", text: info.join("\n") }],
         details: {
-            provider: "fal",
-            model,
-            size: `${images[0].width}x${images[0].height}`,
+            provider: parsed.provider,
+            model: parsed.model,
+            size: params.size,
             path: filePath,
-            bytes: buffer.byteLength,
+            bytes: bytes.byteLength,
         },
     };
 }
@@ -227,40 +158,39 @@ const VideoGenerateSchema = Type.Object({
     prompt: Type.String({ description: "Text prompt describing the video to generate" }),
     path: Type.String({ description: "Output file path (e.g. 'output.mp4')." }),
     model: Type.Optional(Type.String({
-        description: "fal.ai video model ID. Default: 'fal-ai/wan/v2.2-1.3b/text-to-video'. " +
-            "Other options: 'fal-ai/wan/v2.2-a14b/text-to-video' (higher quality, slower).",
+        description: "Override the agent's video_model for this call. Format: '<provider>/<model>' " +
+            "(e.g. 'fal/luma-ray-2-flash', 'fal/luma-ray-2', 'fal/hunyuan-video'). When omitted, uses the agent's configured video_model.",
     })),
-    num_frames: Type.Optional(Type.Number({
-        description: "Number of frames to generate. Default: 81 (~5 seconds at 16fps).",
+    aspect_ratio: Type.Optional(Type.String({
+        description: "Aspect ratio as 'WIDTH:HEIGHT' (e.g. '16:9', '9:16', '1:1').",
     })),
     resolution: Type.Optional(Type.String({
-        description: "Video resolution as 'WIDTHxHEIGHT' (e.g. '854x480', '1280x720'). Default: '854x480' (480p).",
+        description: "Resolution as 'WIDTHxHEIGHT' (e.g. '1280x720'). Provider-dependent.",
     })),
-    num_inference_steps: Type.Optional(Type.Number({
-        description: "Number of inference steps (higher = better quality, slower). Default: 30.",
+    duration: Type.Optional(Type.Number({
+        description: "Video duration in seconds. Provider-dependent — typical range 4-10.",
     })),
-    guidance_scale: Type.Optional(Type.Number({
-        description: "Guidance scale — how closely to follow the prompt. Default: 5.0.",
+    fps: Type.Optional(Type.Number({
+        description: "Frames per second. Provider-dependent.",
     })),
     seed: Type.Optional(Type.Number({
         description: "Random seed for reproducible results. Omit for random.",
     })),
 });
-function createVideoGenerateTool(cwd, sandbox, fs, vault) {
+function createVideoGenerateTool(cwd, sandbox, fs, configuredModel, vault) {
     return {
         name: "video_generate",
         label: "Generate Video",
-        description: "Generate a video from a text prompt using fal.ai (Wan 2.2 models). " +
-            "Output saved as MP4. Models: fal-ai/wan/v2.2-1.3b/text-to-video (default, faster), " +
-            "fal-ai/wan/v2.2-a14b/text-to-video (best quality). " +
-            "Video generation takes 1-5 minutes depending on model and resolution. " +
-            "Credentials resolved from: agent vault > FAL_KEY env var.",
+        description: "Generate a video from a text prompt. " +
+            "Output saved as MP4. Model is configured at agent level (video_model) — pass `model` here only to override " +
+            "per-call. Default: fal/luma-ray-2-flash. Currently supports fal as video provider.",
         parameters: VideoGenerateSchema,
         async execute(_id, params, signal) {
             const filePath = resolve(cwd, params.path);
             assertPathAllowed(filePath, sandbox, "video_generate");
             try {
-                return await generateVideo(filePath, params, fs, vault, signal);
+                const parsed = resolveEffectiveModel(params.model, configuredModel, DEFAULT_VIDEO_MODEL);
+                return await generateVideoWithSdk(filePath, parsed, params, fs, vault, signal);
             }
             catch (err) {
                 return {
@@ -271,55 +201,42 @@ function createVideoGenerateTool(cwd, sandbox, fs, vault) {
         },
     };
 }
-async function generateVideo(filePath, params, fs, vault, signal) {
-    const apiKey = resolveFalKey(vault);
-    const model = params.model ?? "fal-ai/wan/v2.2-1.3b/text-to-video";
-    const input = {
+async function generateVideoWithSdk(filePath, parsed, params, fs, vault, signal) {
+    const { experimental_generateVideo } = await import("ai");
+    const apiKey = resolveProviderKey(parsed.provider, vault);
+    const provider = await resolveVideoProvider(parsed.provider, apiKey);
+    const result = await experimental_generateVideo({
+        model: provider.video(parsed.model),
         prompt: params.prompt,
-    };
-    if (params.num_frames != null)
-        input.num_frames = params.num_frames;
-    if (params.num_inference_steps != null)
-        input.num_inference_steps = params.num_inference_steps;
-    if (params.guidance_scale != null)
-        input.guidance_scale = params.guidance_scale;
-    if (params.seed != null)
-        input.seed = params.seed;
-    // Parse resolution
-    if (params.resolution) {
-        const parts = params.resolution.split("x").map(Number);
-        if (parts.length === 2 && parts[0] > 0 && parts[1] > 0) {
-            input.resolution = { width: parts[0], height: parts[1] };
-        }
-    }
-    const result = await falQueueRequest(model, input, apiKey, VIDEO_TIMEOUT, signal);
-    // fal.ai video response: { video: { url, content_type, file_name, file_size } }
-    const video = result.video;
-    if (!video?.url) {
-        throw new Error("No video in fal.ai response");
+        aspectRatio: params.aspect_ratio,
+        resolution: params.resolution,
+        duration: params.duration,
+        fps: params.fps,
+        seed: params.seed,
+        abortSignal: signal,
+    });
+    const bytes = result.video?.uint8Array;
+    if (!bytes || bytes.byteLength === 0) {
+        throw new Error("No video bytes in SDK response");
     }
-    const videoResp = await fetch(video.url);
-    if (!videoResp.ok)
-        throw new Error(`Failed to download generated video: ${videoResp.status}`);
-    const buffer = Buffer.from(await videoResp.arrayBuffer());
     if (!fs.writeFileBuffer) {
         throw new Error("FileSystem implementation does not support writeFileBuffer (required for binary writes).");
     }
     await fs.mkdir(dirname(filePath));
-    await fs.writeFileBuffer(filePath, new Uint8Array(buffer));
-    const sizeMB = (buffer.byteLength / 1024 / 1024).toFixed(2);
+    await fs.writeFileBuffer(filePath, bytes);
+    const sizeMB = (bytes.byteLength / 1024 / 1024).toFixed(2);
     const info = [
         `Video saved: ${filePath}`,
         `Size: ${sizeMB} MB`,
-        `Model: ${model}`,
+        `Model: ${parsed.provider}/${parsed.model}`,
     ];
     return {
         content: [{ type: "text", text: info.join("\n") }],
         details: {
-            provider: "fal",
-            model,
+            provider: parsed.provider,
+            model: parsed.model,
             path: filePath,
-            bytes: buffer.byteLength,
+            bytes: bytes.byteLength,
         },
     };
 }
@@ -327,21 +244,20 @@ async function generateVideo(filePath, params, fs, vault, signal) {
 const ImageAnalyzeSchema = Type.Object({
     path: Type.String({ description: "Path to the image file to analyze" }),
     prompt: Type.Optional(Type.String({ description: "Question or instruction for the vision model (default: 'Describe this image in detail')" })),
-    provider: Type.Optional(Type.Union([
-        Type.Literal("openai"),
-        Type.Literal("anthropic"),
-    ], { description: "Vision provider (default: openai)" })),
-    model: Type.Optional(Type.String({ description: "Model name. OpenAI: 'gpt-4.1-mini' (default). Anthropic: 'claude-sonnet-4-20250514' (default)." })),
+    model: Type.Optional(Type.String({
+        description: "Override the agent's vision_model for this call. Format: '<provider>/<model>' " +
+            "(e.g. 'openai/gpt-4o-mini', 'anthropic/claude-sonnet-4-20250514'). When omitted, uses the agent's configured vision_model.",
+    })),
     max_tokens: Type.Optional(Type.Number({ description: "Max tokens in response (default: 1024)" })),
 });
-function createAnalyzeTool(cwd, sandbox, fs, vault) {
+function createAnalyzeTool(cwd, sandbox, fs, configuredModel, vault) {
     return {
         name: "image_analyze",
         label: "Analyze Image",
         description: "Analyze an image using AI vision models. Can describe contents, extract text (OCR), " +
             "answer questions about the image, identify objects, read charts, etc. " +
-            "Providers: openai (GPT-4.1-mini, default), anthropic (Claude). " +
-            "Credentials resolved from: agent vault > OPENAI_API_KEY or ANTHROPIC_API_KEY env var.",
+            "Model is configured at agent level (vision_model) — pass `model` here only to override per-call. " +
+            "Default: openai/gpt-4o-mini. Supported providers: openai, anthropic.",
         parameters: ImageAnalyzeSchema,
         async execute(_id, params, signal) {
             const filePath = resolve(cwd, params.path);
@@ -369,143 +285,47 @@ function createAnalyzeTool(cwd, sandbox, fs, vault) {
                     details: { error: "file_too_large", size: fileBuffer.byteLength },
                 };
             }
-            const provider = params.provider ?? "openai";
             try {
-                if (provider === "openai") {
-                    return await analyzeOpenAI(filePath, fileBuffer, params, vault, signal);
-                }
-                else {
-                    return await analyzeAnthropic(filePath, fileBuffer, params, vault, signal);
-                }
+                const parsed = resolveEffectiveModel(params.model, configuredModel, DEFAULT_VISION_MODEL);
+                return await analyzeWithSdk(filePath, fileBuffer, parsed, params, vault, signal);
             }
             catch (err) {
                 return {
-                    content: [{ type: "text", text: `Image analysis error (${provider}): ${err.message}` }],
-                    details: { provider, error: err.message },
+                    content: [{ type: "text", text: `Image analysis error: ${err.message}` }],
+                    details: { error: err.message },
                 };
             }
         },
     };
 }
-async function analyzeOpenAI(filePath, fileBuffer, params, vault, signal) {
-    const apiKey = vault?.getKey("openai", "key") ?? requireEnv("OPENAI_API_KEY");
-    const model = params.model ?? "gpt-4.1-mini";
-    const prompt = params.prompt ?? "Describe this image in detail.";
-    const maxTokens = params.max_tokens ?? 1024;
-    const ext = extname(filePath).toLowerCase();
-    const mime = imageMime(ext);
-    const base64 = fileBuffer.toString("base64");
-    const dataUrl = `data:${mime};base64,${base64}`;
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT);
-    if (signal)
-        signal.addEventListener("abort", () => controller.abort(), { once: true });
-    const response = await fetch("https://api.openai.com/v1/chat/completions", {
-        method: "POST",
-        headers: {
-            Authorization: `Bearer ${apiKey}`,
-            "Content-Type": "application/json",
-        },
-        body: JSON.stringify({
-            model,
-            max_tokens: maxTokens,
-            messages: [
-                {
-                    role: "user",
-                    content: [
-                        { type: "text", text: prompt },
-                        { type: "image_url", image_url: { url: dataUrl, detail: "auto" } },
-                    ],
-                },
-            ],
-        }),
-        signal: controller.signal,
-    });
-    clearTimeout(timer);
-    if (!response.ok) {
-        const errText = await response.text();
-        throw new Error(`OpenAI Vision API ${response.status}: ${errText}`);
-    }
-    const data = await response.json();
-    const analysis = data.choices[0]?.message?.content ?? "";
-    const usage = data.usage;
-    return {
-        content: [{ type: "text", text: analysis }],
-        details: {
-            provider: "openai",
-            model,
-            path: filePath,
-            imageSize: fileBuffer.byteLength,
-            tokens: usage?.total_tokens,
-            promptTokens: usage?.prompt_tokens,
-            completionTokens: usage?.completion_tokens,
-        },
-    };
-}
-async function analyzeAnthropic(filePath, fileBuffer, params, vault, signal) {
-    const apiKey = vault?.getKey("anthropic", "key") ?? requireEnv("ANTHROPIC_API_KEY");
-    const model = params.model ?? "claude-sonnet-4-20250514";
-    const prompt = params.prompt ?? "Describe this image in detail.";
-    const maxTokens = params.max_tokens ?? 1024;
+async function analyzeWithSdk(filePath, fileBuffer, parsed, params, vault, signal) {
+    const { generateText } = await import("ai");
+    const apiKey = resolveProviderKey(parsed.provider, vault);
+    const provider = await resolveVisionProvider(parsed.provider, apiKey);
     const ext = extname(filePath).toLowerCase();
-    const mime = imageMime(ext);
-    const base64 = fileBuffer.toString("base64");
-    // Anthropic only supports specific media types
-    const supportedTypes = ["image/jpeg", "image/png", "image/gif", "image/webp"];
-    const mediaType = supportedTypes.includes(mime) ? mime : "image/png";
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT);
-    if (signal)
-        signal.addEventListener("abort", () => controller.abort(), { once: true });
-    const response = await fetch("https://api.anthropic.com/v1/messages", {
-        method: "POST",
-        headers: {
-            "x-api-key": apiKey,
-            "anthropic-version": "2023-06-01",
-            "Content-Type": "application/json",
-        },
-        body: JSON.stringify({
-            model,
-            max_tokens: maxTokens,
-            messages: [
-                {
-                    role: "user",
-                    content: [
-                        {
-                            type: "image",
-                            source: {
-                                type: "base64",
-                                media_type: mediaType,
-                                data: base64,
-                            },
-                        },
-                        { type: "text", text: prompt },
-                    ],
-                },
-            ],
-        }),
-        signal: controller.signal,
+    const mediaType = imageMime(ext);
+    const result = await generateText({
+        model: provider(parsed.model),
+        maxOutputTokens: params.max_tokens ?? 1024,
+        messages: [{
+                role: "user",
+                content: [
+                    { type: "text", text: params.prompt ?? "Describe this image in detail." },
+                    { type: "image", image: new Uint8Array(fileBuffer), mediaType },
+                ],
+            }],
+        abortSignal: signal,
     });
-    clearTimeout(timer);
-    if (!response.ok) {
-        const errText = await response.text();
-        throw new Error(`Anthropic Vision API ${response.status}: ${errText}`);
-    }
-    const data = await response.json();
-    const analysis = data.content
-        .filter(b => b.type === "text" && b.text)
-        .map(b => b.text)
-        .join("\n");
-    const usage = data.usage;
     return {
-        content: [{ type: "text", text: analysis }],
+        content: [{ type: "text", text: result.text }],
         details: {
-            provider: "anthropic",
-            model,
+            provider: parsed.provider,
+            model: parsed.model,
             path: filePath,
             imageSize: fileBuffer.byteLength,
-            inputTokens: usage?.input_tokens,
-            outputTokens: usage?.output_tokens,
+            tokens: result.usage?.totalTokens,
+            promptTokens: result.usage?.inputTokens,
+            completionTokens: result.usage?.outputTokens,
         },
     };
 }
@@ -513,23 +333,22 @@ export const ALL_IMAGE_TOOL_NAMES = ["image_generate", "image_analyze", "video_g
 /**
  * Create image & video tools for generation, vision analysis, and video creation.
  *
- * @param cwd - Working directory for resolving file paths
- * @param allowedPaths - Sandbox paths for file validation
- * @param allowedTools - Optional filter — only include tools whose names appear here.
- *   Supports wildcards expanded upstream (e.g. "image_*", "video_*").
- * @param vault - Resolved vault for credential resolution (fal-ai, openai, anthropic).
- *   Credentials are resolved as: vault > environment variable.
+ * The 6-arg positional signature is preserved for back-compat. Prefer the
+ * options-object form (`{ cwd, vault, imageModel, ... }`) for new callers.
  */
 export function createImageTools(cwd, allowedPaths, allowedTools, vault, fs) {
-    const sandbox = resolveAllowedPaths(cwd, allowedPaths);
-    const _fs = fs ?? new NodeFileSystem();
+    const opts = typeof cwd === "string"
+        ? { cwd, allowedPaths, allowedTools, vault, fs }
+        : cwd;
+    const sandbox = resolveAllowedPaths(opts.cwd, opts.allowedPaths);
+    const _fs = opts.fs ?? new NodeFileSystem();
     const factories = {
-        image_generate: () => createGenerateTool(cwd, sandbox, _fs, vault),
-        image_analyze: () => createAnalyzeTool(cwd, sandbox, _fs, vault),
-        video_generate: () => createVideoGenerateTool(cwd, sandbox, _fs, vault),
+        image_generate: () => createGenerateTool(opts.cwd, sandbox, _fs, opts.imageModel, opts.vault),
+        image_analyze: () => createAnalyzeTool(opts.cwd, sandbox, _fs, opts.visionModel, opts.vault),
+        video_generate: () => createVideoGenerateTool(opts.cwd, sandbox, _fs, opts.videoModel, opts.vault),
     };
-    const names = allowedTools
-        ? ALL_IMAGE_TOOL_NAMES.filter(n => allowedTools.some(a => a.toLowerCase() === n))
+    const names = opts.allowedTools
+        ? ALL_IMAGE_TOOL_NAMES.filter(n => opts.allowedTools.some(a => a.toLowerCase() === n))
         : ALL_IMAGE_TOOL_NAMES;
     return names.map(n => factories[n]());
 }