Add support in binary tool responses

README.md

@@ -111,6 +111,20 @@ You can also filter resources to mask sensitive information:
 {{ support_ticket_info | regex_replace(r'\b[\w.+-]+@[\w.-]+\.\w+\b', '[EMAIL_REDACTED]') }}
 ```
 
+### Interactively selecting MCP resources and tools
+
+Template variables can be given values either directly or by selecting an MCP tool to call. For example:
+
+```
+# Spec Template (spec.md)
+
+## Task description
+{{ task }}
+```
+
+Running create-spec will then prompt you to either provide a direct value for `task` or select an MCP server, tool and args to call to fetch the task description.
+
+
 ### Initialize a project
 ```
 cxk init

engine/globals.py

@@ -5,12 +5,13 @@
 from mcp.shared.metadata_utils import get_display_name
 from pydantic import AnyUrl
 
-from mcp_client import get_client_session_by_server
+from mcp_client import get_client_session_by_server, handle_binary_content
 from prompt import PromptHelper
+from state import State
 from util.parse import parse_input_string
 
 
-def create_mcp_tool_function(prompt_helper: PromptHelper):
+def create_mcp_tool_function(prompt_helper: PromptHelper, state: State):
     """Create a call_mcp_tool function with state bound."""
 
     async def call_mcp_tool(server: str, tool_name: str, args: dict) -> str | dict[str, Any]:
