jev-mcp-python 0.1.0__py3-none-any.whl

jev_mcp/tools/verify.py

@@ -0,0 +1,141 @@
+"""jev_verify: check claims against evidence (`index.ts:121-238`)."""
+
+from typing import Any
+
+from jev_mcp.domain import ChoiceQuestion, Question, is_json_object
+from jev_mcp.ids import ensure_unique_ids
+from jev_mcp.limits import VERIFY
+from jev_mcp.policy import DEFAULT_AUTO_ACCEPT
+from jev_mcp.tools.base import JevTool, Runtime, ToolResult, caller_actions, define, frame, headline
+from jev_mcp.tools.common import EVIDENCE_SCHEMA, evidence_items
+from jev_mcp.tools.observed import validate_choice, verify_action
+
+RELATION_TO_VERDICT = {"supports": "verified", "contradicts": "contradicted", "says_nothing": "unsupported"}
+"""`RELATION_TO_VERDICT` (`lib.ts:53-57`)."""
+
+RELATION_CRITERIA = {
+    "supports": "The evidence states the claim or directly implies that it is true",
+    "contradicts": "The evidence states the opposite of the claim or implies that it is false",
+    "says_nothing": "The evidence does not address what the claim asserts, either way",
+}
+NO_SOURCE = "No single evidence item contains the content the claim depends on"
+
+DEFINITION = define(
+    "jev_verify",
+    "Verify claims against evidence",
+    "Check each claim against provided evidence text with TypeSafe Jev. Returns per claim: verdict (verified | "
+    "contradicted | unsupported), full probability distribution, confidence, and whether the verdict stands on its "
+    "own (auto) or needs human review. Pattern: docs.typesafe.ai/cookbooks/citation_check. Pass reports, PR "
+    "descriptions, or agent briefs as claims and their cited sources, diffs, or documents as evidence.",
+    {
+        "type": "object",
+        "properties": {
+            "claims": {
+                "type": "array",
+                "items": {"type": "string"},
+                "minItems": VERIFY.claims_min,
+                "description": "Claims to verify, e.g. individual factual statements from a report.",
+            },
+            "evidence": EVIDENCE_SCHEMA,
+            "auto_accept": {
+                "type": "number",
+                "minimum": 0,
+                "maximum": 1,
+                "description": "Verdicts at or above this confidence stand automatically; below it they are flagged "
+                "'review'. Default 0.8.",
+            },
+        },
+        "required": ["claims", "evidence"],
+        "additionalProperties": False,
+    },
+)
+
+
+async def handle(args: dict[str, Any], runtime: Runtime) -> ToolResult:
+    auto_accept: float = args.get("auto_accept", DEFAULT_AUTO_ACCEPT)
+    evidence = ensure_unique_ids(evidence_items(args["evidence"]), "evidence").items
+    claims = ensure_unique_ids([{"text": text} for text in args["claims"]], "claim").items
+
+    questions: dict[str, Question] = {}
+    for claim in claims:
+        claim_id, text = claim["id"], claim["text"]
+        questions[f"relation_{claim_id}"] = ChoiceQuestion(
+            f"How does the evidence relate to claim `{claim_id}` ({text})?", RELATION_CRITERIA
+        )
+        if len(evidence) > 1:
+            criteria: dict[str, str | None] = {str(item["id"]): None for item in evidence}
+            criteria["none"] = NO_SOURCE
+            questions[f"source_{claim_id}"] = ChoiceQuestion(
+                f"Which evidence item does claim `{claim_id}` ({text}) rest on?", criteria
+            )
+
+    state = {
+        "purpose": "Verify each claim in claims against the evidence in evidence.",
+        "claims": claims,
+        "evidence": evidence,
+    }
+    evaluation = await runtime.ask(state, questions)
+    answers = evaluation.answers
+    source_keys = [*(str(item["id"]) for item in evidence), "none"]
+
+    results: list[dict[str, object]] = []
+    for claim in claims:
+        relation = answers.get(f"relation_{claim['id']}")
+        validated = validate_choice(relation, RELATION_TO_VERDICT)
+        # source_* is auxiliary and asked only for several evidence items: its absence never
+        # invalidates the relation, but a present source must name a supplied id or "none".
+        source = validate_choice(answers.get(f"source_{claim['id']}"), source_keys)
+        # Q4 (ADR-0012): a present but malformed confidence invalidates the relation.
+        if (
+            validated is None
+            or not is_json_object(relation)
+            or (relation.get("confidence") is not None and validated.confidence is None)
+        ):
+            results.append(
+                {
+                    "id": claim["id"],
+                    "claim": claim["text"],
+                    "verdict": "unknown",
+                    "probabilities": None,
+                    "confidence": None,
+                    "status": "invalid_response",
+                    "action": "review",
+                    "supporting_evidence": None,
+                }
+            )
+            continue
+        confidence = validated.confidence
+        results.append(
+            {
+                "id": claim["id"],
+                "claim": claim["text"],
+                "verdict": RELATION_TO_VERDICT[validated.choice],
+                "probabilities": validated.probabilities,
+                "confidence": confidence,
+                "action": "review" if confidence is None else verify_action(confidence, auto_accept),
+                "supporting_evidence": source.choice if source is not None and source.choice != "none" else None,
+            }
+        )
+
+    item_actions = caller_actions(r["action"] for r in results)
+    return ToolResult(
+        frame(
+            "jev_verify",
+            evaluation,
+            {
+                "auto_accept": auto_accept,
+                "summary": {
+                    "verified": sum(1 for r in results if r["verdict"] == "verified"),
+                    "contradicted": sum(1 for r in results if r["verdict"] == "contradicted"),
+                    "unsupported": sum(1 for r in results if r["verdict"] == "unsupported"),
+                    "needs_review": sum(1 for r in results if r["action"] == "review"),
+                },
+                "results": results,
+            },
+        ),
+        action=headline(item_actions),
+        item_actions=item_actions,
+    )
+
+
+TOOL = JevTool(DEFINITION, handle)

