askllm-cli 0.1.1__tar.gz → 0.1.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: askllm-cli
-Version: 0.1.1
+Version: 0.1.2
 Summary: Lightweight OpenAI-compatible terminal REPL
 Author: AskLLM
 License: MIT
@@ -201,11 +201,42 @@ Inside the REPL, type `/` to access built-in commands:
 
 ---
 
+## Declarative Web Request Tools
+
+Each `-w`/`--web-request` value creates a separate model tool. A request has a
+name, description, defaults, and `params`. Each parameter supplies the model
+facing name and description, a JSON Schema snippet, and a dotted (or JSON
+Pointer) path into `defaults` to replace:
+
+```json
+{
+  "name": "lookup",
+  "description": "Look up a value.",
+  "defaults": {
+    "uri": "https://example.test/lookup",
+    "query": {"page": 1},
+    "method": "GET"
+  },
+  "params": [
+    {
+      "name": "page",
+      "description": "Result page number.",
+      "schema": {"type": "integer", "minimum": 1},
+      "path": "query.page"
+    }
+  ]
+}
+```
+
+The tool exposed to the model contains only the declared parameters; request
+fields not declared in `params` remain fixed at their defaults. `-w` may be
+repeated, or its value may be a JSON array of request definitions.
+
 ## Command-Line Options
 
 ```
 usage: askllm [-h] [-v] [-m MODEL] [-e ENDPOINT] [-x] [-k API_KEY] [-s SYSTEM]
-              [-H HISTORY_FILE] [--api-mode {auto,chat,responses}]
+              [-H HISTORY_FILE] [-w JSON] [--api-mode {auto,chat,responses}]
 
 options:
   -h, --help            show this help message and exit
@@ -222,6 +253,8 @@ options:
                         System prompt (env: ASKLLM_SYSTEM_PROMPT, OPENAI_SYSTEM_PROMPT)
   -H HISTORY_FILE, --history-file HISTORY_FILE
                         Path to history file (env: ASKLLM_HISTORY_FILE, OPENAI_HISTORY_FILE, default: ~/.askllm_history)
+  -w JSON, --web-request JSON
+                        Expose a declarative web request tool; repeat the option or provide a JSON array
   --api-mode {auto,chat,responses}
                         API mode: auto (probe /v1/responses then fallback to /v1/chat/completions),
                         chat, or responses (env: ASKLLM_API_MODE, OPENAI_API_MODE, default: auto)

{askllm_cli-0.1.1 → askllm_cli-0.1.2}/README.md

@@ -174,11 +174,42 @@ Inside the REPL, type `/` to access built-in commands:
 
 ---
 
+## Declarative Web Request Tools
+
+Each `-w`/`--web-request` value creates a separate model tool. A request has a
+name, description, defaults, and `params`. Each parameter supplies the model
+facing name and description, a JSON Schema snippet, and a dotted (or JSON
+Pointer) path into `defaults` to replace:
+
+```json
+{
+  "name": "lookup",
+  "description": "Look up a value.",
+  "defaults": {
+    "uri": "https://example.test/lookup",
+    "query": {"page": 1},
+    "method": "GET"
+  },
+  "params": [
+    {
+      "name": "page",
+      "description": "Result page number.",
+      "schema": {"type": "integer", "minimum": 1},
+      "path": "query.page"
+    }
+  ]
+}
+```
+
+The tool exposed to the model contains only the declared parameters; request
+fields not declared in `params` remain fixed at their defaults. `-w` may be
+repeated, or its value may be a JSON array of request definitions.
+
 ## Command-Line Options
 
 ```
 usage: askllm [-h] [-v] [-m MODEL] [-e ENDPOINT] [-x] [-k API_KEY] [-s SYSTEM]
-              [-H HISTORY_FILE] [--api-mode {auto,chat,responses}]
+              [-H HISTORY_FILE] [-w JSON] [--api-mode {auto,chat,responses}]
 
 options:
   -h, --help            show this help message and exit