@@ -26,6 +27,13 @@ async def call_mcp_tool(server: str, tool_name: str, args: dict) -> str | dict[s
                 result_unstructured = result.content[0]
                 if isinstance(result_unstructured, types.TextContent):
                     return parse_input_string(result_unstructured.text)
+                elif isinstance(result_unstructured, types.ImageContent | types.AudioContent):
+                    if state.config_dir:
+                        file_path = handle_binary_content(state.config_dir, result_unstructured)
+                        return file_path if file_path else ""
+                    else:
+                        logging.error("Config directory not available for binary data storage")
+                        return ""
                 else:
                     return ""
             except Exception as e:
@@ -38,7 +46,7 @@ async def call_mcp_tool(server: str, tool_name: str, args: dict) -> str | dict[s
     return call_mcp_tool
 
 
-def create_mcp_resource_function():
+def create_mcp_resource_function(state: State):
     """Create a get_mcp_resource function with state bound."""
 
     async def get_mcp_resource(server: str, resource_uri: str) -> str | dict[str, Any]:
@@ -50,6 +58,13 @@ async def get_mcp_resource(server: str, resource_uri: str) -> str | dict[str, An
                 result_unstructured = resource.contents[0]
                 if isinstance(result_unstructured, types.TextResourceContents):
                     return parse_input_string(result_unstructured.text)
+                elif isinstance(result_unstructured, types.BlobResourceContents):
+                    if state.config_dir:
+                        file_path = handle_binary_content(state.config_dir, result_unstructured)
+                        return file_path if file_path else ""
+                    else:
+                        logging.error("Config directory not available for binary data storage")
+                        return ""
                 else:
                     logging.debug(f"Resource {resource_uri} returned non-text content")
                     return ""

engine/template_engine.py

@@ -31,8 +31,8 @@ def __init__(
         self._prompt_helper = prompt_helper
 
         # Add global functions to env to support MCP tools and resources
-        self.env.globals["call_tool"] = create_mcp_tool_function(self._prompt_helper)
-        self.env.globals["get_resource"] = create_mcp_resource_function()
+        self.env.globals["call_tool"] = create_mcp_tool_function(self._prompt_helper, self._state)
+        self.env.globals["get_resource"] = create_mcp_resource_function(self._state)
 
     @classmethod
     def from_file(cls, path: str | Path, state: State, prompt_helper: PromptHelper) -> "TemplateEngine":

mcp_client/__init__.py

@@ -1,5 +1,6 @@
 """MCP (Model Context Protocol) client implementation."""
 
+from .binary_data_handler import handle_binary_content, save_binary_data_to_file
 from .client_session_provider import get_client_session_by_server
 from .config import HTTPServerConfig, MCPServersConfig, SSEServerConfig, StdioServerConfig
 from .session_manager import MCPSessionManager, get_session_manager
@@ -14,4 +15,6 @@
     "KeychainTokenStorageWithFallback",
     "get_session_manager",
     "get_client_session_by_server",
+    "handle_binary_content",
+    "save_binary_data_to_file",
 ]

mcp_client/binary_data_handler.py

@@ -0,0 +1,76 @@
+import base64
+import logging
+import mimetypes
+from pathlib import Path
+from uuid import uuid4
+
+from mcp import types
+
+
+def save_binary_data_to_file(config_dir: Path, data: str, mime_type: str, file_prefix: str = "binary") -> str:
+    """
+    Save binary data (base64-encoded) to a file in the config directory.
+
+    Args:
+        config_dir: The .cxk config directory path
+        data: Base64-encoded binary data
+        mime_type: MIME type of the data (e.g., 'image/png', 'audio/wav')
+        file_prefix: Prefix for the generated filename
+
+    Returns:
+        Relative path to the saved file from the project root
+
+    Raises:
+        Exception: If file save fails (errors are logged but not re-raised)
+    """
+    try:
+        # Create files directory if it doesn't exist
+        files_dir = config_dir / "files"
+        files_dir.mkdir(exist_ok=True)
+
+        # Generate unique filename with appropriate extension
+        extension = mimetypes.guess_extension(mime_type) or ""
+        filename = f"{file_prefix}_{uuid4().hex[:8]}{extension}"
+        file_path = files_dir / filename
+
+        # Decode base64 data and write to file
+        binary_data = base64.b64decode(data)
+        with open(file_path, "wb") as f:
+            f.write(binary_data)
+
+        # Return relative path from project root
+        relative_path = file_path.relative_to(config_dir.parent)
+        logging.info(f"Saved binary data to {relative_path}")
+        return str(relative_path)
+
+    except Exception as e:
+        error_msg = f"Failed to save binary data: {e}"
+        logging.error(error_msg)
+        raise Exception(error_msg) from e
+
+
+def handle_binary_content(config_dir: Path, content) -> str:
+    """
+    Handle binary content from MCP responses, saving to file and returning path.
+
+    Args:
+        config_dir: The .cxk config directory path
+        content: MCP content object (ImageContent, AudioContent, or BlobResourceContents)
+
+    Returns:
+        Relative path to the saved file or empty string if handling fails
+    """
+    try:
+        if isinstance(content, types.ImageContent):
+            return save_binary_data_to_file(config_dir, content.data, content.mimeType, "image")
+        elif isinstance(content, types.AudioContent):
+            return save_binary_data_to_file(config_dir, content.data, content.mimeType, "audio")
+        elif isinstance(content, types.BlobResourceContents):
+            # For blob resources, we don't have mime type info, so we'll save as generic file
+            return save_binary_data_to_file(config_dir, content.blob, "application/octet-stream", "blob")
+        else:
+            logging.warning(f"Unsupported binary content type: {type(content)}")
+            return ""
+    except Exception as e:
+        logging.error(f"Error handling binary content: {e}")
+        return ""

prompt/prompt_helper.py

@@ -1,8 +1,9 @@
 import logging
 
 import questionary
+from mcp import types
 
-from mcp_client import get_session_manager
+from mcp_client import get_session_manager, handle_binary_content
 from state import State
 
 
@@ -221,11 +222,20 @@ async def _collect_var_value_from_mcp(self, var_name: str) -> str:
             # Handle list of content items
             content_parts = []
             for item in result.content:
-                # Try to get text content first (safely)
-                text_content = getattr(item, "text", None)
-                if text_content:
-                    content_parts.append(str(text_content))
-                # For non-text content, convert to string
+                # Handle binary content types
+                if isinstance(item, types.ImageContent | types.AudioContent):
+                    if self._state.config_dir:
+                        file_path = handle_binary_content(self._state.config_dir, item)
+                        if file_path:
+                            content_parts.append(file_path)
+                        else:
+                            logging.error(f"Failed to save binary content for variable '{var_name}'")
+                    else:
+                        logging.error("Config directory not available for binary data storage")
+                # Handle text content
+                elif isinstance(item, types.TextContent):
+                    content_parts.append(str(item.text))
+                # For other content types, convert to string
                 else:
                     content_parts.append(str(item))
             content = "\n".join(content_parts)
@@ -279,6 +289,6 @@ async def _select_mcp_tool(self, tools) -> str | None:
             choice_title = f"{tool.name} - {description}"
             choices.append(questionary.Choice(choice_title, tool.name))
 
-        tool_name = await questionary.select("Select a tool:", choices=choices).ask_async()
+        tool_name = await questionary.select("Select a tool:", choices=choices, use_search_filter=True).ask_async()
 
         return tool_name

tests/mcp_test_server.py

@@ -4,7 +4,7 @@
 
 from typing import Any
 
-from mcp.server.fastmcp import FastMCP
+from mcp.server.fastmcp import FastMCP, Image
 
 # Create an MCP server
 mcp = FastMCP("Test-Server", "1.0.0")
@@ -32,3 +32,11 @@ def jsonTest(cloudId: str, ticketId: str, optional_other: str | None = None) ->
 def get_greeting(name: str) -> str:
     """Get a personalized greeting"""
     return f"Hello, {name}!"
+
+
+# Add a binary tool (tests/files/image1.avif)
+@mcp.tool()
+def get_blob() -> Image:
+    """Get a binary blob test tool"""
+    with open("tests/files/image1.avif", "rb") as f:
+        return Image(data=f.read(), format="avif")

tests/templates/spec10.md

@@ -0,0 +1,7 @@
+# Task Template
+
+## Image links
+
+{% set image = call_tool('test-mcp', 'get_blob', {}) %}
+
+{{ image }}

tests/templates/spec9.md

@@ -1,6 +1,6 @@
 # Task Template
 
-## Issue description
+## Image links
 
 {% set issue = call_tool('github', 'get_issue', {'issue_number': 17, 'owner': 'eyalzh', 'repo': 'browser-control-mcp'}) %}