jev_mcp/validation/__init__.py

@@ -0,0 +1,25 @@
+"""Per-question answer validation. Validation rejects; policy decides (ADR-0002)."""
+
+from jev_mcp.validation.choice import (
+    ARGMAX_TOLERANCE,
+    PROBABILITY_SUM_TOLERANCE,
+    margin,
+    top_probability,
+    validate_choice,
+)
+from jev_mcp.validation.extract import EXTRACT_SUM_TOLERANCE, validate_extract_choice
+from jev_mcp.validation.noul import validate_noul
+from jev_mcp.validation.score import MAX_SCORE, validate_score
+
+__all__ = [
+    "ARGMAX_TOLERANCE",
+    "EXTRACT_SUM_TOLERANCE",
+    "MAX_SCORE",
+    "PROBABILITY_SUM_TOLERANCE",
+    "margin",
+    "top_probability",
+    "validate_choice",
+    "validate_extract_choice",
+    "validate_noul",
+    "validate_score",
+]

jev_mcp/validation/caps.py

@@ -0,0 +1,93 @@
+"""Applying a cap: truncation, budget errors and their frozen texts (ADR-0014). Values live in
+`limits.py`, measurement in `text.py`; the reject behavior is each tool's schema. Every budget here is
+a strict greater-than check — the manifest's `>8000 → error` means 8000 is allowed — and every error
+string is byte-locked by parity fixtures.
+
+A tool cuts through one `CapLedger` per call, so a cut and its record cannot drift apart.
+"""
+
+from dataclasses import dataclass
+from typing import Literal
+
+from jev_mcp.serialize import js_number_to_locale_string_en_us
+from jev_mcp.text import length, truncate
+
+
+def exceeds(total: int, cap: int) -> bool:
+    """Strictly over budget: the cap itself is allowed (manifest `caps.$comment`)."""
+    return total > cap
+
+
+@dataclass(frozen=True, slots=True)
+class CappedText:
+    """A text cut to its cap, and whether the cut dropped anything."""
+
+    value: str
+    truncated: bool
+
+
+def cap_text(text: str, cap: int) -> CappedText:
+    """`truncate(text, cap)` with its flag: truncated exactly when `text` is strictly over `cap` UTF-16 units."""
+    return CappedText(truncate(text, cap), exceeds(length(text), cap))
+
+
+type CapScope = Literal["context", "item"]
+"""Who reads a cut. `context`: a document the judgment is made over (review and gate inputs, gate
+claims and evidence, jev_extract's candidate universe), so Policy never returns auto over it.
+`item`: a candidate's or class's own text (jev_find, jev_rerank, jev_classify), telemetry only — the
+reference returns auto over cut item text."""
+
+
+class CapLedger:
+    """One call's cuts: `text` cuts as `truncate` does and records the scope of every cut it makes."""
+
+    __slots__ = ("_scopes",)
+
+    def __init__(self) -> None:
+        self._scopes: set[CapScope] = set()
+
+    def text(self, value: str, cap: int, scope: CapScope) -> str:
+        capped = cap_text(value, cap)
+        if capped.truncated:
+            self._scopes.add(scope)
+        return capped.value
+
+    def note(self, scope: CapScope) -> None:
+        """Record a cut made elsewhere, such as candidates the regex executor capped or skipped."""
+        self._scopes.add(scope)
+
+    @property
+    def context_cut(self) -> bool:
+        """Whether a document the judgment is made over was cut: the only cut Policy reads."""
+        return "context" in self._scopes
+
+    @property
+    def scopes(self) -> frozenset[CapScope]:
+        """Every scope cut so far, for `ToolResult.truncated`."""
+        return frozenset(self._scopes)
+
+
+def candidate_budget_error(total: int, cap: int, remedy: str) -> str:
+    """jev_rerank and jev_extract share this frozen scaffold; only the remedy sentence differs."""
+    return f"Batch too large: {total} candidate characters exceeds the {cap} character budget. {remedy}"
+
+
+def classify_budget_error(items: int, classes: int, cap: int) -> str:
+    """jev_classify's item-class pair budget: the cap renders as `toLocaleString('en-US')` digits."""
+    return (
+        f"Batch too large: {items} items x {classes} classes exceeds the "
+        f"{js_number_to_locale_string_en_us(cap)} item-class budget. Split the batch."
+    )
+
+
+def gate_evidence_items_error(cap: int) -> str:
+    """jev_gate's item-count budget (`isError` result, not a thrown error)."""
+    return f"evidence exceeds {cap} items; split the gate or trim the evidence."
+
+
+def gate_evidence_aggregate_error(cap: int) -> str:
+    """jev_gate's aggregate budget: the cap renders as `toLocaleString('en-US')` digits (ADR-0014)."""
+    return (
+        f"evidence exceeds the {js_number_to_locale_string_en_us(cap)}-character aggregate budget; "
+        "split the gate or trim the evidence."
+    )

