fetch: split fetch-image from fetch, brave image search (#64)

* fetch: split fetch-image from fetch, brave image search

Resources currently only work well in interactive use cases,
they break as tasks, so let us spin off fetch-image into
its own servlet

Signed-off-by: Edoardo Vacchi <evacchi@users.noreply.github.com>

Author: evacchi

.gitignore

@@ -1 +1,2 @@
-target
+target
+.idea/

servlets/brave-search/README.md

@@ -12,8 +12,7 @@
 
 - `brave-web-search` searches the Web for content (text, image, video, etc...). 
    Generally suitable for text-based searches.
-- `brave-image-search` to fetch pictures. Suggested use combined with the fetch tool,
-   which includes a generic image fetch tool
+- `brave-image-search` to search specifically for pictures.
 
 ## Example
 

servlets/brave-search/main.go

@@ -25,10 +25,6 @@ func loadKeys() {
 	apiKey = k
 }
 
-// Called when the tool is invoked.
-// If you support multiple tools, you must switch on the input.params.name to detect which tool is being called.
-// It takes CallToolRequest as input (The incoming tool request from the LLM)
-// And returns CallToolResult (The servlet's response to the given tool call)
 func Call(input CallToolRequest) (CallToolResult, error) {
 	loadKeys()
 	args := args{input.Params.Arguments.(map[string]any)}

servlets/fetch-image/.cargo/config.toml

@@ -0,0 +1,2 @@
+[build]
+target = "wasm32-wasip1"

servlets/fetch-image/.gitignore

@@ -0,0 +1,21 @@
+# Generated by Cargo
+# will have compiled files and executables
+debug/
+target/
+
+# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
+# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
+Cargo.lock
+
+# These are backup files generated by rustfmt
+**/*.rs.bk
+
+# MSVC Windows builds of rustc generate these, which store debugging information
+*.pdb
+
+# RustRover
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

servlets/fetch-image/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "fetch"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "plugin"
+crate-type = ["cdylib"]
+
+[dependencies]
+#extism-pdk = "1.3.0"
+extism-pdk = "=1.2.1"
+chrono = { version = "0.4", features = ["serde"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+base64-serde = "0.7"
+base64 = "0.21"
+htmd = "0.1.6"

servlets/fetch-image/README.md

@@ -0,0 +1,19 @@
+# Fetch Image Servlet
+
+A servlet that fetches pictures and returns them as resources. Intended for interactive use (e.g. in Claude Desktop).
+
+## What it does
+
+Takes a URL, fetches the image and return it base64-encoded for inline-display.
+
+## Usage
+
+Call with:
+```typescript
+{
+  `arguments`: {
+    `url`: `https://example.com`,  // Required: URL to fetch
+    `mime-type`: "image/png"       // The mime type to filter by
+  }
+}
+```

servlets/fetch-image/prepare.sh

@@ -0,0 +1,38 @@
+#!/bin/bash
+set -eou pipefail
+
+# Function to check if a command exists
+command_exists () {
+  command -v "$1" >/dev/null 2>&1
+}
+
+missing_deps=0
+
+# Check for Cargo
+if ! (command_exists cargo); then
+  missing_deps=1
+  echo "❌ Cargo/rust is not installed."
+  echo ""
+  echo "To install Rust, visit the official download page:"
+  echo "👉 https://www.rust-lang.org/tools/install"
+  echo ""
+  echo "Or install it using a package manager:"
+  echo ""
+  echo "🔹 macOS (Homebrew):"
+  echo "    brew install cargo"
+  echo ""
+  echo "🔹 Ubuntu/Debian:"
+  echo "    sudo apt-get install -y cargo"
+  echo ""
+  echo "🔹 Arch Linux:"
+  echo "    sudo pacman -S rust"
+  echo ""
+fi
+
+# Exit with a bad exit code if any dependencies are missing
+if [ "$missing_deps" -ne 0 ]; then
+  echo "Install the missing dependencies and ensure they are on your path. Then run this command again."
+  # TODO: remove sleep when cli bug is fixed
+  sleep 2
+  exit 1
+fi

servlets/fetch-image/src/lib.rs

@@ -0,0 +1,133 @@
+mod pdk;
+
+use std::collections::BTreeMap;
+
+use base64::Engine;
+use extism_pdk::*;
+use json::Value;
+use pdk::types::{
+    CallToolRequest, CallToolResult, Content, ContentType, ListToolsResult, ToolDescription,
+};
+use serde_json::json;
+
+pub(crate) fn call(input: CallToolRequest) -> Result<CallToolResult, Error> {
+    match input.params.name.as_str() {
+        "fetch-image" => fetch_image(input),
+        _ => Ok(CallToolResult {
+            is_error: Some(true),
+            content: vec![Content {
+                annotations: None,
+                text: Some(format!("Unknown tool: {}", input.params.name)),
+                mime_type: None,
+                r#type: ContentType::Text,
+                data: None,
+            }],
+        }),
+    }
+}
+
+fn fetch_image(input: CallToolRequest) -> Result<CallToolResult, Error> {
+    let args = input.params.arguments.unwrap_or_default();
+    let opt_mime_type = args.get("mime-type");
+    let mut mime_type = "image/png".to_string();
+    if opt_mime_type.is_some() {
+        if let Some(Value::String(mime)) = opt_mime_type {
+            match mime.as_str() {
+                "image/png" | "image/jpeg" | "image/gif" | "image/webp" | "image/svg+xml" => {
+                    mime_type = mime.clone();
+                }
+                _ => {
+                    return Ok(CallToolResult {
+                        is_error: Some(true),
+                        content: vec![Content {
+                            annotations: None,
+                            text: Some("Invalid mime type".into()),
+                            mime_type: None,
+                            r#type: ContentType::Text,
+                            data: None,
+                        }],
+                    });
+                }
+            }
+        }
+    }
+
+    if let Some(Value::String(url)) = args.get("url") {
+        // Create HTTP request
+        let mut req = HttpRequest {
+            url: url.clone(),
+            headers: BTreeMap::new(),
+            method: Some("GET".to_string()),
+        };
+
+        // Add a user agent header to be polite
+        req.headers
+            .insert("User-Agent".to_string(), "fetch-tool/1.0".to_string());
+
+        // Let's filter by content type, we only want images
+        req.headers.insert("Accept".to_string(), mime_type.clone());
+
+        // Perform the request
+        let res = http::request::<()>(&req, None)?;
+
+        // Convert response body to string
+        let body = res.body();
+
+        let encoded_image = base64::engine::general_purpose::STANDARD.encode(body.as_slice());
+
+        Ok(CallToolResult {
+            is_error: None,
+            content: vec![Content {
+                annotations: None,
+                data: Some(encoded_image),
+                mime_type: Some(mime_type),
+                r#type: ContentType::Image,
+                text: None,
+            }],
+        })
+    } else {
+        Ok(CallToolResult {
+            is_error: Some(true),
+            content: vec![Content {
+                annotations: None,
+                text: Some("Please provide a url".into()),
+                mime_type: None,
+                r#type: ContentType::Text,
+                data: None,
+            }],
+        })
+    }
+}
+
+// Called by mcpx to understand how and why to use this tool
+pub(crate) fn describe() -> Result<ListToolsResult, Error> {
+    Ok(ListToolsResult{
+        tools: vec![
+            ToolDescription {
+                name: "fetch-image".into(),
+                description:  "Enables to read images URLs. Fetches the contents of a URL pointing to an image and returns its contents converted to base64".into(),
+                input_schema: json!({
+                    "type": "object",
+                    "properties": {
+                        "url": {
+                            "type": "string",
+                            "description": "The URL of the image to fetch",
+                        },
+                        "mime-type": {
+                            "type": "string",
+                            "description": "The mime type to filter by, it must be of the form image/png, image/jpeg, etc. \
+                            If the URL ends with an image extension, it should match with the mime type \
+                            (e.g. if the URL ends with .png, the mime type should be image/png, if the URL ends with .jpg,\
+                            the mime type should be image/jpeg, if the URL ends with .gif, the mime type should be image/gif, etc.).
+                            If the mime-type is not provided it will default to image/png",
+                        },
+                    },
+                })
+                .as_object()
+                .unwrap()
+                .clone(),
+            },
+
+        ],
+    })
+}