mrmd-ai 0.1.1__tar.gz → 0.1.2__tar.gz

mrmd_ai-0.1.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Maxime Rivest
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{mrmd_ai-0.1.1 → mrmd_ai-0.1.2}/PKG-INFO

@@ -1,7 +1,8 @@
 Metadata-Version: 2.4
 Name: mrmd-ai
-Version: 0.1.1
+Version: 0.1.2
 Summary: AI programs for MRMD editor - completions, fixes, and corrections
+License-File: LICENSE
 Requires-Python: >=3.11
 Requires-Dist: dspy>=2.6
 Requires-Dist: fastapi>=0.115

{mrmd_ai-0.1.1 → mrmd_ai-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mrmd-ai"
-version = "0.1.1"
+version = "0.1.2"
 description = "AI programs for MRMD editor - completions, fixes, and corrections"
 readme = "README.md"
 requires-python = ">=3.11"

mrmd_ai-0.1.2/src/mrmd_ai/custom_programs.py

@@ -0,0 +1,215 @@
+"""
+Custom Program Factory - Generate DSPy modules from user-defined templates.
+
+This module allows users to create custom AI commands without writing code.
+Users define their commands with:
+- name: Display name for the command
+- inputType: What text to process (selection, cursor, fullDoc)
+- outputType: What to do with result (replace, insert)
+- instructions: Natural language instructions for the AI
+
+The factory generates DSPy Signature and Module classes dynamically.
+"""
+
+from typing import Any
+import dspy
+
+
+def create_custom_signature(
+    name: str,
+    instructions: str,
+    input_type: str = "selection",
+    output_type: str = "replace",
+) -> type:
+    """Create a DSPy Signature class from user configuration.
+
+    Args:
+        name: Command name (used for class naming)
+        instructions: User's instructions for the AI
+        input_type: "selection" | "cursor" | "fullDoc"
+        output_type: "replace" | "insert"
+
+    Returns:
+        A DSPy Signature class
+    """
+    # Build the docstring from user instructions
+    docstring = f"""{instructions}
+
+IMPORTANT RULES:
+- Output ONLY the result text, no explanations or meta-commentary
+- Maintain appropriate formatting (markdown, code style, etc.)
+- Be concise and direct
+"""
+
+    # Define input fields based on input type
+    if input_type == "selection":
+        input_fields = {
+            "text": dspy.InputField(desc="The selected text to process"),
+            "local_context": dspy.InputField(desc="Text surrounding the selection for context"),
+            "document_context": dspy.InputField(desc="Broader document context"),
+        }
+    elif input_type == "cursor":
+        input_fields = {
+            "text_before_cursor": dspy.InputField(desc="Text before the cursor position"),
+            "local_context": dspy.InputField(desc="Text surrounding the cursor for context"),
+            "document_context": dspy.InputField(desc="Broader document context"),
+        }
+    else:  # fullDoc
+        input_fields = {
+            "document_context": dspy.InputField(desc="The full document content"),
+        }
+
+    # Define output field
+    output_field_name = "result"
+    output_fields = {
+        output_field_name: dspy.OutputField(desc="The processed result text. Output ONLY the result.")
+    }
+
+    # Create the Signature class dynamically
+    # Clean name for class naming (remove spaces, special chars)
+    class_name = "".join(c for c in name if c.isalnum()) + "Signature"
+
+    signature_class = type(
+        class_name,
+        (dspy.Signature,),
+        {
+            "__doc__": docstring,
+            "__annotations__": {
+                **{k: str for k in input_fields},
+                **{k: str for k in output_fields},
+            },
+            **input_fields,
+            **output_fields,
+        }
+    )
+
+    return signature_class
+
+
+def create_custom_module(
+    name: str,
+    instructions: str,
+    input_type: str = "selection",
+    output_type: str = "replace",
+) -> type:
+    """Create a DSPy Module class from user configuration.
+
+    Args:
+        name: Command name
+        instructions: User's instructions for the AI
+        input_type: "selection" | "cursor" | "fullDoc"
+        output_type: "replace" | "insert"
+
+    Returns:
+        A DSPy Module class (not instance)
+    """
+    signature = create_custom_signature(name, instructions, input_type, output_type)
+
+    # Clean name for class naming
+    class_name = "".join(c for c in name if c.isalnum()) + "Predict"
+
+    class CustomModule(dspy.Module):
+        """Dynamically generated custom command module."""
+
+        def __init__(self):
+            super().__init__()
+            self.predictor = dspy.Predict(signature)
+            self._input_type = input_type
+            self._output_type = output_type
+
+        def forward(self, **kwargs) -> Any:
+            return self.predictor(**kwargs)
+
+    # Set the class name
+    CustomModule.__name__ = class_name
+    CustomModule.__qualname__ = class_name
+
+    return CustomModule
+
+
+class CustomProgramRegistry:
+    """Registry for user-defined custom programs.
+
+    Manages creation and caching of custom DSPy modules.
+    """
+
+    def __init__(self):
+        self._modules: dict[str, type] = {}
+        self._configs: dict[str, dict] = {}
+
+    def register(self, program_id: str, config: dict) -> type:
+        """Register a custom program from configuration.
+
+        Args:
+            program_id: Unique identifier for this program
+            config: Dict with name, instructions, inputType, outputType
+
+        Returns:
+            The generated Module class
+        """
+        module_class = create_custom_module(
+            name=config.get("name", program_id),
+            instructions=config.get("instructions", "Process this text."),
+            input_type=config.get("inputType", "selection"),
+            output_type=config.get("outputType", "replace"),
+        )
+
+        self._modules[program_id] = module_class
+        self._configs[program_id] = config
+
+        return module_class
+
+    def get(self, program_id: str) -> type | None:
+        """Get a registered module class by ID."""
+        return self._modules.get(program_id)
+
+    def get_config(self, program_id: str) -> dict | None:
+        """Get the configuration for a registered program."""
+        return self._configs.get(program_id)
+
+    def unregister(self, program_id: str) -> bool:
+        """Remove a program from the registry."""
+        if program_id in self._modules:
+            del self._modules[program_id]
+            del self._configs[program_id]
+            return True
+        return False
+
+    def clear(self):
+        """Clear all registered programs."""
+        self._modules.clear()
+        self._configs.clear()
+
+    def list_programs(self) -> list[str]:
+        """List all registered program IDs."""
+        return list(self._modules.keys())
+
+    def is_registered(self, program_id: str) -> bool:
+        """Check if a program is registered."""
+        return program_id in self._modules
+
+
+# Global registry instance
+custom_registry = CustomProgramRegistry()
+
+
+def register_custom_programs(commands: list[dict]) -> None:
+    """Register multiple custom programs from a list of command configs.
+
+    Args:
+        commands: List of command configurations, each with:
+            - id or program: Unique identifier
+            - name: Display name
+            - instructions: AI instructions
+            - inputType: selection | cursor | fullDoc
+            - outputType: replace | insert
+    """
+    for cmd in commands:
+        program_id = cmd.get("program") or cmd.get("id")
+        if program_id:
+            custom_registry.register(program_id, cmd)
+
+
+def get_custom_program(program_id: str) -> type | None:
+    """Get a custom program module class by ID."""
+    return custom_registry.get(program_id)

{mrmd_ai-0.1.1 → mrmd_ai-0.1.2}/src/mrmd_ai/juice.py

@@ -213,15 +213,73 @@ SYNTHESIZER_MODEL = ModelConfig(
 )
 
 
+def get_api_key_for_model(model: str, api_keys: dict | None) -> str | None:
+    """Get the appropriate API key for a model based on its provider.
+
+    Uses LiteLLM model naming convention: provider/model-name
+    Supports any provider that the user has configured in settings.
+
+    Args:
+        model: Model identifier (e.g., "anthropic/claude-sonnet-4-5")
+        api_keys: Dict of provider -> API key
+
+    Returns:
+        API key string or None if not found/provided.
+    """
+    if not api_keys:
+        return None
+
+    model_lower = model.lower()
+
+    # Extract provider from model name (LiteLLM format: provider/model-name)
+    if "/" in model:
+        provider = model.split("/")[0].lower()
+        # Check for direct provider match
+        if provider in api_keys and api_keys[provider]:
+            return api_keys[provider]
+
+    # Fallback: Check for known provider patterns in model name
+    # This handles cases like "claude-3-sonnet" without prefix
+    provider_patterns = {
+        "anthropic": ["anthropic/", "claude"],
+        "openai": ["openai/", "gpt-", "o1-", "o3-"],
+        "groq": ["groq/"],
+        "gemini": ["gemini/", "gemini-"],
+        "openrouter": ["openrouter/"],
+        "together_ai": ["together_ai/", "together/"],
+        "fireworks_ai": ["fireworks_ai/", "fireworks/"],
+        "mistral": ["mistral/"],
+        "cohere": ["cohere/"],
+        "deepseek": ["deepseek/"],
+        "ollama": ["ollama/"],
+        "azure": ["azure/"],
+        "bedrock": ["bedrock/"],
+        "vertex_ai": ["vertex_ai/"],
+    }
+
+    for provider, patterns in provider_patterns.items():
+        for pattern in patterns:
+            if pattern in model_lower:
+                if provider in api_keys and api_keys[provider]:
+                    return api_keys[provider]
+                break
+
+    return None
+
+
 def get_lm(
     juice: JuiceLevel | int = JuiceLevel.QUICK,
-    reasoning: ReasoningLevel | int | None = None
+    reasoning: ReasoningLevel | int | None = None,
+    api_keys: dict | None = None,
+    model_override: str | None = None,
 ) -> dspy.LM:
     """Get a dspy.LM configured for the specified juice and reasoning levels.
 
     Args:
         juice: Juice level (0-3). Level 4 (ULTIMATE) requires special handling.
         reasoning: Optional reasoning level (0-5). If None, uses juice level's default.
+        api_keys: Optional dict of provider -> API key. If provided, overrides env vars.
+        model_override: Optional model to use instead of the default for this juice level.
 
     Returns:
         Configured dspy.LM instance.
@@ -235,6 +293,15 @@ def get_lm(
     config = JUICE_MODELS[juice]
     kwargs = config.to_lm_kwargs()
 
+    # Apply model override if provided
+    if model_override:
+        kwargs["model"] = model_override
+
+    # Get API key for this model's provider
+    api_key = get_api_key_for_model(kwargs["model"], api_keys)
+    if api_key:
+        kwargs["api_key"] = api_key
+
     # Apply reasoning level overrides if specified AND model supports reasoning
     if reasoning is not None and config.supports_reasoning:
         if isinstance(reasoning, int):
@@ -313,7 +380,9 @@ class JuicedProgram:
         program: dspy.Module,
         juice: JuiceLevel | int = JuiceLevel.QUICK,
         reasoning: ReasoningLevel | int | None = None,
-        progress_callback: Callable[[str, dict], None] | None = None
+        progress_callback: Callable[[str, dict], None] | None = None,
+        api_keys: dict | None = None,
+        model_override: str | None = None,
     ):
         """Initialize a juiced program.
 
@@ -326,11 +395,15 @@ class JuicedProgram:
                               - "status": General status update
                               - "model_start": A model is starting (ultimate mode)
                               - "model_complete": A model finished (ultimate mode)
+            api_keys: Optional dict of provider -> API key. Overrides env vars.
+            model_override: Optional model to use instead of the default for this juice level.
         """
         self.program = program
         self.juice = JuiceLevel(juice) if isinstance(juice, int) else juice
         self.reasoning = ReasoningLevel(reasoning) if isinstance(reasoning, int) else reasoning
         self.progress_callback = progress_callback
+        self.api_keys = api_keys
+        self.model_override = model_override
 
     def _emit(self, event_type: str, data: dict):
         """Emit a progress event if callback is set."""
@@ -347,7 +420,10 @@ class JuicedProgram:
     def _run_single(self, **kwargs) -> Any:
         """Run with a single model at the specified juice level."""
         config = JUICE_MODELS[self.juice]
-        model_name = config.model.split("/")[-1]
+
+        # Use model override if provided, otherwise use default for juice level
+        actual_model = self.model_override if self.model_override else config.model
+        model_name = actual_model.split("/")[-1]
 
         reasoning_desc = ""
         if self.reasoning is not None:
@@ -356,11 +432,11 @@ class JuicedProgram:
         self._emit("status", {
             "step": "calling_model",
             "model": model_name,
-            "model_full": config.model,
+            "model_full": actual_model,
             "reasoning_level": self.reasoning.value if self.reasoning else None,
         })
 
-        lm = get_lm(self.juice, self.reasoning)
+        lm = get_lm(self.juice, self.reasoning, api_keys=self.api_keys, model_override=self.model_override)
         with dspy.context(lm=lm):
             result = self.program(**kwargs)
 
@@ -416,6 +492,11 @@ class JuicedProgram:
                     if reasoning_config["reasoning_effort"] is not None:
                         lm_kwargs["reasoning_effort"] = reasoning_config["reasoning_effort"]
 
+            # Apply API key for this model's provider
+            api_key = get_api_key_for_model(config.model, self.api_keys)
+            if api_key:
+                lm_kwargs["api_key"] = api_key
+
             lm = dspy.LM(**lm_kwargs)
             model_name = config.model.split("/")[-1]
 
@@ -536,8 +617,12 @@ class JuicedProgram:
         # Create synthesized result
         merged = {}
 
-        # Configure synthesizer LM
-        synth_lm = dspy.LM(**SYNTHESIZER_MODEL.to_lm_kwargs())
+        # Configure synthesizer LM with API key if provided
+        synth_kwargs = SYNTHESIZER_MODEL.to_lm_kwargs()
+        api_key = get_api_key_for_model(SYNTHESIZER_MODEL.model, self.api_keys)
+        if api_key:
+            synth_kwargs["api_key"] = api_key
+        synth_lm = dspy.LM(**synth_kwargs)
 
         # Synthesize each output field
         for field_name, base_value in base_store.items():

{mrmd_ai-0.1.1 → mrmd_ai-0.1.2}/src/mrmd_ai/server.py

@@ -24,6 +24,7 @@ import json
 _executor = ThreadPoolExecutor(max_workers=10)
 
 from .juice import JuiceLevel, ReasoningLevel, JuicedProgram, get_lm, JUICE_MODELS, REASONING_DESCRIPTIONS
+from .custom_programs import custom_registry, register_custom_programs
 from .modules import (
     # Finish
     FinishSentencePredict,
@@ -105,16 +106,91 @@ PROGRAMS = {
 }
 
 # Cached program instances per juice level and reasoning level
+# NOTE: Cache is only used when no custom API keys are provided
 _program_cache: dict[tuple[str, int, int | None], JuicedProgram] = {}
 
 
-def get_program(name: str, juice: int = 0, reasoning: int | None = None) -> JuicedProgram:
-    """Get a JuicedProgram instance for the given program, juice level, and reasoning level."""
+# API key header names
+API_KEY_HEADERS = {
+    "anthropic": "X-Api-Key-Anthropic",
+    "openai": "X-Api-Key-Openai",
+    "groq": "X-Api-Key-Groq",
+    "gemini": "X-Api-Key-Gemini",
+    "openrouter": "X-Api-Key-Openrouter",
+}
+
+
+def extract_api_keys(request: Request) -> dict | None:
+    """Extract API keys from request headers.
+
+    Headers:
+        X-Api-Key-Anthropic: Anthropic API key
+        X-Api-Key-Openai: OpenAI API key
+        X-Api-Key-Groq: Groq API key
+        X-Api-Key-Gemini: Google Gemini API key
+        X-Api-Key-Openrouter: OpenRouter API key
+
+    Returns:
+        Dict of provider -> key if any keys are provided, None otherwise.
+    """
+    api_keys = {}
+    for provider, header in API_KEY_HEADERS.items():
+        key = request.headers.get(header)
+        if key:
+            api_keys[provider] = key
+
+    return api_keys if api_keys else None
+
+
+def get_program(
+    name: str,
+    juice: int = 0,
+    reasoning: int | None = None,
+    api_keys: dict | None = None,
+    model_override: str | None = None,
+) -> JuicedProgram:
+    """Get a JuicedProgram instance for the given program configuration.
+
+    Args:
+        name: Program name (can be built-in or custom)
+        juice: Juice level (0-4)
+        reasoning: Optional reasoning level (0-5)
+        api_keys: Optional dict of provider -> API key
+        model_override: Optional model to use instead of default
+
+    Returns:
+        Configured JuicedProgram instance.
+
+    Note:
+        Programs with custom API keys or model overrides are NOT cached,
+        since they need fresh instances with the provided configuration.
+        Custom programs are never cached.
+    """
+    # Check built-in programs first
+    program_class = PROGRAMS.get(name)
+
+    # If not found, check custom registry
+    if program_class is None:
+        program_class = custom_registry.get(name)
+
+    if program_class is None:
+        raise ValueError(f"Unknown program: {name}")
+
+    # Custom programs and those with custom config are never cached
+    is_custom = name not in PROGRAMS
+    if api_keys or model_override or is_custom:
+        program = program_class()
+        return JuicedProgram(
+            program,
+            juice=juice,
+            reasoning=reasoning,
+            api_keys=api_keys,
+            model_override=model_override,
+        )
+
+    # Use cache for standard built-in requests (no custom keys)
     cache_key = (name, juice, reasoning)
     if cache_key not in _program_cache:
-        if name not in PROGRAMS:
-            raise ValueError(f"Unknown program: {name}")
-        program_class = PROGRAMS[name]
         program = program_class()
         _program_cache[cache_key] = JuicedProgram(program, juice=juice, reasoning=reasoning)
     return _program_cache[cache_key]
@@ -250,6 +326,12 @@ async def run_program(program_name: str, request: Request):
         except ValueError:
             reasoning_level = None
 
+    # Extract API keys from headers (optional)
+    api_keys = extract_api_keys(request)
+
+    # Get model override from header (optional)
+    model_override = request.headers.get("X-Model-Override")
+
     # Get request body
     try:
         params = await request.json()
@@ -258,7 +340,13 @@ async def run_program(program_name: str, request: Request):
 
     # Get program
     try:
-        juiced_program = get_program(program_name, juice_level, reasoning_level)
+        juiced_program = get_program(
+            program_name,
+            juice_level,
+            reasoning_level,
+            api_keys=api_keys,
+            model_override=model_override,
+        )
     except ValueError as e:
         raise HTTPException(status_code=404, detail=str(e))
 
@@ -347,6 +435,12 @@ async def run_program_stream(program_name: str, request: Request):
         except ValueError:
             reasoning_level = None
 
+    # Extract API keys from headers (optional)
+    api_keys = extract_api_keys(request)
+
+    # Get model override from header (optional)
+    model_override = request.headers.get("X-Model-Override")
+
     # Get request body
     try:
         params = await request.json()
@@ -390,10 +484,17 @@ async def run_program_stream(program_name: str, request: Request):
         def run_with_progress():
             """Run the program in a thread, emitting progress events."""
             try:
-                # Create program with progress callback
+                # Create program with progress callback and optional API keys
                 program_class = PROGRAMS[program_name]
                 program = program_class()
-                juiced = JuicedProgram(program, juice=juice_level, reasoning=reasoning_level, progress_callback=progress_callback)
+                juiced = JuicedProgram(
+                    program,
+                    juice=juice_level,
+                    reasoning=reasoning_level,
+                    progress_callback=progress_callback,
+                    api_keys=api_keys,
+                    model_override=model_override,
+                )
 
                 # Emit starting event
                 progress_callback("status", {
@@ -468,6 +569,79 @@ async def run_program_stream(program_name: str, request: Request):
     )
 
 
+# =============================================================================
+# CUSTOM PROGRAMS API
+# =============================================================================
+
+class CustomProgramConfig(BaseModel):
+    """Configuration for a custom program."""
+    id: str  # Unique program ID (e.g., "Custom_cmd-123")
+    name: str
+    instructions: str
+    inputType: str = "selection"  # selection | cursor | fullDoc
+    outputType: str = "replace"  # replace | insert
+
+
+class RegisterCustomProgramsRequest(BaseModel):
+    """Request to register multiple custom programs."""
+    programs: list[CustomProgramConfig]
+
+
+@app.post("/api/custom-programs/register")
+async def register_custom_programs_endpoint(request: RegisterCustomProgramsRequest):
+    """Register custom programs from frontend configuration.
+
+    This endpoint is called when the app starts or when settings change.
+    It clears existing custom programs and registers the new ones.
+    """
+    # Clear existing custom programs
+    custom_registry.clear()
+
+    # Register new programs
+    registered = []
+    for prog in request.programs:
+        try:
+            custom_registry.register(
+                program_id=prog.id,
+                config={
+                    "name": prog.name,
+                    "instructions": prog.instructions,
+                    "inputType": prog.inputType,
+                    "outputType": prog.outputType,
+                }
+            )
+            registered.append(prog.id)
+            print(f"[Custom] Registered: {prog.name} ({prog.id})")
+        except Exception as e:
+            print(f"[Custom] Failed to register {prog.id}: {e}")
+
+    return {"registered": registered, "count": len(registered)}
+
+
+@app.get("/api/custom-programs")
+async def list_custom_programs():
+    """List all registered custom programs."""
+    programs = []
+    for program_id in custom_registry.list_programs():
+        config = custom_registry.get_config(program_id)
+        if config:
+            programs.append({
+                "id": program_id,
+                "name": config.get("name", program_id),
+                "inputType": config.get("inputType", "selection"),
+                "outputType": config.get("outputType", "replace"),
+            })
+    return {"programs": programs}
+
+
+@app.delete("/api/custom-programs/{program_id}")
+async def unregister_custom_program(program_id: str):
+    """Unregister a specific custom program."""
+    if custom_registry.unregister(program_id):
+        return {"success": True, "id": program_id}
+    raise HTTPException(status_code=404, detail=f"Program not found: {program_id}")
+
+
 def main():
     """Run the AI server."""
     import argparse

{mrmd_ai-0.1.1 → mrmd_ai-0.1.2}/uv.lock

@@ -1,5 +1,5 @@
 version = 1
-revision = 2
+revision = 3
 requires-python = ">=3.11"
 resolution-markers = [
     "python_full_version >= '3.14'",
@@ -584,7 +584,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/1f/cb/48e964c452ca2b92175a9b2dca037a553036cb053ba69e284650ce755f13/greenlet-3.3.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:e29f3018580e8412d6aaf5641bb7745d38c85228dacf51a73bd4e26ddf2a6a8e", size = 274908, upload-time = "2025-12-04T14:23:26.435Z" },
     { url = "https://files.pythonhosted.org/packages/28/da/38d7bff4d0277b594ec557f479d65272a893f1f2a716cad91efeb8680953/greenlet-3.3.0-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a687205fb22794e838f947e2194c0566d3812966b41c78709554aa883183fb62", size = 577113, upload-time = "2025-12-04T14:50:05.493Z" },
     { url = "https://files.pythonhosted.org/packages/3c/f2/89c5eb0faddc3ff014f1c04467d67dee0d1d334ab81fadbf3744847f8a8a/greenlet-3.3.0-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4243050a88ba61842186cb9e63c7dfa677ec146160b0efd73b855a3d9c7fcf32", size = 590338, upload-time = "2025-12-04T14:57:41.136Z" },
-    { url = "https://files.pythonhosted.org/packages/80/d7/db0a5085035d05134f8c089643da2b44cc9b80647c39e93129c5ef170d8f/greenlet-3.3.0-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:670d0f94cd302d81796e37299bcd04b95d62403883b24225c6b5271466612f45", size = 601098, upload-time = "2025-12-04T15:07:11.898Z" },
     { url = "https://files.pythonhosted.org/packages/dc/a6/e959a127b630a58e23529972dbc868c107f9d583b5a9f878fb858c46bc1a/greenlet-3.3.0-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6cb3a8ec3db4a3b0eb8a3c25436c2d49e3505821802074969db017b87bc6a948", size = 590206, upload-time = "2025-12-04T14:26:01.254Z" },
     { url = "https://files.pythonhosted.org/packages/48/60/29035719feb91798693023608447283b266b12efc576ed013dd9442364bb/greenlet-3.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2de5a0b09eab81fc6a382791b995b1ccf2b172a9fec934747a7a23d2ff291794", size = 1550668, upload-time = "2025-12-04T15:04:22.439Z" },
     { url = "https://files.pythonhosted.org/packages/0a/5f/783a23754b691bfa86bd72c3033aa107490deac9b2ef190837b860996c9f/greenlet-3.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4449a736606bd30f27f8e1ff4678ee193bc47f6ca810d705981cfffd6ce0d8c5", size = 1615483, upload-time = "2025-12-04T14:27:28.083Z" },
@@ -592,7 +591,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f8/0a/a3871375c7b9727edaeeea994bfff7c63ff7804c9829c19309ba2e058807/greenlet-3.3.0-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:b01548f6e0b9e9784a2c99c5651e5dc89ffcbe870bc5fb2e5ef864e9cc6b5dcb", size = 276379, upload-time = "2025-12-04T14:23:30.498Z" },
     { url = "https://files.pythonhosted.org/packages/43/ab/7ebfe34dce8b87be0d11dae91acbf76f7b8246bf9d6b319c741f99fa59c6/greenlet-3.3.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:349345b770dc88f81506c6861d22a6ccd422207829d2c854ae2af8025af303e3", size = 597294, upload-time = "2025-12-04T14:50:06.847Z" },
     { url = "https://files.pythonhosted.org/packages/a4/39/f1c8da50024feecd0793dbd5e08f526809b8ab5609224a2da40aad3a7641/greenlet-3.3.0-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e8e18ed6995e9e2c0b4ed264d2cf89260ab3ac7e13555b8032b25a74c6d18655", size = 607742, upload-time = "2025-12-04T14:57:42.349Z" },
-    { url = "https://files.pythonhosted.org/packages/77/cb/43692bcd5f7a0da6ec0ec6d58ee7cddb606d055ce94a62ac9b1aa481e969/greenlet-3.3.0-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c024b1e5696626890038e34f76140ed1daf858e37496d33f2af57f06189e70d7", size = 622297, upload-time = "2025-12-04T15:07:13.552Z" },
     { url = "https://files.pythonhosted.org/packages/75/b0/6bde0b1011a60782108c01de5913c588cf51a839174538d266de15e4bf4d/greenlet-3.3.0-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:047ab3df20ede6a57c35c14bf5200fcf04039d50f908270d3f9a7a82064f543b", size = 609885, upload-time = "2025-12-04T14:26:02.368Z" },
     { url = "https://files.pythonhosted.org/packages/49/0e/49b46ac39f931f59f987b7cd9f34bfec8ef81d2a1e6e00682f55be5de9f4/greenlet-3.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2d9ad37fc657b1102ec880e637cccf20191581f75c64087a549e66c57e1ceb53", size = 1567424, upload-time = "2025-12-04T15:04:23.757Z" },
     { url = "https://files.pythonhosted.org/packages/05/f5/49a9ac2dff7f10091935def9165c90236d8f175afb27cbed38fb1d61ab6b/greenlet-3.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:83cd0e36932e0e7f36a64b732a6f60c2fc2df28c351bae79fbaf4f8092fe7614", size = 1636017, upload-time = "2025-12-04T14:27:29.688Z" },
@@ -600,7 +598,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/02/2f/28592176381b9ab2cafa12829ba7b472d177f3acc35d8fbcf3673d966fff/greenlet-3.3.0-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:a1e41a81c7e2825822f4e068c48cb2196002362619e2d70b148f20a831c00739", size = 275140, upload-time = "2025-12-04T14:23:01.282Z" },
     { url = "https://files.pythonhosted.org/packages/2c/80/fbe937bf81e9fca98c981fe499e59a3f45df2a04da0baa5c2be0dca0d329/greenlet-3.3.0-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9f515a47d02da4d30caaa85b69474cec77b7929b2e936ff7fb853d42f4bf8808", size = 599219, upload-time = "2025-12-04T14:50:08.309Z" },
     { url = "https://files.pythonhosted.org/packages/c2/ff/7c985128f0514271b8268476af89aee6866df5eec04ac17dcfbc676213df/greenlet-3.3.0-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7d2d9fd66bfadf230b385fdc90426fcd6eb64db54b40c495b72ac0feb5766c54", size = 610211, upload-time = "2025-12-04T14:57:43.968Z" },
-    { url = "https://files.pythonhosted.org/packages/79/07/c47a82d881319ec18a4510bb30463ed6891f2ad2c1901ed5ec23d3de351f/greenlet-3.3.0-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:30a6e28487a790417d036088b3bcb3f3ac7d8babaa7d0139edbaddebf3af9492", size = 624311, upload-time = "2025-12-04T15:07:14.697Z" },
     { url = "https://files.pythonhosted.org/packages/fd/8e/424b8c6e78bd9837d14ff7df01a9829fc883ba2ab4ea787d4f848435f23f/greenlet-3.3.0-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:087ea5e004437321508a8d6f20efc4cfec5e3c30118e1417ea96ed1d93950527", size = 612833, upload-time = "2025-12-04T14:26:03.669Z" },
     { url = "https://files.pythonhosted.org/packages/b5/ba/56699ff9b7c76ca12f1cdc27a886d0f81f2189c3455ff9f65246780f713d/greenlet-3.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ab97cf74045343f6c60a39913fa59710e4bd26a536ce7ab2397adf8b27e67c39", size = 1567256, upload-time = "2025-12-04T15:04:25.276Z" },
     { url = "https://files.pythonhosted.org/packages/1e/37/f31136132967982d698c71a281a8901daf1a8fbab935dce7c0cf15f942cc/greenlet-3.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5375d2e23184629112ca1ea89a53389dddbffcf417dad40125713d88eb5f96e8", size = 1636483, upload-time = "2025-12-04T14:27:30.804Z" },
@@ -608,7 +605,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/d7/7c/f0a6d0ede2c7bf092d00bc83ad5bafb7e6ec9b4aab2fbdfa6f134dc73327/greenlet-3.3.0-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:60c2ef0f578afb3c8d92ea07ad327f9a062547137afe91f38408f08aacab667f", size = 275671, upload-time = "2025-12-04T14:23:05.267Z" },
     { url = "https://files.pythonhosted.org/packages/44/06/dac639ae1a50f5969d82d2e3dd9767d30d6dbdbab0e1a54010c8fe90263c/greenlet-3.3.0-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0a5d554d0712ba1de0a6c94c640f7aeba3f85b3a6e1f2899c11c2c0428da9365", size = 646360, upload-time = "2025-12-04T14:50:10.026Z" },
     { url = "https://files.pythonhosted.org/packages/e0/94/0fb76fe6c5369fba9bf98529ada6f4c3a1adf19e406a47332245ef0eb357/greenlet-3.3.0-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3a898b1e9c5f7307ebbde4102908e6cbfcb9ea16284a3abe15cab996bee8b9b3", size = 658160, upload-time = "2025-12-04T14:57:45.41Z" },
-    { url = "https://files.pythonhosted.org/packages/93/79/d2c70cae6e823fac36c3bbc9077962105052b7ef81db2f01ec3b9bf17e2b/greenlet-3.3.0-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:dcd2bdbd444ff340e8d6bdf54d2f206ccddbb3ccfdcd3c25bf4afaa7b8f0cf45", size = 671388, upload-time = "2025-12-04T15:07:15.789Z" },
     { url = "https://files.pythonhosted.org/packages/b8/14/bab308fc2c1b5228c3224ec2bf928ce2e4d21d8046c161e44a2012b5203e/greenlet-3.3.0-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5773edda4dc00e173820722711d043799d3adb4f01731f40619e07ea2750b955", size = 660166, upload-time = "2025-12-04T14:26:05.099Z" },
     { url = "https://files.pythonhosted.org/packages/4b/d2/91465d39164eaa0085177f61983d80ffe746c5a1860f009811d498e7259c/greenlet-3.3.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ac0549373982b36d5fd5d30beb8a7a33ee541ff98d2b502714a09f1169f31b55", size = 1615193, upload-time = "2025-12-04T15:04:27.041Z" },
     { url = "https://files.pythonhosted.org/packages/42/1b/83d110a37044b92423084d52d5d5a3b3a73cafb51b547e6d7366ff62eff1/greenlet-3.3.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d198d2d977460358c3b3a4dc844f875d1adb33817f0613f663a656f463764ccc", size = 1683653, upload-time = "2025-12-04T14:27:32.366Z" },
@@ -616,7 +612,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a0/66/bd6317bc5932accf351fc19f177ffba53712a202f9df10587da8df257c7e/greenlet-3.3.0-cp314-cp314t-macosx_11_0_universal2.whl", hash = "sha256:d6ed6f85fae6cdfdb9ce04c9bf7a08d666cfcfb914e7d006f44f840b46741931", size = 282638, upload-time = "2025-12-04T14:25:20.941Z" },
     { url = "https://files.pythonhosted.org/packages/30/cf/cc81cb030b40e738d6e69502ccbd0dd1bced0588e958f9e757945de24404/greenlet-3.3.0-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d9125050fcf24554e69c4cacb086b87b3b55dc395a8b3ebe6487b045b2614388", size = 651145, upload-time = "2025-12-04T14:50:11.039Z" },
     { url = "https://files.pythonhosted.org/packages/9c/ea/1020037b5ecfe95ca7df8d8549959baceb8186031da83d5ecceff8b08cd2/greenlet-3.3.0-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:87e63ccfa13c0a0f6234ed0add552af24cc67dd886731f2261e46e241608bee3", size = 654236, upload-time = "2025-12-04T14:57:47.007Z" },
-    { url = "https://files.pythonhosted.org/packages/69/cc/1e4bae2e45ca2fa55299f4e85854606a78ecc37fead20d69322f96000504/greenlet-3.3.0-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2662433acbca297c9153a4023fe2161c8dcfdcc91f10433171cf7e7d94ba2221", size = 662506, upload-time = "2025-12-04T15:07:16.906Z" },
     { url = "https://files.pythonhosted.org/packages/57/b9/f8025d71a6085c441a7eaff0fd928bbb275a6633773667023d19179fe815/greenlet-3.3.0-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3c6e9b9c1527a78520357de498b0e709fb9e2f49c3a513afd5a249007261911b", size = 653783, upload-time = "2025-12-04T14:26:06.225Z" },
     { url = "https://files.pythonhosted.org/packages/f6/c7/876a8c7a7485d5d6b5c6821201d542ef28be645aa024cfe1145b35c120c1/greenlet-3.3.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:286d093f95ec98fdd92fcb955003b8a3d054b4e2cab3e2707a5039e7b50520fd", size = 1614857, upload-time = "2025-12-04T15:04:28.484Z" },
     { url = "https://files.pythonhosted.org/packages/4f/dc/041be1dff9f23dac5f48a43323cd0789cb798342011c19a248d9c9335536/greenlet-3.3.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c10513330af5b8ae16f023e8ddbfb486ab355d04467c4679c5cfe4659975dd9", size = 1676034, upload-time = "2025-12-04T14:27:33.531Z" },
@@ -1026,7 +1021,7 @@ wheels = [
 
 [[package]]
 name = "mrmd-ai"
-version = "0.1.0"
+version = "0.1.1"
 source = { editable = "." }
 dependencies = [
     { name = "dspy" },