jev_mcp/validation/choice.py

@@ -0,0 +1,65 @@
+"""Choice answer validation (`validateChoiceAnswer`, `index.ts:1174-1198`), `margin` (`lib.ts:120-125`), and
+`top_probability`."""
+
+import math
+from collections.abc import Iterable, Mapping
+
+from jev_mcp.domain.answers import ChoiceAnswer, RawAnswer
+from jev_mcp.domain.json import as_number, is_json_object
+from jev_mcp.serialize import js_key_order
+from jev_mcp.validation.numbers import confidence_of
+
+PROBABILITY_SUM_TOLERANCE = 0.01 + 1e-12
+"""`lib.ts:11`. Kept as the expression: a 0.99 sum is 0.010000000000000009 from 1 and must pass."""
+
+ARGMAX_TOLERANCE = 1e-9
+"""The choice may trail the top probability by at most this much and still count as tied."""
+
+
+def validate_choice(answer: RawAnswer, expected_keys: Iterable[str]) -> ChoiceAnswer | None:
+    """The answer if it is a well-formed Choice over exactly `expected_keys`, else `None`.
+
+    Well-formed: an object whose `choice` is an expected key and whose `probabilities` object has
+    exactly the expected keys, each a finite number in [0, 1], summing to 1 within
+    `PROBABILITY_SUM_TOLERANCE`, with the choice's probability within `ARGMAX_TOLERANCE` of the
+    maximum. A malformed or out-of-range `confidence` becomes `None` and does not reject the answer.
+    """
+    if not is_json_object(answer):
+        return None
+    choice = answer.get("choice")
+    raw_probabilities = answer.get("probabilities")
+    if not isinstance(choice, str) or not is_json_object(raw_probabilities):
+        return None
+    expected = set(expected_keys)
+    keys = list(raw_probabilities)
+    if choice not in expected or len(keys) != len(expected) or not all(key in expected for key in keys):
+        return None
+    probabilities: dict[str, float] = {}
+    for key in keys:
+        value = as_number(raw_probabilities[key])
+        if value is None or not math.isfinite(value) or value < 0 or value > 1:
+            return None
+        probabilities[key] = value
+    # JS sums Object.values left to right in JS property order, one float64 add at a time. Python's
+    # sum() compensates float error since 3.12, so fold by hand.
+    total = 0.0
+    for key in js_key_order(keys):
+        total += probabilities[key]
+    if abs(total - 1) > PROBABILITY_SUM_TOLERANCE:
+        return None
+    if probabilities[choice] < max(probabilities.values()) - ARGMAX_TOLERANCE:
+        return None
+    return ChoiceAnswer(choice=choice, probabilities=probabilities, confidence=confidence_of(answer))
+
+
+def margin(probabilities: Mapping[str, float] | None) -> float:
+    """Top probability minus the runner-up; 0 when there is no runner-up (`marginOf`)."""
+    ranked = sorted((probabilities or {}).values(), reverse=True)
+    if len(ranked) < 2:
+        return 0
+    return ranked[0] - ranked[1]
+
+
+def top_probability(answer: ChoiceAnswer) -> float:
+    """The chosen label's probability, which policy gates: within `ARGMAX_TOLERANCE` of the maximum."""
+    return answer.probabilities[answer.choice]

