mnemom-types 0.1.0__tar.gz

mnemom_types-0.1.0/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: mnemom-types
+Version: 0.1.0
+Summary: Shared type definitions for Mnemom services and SDKs
+Project-URL: Homepage, https://github.com/mnemom/mnemom-types
+Project-URL: Repository, https://github.com/mnemom/mnemom-types.git
+Project-URL: Issues, https://github.com/mnemom/mnemom-types/issues
+Author-email: "Mnemom.ai" <dev@mnemom.ai>
+License-Expression: Apache-2.0
+Keywords: agents,ai,mnemom,reputation,types
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: pydantic>=2.0

mnemom_types-0.1.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "mnemom-types"
+version = "0.1.0"
+description = "Shared type definitions for Mnemom services and SDKs"
+license = "Apache-2.0"
+requires-python = ">=3.10"
+authors = [
+    { name = "Mnemom.ai", email = "dev@mnemom.ai" }
+]
+keywords = [
+    "mnemom",
+    "reputation",
+    "types",
+    "ai",
+    "agents",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Typing :: Typed",
+]
+dependencies = [
+    "pydantic>=2.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/mnemom/mnemom-types"
+Repository = "https://github.com/mnemom/mnemom-types.git"
+Issues = "https://github.com/mnemom/mnemom-types/issues"
+
+[tool.hatch.build.targets.sdist]
+include = ["/src"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/mnemom_types"]

mnemom_types-0.1.0/src/mnemom_types/__init__.py

@@ -0,0 +1,41 @@
+"""mnemom-types — Shared type definitions for Mnemom services and SDKs.
+
+Example::
+
+    from mnemom_types import ReputationScore, ReputationGrade
+    from mnemom_types import GRADE_ORDINALS, COMPONENT_WEIGHTS
+"""
+
+from mnemom_types.constants import (
+    COMPONENT_WEIGHTS,
+    GRADE_ORDINALS,
+    GRADE_SCALE,
+    ComponentWeightEntry,
+    GradeScaleEntry,
+)
+from mnemom_types.gate import GateResult, ReputationGateConfig
+from mnemom_types.reputation import (
+    A2ATrustExtension,
+    ConfidenceLevel,
+    ReputationComponent,
+    ReputationGrade,
+    ReputationScore,
+)
+
+__all__ = [
+    # Reputation types
+    "ReputationGrade",
+    "ConfidenceLevel",
+    "ReputationComponent",
+    "ReputationScore",
+    "A2ATrustExtension",
+    # Gate types
+    "ReputationGateConfig",
+    "GateResult",
+    # Constants
+    "GRADE_ORDINALS",
+    "GRADE_SCALE",
+    "COMPONENT_WEIGHTS",
+    "GradeScaleEntry",
+    "ComponentWeightEntry",
+]

mnemom_types-0.1.0/src/mnemom_types/a2a.py

@@ -0,0 +1,8 @@
+"""A2A trust extension types.
+
+Re-exports from reputation for convenience.
+"""
+
+from .reputation import A2ATrustExtension
+
+__all__ = ["A2ATrustExtension"]

mnemom_types-0.1.0/src/mnemom_types/constants.py

@@ -0,0 +1,57 @@
+"""Reputation constants.
+
+Centralizes grade ordinals, grade scale definitions, and
+component weight definitions used across all services and SDKs.
+"""
+
+from __future__ import annotations
+
+from typing import TypedDict
+
+GRADE_ORDINALS: dict[str, int] = {
+    "AAA": 7,
+    "AA": 6,
+    "A": 5,
+    "BBB": 4,
+    "BB": 3,
+    "B": 2,
+    "CCC": 1,
+    "NR": 0,
+}
+"""Ordinal ranking of reputation grades (higher = better)."""
+
+
+class GradeScaleEntry(TypedDict):
+    grade: str
+    tier: str
+    min: int
+    max: int
+
+
+GRADE_SCALE: list[GradeScaleEntry] = [
+    {"grade": "AAA", "tier": "Exemplary",   "min": 900, "max": 1000},
+    {"grade": "AA",  "tier": "Established", "min": 800, "max": 899},
+    {"grade": "A",   "tier": "Reliable",    "min": 700, "max": 799},
+    {"grade": "BBB", "tier": "Developing",  "min": 600, "max": 699},
+    {"grade": "BB",  "tier": "Emerging",    "min": 500, "max": 599},
+    {"grade": "B",   "tier": "Concerning",  "min": 400, "max": 499},
+    {"grade": "CCC", "tier": "Critical",    "min": 200, "max": 399},
+]
+"""Grade scale from highest to lowest."""
+
+
+class ComponentWeightEntry(TypedDict):
+    key: str
+    label: str
+    weight: float
+    source: str
+
+
+COMPONENT_WEIGHTS: list[ComponentWeightEntry] = [
+    {"key": "integrity_ratio",        "label": "Integrity Ratio",        "weight": 0.40, "source": "Checkpoint clear rate"},
+    {"key": "compliance",             "label": "Compliance",             "weight": 0.20, "source": "Violation impact decay"},
+    {"key": "drift_stability",        "label": "Drift Stability",        "weight": 0.20, "source": "Session stability ratio"},
+    {"key": "trace_completeness",     "label": "Trace Completeness",     "weight": 0.10, "source": "Trace/checkpoint balance"},
+    {"key": "coherence_compatibility", "label": "Coherence Compatibility", "weight": 0.10, "source": "Fleet coherence data"},
+]
+"""Scoring component weights."""

mnemom_types-0.1.0/src/mnemom_types/gate.py

@@ -0,0 +1,39 @@
+"""Reputation gate types.
+
+Types for gating agent interactions based on reputation
+score and grade thresholds.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+from .reputation import ReputationGrade, ReputationScore
+
+
+class ReputationGateConfig(BaseModel):
+    """Configuration for a reputation gate."""
+
+    min_score: Optional[float] = Field(
+        None, description="Minimum numeric score required (0-1000)"
+    )
+    min_grade: Optional[ReputationGrade] = Field(
+        None, description="Minimum letter grade required"
+    )
+    base_url: str = Field(
+        "https://api.mnemom.ai", description="Base URL for the reputation API"
+    )
+
+
+class GateResult(BaseModel):
+    """Result of a reputation gate check."""
+
+    allowed: bool = Field(..., description="Whether the agent passed the gate")
+    score: Optional[ReputationScore] = Field(
+        None, description="The agent's reputation score (None on fetch error)"
+    )
+    reason: Optional[str] = Field(
+        None, description="Reason for denial (None if allowed)"
+    )

mnemom_types-0.1.0/src/mnemom_types/reputation.py

@@ -0,0 +1,75 @@
+"""Reputation score types.
+
+Canonical definitions for Mnemom reputation scores, grades,
+confidence levels, and score components.
+"""
+
+from __future__ import annotations
+
+from typing import Literal, Optional
+
+from pydantic import BaseModel, Field
+
+ReputationGrade = Literal["AAA", "AA", "A", "BBB", "BB", "B", "CCC", "NR"]
+"""Reputation grade scale from AAA (highest) to NR (not rated)."""
+
+ConfidenceLevel = Literal["insufficient", "low", "medium", "high"]
+"""Confidence level of a reputation score."""
+
+
+class ReputationComponent(BaseModel):
+    """A single component contributing to an agent's reputation score."""
+
+    key: str = Field(..., description="Machine-readable key (e.g. 'integrity_ratio')")
+    label: str = Field(..., description="Human-readable label (e.g. 'Integrity Ratio')")
+    score: float = Field(..., description="Raw component score (0-1000)")
+    weight: float = Field(..., description="Weight applied to this component (0-1)")
+    weighted_score: float = Field(..., description="score * weight, rounded")
+    factors: list[str] = Field(default_factory=list, description="Human-readable factors")
+
+
+class A2ATrustExtension(BaseModel):
+    """A2A trust extension for inter-agent reputation sharing."""
+
+    extension_uri: str = Field(..., description="URI identifying this extension")
+    provider: str = Field(..., description="Reputation provider identifier")
+    score: float = Field(..., description="Numeric reputation score")
+    grade: ReputationGrade = Field(..., description="Letter grade")
+    confidence: ConfidenceLevel = Field(..., description="Confidence in the score")
+    verified_url: str = Field(..., description="URL to verify the score")
+    badge_url: str = Field(..., description="URL to the agent's badge")
+    methodology_url: str = Field(..., description="URL to the scoring methodology")
+    last_updated: str = Field(
+        ..., description="When the score was last updated (ISO 8601)"
+    )
+
+
+class ReputationScore(BaseModel):
+    """Full reputation score for an agent."""
+
+    agent_id: str = Field(..., description="Agent identifier")
+    score: float = Field(..., description="Numeric reputation score (0-1000)")
+    grade: ReputationGrade = Field(..., description="Letter grade")
+    tier: str = Field(..., description="Tier label (e.g. 'Exemplary', 'Reliable')")
+    is_eligible: bool = Field(
+        ..., description="Whether the agent is eligible for reputation"
+    )
+    checkpoint_count: int = Field(
+        ..., description="Number of checkpoints contributing to the score"
+    )
+    confidence: ConfidenceLevel = Field(..., description="Confidence in the score")
+    components: list[ReputationComponent] = Field(
+        ..., description="Score components breakdown"
+    )
+    computed_at: str = Field(
+        ..., description="When the score was computed (ISO 8601)"
+    )
+    trend_30d: float = Field(
+        ..., description="30-day score trend (positive = improving)"
+    )
+    visibility: Literal["public", "unlisted", "private"] = Field(
+        ..., description="Visibility setting"
+    )
+    a2a_trust_extension: Optional[A2ATrustExtension] = Field(
+        None, description="Optional A2A trust extension"
+    )