swytchcode-runtime 1.1.1__tar.gz → 1.1.3__tar.gz

{swytchcode_runtime-1.1.1/swytchcode_runtime.egg-info → swytchcode_runtime-1.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swytchcode-runtime
-Version: 1.1.1
+Version: 1.1.3
 Summary: Thin runtime wrapper around the Swytchcode CLI
 Author: Swytchcode
 License: MIT
@@ -184,16 +184,13 @@ curl -fsSL https://cli.swytchcode.com/install.sh | sh
 # 2. Scaffold .swytchcode/ + tooling.json in your project
 swytchcode init
 
-# 3. Log in (opens a browser; creates your Swytchcode session)
-swytchcode login
-
-# 4. Fetch the GitHub integration
+# 3. Fetch the GitHub integration
 swytchcode get github
 
-# 5. Enable the "star a repo" tool - the trust boundary for what this project can call
-swytchcode add user.starred.update
+# 4. Enable the "star a repo" tool - the trust boundary for what this project can call
+swytchcode add method github.user.starred.update
 
-# 6. Connect your GitHub account (opens a browser for the OAuth flow)
+# 5. Connect your GitHub account (opens a browser for the OAuth flow)
 swytchcode auth connect github
 ```
 
@@ -234,17 +231,32 @@ def run_agent():
     # just describing what it would do
     system = f"You are a helpful assistant.\n\n{TOOL_USE_INSTRUCTIONS}"
 
-    response = client.messages.create(
-        model="claude-3-5-sonnet-latest",
-        max_tokens=1024,
-        system=system,
-        tools=tools,
-        messages=[{"role": "user", "content": "Star the swytchcodehq/swytchcode-examples repo on GitHub for me."}],
-    )
-
-    # 4. Run any tool calls Claude made and send the results back
-    results = swx.handle_tool_calls(response)
-    print(results)
+    messages = [{"role": "user", "content": "Star the swytchcodehq/swytchcode-examples repo on GitHub for me."}]
+
+    # 4. Loop until Claude stops requesting tool calls: run any tool calls
+    # Claude made and send the results back so it can keep working toward
+    # a final natural-language reply instead of stopping after one round
+    while True:
+        response = client.messages.create(
+            model="claude-sonnet-5",
+            max_tokens=1024,
+            system=system,
+            tools=tools,
+            messages=messages,
+        )
+        messages.append({"role": "assistant", "content": response.content})
+
+        if response.stop_reason == "max_tokens":
+            raise RuntimeError("Response truncated at max_tokens - increase the limit and retry")
+        if response.stop_reason != "tool_use":
+            break
+
+        tool_results = swx.handle_tool_calls(response)
+        messages.append({"role": "user", "content": tool_results})
+
+    for block in response.content:
+        if block.type == "text":
+            print(block.text)
 
 if __name__ == "__main__":
     run_agent()

{swytchcode_runtime-1.1.1 → swytchcode_runtime-1.1.3}/README.md

@@ -166,16 +166,13 @@ curl -fsSL https://cli.swytchcode.com/install.sh | sh
 # 2. Scaffold .swytchcode/ + tooling.json in your project
 swytchcode init
 
-# 3. Log in (opens a browser; creates your Swytchcode session)
-swytchcode login
-
-# 4. Fetch the GitHub integration
+# 3. Fetch the GitHub integration
 swytchcode get github
 
-# 5. Enable the "star a repo" tool - the trust boundary for what this project can call
-swytchcode add user.starred.update
+# 4. Enable the "star a repo" tool - the trust boundary for what this project can call
+swytchcode add method github.user.starred.update
 
-# 6. Connect your GitHub account (opens a browser for the OAuth flow)
+# 5. Connect your GitHub account (opens a browser for the OAuth flow)
 swytchcode auth connect github
 ```
 
@@ -216,17 +213,32 @@ def run_agent():
     # just describing what it would do
     system = f"You are a helpful assistant.\n\n{TOOL_USE_INSTRUCTIONS}"
 
-    response = client.messages.create(
-        model="claude-3-5-sonnet-latest",
-        max_tokens=1024,
-        system=system,
-        tools=tools,
-        messages=[{"role": "user", "content": "Star the swytchcodehq/swytchcode-examples repo on GitHub for me."}],
-    )
-
-    # 4. Run any tool calls Claude made and send the results back
-    results = swx.handle_tool_calls(response)
-    print(results)
+    messages = [{"role": "user", "content": "Star the swytchcodehq/swytchcode-examples repo on GitHub for me."}]
+
+    # 4. Loop until Claude stops requesting tool calls: run any tool calls
+    # Claude made and send the results back so it can keep working toward
+    # a final natural-language reply instead of stopping after one round
+    while True:
+        response = client.messages.create(
+            model="claude-sonnet-5",
+            max_tokens=1024,
+            system=system,
+            tools=tools,
+            messages=messages,
+        )
+        messages.append({"role": "assistant", "content": response.content})
+
+        if response.stop_reason == "max_tokens":
+            raise RuntimeError("Response truncated at max_tokens - increase the limit and retry")
+        if response.stop_reason != "tool_use":
+            break
+
+        tool_results = swx.handle_tool_calls(response)
+        messages.append({"role": "user", "content": tool_results})
+
+    for block in response.content:
+        if block.type == "text":
+            print(block.text)
 
 if __name__ == "__main__":
     run_agent()

{swytchcode_runtime-1.1.1 → swytchcode_runtime-1.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swytchcode-runtime"
-version = "1.1.1"
+version = "1.1.3"
 description = "Thin runtime wrapper around the Swytchcode CLI"
 readme = "README.md"
 license = { text = "MIT" }

{swytchcode_runtime-1.1.1 → swytchcode_runtime-1.1.3}/swytchcode_runtime/client.py

@@ -51,6 +51,29 @@ def _toolkit_matches(toolkit: str, integration: str) -> bool:
     return tk == project or tk == lib_slug or tk == prefix.lower()
 
 
+def _to_plain(obj: Any) -> Any:
+    """Recursively convert Pydantic models into plain JSON-serializable values.
+
+    LangGraph and CrewAI validate a tool call's arguments against the Pydantic
+    args_schema, so a nested-object field such as `body` reaches execute() as a
+    model instance rather than a dict. json.dumps can't serialize that, which is
+    what raised "Object of type <tool>Schema_body is not JSON serializable".
+    Flattening to dicts here also lets _strip_empty run over the body, which it
+    skips for anything that isn't a dict or list.
+    """
+    dump = getattr(obj, "model_dump", None)  # pydantic v2
+    if callable(dump):
+        return dump(mode="json")
+    legacy = getattr(obj, "dict", None)  # pydantic v1
+    if callable(legacy) and hasattr(obj, "__fields__"):
+        return _to_plain(legacy())
+    if isinstance(obj, dict):
+        return {k: _to_plain(v) for k, v in obj.items()}
+    if isinstance(obj, (list, tuple)):
+        return [_to_plain(v) for v in obj]
+    return obj
+
+
 def _strip_empty(obj: Any) -> Any:
     """Recursively drop keys whose value is None or an empty string ("").
 
@@ -126,7 +149,9 @@ class _Tools:
         return p.format_tools(neutral) if p else neutral
 
     def execute(self, canonical_id: str, args: dict, **options) -> Any:
-        final_args = dict(args)
+        # Flatten any Pydantic models (from agentic providers' arg validation)
+        # to plain values before routing/serialization.
+        final_args = _to_plain(dict(args))
 
         # If args are flat (no body/params top-level keys), wrap them in body
         # as expected by the Swytchcode CLI kernel (like in run-workflow.js)

swytchcode_runtime-1.1.3/swytchcode_runtime/schema.py

@@ -0,0 +1,212 @@
+"""Simplify a tool's input schema for the LLM: expose all fields, mark required ones."""
+
+from __future__ import annotations
+
+from typing import Any
+
+# Map wrekenfile/CLI type names onto JSON Schema types. Lowercase keys already in
+# JSON Schema form (e.g. "string", "integer") map to themselves so a nested
+# `schema` block from `swytchcode info` passes through unchanged.
+_TYPE_MAP = {
+    "int": "integer",
+    "integer": "integer",
+    "float": "number",
+    "number": "number",
+    "double": "number",
+    "bool": "boolean",
+    "boolean": "boolean",
+    "object": "object",
+    "any": "object",
+    "string": "string",
+    "array": "array",
+}
+
+
+def _json_type(raw: Any) -> str:
+    t = str(raw or "string").strip().lower()
+    if t.startswith("[]"):
+        return "array"
+    if t.startswith(("struct(", "map(")):
+        return "object"
+    return _TYPE_MAP.get(t, "string")
+
+
+def _is_valid_name(name: str) -> bool:
+    """Return True if name is a valid tool parameter identifier.
+
+    Anthropic and OpenAI require parameter names to match ^[a-zA-Z0-9_-]+$.
+    Google API schemas include system parameters like $.xgafv which cause
+    Anthropic API 400 Bad Request errors if included in tool schemas.
+    """
+    if not name or name.startswith("$"):
+        return False
+    return all(c.isalnum() or c in ("_", "-") for c in name)
+
+
+def _nested(spec: dict) -> dict | None:
+    """Locate the nested object schema on a field spec.
+
+    `swytchcode info` nests an object body's fields under a `schema` key
+    (``{"TYPE": "OBJECT", "schema": {"properties": {...}, "required": [...]}}``),
+    while a plain JSON Schema keeps `properties` inline. Handle both.
+    """
+    inner = spec.get("schema")
+    if isinstance(inner, dict) and isinstance(inner.get("properties"), dict):
+        return inner
+    if isinstance(spec.get("properties"), dict):
+        return spec
+    return None
+
+
+def _is_required(spec: dict) -> bool:
+    r = spec.get("required", spec.get("REQUIRED"))
+    return r is True or (isinstance(r, str) and r.strip().lower() == "true")
+
+
+def _expand(spec: Any) -> dict:
+    """Convert one field spec into a JSON Schema fragment, recursing into nested
+    object properties and array items so the model sees the full shape."""
+    if not isinstance(spec, dict):
+        return {"type": "string"}
+
+    t = _json_type(spec.get("TYPE", spec.get("type", "string")))
+    out: dict = {"type": t}
+
+    desc = spec.get("DESC", spec.get("description"))
+    if desc:
+        out["description"] = desc
+
+    if t == "object":
+        nested = _nested(spec)
+        if nested is not None:
+            props = nested["properties"]
+            out["properties"] = {
+                name: _expand(child)
+                for name, child in props.items()
+                if _is_valid_name(name)
+            }
+            explicit = nested.get("required")
+            required = list(explicit) if isinstance(explicit, list) else []
+            for name, child in props.items():
+                if (
+                    _is_valid_name(name)
+                    and isinstance(child, dict)
+                    and _is_required(child)
+                    and name not in required
+                ):
+                    required.append(name)
+            out["required"] = [name for name in required if name in out["properties"]]
+    elif t == "array":
+        items = spec.get("items")
+        if items is None and isinstance(spec.get("schema"), dict):
+            items = spec["schema"].get("items")
+        if isinstance(items, dict):
+            out["items"] = _expand(items)
+
+    return out
+
+
+def simplify(inputs: Any) -> dict:
+    # Handle Wrekenfile shape: a list of single-key dicts (e.g. [{"amount": {"TYPE": "INT"...}}])
+    if isinstance(inputs, list):
+        props = {}
+        required = []
+        for item in inputs:
+            if not isinstance(item, dict):
+                continue
+            for name, spec in item.items():
+                if not isinstance(spec, dict) or not _is_valid_name(name):
+                    continue
+
+                # Expand into full JSON Schema, keeping nested object/array shape
+                # (a body's fields live under spec["schema"] and were previously
+                # dropped, leaving the model blind to what to send).
+                props[name] = _expand(spec)
+
+                req = spec.get("REQUIRED", False)
+                loc = str(spec.get("LOCATION", spec.get("location", ""))).lower()
+                is_required = (
+                    loc == "path"
+                    or req is True
+                    or (isinstance(req, str) and req.strip().lower() == "true")
+                )
+                if is_required:
+                    required.append(name)
+
+        # rule: expose ALL fields to the model and list only the
+        # truly-required ones in `required`. A required-only approach hid optional
+        # fields - which left all-optional tools (e.g. Stripe) with an empty schema
+        # so the model called them with no arguments, and blinded the model to
+        # optional fields on tools that do have some required ones.
+        return {"type": "object", "properties": props, "required": required}
+
+    # Fallback to standard JSON Schema handling
+    if not isinstance(inputs, dict):
+        return {"type": "object", "properties": {}, "required": []}
+
+    props = inputs.get("properties") or {}
+    required = inputs.get("required") or []
+    keep = {}
+
+    # Expose all fields (same rule as the wrekenfile branch above); use the
+    # original required list only for the `required` key so optional/nested
+    # fields stay optional instead of being dropped or forced required.
+    for name, spec in props.items():
+        if not _is_valid_name(name):
+            continue
+        if isinstance(spec, dict):
+            loc = str(spec.get("LOCATION", spec.get("location", ""))).lower()
+            if loc == "path" and name not in required:
+                required.append(name)
+
+            if _json_type(spec.get("type", spec.get("TYPE"))) in ("object", "array"):
+                spec = _expand(spec)  # expand nested objects/arrays
+        keep[name] = spec
+
+    return {
+        "type": "object",
+        "properties": keep,
+        "required": [r for r in required if r in keep],
+    }
+
+
+def to_pydantic_model(schema: dict, name: str = "ArgsSchema") -> Any:
+    """Dynamically build a Pydantic model from a JSON schema for LangGraph args_schema."""
+    from pydantic import create_model
+
+    if not schema or "properties" not in schema:
+        return create_model(name)
+
+    fields = {}
+    properties = schema.get("properties", {})
+    required = set(schema.get("required", []))
+
+    for field_name, field_info in properties.items():
+        field_type = str
+        t = field_info.get("type")
+        if t == "integer":
+            field_type = int
+        elif t == "number":
+            field_type = float
+        elif t == "boolean":
+            field_type = bool
+        elif t == "array":
+            field_type = list
+        elif t == "object":
+            # Only build a nested model when the object's fields are known.
+            # A property-less object (freeform body) becomes a plain dict: an
+            # empty model would silently drop every value the agent passed and
+            # then fail to JSON-serialize.
+            if field_info.get("properties"):
+                field_type = to_pydantic_model(field_info, f"{name}_{field_name}")
+            else:
+                field_type = dict
+
+        if field_name in required:
+            fields[field_name] = (field_type, ...)
+        else:
+            # `X | None` so an explicit null is accepted (pydantic v2 rejects
+            # None for a bare non-optional annotation).
+            fields[field_name] = (field_type | None, None)
+
+    return create_model(name, **fields)

{swytchcode_runtime-1.1.1 → swytchcode_runtime-1.1.3/swytchcode_runtime.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swytchcode-runtime
-Version: 1.1.1
+Version: 1.1.3
 Summary: Thin runtime wrapper around the Swytchcode CLI
 Author: Swytchcode
 License: MIT
@@ -184,16 +184,13 @@ curl -fsSL https://cli.swytchcode.com/install.sh | sh
 # 2. Scaffold .swytchcode/ + tooling.json in your project
 swytchcode init
 
-# 3. Log in (opens a browser; creates your Swytchcode session)
-swytchcode login
-
-# 4. Fetch the GitHub integration
+# 3. Fetch the GitHub integration
 swytchcode get github
 
-# 5. Enable the "star a repo" tool - the trust boundary for what this project can call
-swytchcode add user.starred.update
+# 4. Enable the "star a repo" tool - the trust boundary for what this project can call
+swytchcode add method github.user.starred.update
 
-# 6. Connect your GitHub account (opens a browser for the OAuth flow)
+# 5. Connect your GitHub account (opens a browser for the OAuth flow)
 swytchcode auth connect github
 ```
 
@@ -234,17 +231,32 @@ def run_agent():
     # just describing what it would do
     system = f"You are a helpful assistant.\n\n{TOOL_USE_INSTRUCTIONS}"
 
-    response = client.messages.create(
-        model="claude-3-5-sonnet-latest",
-        max_tokens=1024,
-        system=system,
-        tools=tools,
-        messages=[{"role": "user", "content": "Star the swytchcodehq/swytchcode-examples repo on GitHub for me."}],
-    )
-
-    # 4. Run any tool calls Claude made and send the results back
-    results = swx.handle_tool_calls(response)
-    print(results)
+    messages = [{"role": "user", "content": "Star the swytchcodehq/swytchcode-examples repo on GitHub for me."}]
+
+    # 4. Loop until Claude stops requesting tool calls: run any tool calls
+    # Claude made and send the results back so it can keep working toward
+    # a final natural-language reply instead of stopping after one round
+    while True:
+        response = client.messages.create(
+            model="claude-sonnet-5",
+            max_tokens=1024,
+            system=system,
+            tools=tools,
+            messages=messages,
+        )
+        messages.append({"role": "assistant", "content": response.content})
+
+        if response.stop_reason == "max_tokens":
+            raise RuntimeError("Response truncated at max_tokens - increase the limit and retry")
+        if response.stop_reason != "tool_use":
+            break
+
+        tool_results = swx.handle_tool_calls(response)
+        messages.append({"role": "user", "content": tool_results})
+
+    for block in response.content:
+        if block.type == "text":
+            print(block.text)
 
 if __name__ == "__main__":
     run_agent()

{swytchcode_runtime-1.1.1 → swytchcode_runtime-1.1.3}/swytchcode_runtime.egg-info/SOURCES.txt

@@ -23,5 +23,6 @@ swytchcode_runtime/providers/openai_agents.py
 swytchcode_runtime/providers/vercel.py
 tests/test_alias.py
 tests/test_exec_errors.py
+tests/test_nested_body.py
 tests/test_prompts.py
 tests/test_schema_routing.py

{swytchcode_runtime-1.1.1 → swytchcode_runtime-1.1.3}/tests/test_alias.py

@@ -33,9 +33,12 @@ class TestAlias(unittest.TestCase):
         alias2 = _make_alias("a_b", taken)  # Collides on sanitize
 
         self.assertNotEqual(alias1, alias2)
-        
+
         import re
-        self.assertTrue(re.search(r"_[0-9a-f]{6}$", alias2) or re.search(r"_[0-9a-f]{6}$", alias1))
+
+        self.assertTrue(
+            re.search(r"_[0-9a-f]{6}$", alias2) or re.search(r"_[0-9a-f]{6}$", alias1)
+        )
 
 
 if __name__ == "__main__":

swytchcode_runtime-1.1.3/tests/test_nested_body.py

@@ -0,0 +1,203 @@
+import json
+import unittest
+
+from swytchcode_runtime import client as sc_client
+from swytchcode_runtime.client import _to_plain
+from swytchcode_runtime.schema import simplify, to_pydantic_model
+
+# The shape `swytchcode info` returns for a POST tool whose body is an object:
+# the body's fields live under spec["schema"], which simplify() used to drop.
+BODY_INPUTS = [
+    {"owner": {"LOCATION": "path", "TYPE": "STRING"}},
+    {
+        "body": {
+            "LOCATION": "body",
+            "TYPE": "OBJECT",
+            "schema": {
+                "properties": {
+                    "prompt": {"type": "string", "required": True},
+                    "create_pull_request": {"type": "boolean", "required": False},
+                },
+                "required": ["prompt"],
+            },
+        }
+    },
+]
+
+
+class TestNestedBodySchema(unittest.TestCase):
+    def test_object_body_expands_nested_properties(self):
+        body = simplify(BODY_INPUTS)["properties"]["body"]
+        self.assertEqual(body["type"], "object")
+        self.assertIn("prompt", body["properties"])
+        self.assertIn("create_pull_request", body["properties"])
+        self.assertEqual(body["properties"]["prompt"]["type"], "string")
+        self.assertEqual(body["properties"]["create_pull_request"]["type"], "boolean")
+        self.assertEqual(body["required"], ["prompt"])
+
+    def test_deeply_nested_object_expands(self):
+        inputs = [
+            {
+                "body": {
+                    "LOCATION": "body",
+                    "TYPE": "OBJECT",
+                    "schema": {
+                        "properties": {
+                            "start": {
+                                "type": "object",
+                                "schema": {
+                                    "properties": {
+                                        "dateTime": {"type": "string", "required": True}
+                                    }
+                                },
+                            }
+                        }
+                    },
+                }
+            }
+        ]
+        body = simplify(inputs)["properties"]["body"]
+        start = body["properties"]["start"]
+        self.assertEqual(start["type"], "object")
+        self.assertEqual(start["properties"]["dateTime"]["type"], "string")
+        self.assertEqual(start["required"], ["dateTime"])
+
+    def test_array_of_nested_objects_expands(self):
+        inputs = [
+            {
+                "body": {
+                    "LOCATION": "body",
+                    "TYPE": "OBJECT",
+                    "schema": {
+                        "properties": {
+                            "attendees": {
+                                "type": "array",
+                                "items": {
+                                    "type": "object",
+                                    "schema": {
+                                        "properties": {
+                                            "email": {
+                                                "type": "string",
+                                                "required": True,
+                                            }
+                                        }
+                                    },
+                                },
+                            }
+                        }
+                    },
+                }
+            }
+        ]
+        body = simplify(inputs)["properties"]["body"]
+        attendees = body["properties"]["attendees"]
+        self.assertEqual(attendees["type"], "array")
+        self.assertEqual(attendees["items"]["type"], "object")
+        self.assertEqual(attendees["items"]["properties"]["email"]["type"], "string")
+        self.assertEqual(attendees["items"]["required"], ["email"])
+
+    def test_freeform_object_has_no_properties(self):
+        body = simplify([{"body": {"LOCATION": "body", "TYPE": "OBJECT"}}])[
+            "properties"
+        ]["body"]
+        self.assertEqual(body, {"type": "object"})
+
+
+class TestPydanticModel(unittest.TestCase):
+    def test_object_with_properties_builds_nested_model(self):
+        model = to_pydantic_model(simplify(BODY_INPUTS), "T")
+        # body is optional, so its annotation is `NestedModel | None`; unwrap it.
+        nested = [
+            a for a in body_annotation_args(model, "body") if hasattr(a, "model_fields")
+        ]
+        self.assertTrue(nested, "body should be a nested model, not a bare type")
+        # The nested body must be a real model, not an empty one, so it can guide
+        # and validate the agent's arguments.
+        self.assertIn("prompt", nested[0].model_fields)
+
+    def test_property_less_object_maps_to_dict_not_empty_model(self):
+        schema = simplify([{"body": {"LOCATION": "body", "TYPE": "OBJECT"}}])
+        model = to_pydantic_model(schema, "T")
+        # Optional field annotation is `dict | None`; dict must be one of the args.
+        self.assertIn(dict, body_annotation_args(model, "body"))
+
+
+class TestToPlain(unittest.TestCase):
+    def test_converts_nested_pydantic_model_to_dict(self):
+        model_cls = to_pydantic_model(simplify(BODY_INPUTS), "T")
+        instance = model_cls(owner="acme", body={"prompt": "hi"})
+        plain = _to_plain({"body": instance.body})
+        self.assertIsInstance(plain["body"], dict)
+        self.assertEqual(plain["body"]["prompt"], "hi")
+
+
+class TestExecuteSerializesModels(unittest.TestCase):
+    """The regression guard for the reported crash: a Pydantic body must reach
+    the CLI as JSON-serializable data, with empty optionals stripped."""
+
+    def test_execute_serializes_pydantic_body(self):
+        captured = {}
+
+        def fake_exec(cid, input=None, **kwargs):
+            captured["stdin"] = json.dumps(input)  # same call exec_ makes
+            return {"ok": True}
+
+        original = sc_client._exec
+        sc_client._exec = fake_exec
+        try:
+            model_cls = to_pydantic_model(simplify(BODY_INPUTS), "T")
+            body = model_cls(owner="acme", body={"prompt": "hi"}).body
+            client = sc_client.Swytchcode()
+            result = client.tools.execute(
+                "github.agent.tasks.create",
+                {"owner": "acme", "body": body},
+                _raw_inputs=BODY_INPUTS,
+            )
+        finally:
+            sc_client._exec = original
+
+        self.assertEqual(result, {"ok": True})
+        sent = json.loads(captured["stdin"])
+        self.assertEqual(sent["body"]["prompt"], "hi")
+        # create_pull_request was None (unset) and must be stripped, not sent.
+        self.assertNotIn("create_pull_request", sent["body"])
+
+
+class TestSanitizeParameterNames(unittest.TestCase):
+    def test_strips_system_parameters_starting_with_dollar(self):
+        inputs = [
+            {"$.xgafv": {"LOCATION": "query", "TYPE": "STRING"}},
+            {"q": {"LOCATION": "query", "TYPE": "STRING"}},
+        ]
+        res = simplify(inputs)
+        self.assertNotIn("$.xgafv", res["properties"])
+        self.assertIn("q", res["properties"])
+
+    def test_strips_dollar_parameters_from_nested_objects(self):
+        inputs = [
+            {
+                "body": {
+                    "LOCATION": "body",
+                    "TYPE": "OBJECT",
+                    "schema": {
+                        "properties": {
+                            "valid": {"type": "string"},
+                            "$.xgafv": {"type": "string"},
+                        }
+                    },
+                }
+            }
+        ]
+        body = simplify(inputs)["properties"]["body"]
+        self.assertIn("valid", body["properties"])
+        self.assertNotIn("$.xgafv", body["properties"])
+
+
+def body_annotation_args(model, field):
+    import typing
+
+    return typing.get_args(model.model_fields[field].annotation)
+
+
+if __name__ == "__main__":
+    unittest.main()

{swytchcode_runtime-1.1.1 → swytchcode_runtime-1.1.3}/tests/test_prompts.py

@@ -8,7 +8,9 @@ class TestToolUseInstructions(unittest.TestCase):
     def test_is_exported_and_instructs_the_model_to_call_tools(self):
         self.assertIsInstance(TOOL_USE_INSTRUCTIONS, str)
         self.assertTrue(len(TOOL_USE_INSTRUCTIONS) > 0)
-        self.assertRegex(TOOL_USE_INSTRUCTIONS, re.compile("call the matching tool", re.I))
+        self.assertRegex(
+            TOOL_USE_INSTRUCTIONS, re.compile("call the matching tool", re.I)
+        )
 
     def test_scopes_itself_to_swytchcode_tools_only(self):
         self.assertRegex(

swytchcode_runtime-1.1.1/swytchcode_runtime/schema.py

@@ -1,114 +0,0 @@
-"""Simplify a tool's input schema for the LLM: expose all fields, mark required ones."""
-
-from __future__ import annotations
-
-from typing import Any
-
-
-def simplify(inputs: Any) -> dict:
-    # Handle Wrekenfile shape: a list of single-key dicts (e.g. [{"amount": {"TYPE": "INT"...}}])
-    if isinstance(inputs, list):
-        props = {}
-        required = []
-        for item in inputs:
-            if not isinstance(item, dict):
-                continue
-            for name, spec in item.items():
-                if not isinstance(spec, dict):
-                    continue
-
-                # Default to string if TYPE is missing
-                t = spec.get("TYPE", "STRING").lower()
-                if t == "int":
-                    t = "integer"
-                elif t in ("float", "number", "double"):
-                    t = "number"
-                elif t == "bool":
-                    t = "boolean"
-                elif t == "object" or t == "any":
-                    t = "object"
-                elif t.startswith("[]"):
-                    t = "array"
-                else:
-                    t = "string"
-
-                props[name] = {"type": t, "description": spec.get("DESC", "")}
-
-                req = spec.get("REQUIRED", False)
-                loc = str(spec.get("LOCATION", spec.get("location", ""))).lower()
-                is_required = (
-                    loc == "path"
-                    or req is True
-                    or (isinstance(req, str) and req.strip().lower() == "true")
-                )
-                if is_required:
-                    required.append(name)
-
-        # rule: expose ALL fields to the model and list only the
-        # truly-required ones in `required`. A required-only approach hid optional
-        # fields - which left all-optional tools (e.g. Stripe) with an empty schema
-        # so the model called them with no arguments, and blinded the model to
-        # optional fields on tools that do have some required ones.
-        return {"type": "object", "properties": props, "required": required}
-
-    # Fallback to standard JSON Schema handling
-    if not isinstance(inputs, dict):
-        return {"type": "object", "properties": {}, "required": []}
-
-    props = inputs.get("properties") or {}
-    required = inputs.get("required") or []
-    keep = {}
-
-    # Expose all fields (same rule as the wrekenfile branch above); use the
-    # original required list only for the `required` key so optional/nested
-    # fields stay optional instead of being dropped or forced required.
-    for name, spec in props.items():
-        if isinstance(spec, dict):
-            loc = str(spec.get("LOCATION", spec.get("location", ""))).lower()
-            if loc == "path" and name not in required:
-                required.append(name)
-
-            if spec.get("type") == "object" and "properties" in spec:
-                spec = simplify(spec)  # recurse into nested objects
-        keep[name] = spec
-
-    return {
-        "type": "object",
-        "properties": keep,
-        "required": [r for r in required if r in keep],
-    }
-
-
-def to_pydantic_model(schema: dict, name: str = "ArgsSchema") -> Any:
-    """Dynamically build a Pydantic model from a JSON schema for LangGraph args_schema."""
-    from pydantic import create_model
-
-    if not schema or "properties" not in schema:
-        return create_model(name)
-
-    fields = {}
-    properties = schema.get("properties", {})
-    required = set(schema.get("required", []))
-
-    for field_name, field_info in properties.items():
-        field_type = str
-        t = field_info.get("type")
-        if t == "integer":
-            field_type = int
-        elif t == "number":
-            field_type = float
-        elif t == "boolean":
-            field_type = bool
-        elif t == "array":
-            field_type = list
-        elif t == "object":
-            field_type = to_pydantic_model(field_info, f"{name}_{field_name}")
-
-        if field_name in required:
-            fields[field_name] = (field_type, ...)
-        else:
-            # `X | None` so an explicit null is accepted (pydantic v2 rejects
-            # None for a bare non-optional annotation).
-            fields[field_name] = (field_type | None, None)
-
-    return create_model(name, **fields)