jev_mcp/validation/extract.py

@@ -0,0 +1,48 @@
+"""jev_extract's own inline Choice validation (`index.ts:1047-1061`), kept apart from the shared one (Q2, ADR-0012).
+
+It differs from `validate_choice` in two observable ways: the sum tolerance is a bare `<= 0.01`, so a
+0.99 sum (0.010000000000000009 from 1) fails here and passes there; and `probabilities` that are not
+an object count as `{}` rather than rejecting outright, which rejects all the same because the
+expected key set is never empty.
+"""
+
+import math
+from collections.abc import Iterable
+
+from jev_mcp.domain.answers import ChoiceAnswer, RawAnswer
+from jev_mcp.domain.json import as_number, is_json_object
+from jev_mcp.serialize import js_key_order
+from jev_mcp.validation.choice import ARGMAX_TOLERANCE
+from jev_mcp.validation.numbers import confidence_of
+
+EXTRACT_SUM_TOLERANCE = 0.01
+
+
+def validate_extract_choice(answer: RawAnswer, expected_keys: Iterable[str]) -> ChoiceAnswer | None:
+    """The answer if its choice is expected and its probabilities are exactly the expected keys, each a
+    finite number in [0, 1], summing to 1 within `<= 0.01`, with the choice at the maximum; else `None`."""
+    if not is_json_object(answer):
+        return None
+    choice = answer.get("choice")
+    raw = answer.get("probabilities")
+    raw_probabilities: dict[str, object] = raw if is_json_object(raw) else {}
+    expected = set(expected_keys)
+    keys = list(raw_probabilities)
+    if not isinstance(choice, str) or choice not in expected or len(keys) != len(expected):
+        return None
+    if not all(key in expected for key in keys):
+        return None
+    probabilities: dict[str, float] = {}
+    for key in keys:
+        value = as_number(raw_probabilities[key])
+        if value is None or not math.isfinite(value) or value < 0 or value > 1:
+            return None
+        probabilities[key] = value
+    total = 0.0
+    for key in js_key_order(keys):
+        total += probabilities[key]
+    if not abs(total - 1) <= EXTRACT_SUM_TOLERANCE:
+        return None
+    if not probabilities[choice] >= max(probabilities.values()) - ARGMAX_TOLERANCE:
+        return None
+    return ChoiceAnswer(choice=choice, probabilities=probabilities, confidence=confidence_of(answer))

jev_mcp/validation/noul.py

@@ -0,0 +1,15 @@
+"""Noul answer validation (`validateNoulAnswer`, `index.ts:1200-1205`)."""
+
+from jev_mcp.domain.answers import RawAnswer
+from jev_mcp.domain.json import is_json_object
+from jev_mcp.validation.numbers import unit_interval
+
+
+def validate_noul(answer: RawAnswer) -> float | None:
+    """The `noul` probability if it is a finite number in [0, 1], else `None`.
+
+    `0.0` is a valid answer: test the result with `is None`, never for truthiness.
+    """
+    if not is_json_object(answer):
+        return None
+    return unit_interval(answer.get("noul"))

jev_mcp/validation/numbers.py

