opencode-minimax-easy-vision 1.0.0 → 1.2.0

package/README.md

@@ -1,6 +1,10 @@
-# MiniMax Easy Vision
+# Opencode MiniMax Easy Vision
 
-MiniMax Easy Vision is a plugin for [OpenCode](https://opencode.ai) that enables **vision support** when using [MiniMax](https://www.minimax.io/) models. 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,40 +16,118 @@ 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 MiniMax 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 MiniMax model is active
-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 MiniMax vision.
+**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
 
-The plugin activates only 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`
 
-Non-MiniMax models are not affected. Their native vision support continues to work normally.
+### Custom Model Configuration
+
+You can enable this for other models by creating a config file.
+
+#### Locations (Priority Order)
+
+1. **Project level**: `.opencode/opencode-minimax-easy-vision.json`
+2. **User level**: `~/.config/opencode/opencode-minimax-easy-vision.json`
+
+#### Config Format
+
+```json
+{
+  "models": ["minimax/*", "opencode/*", "*/glm-4.7-free"]
+}
+```
+
+#### Pattern Syntax
+
+| 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
+
+* `*suffix` matches values ending with `suffix`
+* `prefix*` matches values starting with `prefix`
+* `*` matches everything
+* `*text*` matches values containing `text`
+
+If the config is missing or empty, it defaults to MiniMax-only behavior.
+
+#### Configuration Examples
+
+**Enable for all models:**
+
+```json
+{
+  "models": ["*"]
+}
+```
+
+**Specific providers:**
+
+```json
+{
+  "models": ["minimax/*", "opencode/*", "google/*"]
+}
+```
+
+**Mix of providers and models:**
+
+```json
+{
+  "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
 
@@ -53,13 +135,13 @@ Non-MiniMax models are not affected. Their native vision support continues to wo
 * JPEG
 * WebP
 
-These formats match the constraints of the 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
 {
@@ -68,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
 {
@@ -101,42 +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 MiniMax 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
-
-### 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"...
-```
+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.
 
-## Limitations
+### Example Interaction
 
-* Uses `experimental.chat.messages.transform`, which may change in future OpenCode versions
-* Images persist until the OS clears the temporary directory
-* Only JPEG, PNG, and WebP are supported
-* The MCP server must have access to the local filesystem
-* Animated GIFs and unsupported formats are skipped
+> **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
 
@@ -145,16 +200,16 @@ 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` for details.
+GPL-3.0. See [LICENSE.md](./LICENSE.md)
 
 ## References
 
-* [https://opencode.ai](https://opencode.ai)
-* [https://opencode.ai/docs/plugins/](https://opencode.ai/docs/plugins/)
-* [https://www.minimax.io/](https://www.minimax.io/)
-* [https://github.com/MiniMax-AI/MiniMax-Coding-Plan-MCP](https://github.com/MiniMax-AI/MiniMax-Coding-Plan-MCP)
-* [https://platform.minimax.io/docs/guides/coding-plan-mcp-guide](https://platform.minimax.io/docs/guides/coding-plan-mcp-guide)
+* [OpenCode Official Website](https://opencode.ai)
+* [OpenCode Plugins Documentation](https://opencode.ai/docs/plugins/)
+* [MiniMax Official Website](https://www.minimax.io/)
+* [MiniMax Coding Plan MCP Repository](https://github.com/MiniMax-AI/MiniMax-Coding-Plan-MCP)
+* [MiniMax API Documentation](https://platform.minimax.io/docs/guides/coding-plan-mcp-guide)

package/dist/index.d.ts

@@ -1,7 +1,4 @@
 import type { Plugin } from "@opencode-ai/plugin";
-/**
- * The main plugin export
- */
 export declare const MinimaxEasyVisionPlugin: Plugin;
 export default MinimaxEasyVisionPlugin;
 //# sourceMappingURL=index.d.ts.map

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;AAsNlD;;GAEG;AACH,eAAO,MAAM,uBAAuB,EAAE,MAgHrC,CAAC;AAGF,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

@@ -1,236 +1,356 @@
-import { tmpdir } from "node:os";
+import { tmpdir, homedir } from "node:os";
 import { join } from "node:path";
-import { mkdir, writeFile } from "node:fs/promises";
+import { mkdir, writeFile, readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
 import { randomUUID } from "node:crypto";
-/**
- * Plugin name for logging
- */
+// Constants
 const PLUGIN_NAME = "minimax-easy-vision";
-/**
- * Temp directory name for saved images
- */
+const CONFIG_FILENAME = "opencode-minimax-easy-vision.json";
 const TEMP_DIR_NAME = "opencode-minimax-vision";
-/**
- * Supported image MIME types (Minimax MCP limitation)
- */
+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",
     "image/jpg",
     "image/webp",
 ]);
-/**
- * Map MIME type to file extension
- */
 const MIME_TO_EXTENSION = {
     "image/png": "png",
     "image/jpeg": "jpg",
     "image/jpg": "jpg",
     "image/webp": "webp",
 };
-/**
- * Check if a model is a Minimax model
- */
-function isMinimaxModel(model) {
+// 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);
+}
+// 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 {
+        const content = await readFile(configPath, "utf-8");
+        const parsed = JSON.parse(content);
+        return parseConfigObject(parsed);
+    }
+    catch {
+        return null;
+    }
+}
+// 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 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 {
+        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 {
+        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;
+}
+// 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));
+    }
+    // Prefix: text*
+    if (p.endsWith("*")) {
+        return v.startsWith(p.slice(0, -1));
+    }
+    // Suffix: *text
+    if (p.startsWith("*")) {
+        return v.endsWith(p.slice(1));
+    }
+    // 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));
+    }
+    // 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));
+}
+function modelMatchesAnyPattern(model) {
     if (!model)
         return false;
-    const providerID = model.providerID.toLowerCase();
-    const modelID = model.modelID.toLowerCase();
-    return (providerID.includes("minimax") ||
-        modelID.includes("minimax") ||
-        modelID.includes("abab") // Minimax model naming convention
-    );
+    const patterns = getConfiguredModels();
+    return patterns.some((pattern) => matchesSinglePattern(pattern, model));
 }
-/**
- * Check if a part is a FilePart with an image
- */
+// 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);
 }
-/**
- * Check if a part is a TextPart
- */
 function isTextPart(part) {
     return part.type === "text";
 }
-/**
- * Parse a data URL and extract the base64 data
- */
-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;
     }
 }
-/**
- * Get file extension from MIME type
- */
-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";
 }
-/**
- * Ensure temp directory exists and return its path
- */
 async function ensureTempDir() {
     const dir = join(tmpdir(), TEMP_DIR_NAME);
     await mkdir(dir, { recursive: true });
     return dir;
 }
-/**
- * Save image data to a temp file and return the path
- */
 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;
 }
-/**
- * Generate the injection prompt for the model
- */
-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)"}`;
 }
-/**
- * Process a message and extract/save any images
- * Returns the paths of saved images
- */
-async function processMessageImages(parts, log) {
-    const savedImages = [];
-    for (const part of parts) {
-        if (!isImageFilePart(part))
-            continue;
-        const filePart = part;
-        const url = filePart.url;
-        // Skip if no URL
-        if (!url) {
-            log(`Skipping image part ${filePart.id}: no URL`);
-            continue;
-        }
-        // Handle file:// URLs - already on disk
-        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;
-        }
-        // Handle data: URLs - need to save to disk
-        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;
+// 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 };
         }
-        // Handle HTTP/HTTPS URLs - Minimax can use these directly
-        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;
 }