@@ -195,6 +226,8 @@ options:
                         System prompt (env: ASKLLM_SYSTEM_PROMPT, OPENAI_SYSTEM_PROMPT)
   -H HISTORY_FILE, --history-file HISTORY_FILE
                         Path to history file (env: ASKLLM_HISTORY_FILE, OPENAI_HISTORY_FILE, default: ~/.askllm_history)
+  -w JSON, --web-request JSON
+                        Expose a declarative web request tool; repeat the option or provide a JSON array
   --api-mode {auto,chat,responses}
                         API mode: auto (probe /v1/responses then fallback to /v1/chat/completions),
                         chat, or responses (env: ASKLLM_API_MODE, OPENAI_API_MODE, default: auto)

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "askllm-cli"
-version = "0.1.1"
+version = "0.1.2"
 description = "Lightweight OpenAI-compatible terminal REPL"
 readme = "README.md"
 requires-python = ">=3.8"

{askllm_cli-0.1.1 → askllm_cli-0.1.2}/src/askllm/__init__.py

@@ -3,7 +3,7 @@ AskLLM - A lightweight Python REPL for asking LLMs (OpenAI-compatible endpoints)
 Powered by prompt_toolkit for a modern, cross-platform interactive terminal UX.
 """
 
-__version__ = "0.1.1"
+__version__ = "0.1.2"
 
 from askllm.cli import LLMClient, REPL, main
 from askllm.executor import PythonExecutor, PYTHON_TOOL

{askllm_cli-0.1.1 → askllm_cli-0.1.2}/src/askllm/cli.py

@@ -20,11 +20,12 @@ from prompt_toolkit.history import FileHistory as _PTFileHistory, InMemoryHistor
 from prompt_toolkit.key_binding import KeyBindings
 
 from askllm.executor import PythonExecutor, PYTHON_TOOL, extract_code_from_args
+from askllm.web import make_tool, execute as execute_web_request, parse_specs
 
 try:
     from askllm import __version__
 except ImportError:
-    __version__ = "0.1.1"
+    __version__ = "0.1.2"
 
 # ANSI color codes
 COLOR_RESET = "\033[0m"
@@ -568,6 +569,7 @@ class REPL:
         code_execution: bool = False,
         history_file: Optional[str] = None,
         api_mode: str = "auto",
+        web_requests: Optional[List[Dict[str, Any]]] = None,
     ):
         self.api_key = api_key
         self.endpoint = endpoint
@@ -575,6 +577,7 @@ class REPL:
         self.system_prompt = system_prompt
         self.code_execution = code_execution
         self.api_mode = api_mode
+        self.web_requests = web_requests or []
         self.executor = PythonExecutor() if self.code_execution else None
         self.client = LLMClient(
             api_key=self.api_key,
@@ -812,8 +815,11 @@ class REPL:
             {"role": "user", "content": user_text}
         ]
 
-        tools = [PYTHON_TOOL] if (self.code_execution and self.executor) else None
-        max_tool_steps = 10
+        tools = [PYTHON_TOOL] if (self.code_execution and self.executor) else []
+        tools.extend(make_tool(spec) for spec in self.web_requests)
+        if not tools:
+            tools = None
+        max_tool_steps = 20
         step = 0
 
         try:
@@ -865,6 +871,16 @@ class REPL:
                     tc_id = tc.get("id") or f"call_{step}_{i}"
                     func_name = tc.get("function", {}).get("name", "run_python")
                     raw_args = tc.get("function", {}).get("arguments", "")
+                    if any(spec.get("name") == func_name for spec in self.web_requests):
+                        spec = next(spec for spec in self.web_requests if spec.get("name") == func_name)
+                        output = execute_web_request(spec, raw_args)
+                        sys.stdout.write(f"\n{COLOR_YELLOW}[Web Request: {func_name}]{COLOR_RESET}\n{output}\n\n")
+                        sys.stdout.flush()
+                        tool_msg = {"role": "tool", "tool_call_id": tc_id, "name": func_name, "content": output}
+                        messages.append(tool_msg)
+                        turn_messages.append(tool_msg)
+                        continue
+
                     code = extract_code_from_args(raw_args)
 
                     sys.stdout.write(f"\n{COLOR_YELLOW}[Python Execution]{COLOR_RESET}\n")
@@ -903,7 +919,9 @@ class REPL:
             print(f"{COLOR_RED}Unexpected error: {e}{COLOR_RESET}\n")
             return
         finally:
-            signal.signal(signal.SIGINT, orig_handler)
+            # signal.signal may return None under tests/non-main-thread contexts.
+            if orig_handler is not None:
+                signal.signal(signal.SIGINT, orig_handler)
 
         if not stop_event["stop"] and len(turn_messages) > 1:
             self.history.extend(turn_messages)
@@ -1044,7 +1062,16 @@ def parse_args(args=None):
         default=get_default_env(["ASKLLM_API_MODE", "OPENAI_API_MODE"], "auto"),
         help="API mode: auto (probe /v1/responses then fallback to /v1/chat/completions), chat, or responses (env: ASKLLM_API_MODE, OPENAI_API_MODE, default: auto)",
     )
-    return parser.parse_args(args)
+    parser.add_argument(
+        "-w", "--web-request", dest="web_requests", action="append", default=[], metavar="JSON",
+        help="Expose a declarative web request tool with named params; may be repeated or supplied as a JSON array",
+    )
+    parsed = parser.parse_args(args)
+    try:
+        parsed.web_requests = [spec for value in parsed.web_requests for spec in parse_specs(value)]
+    except (ValueError, json.JSONDecodeError) as exc:
+        parser.error(f"invalid --web-request JSON: {exc}")
+    return parsed
 
 
 def main(argv=None):
@@ -1057,6 +1084,7 @@ def main(argv=None):
         code_execution=args.code_execution,
         history_file=args.history_file,
         api_mode=args.api_mode,
+        web_requests=args.web_requests,
     )
     repl.run()
 

{askllm_cli-0.1.1 → askllm_cli-0.1.2}/src/askllm/executor.py

@@ -40,6 +40,7 @@ PYTHON_TOOL: Dict[str, Any] = {
         "name": "run_python",
         "description": (
             "Execute Python code in a stateful, persistent REPL session. "
+            "Variables persist, be careful with memory management. "
             "Output from print() and any errors/tracebacks are captured and returned. "
             "Use print() to inspect variables or output results."
         ),

askllm_cli-0.1.2/src/askllm/web.py

@@ -0,0 +1,256 @@
+"""Safe, declarative HTTP request tools exposed to the model."""
+import fnmatch
+import json
+import copy
+import urllib.parse
+import urllib.request
+from typing import Any, Dict, List
+
+
+def _paths(value, prefix=""):
+    if isinstance(value, dict):
+        for k, v in value.items():
+            path = f"{prefix}.{k}" if prefix else k
+            yield path
+            yield from _paths(v, path)
+
+
+def _allowed(path: str, policy: Any) -> bool:
+    """Policy is data: allow/deny glob patterns over replacement paths."""
+    if policy is None:
+        return False
+    if isinstance(policy, list):
+        allow, deny = policy, []
+    elif isinstance(policy, dict):
+        allow = policy.get("allow", policy.get("replace", []))
+        deny = policy.get("deny", [])
+    else:
+        return False
+    if allow is True:
+        allow = ["*"]
+    if isinstance(allow, str): allow = [allow]
+    if isinstance(deny, str): deny = [deny]
+    if any(fnmatch.fnmatchcase(path, str(p)) for p in (deny or [])):
+        return False
+    return any(fnmatch.fnmatchcase(path, str(p)) for p in (allow or []))
+
+
+def _merge(default: Any, replacement: Any, path: str, policy: Any) -> Any:
+    """Apply a replacement while preserving fields not permitted by *policy*.
+
+    Policies are structural glob rules, rather than HTTP/security switches.  A
+    rule such as ``query.user_id`` permits only that value; ``body.*`` permits
+    direct body fields; and ``headers`` permits replacing the complete header
+    list.  An exact/parent match permits replacing the complete value.
+    """
+    if _allowed(path, policy):
+        return replacement
+    if isinstance(default, dict) and isinstance(replacement, dict):
+        result = dict(default)
+        for key, value in replacement.items():
+            child = f"{path}.{key}" if path else str(key)
+            if key in default:
+                result[key] = _merge(default[key], value, child, policy)
+            elif _allowed(child, policy):
+                result[key] = value
+        return result
+    # Lists are intentionally atomic unless their parent path is allowed.  It
+    # avoids surprising partial mutations of headers and array-valued params.
+    return default
+
+
+def _schema(value: Any) -> Dict[str, Any]:
+    """Return a JSON-schema object from a schema snippet."""
+    if isinstance(value, dict):
+        return value
+    if isinstance(value, str):
+        parsed = json.loads(value)
+        if isinstance(parsed, dict):
+            return parsed
+    raise ValueError("parameter schema must be a JSON schema object")
+
+
+def _path_parts(path: str) -> List[str]:
+    """Accept the dotted paths used by the CLI and JSON Pointer paths."""
+    if path.startswith("/"):
+        return [p.replace("~1", "/").replace("~0", "~") for p in path[1:].split("/")]
+    if path.startswith("$."):
+        path = path[2:]
+    elif path == "$":
+        return []
+    return [part for part in path.split(".") if part]
+
+
+def _replace_path(value: Any, path: str, replacement: Any) -> Any:
+    parts = _path_parts(path)
+    if not parts:
+        return replacement
+    result = copy.deepcopy(value)
+    if not isinstance(result, (dict, list)):
+        raise ValueError(f"cannot replace path {path!r}")
+    cursor = result
+    for part in parts[:-1]:
+        if isinstance(cursor, dict):
+            if part not in cursor:
+                cursor[part] = {}
+            cursor = cursor[part]
+        elif isinstance(cursor, list) and part.isdigit():
+            cursor = cursor[int(part)]
+        else:
+            raise ValueError(f"path does not exist: {path}")
+    leaf = parts[-1]
+    if isinstance(cursor, dict):
+        cursor[leaf] = replacement
+    elif isinstance(cursor, list) and leaf.isdigit():
+        cursor[int(leaf)] = replacement
+    else:
+        raise ValueError(f"path does not exist: {path}")
+    return result
+
+
+def _params(spec: Dict[str, Any]) -> List[Dict[str, Any]]:
+    params = spec.get("params")
+    if params is None:
+        return []
+    if not isinstance(params, list):
+        raise ValueError("params must be an array")
+    # Accept both concise names and the explicit names used by configuration
+    # files. Internally all parameters use schema/path.
+    normalized = []
+    for param in params:
+        if not isinstance(param, dict):
+            normalized.append(param)
+            continue
+        item = dict(param)
+        if "schema" not in item and "json_schema" in item:
+            item["schema"] = item["json_schema"]
+        if "path" not in item and "json_path" in item:
+            item["path"] = item["json_path"]
+        normalized.append(item)
+    return normalized
+
+
+def make_tool(spec: Dict[str, Any]) -> Dict[str, Any]:
+    properties: Dict[str, Any] = {}
+    required: List[str] = []
+    params = _params(spec)
+    if params:
+        for param in params:
+            schema = dict(_schema(param["schema"]))
+            schema.setdefault("description", param["description"])
+            properties[param["name"]] = schema
+            if param.get("required", False):
+                required.append(param["name"])
+    else:
+        # Compatibility with the original format. New specs should use params.
+        properties = {
+            "uri": {"type": "string", "description": "Replacement request URI."},
+            "query": {"type": "object", "additionalProperties": True},
+            "body": {"type": "object", "additionalProperties": True},
+            "headers": {"type": "array", "items": {"type": "array", "minItems": 2, "maxItems": 2}},
+            "method": {"type": "string"},
+        }
+    parameters = {"type": "object", "properties": properties, "additionalProperties": False}
+    if required:
+        parameters["required"] = required
+    return {"type": "function", "function": {
+        "name": spec["name"], "description": spec["description"], "parameters": parameters
+    }}
+
+
+def execute(spec: Dict[str, Any], raw_args: str) -> str:
+    try:
+        args = json.loads(raw_args) if raw_args else {}
+        if not isinstance(args, dict): raise ValueError("arguments must be a JSON object")
+    except Exception as e:
+        return json.dumps({"error": f"invalid arguments: {e}"})
+    defaults = spec["defaults"]
+    params = _params(spec)
+    if params:
+        request = copy.deepcopy(defaults)
+        by_name = {param["name"]: param for param in params}
+        for key, value in args.items():
+            if key in by_name:
+                param = by_name[key]
+                request = _replace_path(request, param["path"], value)
+    else:
+        policy = spec.get("policy", {})
+        allowed_keys = ("uri", "query", "body", "headers", "method")
+        request = dict(defaults)
+        for key, value in args.items():
+            if key in allowed_keys:
+                request[key] = _merge(defaults.get(key), value, key, policy)
+    uri = request.get("uri")
+    if not isinstance(uri, str) or not uri:
+        return json.dumps({"error": "defaults.uri must be a non-empty string"})
+    query = request.get("query") or {}
+    if isinstance(query, dict):
+        query_text = urllib.parse.urlencode(query, doseq=True)
+    else:
+        query_text = str(query)
+    if query_text:
+        uri += ("&" if "?" in uri else "?") + query_text
+    body = request.get("body") or {}
+    body_type = body.get("type", "raw") if isinstance(body, dict) else "raw"
+    body_value = body.get("value", "") if isinstance(body, dict) else body
+    if body_type == "json":
+        data = json.dumps(body_value).encode()
+    elif body_type == "form":
+        data = urllib.parse.urlencode(body_value or {}, doseq=True).encode()
+    elif body_type == "raw":
+        data = str(body_value).encode()
+    else:
+        return json.dumps({"error": "body.type must be form, json, or raw"})
+    headers = {}
+    for pair in request.get("headers", []) or []:
+        if isinstance(pair, (list, tuple)) and len(pair) == 2:
+            headers[str(pair[0])] = str(pair[1])
+    if data and body_type == "json" and not any(k.lower() == "content-type" for k in headers):
+        headers["Content-Type"] = "application/json"
+    elif data and body_type == "form" and not any(k.lower() == "content-type" for k in headers):
+        headers["Content-Type"] = "application/x-www-form-urlencoded"
+    req = urllib.request.Request(uri, data=data if data else None,
+                                  headers=headers, method=str(request.get("method", "GET")).upper())
+    try:
+        with urllib.request.urlopen(req, timeout=60) as response:
+            result = {"status": response.status, "headers": dict(response.headers),
+                      "body": response.read().decode("utf-8", "replace")}
+    except Exception as e:
+        result = {"error": str(e)}
+    return json.dumps(result, ensure_ascii=False)
+
+
+def parse_specs(value: str) -> List[Dict[str, Any]]:
+    parsed = json.loads(value)
+    items = parsed if isinstance(parsed, list) else [parsed]
+    for spec in items:
+        if not isinstance(spec, dict) or not all(k in spec for k in ("name", "description", "defaults")):
+            raise ValueError("each web request must contain name, description, and defaults")
+        if "params" not in spec and "policy" not in spec:
+            raise ValueError("each web request must contain params")
+        if "params" in spec:
+            if not isinstance(spec["params"], list):
+                raise ValueError("params must be an array")
+            seen = set()
+            for param in _params(spec):
+                if (not isinstance(param, dict) or
+                        not all(k in param for k in ("name", "description", "schema", "path"))):
+                    raise ValueError("each param must contain name, description, schema, and path (or json_schema and json_path)")
+                if not isinstance(param["name"], str) or not param["name"] or param["name"] in seen:
+                    raise ValueError("parameter names must be unique, non-empty strings")
+                seen.add(param["name"])
+                _schema(param["schema"])
+                if not isinstance(param["path"], str) or not param["path"]:
+                    raise ValueError("parameter path must be a non-empty string")
+        if not isinstance(spec["name"], str) or not spec["name"]:
+            raise ValueError("web request name must be a non-empty string")
+        if not isinstance(spec["defaults"], dict):
+            raise ValueError("defaults must be an object")
+        defaults = spec["defaults"]
+        if "uri" not in defaults or not isinstance(defaults["uri"], str) or not defaults["uri"]:
+            raise ValueError("defaults.uri must be a non-empty string")
+        if "body" in defaults:
+            body = defaults["body"]
+            if not isinstance(body, dict) or body.get("type", "raw") not in ("form", "json", "raw"):
+                raise ValueError("defaults.body.type must be form, json, or raw")
+    return items

{askllm_cli-0.1.1 → askllm_cli-0.1.2}/src/askllm_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: askllm-cli
-Version: 0.1.1
+Version: 0.1.2
 Summary: Lightweight OpenAI-compatible terminal REPL
 Author: AskLLM
 License: MIT
@@ -201,11 +201,42 @@ Inside the REPL, type `/` to access built-in commands:
 
 ---
 
+## Declarative Web Request Tools
+
+Each `-w`/`--web-request` value creates a separate model tool. A request has a
+name, description, defaults, and `params`. Each parameter supplies the model
+facing name and description, a JSON Schema snippet, and a dotted (or JSON
+Pointer) path into `defaults` to replace:
+
+```json
+{
+  "name": "lookup",
+  "description": "Look up a value.",
+  "defaults": {
+    "uri": "https://example.test/lookup",
+    "query": {"page": 1},
+    "method": "GET"
+  },
+  "params": [
+    {
+      "name": "page",
+      "description": "Result page number.",
+      "schema": {"type": "integer", "minimum": 1},
+      "path": "query.page"
+    }
+  ]
+}
+```
+
+The tool exposed to the model contains only the declared parameters; request
+fields not declared in `params` remain fixed at their defaults. `-w` may be
+repeated, or its value may be a JSON array of request definitions.
+
 ## Command-Line Options
 
 ```
 usage: askllm [-h] [-v] [-m MODEL] [-e ENDPOINT] [-x] [-k API_KEY] [-s SYSTEM]
-              [-H HISTORY_FILE] [--api-mode {auto,chat,responses}]
+              [-H HISTORY_FILE] [-w JSON] [--api-mode {auto,chat,responses}]
 
 options:
   -h, --help            show this help message and exit
@@ -222,6 +253,8 @@ options:
                         System prompt (env: ASKLLM_SYSTEM_PROMPT, OPENAI_SYSTEM_PROMPT)
   -H HISTORY_FILE, --history-file HISTORY_FILE
                         Path to history file (env: ASKLLM_HISTORY_FILE, OPENAI_HISTORY_FILE, default: ~/.askllm_history)
+  -w JSON, --web-request JSON
+                        Expose a declarative web request tool; repeat the option or provide a JSON array
   --api-mode {auto,chat,responses}
                         API mode: auto (probe /v1/responses then fallback to /v1/chat/completions),
                         chat, or responses (env: ASKLLM_API_MODE, OPENAI_API_MODE, default: auto)

{askllm_cli-0.1.1 → askllm_cli-0.1.2}/src/askllm_cli.egg-info/SOURCES.txt

@@ -4,10 +4,12 @@ src/askllm/__init__.py
 src/askllm/__main__.py
 src/askllm/cli.py
 src/askllm/executor.py
+src/askllm/web.py
 src/askllm_cli.egg-info/PKG-INFO
 src/askllm_cli.egg-info/SOURCES.txt
 src/askllm_cli.egg-info/dependency_links.txt
 src/askllm_cli.egg-info/entry_points.txt
 src/askllm_cli.egg-info/requires.txt
 src/askllm_cli.egg-info/top_level.txt
-tests/test_askllm.py
+tests/test_askllm.py
+tests/test_web.py

askllm_cli-0.1.2/tests/test_web.py

@@ -0,0 +1,82 @@
+import io
+import json
+import unittest
+from unittest.mock import patch
+
+from askllm.web import execute, make_tool, parse_specs
+from askllm.cli import parse_args
+
+
+class TestWebRequests(unittest.TestCase):
+    def setUp(self):
+        self.spec = {
+            "name": "lookup",
+            "description": "Look up a value.",
+            "defaults": {
+                "uri": "https://example.test/lookup",
+                "query": {"fixed": "yes", "page": 1},
+                "body": {"type": "json", "value": {"url": "https://default.test"}},
+                "headers": [["X-Default", "yes"]],
+                "method": "POST",
+            },
+            "policy": {"allow": ["query.page", "body.value.url"]},
+        }
+
+    def test_parse_single_and_array_specs(self):
+        value = json.dumps([self.spec, {**self.spec, "name": "other"}])
+        specs = parse_specs(value)
+        self.assertEqual([s["name"] for s in specs], ["lookup", "other"])
+
+    def test_parse_rejects_invalid_body_type(self):
+        bad = {**self.spec, "defaults": {**self.spec["defaults"],
+              "body": {"type": "xml", "value": "x"}}}
+        with self.assertRaises(ValueError):
+            parse_specs(json.dumps(bad))
+
+    def test_tool_schema(self):
+        tool = make_tool(self.spec)
+        self.assertEqual(tool["function"]["name"], "lookup")
+        self.assertEqual(tool["function"]["parameters"]["type"], "object")
+        self.assertIn("uri", tool["function"]["parameters"]["properties"])
+
+    def test_execute_applies_structural_policy(self):
+        response = io.BytesIO(b'{"ok":true}')
+        response.status = 200
+        response.headers = {"Content-Type": "application/json"}
+        captured = {}
+
+        def urlopen(request, timeout=60):
+            captured["request"] = request
+            return response
+
+        args = json.dumps({
+            "query": {"page": 3, "fixed": "changed"},
+            "body": {"value": {"url": "https://changed.test", "extra": "ignored"}},
+            "headers": [["X-Evil", "changed"]],
+            "method": "GET",
+        })
+        with patch("urllib.request.urlopen", side_effect=urlopen):
+            result = json.loads(execute(self.spec, args))
+
+        request = captured["request"]
+        self.assertEqual(result["status"], 200)
+        self.assertEqual(request.method, "POST")
+        self.assertIn("fixed=yes", request.full_url)
+        self.assertIn("page=3", request.full_url)
+        self.assertNotIn("changed", request.full_url)
+        self.assertEqual(json.loads(request.data.decode())["url"], "https://changed.test")
+        self.assertEqual(request.get_header("X-default"), "yes")
+
+    def test_execute_invalid_arguments(self):
+        result = json.loads(execute(self.spec, "[]"))
+        self.assertIn("error", result)
+
+    def test_parse_args_repeated_web_request(self):
+        one = json.dumps(self.spec)
+        two = json.dumps({**self.spec, "name": "second"})
+        args = parse_args(["-w", one, "--web-request", two])
+        self.assertEqual([s["name"] for s in args.web_requests], ["lookup", "second"])
+
+
+if __name__ == "__main__":
+    unittest.main()