@@ -0,0 +1,21 @@
+"""Semantic number validators: unit intervals and confidence (ADR-0002, ADR-0019).
+
+Value-shape primitives (`as_number`, `is_json_object`) live in `domain/json.py`.
+"""
+
+import math
+
+from jev_mcp.domain.json import as_number
+
+
+def unit_interval(value: object) -> float | None:
+    """`value` when it is a finite number in [0, 1], else `None`. `-0.0` passes, as `-0 >= 0` in JS."""
+    number = as_number(value)
+    if number is None or not math.isfinite(number) or number < 0 or number > 1:
+        return None
+    return number
+
+
+def confidence_of(answer: dict[str, object]) -> float | None:
+    """A finite confidence in [0, 1], else `None`: unknown, never zero."""
+    return unit_interval(answer.get("confidence"))

jev_mcp/validation/score.py

@@ -0,0 +1,20 @@
+"""Score answer validation (`validateScoreAnswer`, `index.ts:1159-1168`)."""
+
+import math
+
+from jev_mcp.domain.answers import RawAnswer, ScoreAnswer
+from jev_mcp.domain.json import as_number, is_json_object
+from jev_mcp.validation.numbers import confidence_of
+
+MAX_SCORE = 2
+"""Hardcoded in `validateScoreAnswer` (`index.ts:1161`), independent of the question's rubric length."""
+
+
+def validate_score(answer: RawAnswer) -> ScoreAnswer | None:
+    """The answer if `score` is a finite number in [0, 2], else `None`. A bad confidence becomes `None`."""
+    if not is_json_object(answer):
+        return None
+    score = as_number(answer.get("score"))
+    if score is None or not math.isfinite(score) or score < 0 or score > MAX_SCORE:
+        return None
+    return ScoreAnswer(score=score, confidence=confidence_of(answer))

jev_mcp_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,18 @@
+Metadata-Version: 2.5
+Name: jev-mcp-python
+Version: 0.1.0
+Summary: Behavior-compatible Python MCP server exposing TypeSafe's Jev judgment tools.
+Author: Mohamed Elkholy
+License-Expression: MIT
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.12
+Requires-Dist: httpx
+Requires-Dist: mcp<3,>=2.2
+Requires-Dist: pydantic-settings
+Requires-Dist: pydantic>=2
+Provides-Extra: telemetry
+Requires-Dist: opentelemetry-sdk; extra == 'telemetry'
+Requires-Dist: prometheus-client; extra == 'telemetry'
+Provides-Extra: typesafe
+Requires-Dist: typesafe-sdk; extra == 'typesafe'

jev_mcp_python-0.1.0.dist-info/RECORD

