morphsdk 0.2.5__py3-none-any.whl

morphsdk/adapters/anthropic.py

@@ -0,0 +1,360 @@
+"""Anthropic framework adapter -- generates Anthropic Tool-compatible dicts.
+
+Each tool definition follows the Anthropic tool schema::
+
+    {
+        "name": "...",
+        "description": "...",
+        "input_schema": { JSON Schema }
+    }
+
+The :class:`AnthropicTool` wrapper pairs the definition with an ``execute()``
+method so callers can dispatch tool calls in a single object.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import ItemsView, Iterator, KeysView, ValuesView
+from typing import Any, Callable
+
+from .openai import (
+    BROWSER_TOOL_DESCRIPTION,
+    CODEBASE_SEARCH_DESCRIPTION,
+    EDIT_FILE_DESCRIPTION,
+    GITHUB_READ_FILE_DESCRIPTION,
+    GITHUB_SEARCH_DESCRIPTION,
+    MOBILE_TOOL_DESCRIPTION,
+    WARP_GREP_DESCRIPTION,
+)
+
+# ---------------------------------------------------------------------------
+# Tool definition factories
+# ---------------------------------------------------------------------------
+
+def edit_file_tool_def(*, description: str | None = None) -> dict[str, Any]:
+    """Generate an Anthropic Tool dict for ``edit_file``."""
+    return {
+        "name": "edit_file",
+        "description": description or EDIT_FILE_DESCRIPTION,
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "target_filepath": {
+                    "type": "string",
+                    "description": "The path of the target file to modify",
+                },
+                "instruction": {
+                    "type": "string",
+                    "description": (
+                        "A single sentence written in the first person describing "
+                        "what the agent is changing. Used to help disambiguate "
+                        "uncertainty in the edit."
+                    ),
+                },
+                "code_edit": {
+                    "type": "string",
+                    "description": (
+                        "Specify ONLY the precise lines of code that you wish to "
+                        "edit. Use `// ... existing code ...` for unchanged sections."
+                    ),
+                },
+            },
+            "required": ["target_filepath", "instruction", "code_edit"],
+        },
+    }
+
+
+def codebase_search_tool_def(*, description: str | None = None) -> dict[str, Any]:
+    """Generate an Anthropic Tool dict for ``codebase_search``."""
+    return {
+        "name": "codebase_search",
+        "description": description or CODEBASE_SEARCH_DESCRIPTION,
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "explanation": {
+                    "type": "string",
+                    "description": (
+                        "One sentence explanation as to why this tool is being used, "
+                        "and how it contributes to the goal."
+                    ),
+                },
+                "query": {
+                    "type": "string",
+                    "description": (
+                        "A complete question about what you want to understand. "
+                        "Ask as if talking to a colleague: \"How does X work?\", "
+                        "\"What happens when Y?\", \"Where is Z handled?\""
+                    ),
+                },
+                "target_directories": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": (
+                        "Prefix directory paths to limit search scope "
+                        "(single directory only, no glob patterns). "
+                        "Use [] to search entire repo."
+                    ),
+                },
+                "limit": {
+                    "type": "number",
+                    "description": "Maximum results to return (default: 10)",
+                },
+            },
+            "required": ["query", "target_directories", "explanation"],
+        },
+    }
+
+
+def grep_tool_def(
+    *,
+    name: str = "codebase_search",
+    description: str | None = None,
+) -> dict[str, Any]:
+    """Generate an Anthropic Tool dict for the WarpGrep agent."""
+    return {
+        "name": name,
+        "description": description or WARP_GREP_DESCRIPTION,
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "search_term": {
+                    "type": "string",
+                    "description": (
+                        "Search problem statement that this subagent is "
+                        "supposed to research for"
+                    ),
+                },
+            },
+            "required": ["search_term"],
+        },
+    }
+
+
+def github_search_tool_def(*, description: str | None = None) -> dict[str, Any]:
+    """Generate an Anthropic Tool dict for ``github_codebase_search``."""
+    return {
+        "name": "github_codebase_search",
+        "description": description or GITHUB_SEARCH_DESCRIPTION,
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "search_term": {
+                    "type": "string",
+                    "description": (
+                        "A targeted natural-language query describing what to find "
+                        "(e.g. \"How does auth work for SSO users?\"). "
+                        "Not a keyword or symbol name."
+                    ),
+                },
+                "github_url": {
+                    "type": "string",
+                    "description": (
+                        "GitHub repository URL to search "
+                        "(e.g. \"https://github.com/vercel/next.js\"). "
+                        "You must provide either github_url or owner_repo."
+                    ),
+                },
+                "owner_repo": {
+                    "type": "string",
+                    "description": (
+                        "Repository owner/repo shorthand (e.g. \"vercel/next.js\"). "
+                        "You must provide either github_url or owner_repo."
+                    ),
+                },
+                "branch": {
+                    "type": "string",
+                    "description": "Branch to search (defaults to the repository default branch)",
+                },
+            },
+            "required": ["search_term"],
+        },
+    }
+
+
+def github_read_file_tool_def(*, description: str | None = None) -> dict[str, Any]:
+    """Generate an Anthropic Tool dict for ``readfile_github_search``."""
+    return {
+        "name": "readfile_github_search",
+        "description": description or GITHUB_READ_FILE_DESCRIPTION,
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "github": {
+                    "type": "string",
+                    "description": "owner/repo shorthand (e.g., \"vercel/next.js\")",
+                },
+                "path": {
+                    "type": "string",
+                    "description": (
+                        "File path within the repository (e.g., \"src/server/index.ts\")"
+                    ),
+                },
+                "startLine": {
+                    "type": "number",
+                    "description": "Start line number (1-based). Omit to start from beginning.",
+                },
+                "endLine": {
+                    "type": "number",
+                    "description": "End line number (1-based, inclusive). Omit to read to the end.",
+                },
+                "branch": {
+                    "type": "string",
+                    "description": (
+                        "Branch to read from (defaults to the repository default branch)"
+                    ),
+                },
+            },
+            "required": ["github", "path"],
+        },
+    }
+
+
+def browser_tool_def(*, description: str | None = None) -> dict[str, Any]:
+    """Generate an Anthropic Tool dict for ``browser_task``."""
+    return {
+        "name": "browser_task",
+        "description": description or BROWSER_TOOL_DESCRIPTION,
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "task": {
+                    "type": "string",
+                    "description": (
+                        "Natural language description of what to do "
+                        "(e.g., \"Test checkout flow for buying a pineapple\")"
+                    ),
+                },
+                "url": {
+                    "type": "string",
+                    "description": (
+                        "Starting URL (e.g., https://3000-xyz.e2b.dev). "
+                        "Required if navigating to a specific page."
+                    ),
+                },
+                "maxSteps": {
+                    "type": "number",
+                    "description": (
+                        "Maximum number of browser actions to take (1-50). "
+                        "Default: 10. Use 15-30 for complex flows."
+                    ),
+                },
+                "region": {
+                    "type": "string",
+                    "enum": ["sfo", "lon"],
+                    "description": (
+                        "Browserless region: sfo (US West Coast) or lon (Europe). "
+                        "Default: sfo."
+                    ),
+                },
+            },
+            "required": ["task"],
+        },
+    }
+
+
+def mobile_tool_def(*, description: str | None = None) -> dict[str, Any]:
+    """Generate an Anthropic Tool dict for ``mobile_task``."""
+    return {
+        "name": "mobile_task",
+        "description": description or MOBILE_TOOL_DESCRIPTION,
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "task": {
+                    "type": "string",
+                    "description": "Natural language description of what to do in the mobile app",
+                },
+                "app": {
+                    "type": "string",
+                    "description": "Application identifier (bundle ID or BrowserStack bs:// URL)",
+                },
+                "platform": {
+                    "type": "string",
+                    "enum": ["ios", "android"],
+                    "description": "Target platform (default: ios)",
+                },
+                "max_steps": {
+                    "type": "number",
+                    "description": "Maximum agent steps (default: 50)",
+                },
+            },
+            "required": ["task", "app"],
+        },
+    }
+
+
+# ---------------------------------------------------------------------------
+# AnthropicTool -- pairs a definition with an executor
+# ---------------------------------------------------------------------------
+
+class AnthropicTool:
+    """A tool definition paired with an executor for Anthropic messages.
+
+    Behaves like a dict (can be passed directly to ``tools=[tool]``) while
+    also exposing ``execute()`` and ``format_result()`` methods.
+
+    Example::
+
+        tool = morph.edit.as_anthropic_tool(base_dir="./src")
+
+        # Pass to Anthropic
+        response = client.messages.create(
+            model="claude-sonnet-4-5-20250929",
+            tools=[tool],
+            messages=[...],
+        )
+
+        # Execute
+        result = tool.execute(tool_use_block.input)
+        formatted = tool.format_result(result)
+    """
+
+    def __init__(
+        self,
+        definition: dict[str, Any],
+        executor: Callable[..., Any],
+        formatter: Callable[..., str],
+        system_prompt: str = "",
+    ) -> None:
+        self._definition = definition
+        self._executor = executor
+        self._formatter = formatter
+        self.system_prompt = system_prompt
+
+    # -- dict protocol so Anthropic SDK accepts this as a tool ---
+    def __getitem__(self, key: str) -> Any:
+        return self._definition[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self._definition
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self._definition)
+
+    def keys(self) -> KeysView[str]:
+        return self._definition.keys()
+
+    def items(self) -> ItemsView[str, Any]:
+        return self._definition.items()
+
+    def values(self) -> ValuesView[Any]:
+        return self._definition.values()
+
+    def to_dict(self) -> dict[str, Any]:
+        """Return the raw tool definition dict."""
+        return self._definition
+
+    # -- execution ---
+    def execute(self, input: dict[str, Any] | str) -> Any:
+        """Execute the tool with the given input.
+
+        *input* may be a dict (from ``tool_use.input``) or a JSON string.
+        """
+        args: dict[str, Any] = json.loads(input) if isinstance(input, str) else input
+        return self._executor(**args)
+
+    def format_result(self, result: Any) -> str:
+        """Format a result for passing back as a tool_result content block."""
+        return self._formatter(result)

morphsdk/adapters/langchain.py

@@ -0,0 +1,120 @@
+"""LangChain framework adapter -- generates LangChain-compatible tool instances.
+
+Requires ``langchain-core`` as an optional dependency. All imports are
+deferred so the adapter module can be imported even when LangChain is not
+installed; a clear error is raised at tool-creation time if the dependency
+is missing.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Callable, Optional, cast
+
+if TYPE_CHECKING:
+    from pydantic import BaseModel
+
+
+def _ensure_langchain() -> None:
+    """Raise a helpful error if langchain-core is not installed."""
+    try:
+        import langchain_core  # noqa: F401
+    except ImportError:
+        raise ImportError(
+            "LangChain adapter requires 'langchain-core'. "
+            "Install it with: pip install langchain-core"
+        ) from None
+
+
+def create_tool(
+    *,
+    name: str,
+    description: str,
+    args_schema: dict[str, Any],
+    executor: Callable[..., Any],
+    formatter: Callable[..., str] | None = None,
+) -> Any:
+    """Create a LangChain ``StructuredTool`` from a Morph tool specification.
+
+    Parameters
+    ----------
+    name:
+        Tool name (e.g. ``edit_file``).
+    description:
+        Tool description shown to the LLM.
+    args_schema:
+        JSON Schema dict describing the tool parameters.
+    executor:
+        Callable that executes the tool. Receives kwargs matching the schema.
+    formatter:
+        Optional callable to format the result as a string.
+
+    Returns
+    -------
+    A ``langchain_core.tools.StructuredTool`` instance.
+    """
+    _ensure_langchain()
+
+    from langchain_core.tools import StructuredTool
+
+    def _run(**kwargs: Any) -> str:
+        result = executor(**kwargs)
+        if formatter is not None:
+            return formatter(result)
+        return str(result)
+
+    # Build a Pydantic model from the JSON schema for LangChain's args_schema
+    input_model = _json_schema_to_pydantic(name, args_schema)
+
+    return StructuredTool(
+        name=name,
+        description=description,
+        func=_run,
+        args_schema=input_model,
+    )
+
+
+def _json_schema_to_pydantic(tool_name: str, schema: dict[str, Any]) -> type[BaseModel]:
+    """Convert a flat JSON Schema ``properties`` dict to a Pydantic model.
+
+    This handles the common case of top-level string/number/array properties.
+    Nested objects are left as ``dict``.
+    """
+    _ensure_langchain()
+
+    from pydantic import Field, create_model
+
+    properties = schema.get("properties", {})
+    required = set(schema.get("required", []))
+    field_definitions: dict[str, Any] = {}
+
+    _TYPE_MAP = {
+        "string": str,
+        "number": float,
+        "integer": int,
+        "boolean": bool,
+        "object": dict,
+    }
+
+    for prop_name, prop_schema in properties.items():
+        prop_type = prop_schema.get("type", "string")
+        description = prop_schema.get("description", "")
+
+        python_type: type[Any]
+        if prop_type == "array":
+            item_type = _TYPE_MAP.get(
+                prop_schema.get("items", {}).get("type", "string"), str
+            )
+            python_type = list[item_type]  # type: ignore[valid-type]
+        else:
+            python_type = _TYPE_MAP.get(prop_type, str)
+
+        if prop_name in required:
+            field_definitions[prop_name] = (python_type, Field(description=description))
+        else:
+            field_definitions[prop_name] = (
+                Optional[python_type],
+                Field(default=None, description=description),
+            )
+
+    model_name = f"{tool_name.title().replace('_', '')}Input"
+    return cast("type[BaseModel]", create_model(model_name, **field_definitions))