agent-json-reliability 0.1.0__tar.gz

agent_json_reliability-0.1.0/LICENSE

@@ -0,0 +1,5 @@
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND.

agent_json_reliability-0.1.0/PKG-INFO

@@ -0,0 +1,128 @@
+Metadata-Version: 2.4
+Name: agent-json-reliability
+Version: 0.1.0
+Summary: Deterministic JSON repair and JSON Schema validation for AI agents and software. No LLM required.
+Author: Agent JSON Reliability contributors
+License: MIT
+Project-URL: Homepage, https://github.com/toninovo4249-ai/agent-json-reliability
+Keywords: json,json-schema,json-repair,ai-agents,mcp,structured-output
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: uvicorn>=0.30.0
+Requires-Dist: jsonschema>=4.23.0
+Dynamic: license-file
+
+# Agent JSON Reliability
+
+STATUS=BETA version `0.1.0`
+
+AI agents and software frequently emit malformed JSON: markdown fences, trailing commas, single quotes, `True`/`False`/`None`, and extra prose around one object.
+
+**Agent JSON Reliability** is a deterministic pipeline for that failure mode:
+
+1. **inspect** — diagnose whether the text is JSON and which failures are present
+2. **safe repair** — apply only structural, unambiguous fixes
+3. **validate** — optional JSON Schema check on the result
+4. **structured diagnostics** — `valid_original`, `repaired`, `valid_final`, `schema_valid`, `unsafe_or_ambiguous`, `changes`, `errors`
+
+This is not a generic jsonschema wrapper. The primary value is turning **malformed agent output** into reliable structured data **without an LLM** and **without inventing semantic values**.
+
+When repair would require guessing (truncated objects, missing values, competing JSON documents), the service **refuses**. That is correct behavior.
+
+Primary HTTP endpoint: `POST /v1/json/reliable`
+
+MCP tools (same core functions, no duplicate implementation): `json_reliable` / `reliable_json`, `validate_json`, `repair_json`, `inspect_json`
+
+<!-- mcp-name: io.github.toninovo4249-ai/agent-json-reliability -->
+
+## Before / after (safe repair)
+
+Malformed agent output:
+
+```json
+{
+  "text": "```json\n{\"name\":\"alice\",\"age\":30,}\n```"
+}
+```
+
+Expected result (semantically equivalent valid JSON):
+
+- `valid_original=false`
+- `repaired=true`
+- `valid_final=true`
+- `unsafe_or_ambiguous=false`
+- `json` → `{"name":"alice","age":30}`
+
+If a schema is supplied and satisfied: `schema_valid=true`.
+
+## Safe refusal (ambiguous)
+
+Truncated input such as `{"user":` is JSON-intended but not deterministically repairable without inventing keys or values.
+
+Expected:
+
+- HTTP `200` (documented safe response)
+- `valid_final=false`
+- `unsafe_or_ambiguous=true` **or** `repaired=false`
+
+Do not treat a correct refusal as a product failure.
+
+## Run locally (no Hunter)
+
+```bash
+python -m pip install -r requirements.txt
+python serve.py
+```
+
+Binds `127.0.0.1:8770` by default. Set `PUBLIC_BASE_URL` to an HTTPS origin only when you expose the process yourself. Do not commit a temporary tunnel hostname as the canonical URL.
+
+## HTTP examples
+
+See `examples/curl.md`, `examples/python.py`, `examples/javascript.js`.
+
+Remote examples use `${PUBLIC_BASE_URL}`. Local default is `http://127.0.0.1:8770`.
+
+Share URLs (optional, unverified telemetry tags):
+
+- `/?source=github`
+- `/?source=mcp-registry`
+- `/?source=api-directory`
+
+## MCP (stdio — durable)
+
+Package transport does not depend on a temporary public URL.
+
+```json
+{
+  "mcpServers": {
+    "agent-json-reliability": {
+      "command": "python",
+      "args": ["-m", "products.gateway.mcp_stdio"]
+    }
+  }
+}
+```
+
+After you publish to PyPI (free): `uvx agent-json-reliability`.
+
+Remote HTTP MCP (`POST /mcp`) is for a running instance. Prefer stdio/package for Official MCP Registry metadata.
+
+## Machine discovery
+
+- `GET /.well-known/agent-services.json`
+- `GET /openapi.json`
+- `GET /llms.txt`
+- `GET /AGENTS.md`
+- `POST /mcp` JSON-RPC (`tools/list`, `tools/call`)
+
+## What this package does not include
+
+No Hunter market database, no private reports, no Windows user paths, no collectors, no wallets, no x402 payment.
+
+Free beta: no auth, no payment.

agent_json_reliability-0.1.0/README.md

@@ -0,0 +1,108 @@
+# Agent JSON Reliability
+
+STATUS=BETA version `0.1.0`
+
+AI agents and software frequently emit malformed JSON: markdown fences, trailing commas, single quotes, `True`/`False`/`None`, and extra prose around one object.
+
+**Agent JSON Reliability** is a deterministic pipeline for that failure mode:
+
+1. **inspect** — diagnose whether the text is JSON and which failures are present
+2. **safe repair** — apply only structural, unambiguous fixes
+3. **validate** — optional JSON Schema check on the result
+4. **structured diagnostics** — `valid_original`, `repaired`, `valid_final`, `schema_valid`, `unsafe_or_ambiguous`, `changes`, `errors`
+
+This is not a generic jsonschema wrapper. The primary value is turning **malformed agent output** into reliable structured data **without an LLM** and **without inventing semantic values**.
+
+When repair would require guessing (truncated objects, missing values, competing JSON documents), the service **refuses**. That is correct behavior.
+
+Primary HTTP endpoint: `POST /v1/json/reliable`
+
+MCP tools (same core functions, no duplicate implementation): `json_reliable` / `reliable_json`, `validate_json`, `repair_json`, `inspect_json`
+
+<!-- mcp-name: io.github.toninovo4249-ai/agent-json-reliability -->
+
+## Before / after (safe repair)
+
+Malformed agent output:
+
+```json
+{
+  "text": "```json\n{\"name\":\"alice\",\"age\":30,}\n```"
+}
+```
+
+Expected result (semantically equivalent valid JSON):
+
+- `valid_original=false`
+- `repaired=true`
+- `valid_final=true`
+- `unsafe_or_ambiguous=false`
+- `json` → `{"name":"alice","age":30}`
+
+If a schema is supplied and satisfied: `schema_valid=true`.
+
+## Safe refusal (ambiguous)
+
+Truncated input such as `{"user":` is JSON-intended but not deterministically repairable without inventing keys or values.
+
+Expected:
+
+- HTTP `200` (documented safe response)
+- `valid_final=false`
+- `unsafe_or_ambiguous=true` **or** `repaired=false`
+
+Do not treat a correct refusal as a product failure.
+
+## Run locally (no Hunter)
+
+```bash
+python -m pip install -r requirements.txt
+python serve.py
+```
+
+Binds `127.0.0.1:8770` by default. Set `PUBLIC_BASE_URL` to an HTTPS origin only when you expose the process yourself. Do not commit a temporary tunnel hostname as the canonical URL.
+
+## HTTP examples
+
+See `examples/curl.md`, `examples/python.py`, `examples/javascript.js`.
+
+Remote examples use `${PUBLIC_BASE_URL}`. Local default is `http://127.0.0.1:8770`.
+
+Share URLs (optional, unverified telemetry tags):
+
+- `/?source=github`
+- `/?source=mcp-registry`
+- `/?source=api-directory`
+
+## MCP (stdio — durable)
+
+Package transport does not depend on a temporary public URL.
+
+```json
+{
+  "mcpServers": {
+    "agent-json-reliability": {
+      "command": "python",
+      "args": ["-m", "products.gateway.mcp_stdio"]
+    }
+  }
+}
+```
+
+After you publish to PyPI (free): `uvx agent-json-reliability`.
+
+Remote HTTP MCP (`POST /mcp`) is for a running instance. Prefer stdio/package for Official MCP Registry metadata.
+
+## Machine discovery
+
+- `GET /.well-known/agent-services.json`
+- `GET /openapi.json`
+- `GET /llms.txt`
+- `GET /AGENTS.md`
+- `POST /mcp` JSON-RPC (`tools/list`, `tools/call`)
+
+## What this package does not include
+
+No Hunter market database, no private reports, no Windows user paths, no collectors, no wallets, no x402 payment.
+
+Free beta: no auth, no payment.

agent_json_reliability-0.1.0/agent_json_reliability.egg-info/PKG-INFO

@@ -0,0 +1,128 @@
+Metadata-Version: 2.4
+Name: agent-json-reliability
+Version: 0.1.0
+Summary: Deterministic JSON repair and JSON Schema validation for AI agents and software. No LLM required.
+Author: Agent JSON Reliability contributors
+License: MIT
+Project-URL: Homepage, https://github.com/toninovo4249-ai/agent-json-reliability
+Keywords: json,json-schema,json-repair,ai-agents,mcp,structured-output
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: uvicorn>=0.30.0
+Requires-Dist: jsonschema>=4.23.0
+Dynamic: license-file
+
+# Agent JSON Reliability
+
+STATUS=BETA version `0.1.0`
+
+AI agents and software frequently emit malformed JSON: markdown fences, trailing commas, single quotes, `True`/`False`/`None`, and extra prose around one object.
+
+**Agent JSON Reliability** is a deterministic pipeline for that failure mode:
+
+1. **inspect** — diagnose whether the text is JSON and which failures are present
+2. **safe repair** — apply only structural, unambiguous fixes
+3. **validate** — optional JSON Schema check on the result
+4. **structured diagnostics** — `valid_original`, `repaired`, `valid_final`, `schema_valid`, `unsafe_or_ambiguous`, `changes`, `errors`
+
+This is not a generic jsonschema wrapper. The primary value is turning **malformed agent output** into reliable structured data **without an LLM** and **without inventing semantic values**.
+
+When repair would require guessing (truncated objects, missing values, competing JSON documents), the service **refuses**. That is correct behavior.
+
+Primary HTTP endpoint: `POST /v1/json/reliable`
+
+MCP tools (same core functions, no duplicate implementation): `json_reliable` / `reliable_json`, `validate_json`, `repair_json`, `inspect_json`
+
+<!-- mcp-name: io.github.toninovo4249-ai/agent-json-reliability -->
+
+## Before / after (safe repair)
+
+Malformed agent output:
+
+```json
+{
+  "text": "```json\n{\"name\":\"alice\",\"age\":30,}\n```"
+}
+```
+
+Expected result (semantically equivalent valid JSON):
+
+- `valid_original=false`
+- `repaired=true`
+- `valid_final=true`
+- `unsafe_or_ambiguous=false`
+- `json` → `{"name":"alice","age":30}`
+
+If a schema is supplied and satisfied: `schema_valid=true`.
+
+## Safe refusal (ambiguous)
+
+Truncated input such as `{"user":` is JSON-intended but not deterministically repairable without inventing keys or values.
+
+Expected:
+
+- HTTP `200` (documented safe response)
+- `valid_final=false`
+- `unsafe_or_ambiguous=true` **or** `repaired=false`
+
+Do not treat a correct refusal as a product failure.
+
+## Run locally (no Hunter)
+
+```bash
+python -m pip install -r requirements.txt
+python serve.py
+```
+
+Binds `127.0.0.1:8770` by default. Set `PUBLIC_BASE_URL` to an HTTPS origin only when you expose the process yourself. Do not commit a temporary tunnel hostname as the canonical URL.
+
+## HTTP examples
+
+See `examples/curl.md`, `examples/python.py`, `examples/javascript.js`.
+
+Remote examples use `${PUBLIC_BASE_URL}`. Local default is `http://127.0.0.1:8770`.
+
+Share URLs (optional, unverified telemetry tags):
+
+- `/?source=github`
+- `/?source=mcp-registry`
+- `/?source=api-directory`
+
+## MCP (stdio — durable)
+
+Package transport does not depend on a temporary public URL.
+
+```json
+{
+  "mcpServers": {
+    "agent-json-reliability": {
+      "command": "python",
+      "args": ["-m", "products.gateway.mcp_stdio"]
+    }
+  }
+}
+```
+
+After you publish to PyPI (free): `uvx agent-json-reliability`.
+
+Remote HTTP MCP (`POST /mcp`) is for a running instance. Prefer stdio/package for Official MCP Registry metadata.
+
+## Machine discovery
+
+- `GET /.well-known/agent-services.json`
+- `GET /openapi.json`
+- `GET /llms.txt`
+- `GET /AGENTS.md`
+- `POST /mcp` JSON-RPC (`tools/list`, `tools/call`)
+
+## What this package does not include
+
+No Hunter market database, no private reports, no Windows user paths, no collectors, no wallets, no x402 payment.
+
+Free beta: no auth, no payment.

agent_json_reliability-0.1.0/agent_json_reliability.egg-info/SOURCES.txt

@@ -0,0 +1,34 @@
+LICENSE
+README.md
+pyproject.toml
+serve.py
+agent_json_reliability.egg-info/PKG-INFO
+agent_json_reliability.egg-info/SOURCES.txt
+agent_json_reliability.egg-info/dependency_links.txt
+agent_json_reliability.egg-info/entry_points.txt
+agent_json_reliability.egg-info/requires.txt
+agent_json_reliability.egg-info/top_level.txt
+products/__init__.py
+products/agent_json_reliability/__init__.py
+products/agent_json_reliability/inspect.py
+products/agent_json_reliability/reliable.py
+products/agent_json_reliability/repair.py
+products/agent_json_reliability/validate.py
+products/beta/__init__.py
+products/beta/app.py
+products/beta/batch.py
+products/beta/catalog.py
+products/beta/identity.py
+products/beta/landing.py
+products/beta/security.py
+products/beta/selfcheck.py
+products/beta/settings.py
+products/beta/store.py
+products/common/__init__.py
+products/common/timing.py
+products/gateway/__init__.py
+products/gateway/manifest.py
+products/gateway/mcp_server.py
+products/gateway/mcp_stdio.py
+products/gateway/rate_limit.py
+tests/test_public_semantics.py

agent_json_reliability-0.1.0/agent_json_reliability.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agent_json_reliability-0.1.0/agent_json_reliability.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+agent-json-reliability = products.gateway.mcp_stdio:main
+agent-json-reliability-serve = serve:main

agent_json_reliability-0.1.0/agent_json_reliability.egg-info/requires.txt

@@ -0,0 +1,3 @@
+fastapi>=0.115.0
+uvicorn>=0.30.0
+jsonschema>=4.23.0

agent_json_reliability-0.1.0/agent_json_reliability.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+products
+serve

agent_json_reliability-0.1.0/products/__init__.py

@@ -0,0 +1 @@
+"""Local zero-cost product prototypes. Independent of collectors."""

agent_json_reliability-0.1.0/products/agent_json_reliability/__init__.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from products.agent_json_reliability.inspect import inspect_json
+from products.agent_json_reliability.repair import repair_json
+from products.agent_json_reliability.validate import validate_json
+
+__all__ = ["validate_json", "repair_json", "inspect_json"]

agent_json_reliability-0.1.0/products/agent_json_reliability/inspect.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import json
+import re
+from typing import Any
+
+from products.agent_json_reliability.repair import repair_json
+from products.common.timing import Clock
+
+_FAILURES = [
+    ("markdown_fence", re.compile(r"```")),
+    ("trailing_comma", re.compile(r",\s*[}\]]")),
+    ("single_quotes", re.compile(r"'")),
+    ("python_literals", re.compile(r"\b(True|False|None)\b")),
+    ("comments", re.compile(r"//|/\*")),
+    ("leading_prose", None),
+    ("truncated", None),
+]
+
+
+def inspect_json(text: str) -> dict[str, Any]:
+    with Clock() as sw:
+        if not isinstance(text, str):
+            text = str(text)
+        raw = text.strip()
+        valid = False
+        err_pos = None
+        try:
+            json.loads(raw)
+            valid = True
+        except json.JSONDecodeError as e:
+            err_pos = e.pos
+        types: list[str] = []
+        if re.search(r"```", raw):
+            types.append("markdown_fence")
+        if re.search(r",\s*[}\]]", raw):
+            types.append("trailing_comma")
+        if "'" in raw and '"' not in raw:
+            types.append("single_quotes")
+        if re.search(r"\b(True|False|None)\b", raw):
+            types.append("python_literals")
+        if "//" in raw or "/*" in raw:
+            types.append("comments")
+        stripped = raw.lstrip()
+        if stripped and stripped[0] not in "{[":
+            types.append("leading_prose")
+        if raw.count("{") > raw.count("}") or raw.count("[") > raw.count("]"):
+            types.append("truncated")
+        if re.search(r"\}\s*\{", raw):
+            types.append("multiple_objects")
+        likely = valid or bool(re.search(r"[\{\[]", raw))
+        rep = repair_json(raw)
+        complexity = min(100, raw.count("{") + raw.count("[") + raw.count(":") + len(raw) // 200)
+        return {
+            "valid_json": valid,
+            "likely_json": likely,
+            "error_position": err_pos,
+            "detected_failure_types": types,
+            "repair_possible": bool(rep.get("repaired") or valid),
+            "estimated_complexity": complexity,
+            "processing_ms": sw.ms,
+        }

agent_json_reliability-0.1.0/products/agent_json_reliability/reliable.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from typing import Any
+
+from products.agent_json_reliability.inspect import inspect_json
+from products.agent_json_reliability.repair import repair_json
+from products.agent_json_reliability.validate import validate_json
+from products.common.timing import Clock
+
+
+def reliable_json(text: str, schema: dict | None = None, mode: str = "safe") -> dict[str, Any]:
+    """inspect → safe repair if needed → optional schema validate. Same primitives as HTTP tools."""
+    with Clock() as sw:
+        insp = inspect_json(text)
+        valid_original = bool(insp.get("valid_json"))
+        changes: list[str] = []
+        repaired = False
+        payload: Any = None
+        unsafe = False
+        if valid_original:
+            import json
+
+            payload = json.loads(text.strip().lstrip("\ufeff"))
+        else:
+            rep = repair_json(text, mode)
+            repaired = bool(rep.get("repaired"))
+            payload = rep.get("json")
+            changes = list(rep.get("changes") or [])
+            unsafe = bool(rep.get("unsafe_or_ambiguous"))
+        valid_final = payload is not None
+        schema_valid = None
+        errors: list = []
+        if valid_final and schema is not None:
+            v = validate_json(payload, schema)
+            schema_valid = v.get("schema_valid")
+            errors = v.get("errors") or []
+            valid_final = bool(schema_valid)
+        elif not valid_final:
+            errors = [{"message": "unrepaired_or_invalid"}]
+        return {
+            "valid_original": valid_original,
+            "repaired": repaired,
+            "json": payload,
+            "valid_final": valid_final and payload is not None and (schema_valid is not False),
+            "schema_valid": schema_valid,
+            "unsafe_or_ambiguous": unsafe,
+            "changes": changes,
+            "errors": errors,
+            "inspect": insp,
+            "processing_ms": sw.ms,
+            "outcome_class": _outcome(valid_original, repaired, payload, schema_valid, errors),
+        }
+
+
+def _outcome(valid_original, repaired, payload, schema_valid, errors) -> str:
+    if schema_valid is False:
+        return "SCHEMA_INVALID"
+    if schema_valid is True:
+        return "SCHEMA_VALID"
+    if valid_original:
+        return "ORIGINAL_VALID"
+    if repaired and payload is not None:
+        return "SAFE_REPAIR_SUCCESS"
+    if any((e.get("message") or "").startswith("schema") for e in errors or []):
+        return "INVALID_SCHEMA"
+    return "SAFE_REPAIR_REFUSED"