opencode-minimax-easy-vision 1.1.1 → 1.2.0

package/README.md

@@ -1,6 +1,10 @@
 # Opencode MiniMax Easy Vision
 
-MiniMax Easy Vision is a plugin for [OpenCode](https://opencode.ai) that enables **vision support** for models that lack native image attachment support. Originally built for [MiniMax](https://www.minimax.io/) models, it can be configured to work with any model that requires MCP-based image handling. It restores a simple "paste and ask" workflow by automatically handling image assets and routing them through the [MiniMax Coding Plan MCP](https://github.com/MiniMax-AI/MiniMax-Coding-Plan-MCP).
+MiniMax Easy Vision is a plugin for [OpenCode](https://opencode.ai) that enables **vision support** for models that lack native image attachment support.
+
+Originally built for [MiniMax](https://www.minimax.io/) models, it can be configured to work with any model that requires MCP-based image handling.
+
+It restores the "paste and ask" workflow by automatically saving image assets and routing them through the [MiniMax Coding Plan MCP](https://github.com/MiniMax-AI/MiniMax-Coding-Plan-MCP)
 
 ## Demo
 
@@ -12,84 +16,75 @@ https://github.com/user-attachments/assets/826f90ea-913f-427e-ace8-0b711302c497
 
 ## The Problem
 
-When using MiniMax models (for example, MiniMax M2.1) inside OpenCode, users run into a limitation: **vision is not supported via native image attachments**.
+When using MiniMax models (like MiniMax M2.1) in OpenCode, native image attachments aren't supported. 
 
-MiniMax models rely on the MiniMax Coding Plan MCP's `understand_image` tool, which requires an explicit file path or URL. This breaks the normal chat workflow:
+These models expect the MiniMax Coding Plan MCP's `understand_image` tool, which requires an explicit file path. This breaks the normal flow:
 
-* **Ignored images**: Images pasted directly into chat are ignored by MiniMax models.
-* **Manual steps**: Users must save screenshots, locate file paths, and reference them manually.
-* **Broken flow**: The "paste and ask" vision workflow available in other models is lost.
+* **Ignored images**: Pasted images are simply ignored by the model.
+* **Manual steps**: You have to save screenshots manually, find the path, and reference it in your prompt.
+* **Broken flow**: The "paste and ask" experience available with Claude or GPT models is lost.
 
 ## What This Plugin Does
 
-This plugin removes that friction by automating the vision pipeline for configured models.
+This plugin automates the vision pipeline so you don't have to think about it.
 
-Internally, it:
+**How it works:**
 
-1. Detects when a configured model is active (MiniMax by default)
-2. Intercepts images pasted into the chat
-3. Saves them to a temporary local directory
-4. Injects the required context so the model can invoke the `understand_image` MCP tool with the correct file path
+1. **Detects** when a configured model is active.
+2. **Intercepts** images pasted into the chat.
+3. **Saves** them to a temporary local directory.
+4. **Injects** the necessary context for the model to invoke the `understand_image` tool with the correct path.
 
-From the user's perspective, pasted images simply work with vision, just like how it works out of the box with other vision-capable models like Claude.
+**Result:** You just paste the image and ask your question just like how you do with Claude or GPT models. The plugin handles the rest.
 
 ## Supported Models
 
-By default, the plugin activates for MiniMax models, identified by:
+By default, the plugin activates for MiniMax models:
 
 * **Provider ID** containing `minimax`
 * **Model ID** containing `minimax` or `abab`
 
-Examples:
-
+**Examples:**
 * `minimax/minimax-m2.1`
 * `minimax/abab6.5s-chat`
 
 ### Custom Model Configuration
 
-You can configure which models the plugin applies to by creating a config file.
-
-#### Config File Locations
+You can enable this for other models by creating a config file.
 
-The plugin looks for configuration in these locations (in order of priority):
+#### Locations (Priority Order)
 
 1. **Project level**: `.opencode/opencode-minimax-easy-vision.json`
 2. **User level**: `~/.config/opencode/opencode-minimax-easy-vision.json`
 
-Project-level config takes precedence over user-level config.
-
-#### Config File Format
+#### Config Format
 
 ```json
 {
-  "models": ["minimax/*", "glm/*", "openai/gpt-4-vision"]
+  "models": ["minimax/*", "opencode/*", "*/glm-4.7-free"]
 }
 ```
 
 #### Pattern Syntax
 
-Model patterns use a `provider/model` format with wildcard support:
-
-| Pattern        | Description                                         |
-| -------------- | --------------------------------------------------- |
-| `*`            | Match ALL models (global wildcard)                  |
-| `minimax/*`    | Match all models from the `minimax` provider        |
-| `*/glm-4v`     | Match `glm-4v` model from any provider              |
-| `openai/gpt-4` | Exact match for provider and model                  |
-| `*/abab*`      | Match any model containing `abab` from any provider |
+| Pattern          | Matches                                 |
+| ---------------- | --------------------------------------- |
+| `*`              | Match ALL models                        |
+| `minimax/*`      | All models from the `minimax` provider  |
+| `*/glm-4.7-free` | Specific model from any provider        |
+| `opencode/*`     | All models from the `opencode` provider |
+| `*/abab*`        | Any model containing `abab`             |
 
 #### Wildcard Rules
 
-* `*` at the start matches any prefix: `*suffix` matches values ending with `suffix`
-* `*` at the end matches any suffix: `prefix*` matches values starting with `prefix`
-* `*` alone matches everything
+* `*suffix` matches values ending with `suffix`
+* `prefix*` matches values starting with `prefix`
+* `*` matches everything
 * `*text*` matches values containing `text`
 
-#### Precedence
-
-When multiple patterns are specified, the first matching pattern wins. If the `models` array is empty or the config file doesn't exist, the plugin falls back to default MiniMax-only behavior.
+If the config is missing or empty, it defaults to MiniMax-only behavior.
 
-#### Examples
+#### Configuration Examples
 
 **Enable for all models:**
 
@@ -99,35 +94,54 @@ When multiple patterns are specified, the first matching pattern wins. If the `m
 }
 ```
 
-**Enable for specific providers:**
+**Specific providers:**
 
 ```json
 {
-  "models": ["minimax/*", "glm/*", "zhipu/*"]
+  "models": ["minimax/*", "opencode/*", "google/*"]
 }
 ```
 
-**Mix of providers and specific models:**
+**Mix of providers and models:**
 
 ```json
 {
-  "models": ["minimax/*", "openai/gpt-4-vision", "*/claude-3*"]
+  "models": ["minimax/*", "opencode/gpt-5-nano", "*/claude-3-7-sonnet*"]
 }
 ```
 
+### Custom Image Analysis Tool
+
+By default, the plugin uses `mcp_minimax_understand_image` from the MiniMax Coding Plan MCP. You can configure a different MCP tool for image analysis:
+
+```json
+{
+  "models": ["*"],
+  "imageAnalysisTool": "mcp_openrouter_analyze_image"
+}
+```
+
+This allows you to use other MCP servers that provide image analysis capabilities, such as:
+
+* [openrouter-image-mcp](https://github.com/JonathanJude/openrouter-image-mcp) - Uses OpenRouter with GPT-4V, Claude, Gemini
+* [mcp-image-recognition](https://github.com/mario-andreschak/mcp-image-recognition) - Uses Anthropic/OpenAI Vision APIs
+* [Peekaboo](https://github.com/steipete/Peekaboo) - macOS screenshot + AI analysis
+
+The plugin will instruct the model to use the configured tool. The tool should accept an image file path as input.
+
 ## Supported Image Formats
 
 * PNG
 * JPEG
 * WebP
 
-*(These formats are dictated by the limitations of the [MiniMax Coding Plan MCP](https://github.com/MiniMax-AI/MiniMax-Coding-Plan-MCP) `understand_image` tool.)*
+*(Limited by the [MiniMax Coding Plan MCP](https://github.com/MiniMax-AI/MiniMax-Coding-Plan-MCP) `understand_image` tool.)*
 
 ## Installation
 
 ### Via npm
 
-Add the plugin to the `plugin` array in your `opencode.json` file:
+Just add the plugin to the `plugin` array in your `opencode.json` file:
 
 ```json
 {
@@ -136,23 +150,18 @@ Add the plugin to the `plugin` array in your `opencode.json` file:
 }
 ```
 
-### From local source
+### From Local Source
 
-1. Clone or download this repository
+1. Clone the repository.
 2. Build the plugin:
-
    ```bash
-   npm install
-   npm run build
+   npm install && npm run build
    ```
-3. Copy the built file to your OpenCode plugin directory:
-
-   * Project-level: `.opencode/plugin/minimax-easy-vision.js`
-   * Global: `~/.config/opencode/plugin/minimax-easy-vision.js`
+3. Copy the built `dist/index.js` into your OpenCode plugin directory.
 
 ## Prerequisites
 
-The MiniMax Coding Plan MCP server must be configured in `opencode.json`:
+The MiniMax Coding Plan MCP server must be configured in your `opencode.json`:
 
 ```json
 {
@@ -169,34 +178,20 @@ The MiniMax Coding Plan MCP server must be configured in `opencode.json`:
 }
 ```
 
-For full setup details, refer to the MiniMax Coding Plan MCP and MiniMax API documentation.
-
 ## Usage
 
-1. Start OpenCode with a supported model (MiniMax by default, or any configured model)
-2. Paste an image into the chat (`Cmd+V` / `Ctrl+V`)
-3. Ask a question about the image
-
-What happens internally:
-
-* The image is saved to `{tmpdir}/opencode-minimax-vision/<uuid>.<ext>`
-* Instructions are injected for the model to use the `understand_image` MCP tool
-* The model performs vision analysis and responds
+1. Select a supported model in OpenCode.
+2. Paste an image (`Cmd+V` / `Ctrl+V`).
+3. Ask a question about it, just like how you do for other models with native vision support.
 
-### Example interaction
+### Example Interaction
 
-```text
-You: [pasted screenshot] What does this error message say?
-
-# Automatically injected:
-# [SYSTEM: Image Attachment Detected]
-# 1 image has been saved to: /tmp/opencode-minimax-vision/abc123.png
-# To analyze this image, use the understand_image MCP tool...
-
-Model: I'll analyze the screenshot using the understand_image tool.
-[Calls mcp_minimax_understand_image with the saved path]
-Model: The error message indicates a "TypeError: Cannot read property 'foo' of undefined"...
-```
+> **You**: [pasted screenshot] Why is this failing?
+>
+> **Model**: I'll check the image using the `understand_image` tool.
+> `[Calls mcp_minimax_understand_image path="/tmp/xyz.png"]`
+> 
+> **Model**: The error suggests a syntax error on line 12.
 
 ## Development
 
@@ -205,11 +200,11 @@ npm install
 npm run build
 ```
 
-The built plugin will be available at `dist/index.js`.
+The built plugin will be available at `dist/index.js`
 
 ## License
 
-GPL-3.0. See [LICENSE.md](./LICENCE.md) for details.
+GPL-3.0. See [LICENSE.md](./LICENSE.md)
 
 ## References
 

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAgTlD,eAAO,MAAM,uBAAuB,EAAE,MAwGrC,CAAC;AAEF,eAAe,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAqdlD,eAAO,MAAM,uBAAuB,EAAE,MA+DrC,CAAC;AAEF,eAAe,uBAAuB,CAAC"}

package/dist/index.js

@@ -3,9 +3,13 @@ import { join } from "node:path";
 import { mkdir, writeFile, readFile } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import { randomUUID } from "node:crypto";
+// Constants
 const PLUGIN_NAME = "minimax-easy-vision";
 const CONFIG_FILENAME = "opencode-minimax-easy-vision.json";
 const TEMP_DIR_NAME = "opencode-minimax-vision";
+const MAX_TOOL_NAME_LENGTH = 256;
+const DEFAULT_MODEL_PATTERNS = ["minimax/*", "*/abab*"];
+const DEFAULT_IMAGE_ANALYSIS_TOOL = "mcp_minimax_understand_image";
 const SUPPORTED_MIME_TYPES = new Set([
     "image/png",
     "image/jpeg",
@@ -18,135 +22,200 @@ const MIME_TO_EXTENSION = {
     "image/jpg": "jpg",
     "image/webp": "webp",
 };
-const DEFAULT_MODEL_PATTERNS = ["minimax/*", "*/abab*"];
+// Plugin State
 let pluginConfig = {};
+// Config: Path Resolution
 function getUserConfigPath() {
     return join(homedir(), ".config", "opencode", CONFIG_FILENAME);
 }
 function getProjectConfigPath(directory) {
     return join(directory, ".opencode", CONFIG_FILENAME);
 }
-async function loadConfigFile(configPath) {
+// Config: File Parsing
+function parseModelsArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const models = value.filter((m) => typeof m === "string");
+    return models.length > 0 ? models : undefined;
+}
+function parseImageAnalysisTool(value) {
+    if (typeof value !== "string")
+        return undefined;
+    if (value.trim() === "")
+        return undefined;
+    if (value.length > MAX_TOOL_NAME_LENGTH)
+        return undefined;
+    return value;
+}
+function parseConfigObject(raw) {
+    if (!raw || typeof raw !== "object")
+        return {};
+    const obj = raw;
+    return {
+        models: parseModelsArray(obj.models),
+        imageAnalysisTool: parseImageAnalysisTool(obj.imageAnalysisTool),
+    };
+}
+async function readConfigFile(configPath) {
+    if (!existsSync(configPath))
+        return null;
     try {
-        if (!existsSync(configPath)) {
-            return null;
-        }
         const content = await readFile(configPath, "utf-8");
         const parsed = JSON.parse(content);
-        if (parsed && typeof parsed === "object" && parsed !== null) {
-            const config = parsed;
-            if (Array.isArray(config.models)) {
-                const models = config.models.filter((m) => typeof m === "string");
-                return { models };
-            }
-        }
-        return {};
+        return parseConfigObject(parsed);
     }
     catch {
         return null;
     }
 }
-// Config precedence: project > user > defaults
+// Config: Precedence & Merging (project > user > defaults)
+function selectWithPrecedence(projectValue, userValue, defaultValue) {
+    if (projectValue !== undefined) {
+        return { value: projectValue, source: "project" };
+    }
+    if (userValue !== undefined) {
+        return { value: userValue, source: "user" };
+    }
+    return { value: defaultValue, source: "default" };
+}
 async function loadPluginConfig(directory, log) {
-    const userConfigPath = getUserConfigPath();
-    const projectConfigPath = getProjectConfigPath(directory);
-    const userConfig = await loadConfigFile(userConfigPath);
-    const projectConfig = await loadConfigFile(projectConfigPath);
-    if (projectConfig?.models && projectConfig.models.length > 0) {
-        pluginConfig = projectConfig;
-        log(`Loaded project config from ${projectConfigPath}: ${projectConfig.models.join(", ")}`);
+    const userConfig = await readConfigFile(getUserConfigPath());
+    const projectConfig = await readConfigFile(getProjectConfigPath(directory));
+    // Resolve models with precedence
+    const modelsResult = selectWithPrecedence(projectConfig?.models, userConfig?.models, undefined);
+    if (modelsResult.source !== "default") {
+        log(`Loaded models from ${modelsResult.source} config: ${modelsResult.value.join(", ")}`);
     }
-    else if (userConfig?.models && userConfig.models.length > 0) {
-        pluginConfig = userConfig;
-        log(`Loaded user config from ${userConfigPath}: ${userConfig.models.join(", ")}`);
+    else {
+        log(`Using default models: ${DEFAULT_MODEL_PATTERNS.join(", ")}`);
+    }
+    // Resolve imageAnalysisTool with precedence
+    const toolResult = selectWithPrecedence(projectConfig?.imageAnalysisTool, userConfig?.imageAnalysisTool, undefined);
+    if (toolResult.source !== "default") {
+        log(`Using imageAnalysisTool from ${toolResult.source} config: ${toolResult.value}`);
     }
     else {
-        pluginConfig = {};
-        log(`No config found, using defaults: ${DEFAULT_MODEL_PATTERNS.join(", ")}`);
+        log(`Using default imageAnalysisTool: ${DEFAULT_IMAGE_ANALYSIS_TOOL}`);
     }
+    pluginConfig = {
+        models: modelsResult.value,
+        imageAnalysisTool: toolResult.value,
+    };
+}
+// Config: Accessors
+function getConfiguredModels() {
+    return pluginConfig.models ?? DEFAULT_MODEL_PATTERNS;
+}
+function getImageAnalysisTool() {
+    return pluginConfig.imageAnalysisTool ?? DEFAULT_IMAGE_ANALYSIS_TOOL;
 }
-// Order matters: check *text* before *text or text* to avoid false matches
-function matchesPattern(pattern, value) {
-    const lowerPattern = pattern.toLowerCase();
-    const lowerValue = value.toLowerCase();
-    if (lowerPattern === "*") {
+// Pattern Matching (supports wildcards: *, prefix*, *suffix, *contains*)
+function matchesWildcardPattern(pattern, value) {
+    const p = pattern.toLowerCase();
+    const v = value.toLowerCase();
+    // Global wildcard
+    if (p === "*")
         return true;
+    // Contains: *text*
+    if (p.startsWith("*") && p.endsWith("*") && p.length > 2) {
+        return v.includes(p.slice(1, -1));
     }
-    if (lowerPattern.startsWith("*") &&
-        lowerPattern.endsWith("*") &&
-        lowerPattern.length > 2) {
-        const middle = lowerPattern.slice(1, -1);
-        return lowerValue.includes(middle);
+    // Prefix: text*
+    if (p.endsWith("*")) {
+        return v.startsWith(p.slice(0, -1));
     }
-    if (lowerPattern.endsWith("*")) {
-        const prefix = lowerPattern.slice(0, -1);
-        return lowerValue.startsWith(prefix);
+    // Suffix: *text
+    if (p.startsWith("*")) {
+        return v.endsWith(p.slice(1));
     }
-    if (lowerPattern.startsWith("*")) {
-        const suffix = lowerPattern.slice(1);
-        return lowerValue.endsWith(suffix);
+    // Exact match
+    return v === p;
+}
+function matchesSinglePattern(pattern, model) {
+    // Global wildcard matches everything
+    if (pattern === "*")
+        return true;
+    const slashIndex = pattern.indexOf("/");
+    // No slash: match against both provider and model
+    if (slashIndex === -1) {
+        return (matchesWildcardPattern(pattern, model.modelID) ||
+            matchesWildcardPattern(pattern, model.providerID));
     }
-    return lowerValue === lowerPattern;
+    // With slash: match provider/model separately
+    const providerPattern = pattern.slice(0, slashIndex);
+    const modelPattern = pattern.slice(slashIndex + 1);
+    return (matchesWildcardPattern(providerPattern, model.providerID) &&
+        matchesWildcardPattern(modelPattern, model.modelID));
 }
-// Pattern format: "provider/model" with wildcards. No slash = match against both.
-function modelMatchesPatterns(model, patterns) {
+function modelMatchesAnyPattern(model) {
     if (!model)
         return false;
-    for (const pattern of patterns) {
-        if (pattern === "*") {
-            return true;
-        }
-        const slashIndex = pattern.indexOf("/");
-        if (slashIndex === -1) {
-            if (matchesPattern(pattern, model.modelID)) {
-                return true;
-            }
-            if (matchesPattern(pattern, model.providerID)) {
-                return true;
-            }
-        }
-        else {
-            const providerPattern = pattern.slice(0, slashIndex);
-            const modelPattern = pattern.slice(slashIndex + 1);
-            const providerMatches = matchesPattern(providerPattern, model.providerID);
-            const modelMatches = matchesPattern(modelPattern, model.modelID);
-            if (providerMatches && modelMatches) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-function shouldApplyVisionHook(model) {
-    const patterns = pluginConfig.models && pluginConfig.models.length > 0
-        ? pluginConfig.models
-        : DEFAULT_MODEL_PATTERNS;
-    return modelMatchesPatterns(model, patterns);
+    const patterns = getConfiguredModels();
+    return patterns.some((pattern) => matchesSinglePattern(pattern, model));
 }
+// Type Guards
+//
+// Messages in OpenCode contain "parts" - an array of different content types:
+// - TextPart: The user's typed text
+// - FilePart: Attached files (images, PDFs, etc.) with mime type and URL
 function isImageFilePart(part) {
     if (part.type !== "file")
         return false;
-    const filePart = part;
-    return SUPPORTED_MIME_TYPES.has(filePart.mime?.toLowerCase() ?? "");
+    const mime = part.mime?.toLowerCase() ?? "";
+    return SUPPORTED_MIME_TYPES.has(mime);
 }
 function isTextPart(part) {
     return part.type === "text";
 }
-function parseDataUrl(dataUrl) {
+// Image Processing: URL Handlers
+//
+// Images can arrive via different URL schemes:
+// - file://  → Already on disk, just need the local path
+// - data:    → Base64-encoded, must decode and save to temp file
+// - http(s): → Remote URL, pass through for MCP tool to fetch directly
+function handleFileUrl(url, filePart, log) {
+    // Image is already saved locally; strip the file:// prefix to get the path
+    const localPath = url.replace("file://", "");
+    log(`Image already on disk: ${localPath}`);
+    return { path: localPath, mime: filePart.mime, partId: filePart.id };
+}
+function parseBase64DataUrl(dataUrl) {
     const match = dataUrl.match(/^data:([^;]+);base64,(.+)$/);
     if (!match)
         return null;
     try {
-        return {
-            mime: match[1],
-            data: Buffer.from(match[2], "base64"),
-        };
+        return { mime: match[1], data: Buffer.from(match[2], "base64") };
     }
     catch {
         return null;
     }
 }
-function getExtension(mime) {
+async function handleDataUrl(url, filePart, log) {
+    // Pasted clipboard images arrive as base64 data URLs.
+    // Decode and save to a temp file so the MCP tool can read it.
+    const parsed = parseBase64DataUrl(url);
+    if (!parsed) {
+        log(`Failed to parse data URL for part ${filePart.id}`);
+        return null;
+    }
+    try {
+        const savedPath = await saveImageToTemp(parsed.data, parsed.mime);
+        log(`Saved image to: ${savedPath}`);
+        return { path: savedPath, mime: parsed.mime, partId: filePart.id };
+    }
+    catch (err) {
+        log(`Failed to save image: ${err}`);
+        return null;
+    }
+}
+function handleHttpUrl(url, filePart, log) {
+    // Remote URLs are passed directly to the MCP tool, which can fetch them itself.
+    // This avoids unnecessary network requests and disk I/O.
+    log(`Image is remote URL: ${url}`);
+    return { path: url, mime: filePart.mime, partId: filePart.id };
+}
+// Image Processing: File Operations
+function getExtensionForMime(mime) {
     return MIME_TO_EXTENSION[mime.toLowerCase()] ?? "png";
 }
 async function ensureTempDir() {
@@ -156,91 +225,112 @@ async function ensureTempDir() {
 }
 async function saveImageToTemp(data, mime) {
     const tempDir = await ensureTempDir();
-    const ext = getExtension(mime);
-    const filename = `${randomUUID()}.${ext}`;
+    const filename = `${randomUUID()}.${getExtensionForMime(mime)}`;
     const filepath = join(tempDir, filename);
     await writeFile(filepath, data);
     return filepath;
 }
-function generateInjectionPrompt(imagePaths, userText) {
-    if (imagePaths.length === 0)
+// Image Processing: Main Processor
+async function processImagePart(filePart, log) {
+    const url = filePart.url;
+    if (!url) {
+        log(`Skipping image part ${filePart.id}: no URL`);
+        return null;
+    }
+    if (url.startsWith("file://")) {
+        return handleFileUrl(url, filePart, log);
+    }
+    if (url.startsWith("data:")) {
+        return handleDataUrl(url, filePart, log);
+    }
+    if (url.startsWith("http://") || url.startsWith("https://")) {
+        return handleHttpUrl(url, filePart, log);
+    }
+    log(`Unsupported URL scheme for part ${filePart.id}: ${url.substring(0, 50)}...`);
+    return null;
+}
+async function extractImagesFromParts(parts, log) {
+    const savedImages = [];
+    for (const part of parts) {
+        if (!isImageFilePart(part))
+            continue;
+        const result = await processImagePart(part, log);
+        if (result) {
+            savedImages.push(result);
+        }
+    }
+    return savedImages;
+}
+// Prompt Generation
+//
+// Since the target model doesn't natively understand image attachments,
+// we replace them with text instructions that tell the model to use an
+// MCP tool (e.g., understand_image) with the file path or URL.
+// The user's original text is preserved as "User's request: ...".
+function generateInjectionPrompt(images, userText, toolName) {
+    if (images.length === 0)
         return userText;
-    const isSingle = imagePaths.length === 1;
-    const imageList = imagePaths
+    const isSingle = images.length === 1;
+    const imageList = images
         .map((img, idx) => `- Image ${idx + 1}: ${img.path}`)
         .join("\n");
-    return `The user has shared ${isSingle ? "an image" : `${imagePaths.length} images`}. The ${isSingle ? "image is" : "images are"} saved at:
+    const imageCountText = isSingle ? "an image" : `${images.length} images`;
+    const imagePlural = isSingle ? "image is" : "images are";
+    const analyzeText = isSingle ? "this image" : "each image";
+    return `The user has shared ${imageCountText}. The ${imagePlural} saved at:
 ${imageList}
 
-Use the \`mcp_minimax_understand_image\` tool to analyze ${isSingle ? "this image" : "each image"}. Pass the file path as \`image_source\` and describe what to look for in \`prompt\`.
+Use the \`${toolName}\` tool to analyze ${analyzeText}.
 
 User's request: ${userText || "(analyze the image)"}`;
 }
-async function processMessageImages(parts, log) {
-    const savedImages = [];
-    for (const part of parts) {
-        if (!isImageFilePart(part))
-            continue;
-        const filePart = part;
-        const url = filePart.url;
-        if (!url) {
-            log(`Skipping image part ${filePart.id}: no URL`);
-            continue;
+// Message Transformation
+//
+// The transformation flow:
+// 1. Find the last user message (most recent request)
+// 2. Extract and save any images from its parts
+// 3. Remove the image parts (they can't be sent to the model)
+// 4. Replace/update the text part with injection instructions
+function findLastUserMessage(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].info.role === "user") {
+            return { message: messages[i], index: i };
         }
-        if (url.startsWith("file://")) {
-            const localPath = url.replace("file://", "");
-            log(`Image already on disk: ${localPath}`);
-            savedImages.push({
-                path: localPath,
-                mime: filePart.mime,
-                partId: filePart.id,
-            });
-            continue;
-        }
-        if (url.startsWith("data:")) {
-            const parsed = parseDataUrl(url);
-            if (!parsed) {
-                log(`Failed to parse data URL for part ${filePart.id}`);
-                continue;
-            }
-            try {
-                const savedPath = await saveImageToTemp(parsed.data, parsed.mime);
-                log(`Saved image to: ${savedPath}`);
-                savedImages.push({
-                    path: savedPath,
-                    mime: parsed.mime,
-                    partId: filePart.id,
-                });
-            }
-            catch (err) {
-                log(`Failed to save image: ${err}`);
-            }
-            continue;
-        }
-        if (url.startsWith("http://") || url.startsWith("https://")) {
-            log(`Image is remote URL: ${url}`);
-            savedImages.push({
-                path: url,
-                mime: filePart.mime,
-                partId: filePart.id,
-            });
-            continue;
-        }
-        log(`Unsupported URL scheme for part ${filePart.id}: ${url.substring(0, 50)}...`);
     }
-    return savedImages;
+    return null;
+}
+function getModelFromMessage(message) {
+    const info = message.info;
+    return info.model;
+}
+function removeProcessedImageParts(parts, processedIds) {
+    // Remove image parts that were successfully processed; they've been converted
+    // to file paths in the injection prompt and the model can't interpret raw images.
+    return parts.filter((part) => !(part.type === "file" && processedIds.has(part.id)));
+}
+function updateOrCreateTextPart(message, newText) {
+    const textPartIndex = message.parts.findIndex(isTextPart);
+    if (textPartIndex !== -1) {
+        message.parts[textPartIndex].text = newText;
+    }
+    else {
+        const newTextPart = {
+            id: `transformed-${randomUUID()}`,
+            sessionID: message.info.sessionID,
+            messageID: message.info.id,
+            type: "text",
+            text: newText,
+            synthetic: true,
+        };
+        message.parts.unshift(newTextPart);
+    }
 }
+// Plugin Export
 export const MinimaxEasyVisionPlugin = async (input) => {
     const { client, directory } = input;
     const log = (msg) => {
         client.app
-            .log({
-            body: {
-                service: PLUGIN_NAME,
-                level: "info",
-                message: msg,
-            },
-        })
+            .log({ body: { service: PLUGIN_NAME, level: "info", message: msg } })
             .catch(() => { });
     };
     await loadPluginConfig(directory, log);
@@ -248,29 +338,19 @@ export const MinimaxEasyVisionPlugin = async (input) => {
     return {
         "experimental.chat.messages.transform": async (_input, output) => {
             const { messages } = output;
-            let lastUserMessage;
-            let lastUserIndex = -1;
-            for (let i = messages.length - 1; i >= 0; i--) {
-                if (messages[i].info.role === "user") {
-                    lastUserMessage = messages[i];
-                    lastUserIndex = i;
-                    break;
-                }
-            }
-            if (!lastUserMessage) {
+            const result = findLastUserMessage(messages);
+            if (!result)
                 return;
-            }
-            const userInfo = lastUserMessage.info;
-            if (!shouldApplyVisionHook(userInfo.model)) {
+            const { message: lastUserMessage, index: lastUserIndex } = result;
+            const model = getModelFromMessage(lastUserMessage);
+            if (!modelMatchesAnyPattern(model))
                 return;
-            }
             log("Model matched, checking for images...");
             const hasImages = lastUserMessage.parts.some(isImageFilePart);
-            if (!hasImages) {
+            if (!hasImages)
                 return;
-            }
             log("Found images in message, processing...");
-            const savedImages = await processMessageImages(lastUserMessage.parts, log);
+            const savedImages = await extractImagesFromParts(lastUserMessage.parts, log);
             if (savedImages.length === 0) {
                 log("No images were successfully saved");
                 return;
@@ -278,25 +358,10 @@ export const MinimaxEasyVisionPlugin = async (input) => {
             log(`Saved ${savedImages.length} image(s), transforming message...`);
             const existingTextPart = lastUserMessage.parts.find(isTextPart);
             const userText = existingTextPart?.text ?? "";
-            const transformedText = generateInjectionPrompt(savedImages.map((img) => ({ path: img.path, mime: img.mime })), userText);
-            const processedPartIds = new Set(savedImages.map((img) => img.partId));
-            lastUserMessage.parts = lastUserMessage.parts.filter((part) => !(part.type === "file" && processedPartIds.has(part.id)));
-            const textPartIndex = lastUserMessage.parts.findIndex(isTextPart);
-            if (textPartIndex !== -1) {
-                const textPart = lastUserMessage.parts[textPartIndex];
-                textPart.text = transformedText;
-            }
-            else {
-                const newTextPart = {
-                    id: `transformed-${randomUUID()}`,
-                    sessionID: lastUserMessage.info.sessionID,
-                    messageID: lastUserMessage.info.id,
-                    type: "text",
-                    text: transformedText,
-                    synthetic: true,
-                };
-                lastUserMessage.parts.unshift(newTextPart);
-            }
+            const transformedText = generateInjectionPrompt(savedImages, userText, getImageAnalysisTool());
+            const processedIds = new Set(savedImages.map((img) => img.partId));
+            lastUserMessage.parts = removeProcessedImageParts(lastUserMessage.parts, processedIds);
+            updateOrCreateTextPart(lastUserMessage, transformedText);
             messages[lastUserIndex] = lastUserMessage;
             log("Successfully injected image path instructions");
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-minimax-easy-vision",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "OpenCode plugin that enables vision support for Minimax models by saving pasted images and injecting MCP tool instructions",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",