mcp-as-code 0.1.5__tar.gz → 0.1.7__tar.gz

{mcp_as_code-0.1.5 → mcp_as_code-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-as-code
-Version: 0.1.5
+Version: 0.1.7
 Summary: Execute MCP tools through generated Python code interfaces
 License-Expression: Apache-2.0
 License-File: LICENSE
@@ -8,15 +8,18 @@ Requires-Python: >=3.11
 Requires-Dist: click>=8.1
 Requires-Dist: httpx>=0.28
 Requires-Dist: jinja2>=3.1
-Requires-Dist: matchlock==0.2.15
 Requires-Dist: mcp>=1.24.0
 Requires-Dist: pydantic>=2.0
+Provides-Extra: matchlock
+Requires-Dist: matchlock<0.3.0,>=0.2.15; extra == 'matchlock'
 Description-Content-Type: text/markdown
 
 # maco
 
 **Connect every MCP server you need, keeping your agent's context lean.**
 
+https://github.com/user-attachments/assets/4b91ea97-d48e-41c5-8189-0da8522ac459
+
 As the number of MCP servers you connect grows, tool schemas and intermediate tool call results clutter your agent's context. `maco` (mcp-as-code) collapses them all into a single endpoint with a programmatic interface.
 
 Instead of loading hundreds if not thousands of tool schemas upfront, `maco` reconstructs every MCP tool as Pydantic models and Python functions in a virtual filesystem and hands your agent just two of its favourite tools: `bash` to navigate, and `code_execute` to run. The agent discovers and composes tools as code, the thing frontier models do best.
@@ -42,26 +45,30 @@ tools
 **Programmatic leverage:** the agent is given a real programming language, Python, allowing it to orchestrate complex control flows with exceptional context-efficiency using loops, conditions, and state management.
 
 ```python
+import asyncio
 from collections import Counter
-from tools.github import listCommits
-
-owner, repo, page, counts = "openclaw", "openclaw", 1, Counter()
-
-while True:
-    commits = listCommits(owner=owner, repo=repo, perPage=100, page=page)
-    for commit in commits:
-        login = (commit.get("author") or {}).get("login")
-        if login and "bot" not in login.lower():
-            counts[login] += 1
-    if len(commits) < 100 or page >= 20:
-        break
-    page += 1
-
-total = sum(counts.values())
-for login, count in counts.most_common():
-    if count / total < 0.01:
-        break
-    print(f"@{login}: {count} commits ({count / total:.1%})")
+from tools.github import ListCommitsInput, list_commits
+
+async def main():
+    owner, repo, page, counts = "openclaw", "openclaw", 1, Counter()
+
+    while True:
+        commits = await list_commits(ListCommitsInput(owner=owner, repo=repo, per_page=100, page=page))
+        for commit in commits:
+            login = (commit.get("author") or {}).get("login")
+            if login and "bot" not in login.lower():
+                counts[login] += 1
+        if len(commits) < 100 or page >= 20:
+            break
+        page += 1
+
+    total = sum(counts.values())
+    for login, count in counts.most_common():
+        if count / total < 0.01:
+            break
+        print(f"@{login}: {count} commits ({count / total:.1%})")
+
+asyncio.run(main())
 ```
 
 The example above illustrates the MCP code that will be executed to find the top contributors to an open-source repository.
@@ -74,6 +81,14 @@ Install the Python package `mcp-as-code`; it provides the `maco` executable:
 uv tool install mcp-as-code
 ```
 
+To use the Matchlock sandbox provider, install the optional Matchlock support instead:
+
+```bash
+uv tool install 'mcp-as-code[matchlock]'
+```
+
+The Matchlock binary must also be installed and available on `PATH`.
+
 Then verify the CLI:
 
 ```bash
@@ -141,9 +156,16 @@ See [`docs/mcp-config.md`](docs/mcp-config.md) for the full config reference, in
 
 Choose the execution provider with `--provider`:
 
-- `local`: fastest feedback loop; runs commands as local subprocesses.
-- `docker`: runs commands in a long-lived Docker container.
-- `matchlock`: runs commands in a long-lived Matchlock micro-VM.
+- `local`: ideally for local development and fast feedback loop, or maco is already running in an isolated sandbox.
+- `docker`: runs mcp bash and code execution in a long-lived Docker container.
+- `matchlock`: runs mcp bash and code execution in a long-lived Matchlock micro-VM; requires `mcp-as-code[matchlock]` and the Matchlock binary.
+
+## Credits
+
+`maco` is inspired by and builds on ideas from:
+
+- [Code execution with MCP: Building more efficient agents](https://www.anthropic.com/engineering/code-execution-with-mcp)
+- [Code Mode: the better way to use MCP](https://blog.cloudflare.com/code-mode/)
 
 ## License
 

{mcp_as_code-0.1.5 → mcp_as_code-0.1.7}/README.md

@@ -2,6 +2,8 @@
 
 **Connect every MCP server you need, keeping your agent's context lean.**
 
+https://github.com/user-attachments/assets/4b91ea97-d48e-41c5-8189-0da8522ac459
+
 As the number of MCP servers you connect grows, tool schemas and intermediate tool call results clutter your agent's context. `maco` (mcp-as-code) collapses them all into a single endpoint with a programmatic interface.
 
 Instead of loading hundreds if not thousands of tool schemas upfront, `maco` reconstructs every MCP tool as Pydantic models and Python functions in a virtual filesystem and hands your agent just two of its favourite tools: `bash` to navigate, and `code_execute` to run. The agent discovers and composes tools as code, the thing frontier models do best.
@@ -27,26 +29,30 @@ tools
 **Programmatic leverage:** the agent is given a real programming language, Python, allowing it to orchestrate complex control flows with exceptional context-efficiency using loops, conditions, and state management.
 
 ```python
+import asyncio
 from collections import Counter
-from tools.github import listCommits
-
-owner, repo, page, counts = "openclaw", "openclaw", 1, Counter()
-
-while True:
-    commits = listCommits(owner=owner, repo=repo, perPage=100, page=page)
-    for commit in commits:
-        login = (commit.get("author") or {}).get("login")
-        if login and "bot" not in login.lower():
-            counts[login] += 1
-    if len(commits) < 100 or page >= 20:
-        break
-    page += 1
-
-total = sum(counts.values())
-for login, count in counts.most_common():
-    if count / total < 0.01:
-        break
-    print(f"@{login}: {count} commits ({count / total:.1%})")
+from tools.github import ListCommitsInput, list_commits
+
+async def main():
+    owner, repo, page, counts = "openclaw", "openclaw", 1, Counter()
+
+    while True:
+        commits = await list_commits(ListCommitsInput(owner=owner, repo=repo, per_page=100, page=page))
+        for commit in commits:
+            login = (commit.get("author") or {}).get("login")
+            if login and "bot" not in login.lower():
+                counts[login] += 1
+        if len(commits) < 100 or page >= 20:
+            break
+        page += 1
+
+    total = sum(counts.values())
+    for login, count in counts.most_common():
+        if count / total < 0.01:
+            break
+        print(f"@{login}: {count} commits ({count / total:.1%})")
+
+asyncio.run(main())
 ```
 
 The example above illustrates the MCP code that will be executed to find the top contributors to an open-source repository.
@@ -59,6 +65,14 @@ Install the Python package `mcp-as-code`; it provides the `maco` executable:
 uv tool install mcp-as-code
 ```
 
+To use the Matchlock sandbox provider, install the optional Matchlock support instead:
+
+```bash
+uv tool install 'mcp-as-code[matchlock]'
+```
+
+The Matchlock binary must also be installed and available on `PATH`.
+
 Then verify the CLI:
 
 ```bash
@@ -126,9 +140,16 @@ See [`docs/mcp-config.md`](docs/mcp-config.md) for the full config reference, in
 
 Choose the execution provider with `--provider`:
 
-- `local`: fastest feedback loop; runs commands as local subprocesses.
-- `docker`: runs commands in a long-lived Docker container.
-- `matchlock`: runs commands in a long-lived Matchlock micro-VM.
+- `local`: ideally for local development and fast feedback loop, or maco is already running in an isolated sandbox.
+- `docker`: runs mcp bash and code execution in a long-lived Docker container.
+- `matchlock`: runs mcp bash and code execution in a long-lived Matchlock micro-VM; requires `mcp-as-code[matchlock]` and the Matchlock binary.
+
+## Credits
+
+`maco` is inspired by and builds on ideas from:
+
+- [Code execution with MCP: Building more efficient agents](https://www.anthropic.com/engineering/code-execution-with-mcp)
+- [Code Mode: the better way to use MCP](https://blog.cloudflare.com/code-mode/)
 
 ## License
 

{mcp_as_code-0.1.5 → mcp_as_code-0.1.7}/examples/serve-mcp/README.md

@@ -11,7 +11,7 @@ This example shows how to expose several upstream MCP servers through one compac
 - `node`/`npx`, for Playwright MCP
 - A GitHub personal access token in `GITHUB_TOKEN`, used by the hosted GitHub MCP server
 - Docker, only if you use the Docker sandbox provider
-- Optional: Matchlock, for the Matchlock sandbox provider
+- Optional: `mcp-as-code[matchlock]` and the Matchlock binary, for the Matchlock sandbox provider
 
 If you are already authenticated with the GitHub CLI, export a token directly:
 

{mcp_as_code-0.1.5 → mcp_as_code-0.1.7}/pyproject.toml

@@ -9,11 +9,15 @@ dependencies = [
     "click>=8.1",
     "httpx>=0.28",
     "jinja2>=3.1",
-    "matchlock==0.2.15",
     "mcp>=1.24.0",
     "pydantic>=2.0",
 ]
 
+[project.optional-dependencies]
+matchlock = [
+    "matchlock>=0.2.15,<0.3.0",
+]
+
 [project.scripts]
 maco = "maco.cli:main"
 

{mcp_as_code-0.1.5 → mcp_as_code-0.1.7}/src/maco/__init__.py

@@ -1,3 +1,3 @@
 """maco Python interface generator and MCP code-execution server."""
 
-__version__ = "0.1.5"
+__version__ = "0.1.7"

{mcp_as_code-0.1.5 → mcp_as_code-0.1.7}/src/maco/codegen.py

@@ -3,8 +3,8 @@
 from __future__ import annotations
 
 import asyncio
-from collections import Counter
 from dataclasses import dataclass
+import hashlib
 import json
 import keyword
 from pathlib import Path
@@ -16,6 +16,7 @@ from urllib.request import Request, urlopen
 
 from jinja2 import Environment, PackageLoader, StrictUndefined
 
+from . import __version__
 from .config import MacoConfig
 from .mcp_manager import MCPManager
 
@@ -36,6 +37,38 @@ def _pyrepr(value: Any) -> str:
 _CODEGEN_TEMPLATES.filters["pyrepr"] = _pyrepr
 
 
+PYDANTIC_RESERVED_FIELD_NAMES = {
+    "construct",
+    "copy",
+    "dict",
+    "from_orm",
+    "json",
+    "model_computed_fields",
+    "model_config",
+    "model_construct",
+    "model_copy",
+    "model_dump",
+    "model_dump_json",
+    "model_extra",
+    "model_fields",
+    "model_fields_set",
+    "model_json_schema",
+    "model_parametrized_name",
+    "model_post_init",
+    "model_rebuild",
+    "model_validate",
+    "model_validate_json",
+    "model_validate_strings",
+    "parse_file",
+    "parse_obj",
+    "parse_raw",
+    "schema",
+    "schema_json",
+    "update_forward_refs",
+    "validate",
+}
+
+
 @dataclass(frozen=True)
 class GenerationStats:
     server_count: int
@@ -52,6 +85,13 @@ class TypeSource:
     is_model: bool = False
 
 
+@dataclass(frozen=True)
+class ToolExport:
+    function: str
+    input_type: str
+    output_type: str
+
+
 async def generate_async(
     config: MacoConfig,
     workspace: str | Path = ".maco",
@@ -124,8 +164,11 @@ def generate_from_catalog(
     _write_client(client_path)
 
     manifest = {
-        "version": 1,
+        "version": 2,
+        "generator": "maco.codegen",
+        "generator_version": __version__ or "unknown",
         "config": str(config_path) if config_path is not None else None,
+        "config_hash": _file_hash(config_path) if config_path is not None else None,
         "package": package_name,
         "servers": [],
     }
@@ -140,7 +183,7 @@ def generate_from_catalog(
         server_dir.mkdir(parents=True, exist_ok=True)
         tool_module_names = _unique_sanitized_names(tool["name"] for tool in tools)
 
-        exports: list[str] = []
+        exports: list[ToolExport] = []
         server_manifest = {
             "name": server_name,
             "module": server_module,
@@ -150,14 +193,18 @@ def generate_from_catalog(
             tool_name = tool["name"]
             func_name = tool_module_names[tool_name]
             module_path = server_dir / f"{func_name}.py"
-            _write_tool(module_path, server_name, tool, func_name, client_module)
-            exports.append(func_name)
+            tool_export = _write_tool(module_path, server_name, tool, func_name, client_module)
+            exports.append(tool_export)
             server_manifest["tools"].append(
                 {
                     "name": tool_name,
                     "function": func_name,
                     "module": f"{package_name}.{server_module}.{func_name}",
                     "description": tool.get("description") or "",
+                    "input_type": tool_export.input_type,
+                    "output_type": tool_export.output_type,
+                    "input_schema_hash": _schema_hash(tool.get("inputSchema")),
+                    "output_schema_hash": _schema_hash(tool.get("outputSchema")),
                 }
             )
             tool_count += 1
@@ -292,7 +339,7 @@ def _write_tool(
     tool: dict[str, Any],
     func_name: str,
     client_module: str,
-) -> None:
+) -> ToolExport:
     tool_name = tool["name"]
     description = tool.get("description") or ""
     input_schema = tool.get("inputSchema") or {"type": "object", "properties": {}}
@@ -303,26 +350,30 @@ def _write_tool(
         output_schema,
         missing_type_expr="_t.Any",
     )
-    return_expr = _return_expr(output_type)
     _write_template(
         path,
         "codegen/tool.py.j2",
         description=description,
         docstring=_docstring(description, input_schema, output_schema),
         func_name=func_name,
-        input_is_model=input_type.is_model,
+        input_default_suffix=_input_default_suffix(input_schema),
         input_type_expr=input_type.type_expr,
         input_type_source=input_type.source,
         output_type_expr=output_type.type_expr,
         output_type_source=output_type.source,
-        return_expr=return_expr,
         client_module=client_module,
         server_name=server_name,
         tool_name=tool_name,
     )
 
+    return ToolExport(
+        function=func_name,
+        input_type=input_type.type_expr,
+        output_type=output_type.type_expr,
+    )
 
-def _write_server_init(path: Path, exports: list[str]) -> None:
+
+def _write_server_init(path: Path, exports: list[ToolExport]) -> None:
     _write_template(path, "codegen/server_init.py.j2", exports=exports)
 
 
@@ -355,10 +406,14 @@ def _schema_to_type(
 ) -> TypeSource:
     schema = _resolve_schema_ref(schema, root_schema)
 
+    all_of_schema = _merged_all_of_schema(schema, root_schema)
+    if all_of_schema is not None:
+        return _schema_to_type(type_name, all_of_schema, root_schema, used_names, define_named=define_named)
+
     if "const" in schema:
-        return _maybe_alias(type_name, _literal_type([schema["const"]]), used_names, define_named)
+        return _maybe_alias(type_name, _literal_type([schema["const"]]), used_names, define_named, schema=schema)
     if isinstance(schema.get("enum"), list) and schema["enum"]:
-        return _maybe_alias(type_name, _literal_type(schema["enum"]), used_names, define_named)
+        return _maybe_alias(type_name, _literal_type(schema["enum"]), used_names, define_named, schema=schema)
 
     for key in ("oneOf", "anyOf"):
         variants = schema.get(key)
@@ -386,10 +441,6 @@ def _schema_to_type(
                 definitions,
             )
 
-    all_of = schema.get("allOf")
-    if isinstance(all_of, list) and len(all_of) == 1 and isinstance(all_of[0], dict):
-        return _schema_to_type(type_name, all_of[0], root_schema, used_names, define_named=define_named)
-
     schema_type = schema.get("type")
     if isinstance(schema_type, list):
         definitions = []
@@ -424,16 +475,17 @@ def _schema_to_type(
                 used_names,
                 define_named,
                 [item_type.source],
+                schema=schema,
             )
-        return _maybe_alias(type_name, "list[_t.Any]", used_names, define_named)
+        return _maybe_alias(type_name, "list[_t.Any]", used_names, define_named, schema=schema)
     if schema_type == "string":
-        return _maybe_alias(type_name, "str", used_names, define_named)
+        return _maybe_alias(type_name, "str", used_names, define_named, schema=schema)
     if schema_type == "integer":
-        return _maybe_alias(type_name, "int", used_names, define_named)
+        return _maybe_alias(type_name, "int", used_names, define_named, schema=schema)
     if schema_type == "number":
-        return _maybe_alias(type_name, "float", used_names, define_named)
+        return _maybe_alias(type_name, "float", used_names, define_named, schema=schema)
     if schema_type == "boolean":
-        return _maybe_alias(type_name, "bool", used_names, define_named)
+        return _maybe_alias(type_name, "bool", used_names, define_named, schema=schema)
     if schema_type == "null":
         return _maybe_alias(type_name, "None", used_names, define_named)
     return _maybe_alias(type_name, "_t.Any", used_names, define_named)
@@ -448,7 +500,19 @@ def _object_type_source(
     define_named: bool,
 ) -> TypeSource:
     properties = schema.get("properties")
-    if isinstance(properties, dict) and properties:
+    additional = schema.get("additionalProperties")
+    if (not properties) and isinstance(additional, dict):
+        value_type = _schema_to_type(f"{type_name}Value", additional, root_schema, used_names)
+        return _maybe_alias(
+            type_name,
+            f"dict[str, {value_type.type_expr}]",
+            used_names,
+            define_named,
+            [value_type.source],
+            schema=schema,
+        )
+
+    if isinstance(properties, dict):
         reserved_name = _reserve_type_name(type_name, used_names)
         required = {field for field in schema.get("required", []) if isinstance(field, str)}
         definitions: list[str] = []
@@ -478,23 +542,64 @@ def _object_type_source(
                     "type_expr": type_expr,
                 }
             )
-        definitions.append(_render_source("codegen/model.py.j2", class_name=reserved_name, fields=fields))
-        return TypeSource(_join_definitions(definitions), reserved_name, is_model=True)
-
-    additional = schema.get("additionalProperties")
-    if isinstance(additional, dict):
-        value_type = _schema_to_type(f"{type_name}Value", additional, root_schema, used_names)
-        return _maybe_alias(
-            type_name,
-            f"dict[str, {value_type.type_expr}]",
-            used_names,
-            define_named,
-            [value_type.source],
+        definitions.append(
+            _render_source(
+                "codegen/model.py.j2",
+                class_name=reserved_name,
+                extra_behavior=_extra_behavior(schema),
+                fields=fields,
+            )
         )
+        return TypeSource(_join_definitions(definitions), reserved_name, is_model=True)
 
     return _maybe_alias(type_name, "dict[str, _t.Any]", used_names, define_named)
 
 
+def _merged_all_of_schema(schema: dict[str, Any], root_schema: dict[str, Any]) -> dict[str, Any] | None:
+    all_of = schema.get("allOf")
+    if not isinstance(all_of, list) or not all_of:
+        return None
+
+    merged = {key: value for key, value in schema.items() if key != "allOf"}
+    properties: dict[str, Any] = dict(merged.get("properties") or {}) if isinstance(merged.get("properties"), dict) else {}
+    required: list[str] = [item for item in merged.get("required", []) if isinstance(item, str)]
+    additional_properties = merged.get("additionalProperties")
+
+    for item in all_of:
+        if not isinstance(item, dict):
+            return None
+        item_schema = _resolve_schema_ref(item, root_schema)
+        if not _is_object_schema(item_schema):
+            return item_schema if len(all_of) == 1 and not properties else None
+        item_properties = item_schema.get("properties")
+        if isinstance(item_properties, dict):
+            properties.update(item_properties)
+        for required_field in item_schema.get("required", []):
+            if isinstance(required_field, str) and required_field not in required:
+                required.append(required_field)
+        item_additional = item_schema.get("additionalProperties")
+        if item_additional is False:
+            additional_properties = False
+        elif additional_properties is None and item_additional is not None:
+            additional_properties = item_additional
+
+    merged["type"] = "object"
+    merged["properties"] = properties
+    if required:
+        merged["required"] = required
+    if additional_properties is not None:
+        merged["additionalProperties"] = additional_properties
+    return merged
+
+
+def _is_object_schema(schema: dict[str, Any]) -> bool:
+    return schema.get("type") == "object" or "properties" in schema
+
+
+def _extra_behavior(schema: dict[str, Any]) -> str:
+    return "forbid" if schema.get("additionalProperties") is False else "allow"
+
+
 def _resolve_schema_ref(schema: dict[str, Any], root_schema: dict[str, Any]) -> dict[str, Any]:
     ref = schema.get("$ref")
     if not isinstance(ref, str) or not ref.startswith("#/"):
@@ -518,22 +623,14 @@ def _maybe_alias(
     used_names: set[str],
     define_named: bool,
     definitions: list[str] | None = None,
+    *,
+    schema: dict[str, Any] | None = None,
 ) -> TypeSource:
     definitions = definitions or []
     if not define_named:
         return TypeSource(_join_definitions(definitions), type_expr)
     reserved_name = _reserve_type_name(type_name, used_names)
-    if _is_root_model_expr(type_expr):
-        return TypeSource(
-            _join_definitions(
-                [
-                    *definitions,
-                    _render_source("codegen/root_model.py.j2", class_name=reserved_name, type_expr=type_expr),
-                ]
-            ),
-            reserved_name,
-            is_model=True,
-        )
+    type_expr = _annotated_type(type_expr, schema)
     return TypeSource(_join_definitions([*definitions, _render_type_alias(reserved_name, type_expr)]), reserved_name)
 
 
@@ -541,10 +638,6 @@ def _render_type_alias(type_name: str, type_expr: str) -> str:
     return _render_source("codegen/type_alias.py.j2", type_name=type_name, type_expr=type_expr)
 
 
-def _is_root_model_expr(type_expr: str) -> bool:
-    return type_expr not in {"_t.Any", "None"} and not type_expr.startswith("dict[")
-
-
 def _field_default(prop_name: str, schema: dict[str, Any], required: set[str]) -> str:
     if "default" in schema:
         return repr(schema["default"])
@@ -561,26 +654,16 @@ def _field_args(prop_name: str, schema: dict[str, Any], default: str, field_name
     title = schema.get("title")
     if isinstance(title, str) and title:
         kwargs.append(f"title={title!r}")
-    for schema_key, field_key in (
-        ("minimum", "ge"),
-        ("maximum", "le"),
-        ("exclusiveMinimum", "gt"),
-        ("exclusiveMaximum", "lt"),
-        ("minLength", "min_length"),
-        ("maxLength", "max_length"),
-        ("pattern", "pattern"),
-    ):
-        if schema_key in schema:
-            kwargs.append(f"{field_key}={schema[schema_key]!r}")
+    kwargs.extend(_constraint_args(schema))
     return f"Field({', '.join(kwargs)})"
 
 
 def _safe_field_name(name: str, used_fields: set[str]) -> str:
-    candidate = re.sub(r"\W", "_", name)
-    if not candidate or candidate[0].isdigit():
+    candidate = _sanitize_identifier(name)
+    if candidate.startswith("_"):
+        candidate = f"field_{candidate.lstrip('_') or 'value'}"
+    if candidate in PYDANTIC_RESERVED_FIELD_NAMES:
         candidate = f"field_{candidate}"
-    if keyword.iskeyword(candidate):
-        candidate += "_"
     base = candidate
     index = 2
     while candidate in used_fields:
@@ -601,14 +684,6 @@ def _is_nullable(schema: dict[str, Any]) -> bool:
     return schema_type == "null" or (isinstance(schema_type, list) and "null" in schema_type)
 
 
-def _return_expr(output_type: TypeSource) -> str:
-    if output_type.type_expr == "_t.Any":
-        return "result"
-    if output_type.is_model:
-        return f"{output_type.type_expr}.model_validate(result)"
-    return f"_t.cast({output_type.type_expr}, result)"
-
-
 def _literal_type(values: list[Any]) -> str:
     return "_t.Literal[{}]".format(", ".join(repr(value) for value in values))
 
@@ -646,22 +721,26 @@ def _docstring(description: str, input_schema: dict[str, Any], output_schema: An
 
 
 def _unique_sanitized_names(names: Any) -> dict[str, str]:
-    originals = list(names)
-    base_names = [_sanitize_identifier(name) for name in originals]
-    counts: Counter[str] = Counter()
+    originals = [str(name) for name in names]
+    groups: dict[str, list[str]] = {}
+    for original in originals:
+        groups.setdefault(_sanitize_identifier(original), []).append(original)
     result: dict[str, str] = {}
-    for original, base in zip(originals, base_names, strict=True):
-        counts[base] += 1
-        result[original] = base if counts[base] == 1 else f"{base}_{counts[base]}"
+    for base, group in groups.items():
+        if len(group) == 1:
+            result[group[0]] = base
+            continue
+        for index, original in enumerate(sorted(group), start=1):
+            result[original] = base if index == 1 else f"{base}_{index}"
     return result
 
 
 def _sanitize_identifier(name: str) -> str:
-    words = [part for part in re.split(r"[^0-9A-Za-z]+", name.strip()) if part]
+    words = [word for part in re.split(r"[^0-9A-Za-z]+", name.strip()) for word in _identifier_words(part)]
     if not words:
         result = "tool"
     else:
-        result = words[0].lower() + "".join(part[:1].upper() + part[1:] for part in words[1:])
+        result = "_".join(part.lower() for part in words)
     result = re.sub(r"\W", "_", result)
     if result[0].isdigit():
         result = f"_{result}"
@@ -670,6 +749,73 @@ def _sanitize_identifier(name: str) -> str:
     return result
 
 
+def _identifier_words(part: str) -> list[str]:
+    return re.findall(r"[A-Z]+(?=[A-Z][a-z]|\d|$)|[A-Z]?[a-z]+|\d+", part)
+
+
+def _input_default_suffix(schema: Any) -> str:
+    if not isinstance(schema, dict):
+        return " = None"
+    schema = _resolve_schema_ref(schema, schema)
+    if not _is_object_schema(schema):
+        return ""
+    required = schema.get("required")
+    if isinstance(required, list) and any(isinstance(item, str) for item in required):
+        return ""
+    return " | None = None"
+
+
+def _annotated_type(type_expr: str, schema: dict[str, Any] | None) -> str:
+    if schema is None:
+        return type_expr
+    constraints = _constraint_args(schema)
+    if not constraints:
+        return type_expr
+    return f"_t.Annotated[{type_expr}, Field({', '.join(constraints)})]"
+
+
+def _constraint_args(schema: dict[str, Any]) -> list[str]:
+    args: list[str] = []
+    for schema_key, field_key in (
+        ("minimum", "ge"),
+        ("maximum", "le"),
+        ("exclusiveMinimum", "gt"),
+        ("exclusiveMaximum", "lt"),
+        ("multipleOf", "multiple_of"),
+        ("minLength", "min_length"),
+        ("maxLength", "max_length"),
+        ("minItems", "min_length"),
+        ("maxItems", "max_length"),
+        ("minProperties", "min_length"),
+        ("maxProperties", "max_length"),
+        ("pattern", "pattern"),
+    ):
+        if schema_key in schema:
+            args.append(f"{field_key}={schema[schema_key]!r}")
+
+    json_schema_extra = {key: schema[key] for key in ("format", "uniqueItems") if key in schema}
+    if json_schema_extra:
+        args.append(f"json_schema_extra={json_schema_extra!r}")
+    return args
+
+
+def _schema_hash(schema: Any) -> str | None:
+    if schema is None:
+        return None
+    encoded = json.dumps(schema, sort_keys=True, separators=(",", ":"), default=str).encode("utf-8")
+    return hashlib.sha256(encoded).hexdigest()
+
+
+def _file_hash(path: str | Path | None) -> str | None:
+    if path is None:
+        return None
+    try:
+        data = Path(path).expanduser().read_bytes()
+    except OSError:
+        return None
+    return hashlib.sha256(data).hexdigest()
+
+
 def _class_name(func_name: str) -> str:
     parts = [part for part in re.split(r"[^0-9A-Za-z]+", str(func_name)) if part]
     result = "".join(part[:1].upper() + part[1:] for part in parts) or "Tool"

{mcp_as_code-0.1.5 → mcp_as_code-0.1.7}/src/maco/sandbox/providers/base.py

@@ -63,7 +63,6 @@ class BaseSandboxProvider:
             raise SandboxError("path must be relative and inside the sandbox scratch directory")
         return relative
 
-
 class RemoteSandboxProvider(BaseSandboxProvider):
     guest_workspace = SANDBOX_SDK_ROOT
     guest_scratch = "/workspace"

{mcp_as_code-0.1.5 → mcp_as_code-0.1.7}/src/maco/sandbox/providers/matchlock.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from importlib import import_module
 import shlex
 import sys
 from typing import Any
@@ -215,10 +216,10 @@ def _replace_url_host(url: str, host: str) -> str:
 
 def _load_matchlock_sdk() -> tuple[type[Any], type[Any], type[Any]]:
     try:
-        from matchlock import Client, Config, Sandbox
+        matchlock = import_module("matchlock")
     except ImportError as exc:  # pragma: no cover - depends on optional package availability
         raise SandboxError(
             "matchlock provider requires the Matchlock Python SDK; "
-            "install `maco-sandbox[matchlock]` or `matchlock`"
+            "install `mcp-as-code[matchlock]`"
         ) from exc
-    return Client, Config, Sandbox
+    return matchlock.Client, matchlock.Config, matchlock.Sandbox

{mcp_as_code-0.1.5 → mcp_as_code-0.1.7}/src/maco/serve_mcp.py

@@ -184,8 +184,8 @@ def serve_mcp(options: ServeMcpOptions) -> None:
         gateway = GatewayInfo(url=gateway_server.url, token=gateway_server.token)
         tools_by_server = fetch_gateway_tools(gateway.url, token=gateway.token)
         modules = sorted(server_module_names(tools_by_server.keys()).values())
-        if options.provider.replace("_", "-").lower() == "local":
-            _clean_local_sdk(workspace, clean=options.clean)
+        if normalized_provider == "local":
+            _clean_local_sdk(workspace)
             stats = generate_sandbox_sdk(tools_by_server, workspace=workspace, clean=False)
             print(_LOCAL_SDK_GENERATED_TEMPLATE.render(stats=stats).strip())
         context = SandboxContext(
@@ -389,9 +389,7 @@ def _guest_tools_root(provider: SandboxProvider) -> str:
     return f"{provider.guest_workspace.rstrip('/')}/tools"
 
 
-def _clean_local_sdk(workspace: Path, *, clean: bool) -> None:
-    if not clean:
-        return
+def _clean_local_sdk(workspace: Path) -> None:
     for path in [workspace / "tools", workspace / "manifest.json", workspace / "pyproject.toml"]:
         if path.is_dir():
             import shutil

{mcp_as_code-0.1.5 → mcp_as_code-0.1.7}/src/maco/templates/code_execute_description.j2

@@ -3,7 +3,14 @@ Run Python code in the sandbox. Use this for multi-step MCP work, loops, filteri
 For most tasks, pass only the code argument. If filename is omitted, maco writes the code to a deterministic content-addressed path like <hash>.py under the writable scratch directory. Use filename only when a readable traceback path or stable named script matters. Use args only when the script explicitly reads command-line arguments.
 
 Import generated tools with:
-  from tools.<server> import <tool>
+  import asyncio
+  from tools.<server> import <ToolInput>, <tool>
+  async def main():
+      result = await <tool>(<ToolInput>(<fields>))
+  asyncio.run(main())
+
+Independent tool calls can run concurrently:
+  result_a, result_b = await asyncio.gather(tool_a(input_a), tool_b(input_b))
 
 {% include "server_catalog.j2" %}
 

{mcp_as_code-0.1.5 → mcp_as_code-0.1.7}/src/maco/templates/codegen/client.py.j2

@@ -6,15 +6,16 @@ import json
 import os
 from pathlib import Path
 from typing import Any
-from urllib.error import HTTPError, URLError
-from urllib.request import Request, urlopen
+
+import httpx
+from pydantic import BaseModel, TypeAdapter
 
 
 _CURRENT_DIR = Path(__file__).resolve().parent
 _WORKSPACE_DIR = _CURRENT_DIR.parent
 
 
-def call_mcp_tool(
+async def _call_mcp_tool(
     server_name: str,
     tool_name: str,
     arguments: dict[str, Any] | None = None,
@@ -48,14 +49,16 @@ def call_mcp_tool(
     if token:
         headers["Authorization"] = f"Bearer {token}"
 
-    request = Request(url, data=payload, headers=headers, method="POST")
     try:
-        with urlopen(request, timeout=timeout) as response:
-            raw = response.read().decode("utf-8")
-    except HTTPError as exc:
-        detail = exc.read().decode("utf-8", errors="replace")
-        raise RuntimeError(f"MCP tool {server_name}.{tool_name} failed: HTTP {exc.code}: {detail}") from exc
-    except URLError as exc:
+        async with httpx.AsyncClient(timeout=timeout) as client:
+            response = await client.post(url, content=payload, headers=headers)
+            raw = response.text
+            response.raise_for_status()
+    except httpx.HTTPStatusError as exc:
+        raise RuntimeError(
+            f"MCP tool {server_name}.{tool_name} failed: HTTP {exc.response.status_code}: {exc.response.text}"
+        ) from exc
+    except httpx.RequestError as exc:
         raise RuntimeError(f"failed to connect to maco gateway at {url}: {exc}") from exc
 
     result = json.loads(raw)
@@ -101,3 +104,27 @@ def _content_text(result: dict[str, Any]) -> str:
         else:
             parts.append(str(block))
     return "".join(parts)
+
+
+async def call_mcp_tool(
+    server_name: str,
+    tool_name: str,
+    input_type: Any,
+    output_type: Any,
+    arguments: Any = None,
+) -> Any:
+    """Validate typed MCP arguments, call the tool, and validate the result."""
+
+    validated_input = TypeAdapter(input_type).validate_python({} if arguments is None else arguments)
+    result = await _call_mcp_tool(server_name, tool_name, _mcp_arguments(validated_input))
+    return TypeAdapter(output_type).validate_python(result)
+
+
+def _mcp_arguments(value: Any) -> dict[str, Any]:
+    if value is None:
+        return {}
+    if isinstance(value, BaseModel):
+        return value.model_dump(by_alias=True, exclude_none=True)
+    if isinstance(value, dict):
+        return value
+    raise TypeError(f"MCP tool arguments must validate to an object, got {type(value).__name__}")

{mcp_as_code-0.1.5 → mcp_as_code-0.1.7}/src/maco/templates/codegen/model.py.j2

@@ -1,5 +1,5 @@
 class {{ class_name }}(BaseModel):
-    model_config = ConfigDict(populate_by_name=True, extra='allow')
+    model_config = ConfigDict(populate_by_name=True, extra={{ extra_behavior | pyrepr }})
 
 {% for field in fields %}
     {{ field.name }}: {{ field.type_expr }} = {{ field.field_args }}

{mcp_as_code-0.1.5 → mcp_as_code-0.1.7}/src/maco/templates/codegen/pyproject.toml.j2

@@ -3,6 +3,6 @@ name = "maco-generated-workspace"
 version = "0.0.0"
 requires-python = ">=3.11"
 dependencies = [
+  "httpx>=0.28",
   "pydantic>=2.0",
 ]
-

mcp_as_code-0.1.7/src/maco/templates/codegen/server_init.py.j2

@@ -0,0 +1,12 @@
+# This file is automatically generated by maco. Do not edit.
+{% for export in exports %}
+from .{{ export.function }} import {{ export.function }}, {{ export.input_type }}, {{ export.output_type }}
+{% endfor %}
+
+__all__ = [
+{% for export in exports %}
+    {{ export.function | pyrepr }},
+    {{ export.input_type | pyrepr }},
+    {{ export.output_type | pyrepr }},
+{% endfor %}
+]

mcp_as_code-0.1.7/src/maco/templates/codegen/tool.py.j2

@@ -0,0 +1,21 @@
+# This file is automatically generated by maco. Do not edit.
+
+from __future__ import annotations
+
+import typing as _t
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from {{ client_module }} import call_mcp_tool
+
+
+{{ input_type_source }}
+
+
+{{ output_type_source }}
+
+
+async def {{ func_name }}(arguments: {{ input_type_expr }}{{ input_default_suffix }}) -> {{ output_type_expr }}:
+    """{{ docstring }}"""
+
+    return await call_mcp_tool({{ server_name | pyrepr }}, {{ tool_name | pyrepr }}, {{ input_type_expr }}, {{ output_type_expr }}, arguments)

{mcp_as_code-0.1.5 → mcp_as_code-0.1.7}/src/maco/templates/serve_mcp_instructions.j2

@@ -1,7 +1,13 @@
 Run shell and Python code in a sandbox with generated maco tools.
 
 Generated MCP tools are importable as:
-  from tools.<server> import <tool>
+  import asyncio
+  from tools.<server> import <ToolInput>, <tool>
+  async def main():
+      result = await <tool>(<ToolInput>(<fields>))
+  asyncio.run(main())
+
+Independent calls can run in parallel with asyncio.gather(call_a, call_b).
 
 {% include "server_catalog.j2" %}
 

mcp_as_code-0.1.5/src/maco/templates/codegen/root_model.py.j2

@@ -1,3 +0,0 @@
-class {{ class_name }}(RootModel[{{ type_expr }}]):
-    pass
-

mcp_as_code-0.1.5/src/maco/templates/codegen/server_init.py.j2

@@ -1,11 +0,0 @@
-# This file is automatically generated by maco. Do not edit.
-{% for name in exports %}
-from .{{ name }} import {{ name }}
-{% endfor %}
-
-__all__ = [
-{% for name in exports %}
-    {{ name | pyrepr }},
-{% endfor %}
-]
-

mcp_as_code-0.1.5/src/maco/templates/codegen/tool.py.j2

@@ -1,38 +0,0 @@
-# This file is automatically generated by maco. Do not edit.
-
-from __future__ import annotations
-
-import typing as _t
-
-from pydantic import BaseModel, ConfigDict, Field, RootModel
-
-from {{ client_module }} import call_mcp_tool
-
-
-SERVER_NAME = {{ server_name | pyrepr }}
-TOOL_NAME = {{ tool_name | pyrepr }}
-DESCRIPTION = {{ description | pyrepr }}
-
-
-{{ input_type_source }}
-
-
-{{ output_type_source }}
-
-
-def {{ func_name }}(arguments: {{ input_type_expr }} | dict[str, _t.Any] | None = None, **kwargs: _t.Any) -> {{ output_type_expr }}:
-    """{{ docstring }}"""
-
-    payload: dict[str, _t.Any] = {}
-    if arguments is not None:
-        if isinstance(arguments, BaseModel):
-            payload.update(arguments.model_dump(by_alias=True, exclude_none=True))
-        else:
-            payload.update(arguments)
-    payload.update(kwargs)
-{% if input_is_model %}
-    validated_input = {{ input_type_expr }}.model_validate(payload)
-    payload = validated_input.model_dump(by_alias=True, exclude_none=True)
-{% endif %}
-    result = call_mcp_tool(SERVER_NAME, TOOL_NAME, payload)
-    return {{ return_expr }}