-/**
- * The main plugin export
- */
+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 } = input;
-    // Simple logging helper
+    const { client, directory } = input;
     const log = (msg) => {
         client.app
-            .log({
-            body: {
-                service: PLUGIN_NAME,
-                level: "info",
-                message: msg,
-            },
-        })
-            .catch(() => {
-            // Ignore logging errors
-        });
+            .log({ body: { service: PLUGIN_NAME, level: "info", message: msg } })
+            .catch(() => { });
     };
+    await loadPluginConfig(directory, log);
     log("Plugin initialized");
     return {
-        /**
-         * Transform messages before they're sent to the LLM
-         * This is where we intercept images and inject the MCP tool instructions
-         */
         "experimental.chat.messages.transform": async (_input, output) => {
             const { messages } = output;
-            // Find the last user message
-            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) {
-                return; // No user message to process
-            }
-            // Check if using Minimax model
-            const userInfo = lastUserMessage.info;
-            if (!isMinimaxModel(userInfo.model)) {
-                return; // Not a Minimax model, skip
-            }
-            log("Detected Minimax model, checking for images...");
-            // Check if there are any image parts
+            const result = findLastUserMessage(messages);
+            if (!result)
+                return;
+            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) {
-                return; // No images to process
-            }
+            if (!hasImages)
+                return;
             log("Found images in message, processing...");
-            // Process and save images
-            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;
@@ -238,29 +358,13 @@ 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");
         },
     };
 };
-// Default export for OpenCode plugin loading
 export default MinimaxEasyVisionPlugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-minimax-easy-vision",
-  "version": "1.0.0",
+  "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",