@@ -0,0 +1,65 @@
+jev_mcp/__init__.py,sha256=Y3OqXXAVz5Aghh4oB41l8AdJBH2YLXg-xvXUtFmW9Bk,100
+jev_mcp/__main__.py,sha256=S6Z_k4U5SvGR6tFlZIwQ1Sfcd9hHheFXTNWNtA7VuFI,40
+jev_mcp/errors.py,sha256=PrKsvmgvvZ6DwY74-HT8YVZgsd9LdoyAfJA9dDTPazM,2229
+jev_mcp/ids.py,sha256=rC0hTVsfkwcvirh7ezFzm5xHuFtOcMwMFWRuW5VCAz4,1837
+jev_mcp/limits.py,sha256=Xbb6HTHVLdQfRnizZRkLz04meEsgPFF-FnhP6HAO5FU,6283
+jev_mcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jev_mcp/serialize.py,sha256=iFyPxMOVIqF4_U6VPNaxXn6SmvZ9pTTufM6BAiAMe8M,8469
+jev_mcp/server.py,sha256=5yeSUjZaDo1VF6i1waFQ8TCSeK8wskRrqRss9m595Jc,7009
+jev_mcp/settings.py,sha256=YJ0jMvvpTk9HBXiEHiwW4DieWTfas93GZUDUUObrcYo,3924
+jev_mcp/stdio.py,sha256=wGjaV9putJo1WW_p8NLLXRzd9weMT6hfGixKjHUReDI,4447
+jev_mcp/telemetry.py,sha256=W6HDPfe17PYgurOH7ki67qHxai12HPIYPoBcPA837xQ,9575
+jev_mcp/text.py,sha256=GwdEv9uuEC5sI1Q66GilES68f8tMwCi1qwXizDBESwE,1667
+jev_mcp/domain/__init__.py,sha256=8jKsnNNSbjvxyAkEptH9DCHNXwvGfFAdpciDH41_EoY,747
+jev_mcp/domain/answers.py,sha256=yz-8Lbk616O0m__LkpWABcWH1GXEpFUuzhuFh43asQg,786
+jev_mcp/domain/json.py,sha256=W-Q3QgDPdd8HnGiETJt1Cse4D4CwygMDBqVl1x3aGu8,1958
+jev_mcp/domain/questions.py,sha256=zfzDWzmznhzeQmTAcGkX4gI8dQFDpDARHM5crlhVtYU,2641
+jev_mcp/domain/usage.py,sha256=ER9eLP6lvGYufH9Bz_QQVhUNbbNdh5fImV_PBjWrxPU,489
+jev_mcp/extract/__init__.py,sha256=MYqBzKQXDHpbZs4HmuGr-hxjrjngSkYB793jNdmsZ9M,91
+jev_mcp/extract/candidates.py,sha256=fM4yGEGmBJmHZ4BVReYu8e1Cn8YvmApVZEWePWY4vuI,3190
+jev_mcp/extract/dialect.py,sha256=Uccbzk0DfL3SwVOgZ_dbY57UX94Kp36zXGuf0UitjY4,15596
+jev_mcp/extract/executor.py,sha256=C5WXzX4CNt-LEVkbRCTUu-88zoue3JgChzCasl-608g,4284
+jev_mcp/extract/worker.py,sha256=TVVJZHL7zL5jgqHlOCl7gUNz3xYnZ9sFBHWKJzw0OHI,8100
+jev_mcp/policy/__init__.py,sha256=QS7YjLQBlbNaCHI4GvME48_fkpyTxXKBYVYPJTHL0-E,2691
+jev_mcp/policy/actions.py,sha256=smQ2FspoNWCRhvLIY-znj-PwYnKt5uguBwBgYmVcArA,1699
+jev_mcp/policy/claims.py,sha256=0Id-vBL4-EenADnnyBGwIdWvnBHa-AYtkZmb9sGBhHI,3882
+jev_mcp/policy/extract.py,sha256=2vN4dKPbWHKbSeEesy1hP1JMlHgnOcNo7vPtTau3G0g,2829
+jev_mcp/policy/ranking.py,sha256=AX6XCQhHKV-XpL9eO8wU2YC98pm1K4hVn8QX6Kzks10,1904
+jev_mcp/policy/review.py,sha256=pLmeHKIN0_7HTnPu099nww5hMF-LiQ-RiYDQm_YvQAs,2809
+jev_mcp/policy/screen.py,sha256=4sDq58tFtgEqBw7VpVTT3R7SD03wl9OXMttPRIFHEb4,2042
+jev_mcp/policy/thresholds.py,sha256=am5XDxbQfQlE6OHRNJ4456IEiUqMEH-kiIl0T-HtXrU,2500
+jev_mcp/providers/__init__.py,sha256=PRxY1Sm9RjtxrPeGXSH3leSjnKHI8OD15I3wsq2qie0,662
+jev_mcp/providers/base.py,sha256=uy1igied3xAnI-xhVihf-kBCoT4vLgt9fm6rArz_Ggo,10024
+jev_mcp/providers/cloudflare.py,sha256=03uwX34SeZ6MX289nO28i5hCqFbWScY9ydKZkBy8nQ8,2877
+jev_mcp/providers/compatible.py,sha256=JfTJscq2H-tXDAMGnmVFyYR_wCJHr5xdiM5nDPtsEo8,1474
+jev_mcp/providers/openrouter.py,sha256=5m6CVYrk7X7YFVJ4NtUiITnTm6rDbXIMCRtypz7H6Vg,2000
+jev_mcp/providers/resolver.py,sha256=qK0IihOQNev0CDLninWh8tmyIeU5zTcE0VxQtxOqDHU,4666
+jev_mcp/providers/typesafe.py,sha256=WOTOThtjHdY24ZIYpKjQMfCn9ym6bjCyERj_EB1y28c,4815
+jev_mcp/tools/__init__.py,sha256=otMXydCjjQsFyVBhJomdzmZGeL2OumLp2qI7F1PowcA,622
+jev_mcp/tools/arguments.py,sha256=xvfnAUTv90XSjLBo9hBTv32umAXTvgAYLn79NTVh-HA,19016
+jev_mcp/tools/base.py,sha256=yd89fkqwkxasGG-tzhoFAQ0awR-9vn0di_OYZLxldjo,6309
+jev_mcp/tools/classify.py,sha256=it4GEZYQZ3Dk37BSjn10f6PbU1KqsgwqRgB4d3-nDNI,8352
+jev_mcp/tools/common.py,sha256=iS5SHYdYGwC7OA16ld-AzOm7kNmTqm7UGaM0sBbYGXM,3597
+jev_mcp/tools/compare.py,sha256=TGKDd_je8YHCjkiGUYaxwvmOf9YSkcqkYGEM4ReBjFg,6316
+jev_mcp/tools/decide.py,sha256=55IKurxrinRX8jMaXTNcKJ6G_J9Jth0WgiyOSk4RVeg,9096
+jev_mcp/tools/extract.py,sha256=CwVgW-oUEOEEuGrA39IRz0UDpxqC7ZWsWseOosKWxQ0,11802
+jev_mcp/tools/find.py,sha256=WhVpozOTynf1MVU7DyokZDQC-kzX33s5PMPdvEoa6wk,4309
+jev_mcp/tools/gate.py,sha256=sDvuq1eEKF_xEYWlRqIMqh7KRhus927KQD1jfrGng7s,9708
+jev_mcp/tools/observed.py,sha256=K8rwrNYZ-PvOs-tqRscI0T7A-qxPtdDcGxOPkJw7duQ,3005
+jev_mcp/tools/rerank.py,sha256=4cFPL_XN9jzlAS43LFKzxh4JOzVoPX1slbnqn5YXsx4,5692
+jev_mcp/tools/review.py,sha256=vAxniHy8tJIuKOhanZP9_hMa3IqNvPkzufnaMzxwp8M,9153
+jev_mcp/tools/screen.py,sha256=qoj5qDTCzFQ3YWGjWPTLeqGN15qhDu2q8voNv8f0tOA,5418
+jev_mcp/tools/toolset.py,sha256=_Xt-IstwSdeKSu9nUV1kW9FSc6-Bz9BHj9PSLHsxJD8,4097
+jev_mcp/tools/verify.py,sha256=Jucai4bXJM7SZjnsEqr05e-SU9mN4RK9oy6ww0-D1HU,6125
+jev_mcp/validation/__init__.py,sha256=7ArxeBS3nB4NkBV-tybk37im6wjF8DT4Y0CdybJDC2E,686
+jev_mcp/validation/caps.py,sha256=0-c6luzDPJvqZlbj-jH7oiCyBZ5xTq6ZOvPscxDa4Xs,3670
+jev_mcp/validation/choice.py,sha256=XxyKd_a5lSLe6v3_mPkCtkErn_UeuZRxZx03t2AwuRA,2945
+jev_mcp/validation/extract.py,sha256=u09dkE0niM0SAGmKxv0fbzIj_bxWI516rctdrH5d3Ts,2188
+jev_mcp/validation/noul.py,sha256=uLOYxcJ8vYjbIJeac45DGFugURKhZ1aKNTbwznqmleY,548
+jev_mcp/validation/numbers.py,sha256=CBGn8LxC0pe9T238tC6NTMYs8c4C0SLLF9PcMiEyO8M,719
+jev_mcp/validation/score.py,sha256=sEWc_PvNe-ItXgNvLBCa3BkgPzK_u_dDc43MSUyHrgU,823
+jev_mcp_python-0.1.0.dist-info/METADATA,sha256=v9-KBzdcZM_xkUh5k46TbOnFQoC_I7KjsEXo_8gtfHI,608
+jev_mcp_python-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+jev_mcp_python-0.1.0.dist-info/entry_points.txt,sha256=mXeDrPdSj93_9s9tKe3IfpLKNooMUDxl0ow5jvxZkUA,55
+jev_mcp_python-0.1.0.dist-info/licenses/LICENSE,sha256=YkwtlAJeUBMPltHLdl_UZphqiHjjPhAWOa-b6AFnIwc,1435
+jev_mcp_python-0.1.0.dist-info/RECORD,,

jev_mcp_python-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

jev_mcp_python-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+jev-mcp-python = jev_mcp.server:main

jev_mcp_python-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mohamed Elkholy⁠​‌​​‌‌​‌​‌‌​‌‌‌‌​‌‌​‌​​​​‌‌​​​​‌​‌‌​‌‌​‌​‌‌​​‌​‌​‌‌​​‌​​​​‌​​​​​​‌​​​‌​‌​‌‌​‌‌​​​‌‌​‌​‌‌​‌‌​‌​​​​‌‌​‌‌‌‌​‌‌​‌‌​​​‌‌‌‌​​‌
+
+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 above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.