agentmesh_runtime 3.1.0__py3-none-any.whl

agent_runtime/__init__.py

@@ -0,0 +1,176 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+"""
+Agent Runtime — Execution supervisor for multi-agent sessions.
+
+This package is the successor to ``agent-hypervisor``.  It re-exports the
+full public API from ``hypervisor`` so that callers can migrate their imports
+incrementally::
+
+    # Old
+    from hypervisor import Hypervisor, SessionConfig
+    # New (equivalent)
+    from agent_runtime import Hypervisor, SessionConfig
+
+The ``agent-hypervisor`` package remains available for backward compatibility
+and will be deprecated in a future release.
+"""
+
+from hypervisor import (  # noqa: F401
+    __version__,
+    # Core
+    Hypervisor,
+    # Models
+    ConsistencyMode,
+    ExecutionRing,
+    ReversibilityLevel,
+    SessionConfig,
+    SessionState,
+    # Session
+    SharedSessionObject,
+    SessionVFS,
+    VFSEdit,
+    VFSPermissionError,
+    VectorClock,
+    VectorClockManager,
+    CausalViolationError,
+    IntentLockManager,
+    LockIntent,
+    LockContentionError,
+    DeadlockError,
+    IsolationLevel,
+    # Liability
+    VouchRecord,
+    VouchingEngine,
+    SlashingEngine,
+    LiabilityMatrix,
+    CausalAttributor,
+    AttributionResult,
+    QuarantineManager,
+    QuarantineReason,
+    LiabilityLedger,
+    LedgerEntryType,
+    # Rings
+    RingEnforcer,
+    ActionClassifier,
+    RingElevationManager,
+    RingElevation,
+    ElevationDenialReason,
+    RingBreachDetector,
+    BreachSeverity,
+    # Reversibility
+    ReversibilityRegistry,
+    # Saga
+    SagaOrchestrator,
+    SagaTimeoutError,
+    SagaState,
+    StepState,
+    FanOutOrchestrator,
+    FanOutPolicy,
+    CheckpointManager,
+    SemanticCheckpoint,
+    SagaDSLParser,
+    SagaDefinition,
+    # Audit
+    DeltaEngine,
+    CommitmentEngine,
+    EphemeralGC,
+    # Verification
+    TransactionHistoryVerifier,
+    # Observability
+    HypervisorEventBus,
+    EventType,
+    HypervisorEvent,
+    CausalTraceId,
+    # Security
+    AgentRateLimiter,
+    RateLimitExceeded,
+    KillSwitch,
+    KillResult,
+)
+
+__all__ = [
+    "__version__",
+    "Hypervisor",
+    "ConsistencyMode",
+    "ExecutionRing",
+    "ReversibilityLevel",
+    "SessionConfig",
+    "SessionState",
+    "SharedSessionObject",
+    "SessionVFS",
+    "VFSEdit",
+    "VFSPermissionError",
+    "VectorClock",
+    "VectorClockManager",
+    "CausalViolationError",
+    "IntentLockManager",
+    "LockIntent",
+    "LockContentionError",
+    "DeadlockError",
+    "IsolationLevel",
+    "VouchRecord",
+    "VouchingEngine",
+    "SlashingEngine",
+    "LiabilityMatrix",
+    "CausalAttributor",
+    "AttributionResult",
+    "QuarantineManager",
+    "QuarantineReason",
+    "LiabilityLedger",
+    "LedgerEntryType",
+    "RingEnforcer",
+    "ActionClassifier",
+    "RingElevationManager",
+    "RingElevation",
+    "ElevationDenialReason",
+    "RingBreachDetector",
+    "BreachSeverity",
+    "ReversibilityRegistry",
+    "SagaOrchestrator",
+    "SagaTimeoutError",
+    "SagaState",
+    "StepState",
+    "FanOutOrchestrator",
+    "FanOutPolicy",
+    "CheckpointManager",
+    "SemanticCheckpoint",
+    "SagaDSLParser",
+    "SagaDefinition",
+    "DeltaEngine",
+    "CommitmentEngine",
+    "EphemeralGC",
+    "TransactionHistoryVerifier",
+    "HypervisorEventBus",
+    "EventType",
+    "HypervisorEvent",
+    "CausalTraceId",
+    "AgentRateLimiter",
+    "RateLimitExceeded",
+    "KillSwitch",
+    "KillResult",
+]
+
+# ============================================================================
+# Deployment Runtime (v3.0.2+)
+# ============================================================================
+
+from agent_runtime.deploy import (
+    DeploymentResult,
+    DeploymentStatus,
+    DeploymentTarget,
+    DockerDeployer,
+    GovernanceConfig,
+    KubernetesDeployer,
+)
+
+# Update __all__ to include new exports
+__all__ = [
+    *__all__,
+    "DeploymentResult",
+    "DeploymentStatus",
+    "DeploymentTarget",
+    "DockerDeployer",
+    "GovernanceConfig",
+    "KubernetesDeployer",
+]

agent_runtime/deploy.py

@@ -0,0 +1,350 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+"""Deployment runtime for governed AI agents.
+
+Provides deployment targets for running governed agents in production:
+- Docker containers with policy enforcement
+- Kubernetes (AKS) pods with governance sidecars
+- Local process with sandbox isolation
+"""
+from __future__ import annotations
+
+import json
+import logging
+import shutil
+import subprocess
+import tempfile
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import Any, Protocol
+
+logger = logging.getLogger(__name__)
+
+
+class DeploymentStatus(str, Enum):
+    PENDING = "pending"
+    DEPLOYING = "deploying"
+    RUNNING = "running"
+    STOPPED = "stopped"
+    FAILED = "failed"
+    TERMINATED = "terminated"
+
+
+@dataclass
+class GovernanceConfig:
+    """Governance configuration injected into deployed agents."""
+    policy_path: str = ""
+    trust_level: str = "standard"
+    audit_enabled: bool = True
+    max_tool_calls: int = 100
+    rate_limit_rpm: int = 60
+    kill_switch_enabled: bool = True
+    retention_days: int = 180
+
+
+@dataclass
+class DeploymentResult:
+    """Result of a deployment operation."""
+    status: DeploymentStatus
+    target: str
+    agent_id: str
+    endpoint: str = ""
+    container_id: str = ""
+    error: str = ""
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+class DeploymentTarget(Protocol):
+    """Protocol for deployment targets."""
+    def deploy(self, agent_id: str, image: str, config: GovernanceConfig, **kwargs: Any) -> DeploymentResult: ...
+    def stop(self, agent_id: str) -> DeploymentResult: ...
+    def status(self, agent_id: str) -> DeploymentResult: ...
+    def logs(self, agent_id: str, tail: int = 100) -> str: ...
+
+
+class DockerDeployer:
+    """Deploy governed agents as Docker containers.
+
+    Usage:
+        deployer = DockerDeployer()
+        result = deployer.deploy(
+            agent_id="analyst-001",
+            image="agent-os:latest",
+            config=GovernanceConfig(policy_path="/policies/strict.yaml"),
+        )
+    """
+
+    def __init__(self, network: str = "agent-governance", docker_cmd: str = "docker") -> None:
+        self._network = network
+        self._docker = docker_cmd
+        self._ensure_docker()
+
+    def _ensure_docker(self) -> None:
+        if not shutil.which(self._docker):
+            raise RuntimeError(f"{self._docker} not found in PATH")
+
+    def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:
+        cmd = [self._docker] + args
+        logger.debug("Running: %s", " ".join(cmd))
+        return subprocess.run(cmd, capture_output=True, text=True, check=check, timeout=60)
+
+    def deploy(self, agent_id: str, image: str, config: GovernanceConfig,
+               port: int = 0, env: dict[str, str] | None = None, **kwargs: Any) -> DeploymentResult:
+        container_name = f"agt-{agent_id}"
+        cmd = [
+            "run", "-d",
+            "--name", container_name,
+            "--network", self._network,
+            "--label", f"agt.agent-id={agent_id}",
+            "--label", "agt.managed=true",
+            "--restart", "unless-stopped",
+            # Security: drop all capabilities, add only what's needed
+            "--cap-drop", "ALL",
+            "--security-opt", "no-new-privileges",
+            "--read-only",
+            "--tmpfs", "/tmp:rw,noexec,nosuid",
+            # Governance config as env vars
+            "-e", f"AGT_POLICY_PATH={config.policy_path}",
+            "-e", f"AGT_TRUST_LEVEL={config.trust_level}",
+            "-e", f"AGT_AUDIT_ENABLED={str(config.audit_enabled).lower()}",
+            "-e", f"AGT_MAX_TOOL_CALLS={config.max_tool_calls}",
+            "-e", f"AGT_RATE_LIMIT_RPM={config.rate_limit_rpm}",
+            "-e", f"AGT_KILL_SWITCH={str(config.kill_switch_enabled).lower()}",
+            "-e", f"AGT_RETENTION_DAYS={config.retention_days}",
+        ]
+        if port:
+            cmd.extend(["-p", f"127.0.0.1:{port}:8080"])
+        if env:
+            for k, v in env.items():
+                cmd.extend(["-e", f"{k}={v}"])
+        cmd.append(image)
+
+        try:
+            # Ensure network exists
+            self._run(["network", "create", self._network], check=False)
+            result = self._run(cmd)
+            container_id = result.stdout.strip()[:12]
+            return DeploymentResult(
+                status=DeploymentStatus.RUNNING,
+                target="docker",
+                agent_id=agent_id,
+                container_id=container_id,
+                endpoint=f"http://localhost:{port}" if port else "",
+            )
+        except subprocess.CalledProcessError as e:
+            return DeploymentResult(
+                status=DeploymentStatus.FAILED,
+                target="docker",
+                agent_id=agent_id,
+                error=e.stderr.strip(),
+            )
+
+    def stop(self, agent_id: str) -> DeploymentResult:
+        container_name = f"agt-{agent_id}"
+        try:
+            self._run(["stop", container_name])
+            self._run(["rm", container_name])
+            return DeploymentResult(
+                status=DeploymentStatus.STOPPED,
+                target="docker",
+                agent_id=agent_id,
+            )
+        except subprocess.CalledProcessError as e:
+            return DeploymentResult(
+                status=DeploymentStatus.FAILED,
+                target="docker",
+                agent_id=agent_id,
+                error=e.stderr.strip(),
+            )
+
+    def status(self, agent_id: str) -> DeploymentResult:
+        container_name = f"agt-{agent_id}"
+        try:
+            result = self._run(["inspect", container_name, "--format", "{{.State.Status}}"])
+            state = result.stdout.strip()
+            status_map = {"running": DeploymentStatus.RUNNING, "exited": DeploymentStatus.STOPPED}
+            return DeploymentResult(
+                status=status_map.get(state, DeploymentStatus.FAILED),
+                target="docker",
+                agent_id=agent_id,
+                container_id=container_name,
+            )
+        except subprocess.CalledProcessError:
+            return DeploymentResult(
+                status=DeploymentStatus.STOPPED,
+                target="docker",
+                agent_id=agent_id,
+            )
+
+    def logs(self, agent_id: str, tail: int = 100) -> str:
+        try:
+            result = self._run(["logs", f"agt-{agent_id}", "--tail", str(tail)])
+            return result.stdout
+        except subprocess.CalledProcessError:
+            return ""
+
+
+class KubernetesDeployer:
+    """Deploy governed agents to Kubernetes (AKS) with governance sidecars.
+
+    Usage:
+        deployer = KubernetesDeployer(namespace="agents")
+        result = deployer.deploy(
+            agent_id="analyst-001",
+            image="myregistry.azurecr.io/agent-os:3.0.2",
+            config=GovernanceConfig(policy_path="/policies/strict.yaml"),
+        )
+    """
+
+    def __init__(self, namespace: str = "agent-governance", kubectl_cmd: str = "kubectl",
+                 context: str | None = None) -> None:
+        self._namespace = namespace
+        self._kubectl = kubectl_cmd
+        self._context = context
+        self._ensure_kubectl()
+
+    def _ensure_kubectl(self) -> None:
+        if not shutil.which(self._kubectl):
+            raise RuntimeError(f"{self._kubectl} not found in PATH")
+
+    def _run(self, args: list[str], check: bool = True) -> subprocess.CompletedProcess[str]:
+        cmd = [self._kubectl]
+        if self._context:
+            cmd.extend(["--context", self._context])
+        cmd.extend(args)
+        logger.debug("Running: %s", " ".join(cmd))
+        return subprocess.run(cmd, capture_output=True, text=True, check=check, timeout=120)
+
+    def _build_pod_manifest(self, agent_id: str, image: str, config: GovernanceConfig) -> dict[str, Any]:
+        return {
+            "apiVersion": "v1",
+            "kind": "Pod",
+            "metadata": {
+                "name": f"agt-{agent_id}",
+                "namespace": self._namespace,
+                "labels": {
+                    "app.kubernetes.io/name": "agent-governance",
+                    "app.kubernetes.io/component": "agent",
+                    "agt.agent-id": agent_id,
+                    "agt.trust-level": config.trust_level,
+                },
+            },
+            "spec": {
+                "securityContext": {
+                    "runAsNonRoot": True,
+                    "runAsUser": 1000,
+                    "fsGroup": 1000,
+                    "seccompProfile": {"type": "RuntimeDefault"},
+                },
+                "containers": [
+                    {
+                        "name": "agent",
+                        "image": image,
+                        "imagePullPolicy": "IfNotPresent",
+                        "securityContext": {
+                            "allowPrivilegeEscalation": False,
+                            "capabilities": {"drop": ["ALL"]},
+                            "readOnlyRootFilesystem": True,
+                        },
+                        "env": [
+                            {"name": "AGT_POLICY_PATH", "value": config.policy_path},
+                            {"name": "AGT_TRUST_LEVEL", "value": config.trust_level},
+                            {"name": "AGT_AUDIT_ENABLED", "value": str(config.audit_enabled).lower()},
+                            {"name": "AGT_MAX_TOOL_CALLS", "value": str(config.max_tool_calls)},
+                            {"name": "AGT_RATE_LIMIT_RPM", "value": str(config.rate_limit_rpm)},
+                            {"name": "AGT_KILL_SWITCH", "value": str(config.kill_switch_enabled).lower()},
+                            {"name": "AGT_RETENTION_DAYS", "value": str(config.retention_days)},
+                        ],
+                        "resources": {
+                            "requests": {"cpu": "100m", "memory": "256Mi"},
+                            "limits": {"cpu": "500m", "memory": "512Mi"},
+                        },
+                        "volumeMounts": [{"name": "tmp", "mountPath": "/tmp"}],
+                    },
+                ],
+                "volumes": [{"name": "tmp", "emptyDir": {"sizeLimit": "100Mi"}}],
+                "restartPolicy": "Always",
+                "terminationGracePeriodSeconds": 30,
+            },
+        }
+
+    def deploy(self, agent_id: str, image: str, config: GovernanceConfig, **kwargs: Any) -> DeploymentResult:
+        manifest = self._build_pod_manifest(agent_id, image, config)
+        manifest_json = json.dumps(manifest)
+        try:
+            # Ensure namespace
+            self._run(["create", "namespace", self._namespace], check=False)
+            tmp_dir = Path(tempfile.gettempdir())
+            manifest_path = tmp_dir / f"agt-{agent_id}-manifest.json"
+            try:
+                manifest_path.write_text(manifest_json, encoding="utf-8")
+                self._run(["apply", "-f", str(manifest_path)])
+            finally:
+                manifest_path.unlink(missing_ok=True)
+            return DeploymentResult(
+                status=DeploymentStatus.DEPLOYING,
+                target="kubernetes",
+                agent_id=agent_id,
+                metadata={"namespace": self._namespace},
+            )
+        except subprocess.CalledProcessError as e:
+            return DeploymentResult(
+                status=DeploymentStatus.FAILED,
+                target="kubernetes",
+                agent_id=agent_id,
+                error=e.stderr.strip(),
+            )
+
+    def stop(self, agent_id: str) -> DeploymentResult:
+        try:
+            self._run(["delete", "pod", f"agt-{agent_id}", "-n", self._namespace])
+            return DeploymentResult(
+                status=DeploymentStatus.TERMINATED,
+                target="kubernetes",
+                agent_id=agent_id,
+            )
+        except subprocess.CalledProcessError as e:
+            return DeploymentResult(
+                status=DeploymentStatus.FAILED,
+                target="kubernetes",
+                agent_id=agent_id,
+                error=e.stderr.strip(),
+            )
+
+    def status(self, agent_id: str) -> DeploymentResult:
+        try:
+            result = self._run([
+                "get", "pod", f"agt-{agent_id}",
+                "-n", self._namespace,
+                "-o", "jsonpath={.status.phase}",
+            ])
+            phase = result.stdout.strip()
+            phase_map = {
+                "Running": DeploymentStatus.RUNNING,
+                "Pending": DeploymentStatus.DEPLOYING,
+                "Succeeded": DeploymentStatus.STOPPED,
+                "Failed": DeploymentStatus.FAILED,
+            }
+            return DeploymentResult(
+                status=phase_map.get(phase, DeploymentStatus.FAILED),
+                target="kubernetes",
+                agent_id=agent_id,
+            )
+        except subprocess.CalledProcessError:
+            return DeploymentResult(
+                status=DeploymentStatus.STOPPED,
+                target="kubernetes",
+                agent_id=agent_id,
+            )
+
+    def logs(self, agent_id: str, tail: int = 100) -> str:
+        try:
+            result = self._run([
+                "logs", f"agt-{agent_id}",
+                "-n", self._namespace,
+                "--tail", str(tail),
+            ])
+            return result.stdout
+        except subprocess.CalledProcessError:
+            return ""

agentmesh_runtime-3.1.0.dist-info/METADATA

@@ -0,0 +1,131 @@
+Metadata-Version: 2.4
+Name: agentmesh_runtime
+Version: 3.1.0
+Summary: Public Preview — AgentMesh Runtime: Execution supervisor for multi-agent sessions with privilege rings, saga orchestration, and audit trails
+Project-URL: Homepage, https://github.com/microsoft/agent-governance-toolkit
+Project-URL: Repository, https://github.com/microsoft/agent-governance-toolkit
+Project-URL: Documentation, https://github.com/microsoft/agent-governance-toolkit/tree/main/packages/agent-runtime
+Project-URL: Bug Tracker, https://github.com/microsoft/agent-governance-toolkit/issues
+Author-email: Microsoft Corporation <agentgovtoolkit@microsoft.com>
+Maintainer-email: Agent Governance Toolkit Team <agentgovtoolkit@microsoft.com>
+License: MIT
+License-File: LICENSE
+Keywords: agents,ai,audit,execution-rings,governance,hash-chain,liability,multi-agent,runtime,safety,saga,shared-sessions,trust
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: agent-hypervisor<4.0,>=2.1.0
+Requires-Dist: jsonschema<5.0,>=4.0.0
+Description-Content-Type: text/markdown
+
+<div align="center">
+
+# AgentMesh Runtime
+
+**Execution supervisor for multi-agent sessions — privilege rings, saga orchestration, and governance enforcement**
+
+*Part of the [Agent Governance Toolkit](https://github.com/microsoft/agent-governance-toolkit)*
+
+[![CI](https://github.com/microsoft/agent-governance-toolkit/actions/workflows/ci.yml/badge.svg)](https://github.com/microsoft/agent-governance-toolkit/actions/workflows/ci.yml)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](../../LICENSE)
+[![Python](https://img.shields.io/badge/python-3.11+-blue.svg)](https://python.org)
+[![PyPI](https://img.shields.io/pypi/v/agentmesh-runtime)](https://pypi.org/project/agentmesh-runtime/)
+
+</div>
+
+> [!IMPORTANT]
+> **Public Preview** — The `agentmesh-runtime` package on PyPI is a Microsoft-signed
+> public preview release. APIs may change before GA.
+
+---
+
+> **Note:** This package was renamed from `agent-runtime` to `agentmesh-runtime` to avoid a PyPI
+> name collision with the AutoGen team's package. The `agent-hypervisor` package remains the
+> canonical upstream implementation; `agentmesh-runtime` is a thin re-export wrapper for
+> incremental import migration.
+
+## What is Agent Runtime?
+
+Agent Runtime provides **execution-level supervision** for autonomous AI agents. While Agent OS handles
+policy decisions and AgentMesh handles trust/identity, Agent Runtime enforces those decisions at the
+session level:
+
+- **Execution Rings** — 4-tier privilege model (Ring 0–3) controlling what agents can do at runtime
+- **Shared Sessions** — Multi-agent session management with consistency modes (strict, eventual, causal)
+- **Saga Orchestration** — Compensating transactions for multi-step agent workflows
+- **Kill Switch** — Immediate termination with audit trail and blast radius containment
+- **Joint Liability** — Attribution tracking across multi-agent collaborations
+- **Audit Trails** — Hash-chained, append-only execution logs
+
+## Quick Start
+
+```bash
+pip install agentmesh-runtime
+```
+
+```python
+from hypervisor import Hypervisor, SessionConfig, ConsistencyMode
+
+# Create the runtime supervisor
+hv = Hypervisor()
+
+# Create a governed session
+session = await hv.create_session(
+    config=SessionConfig(consistency_mode=ConsistencyMode.EVENTUAL)
+)
+
+# Execute with privilege enforcement
+result = await session.execute(
+    agent_id="researcher-1",
+    action="tool_call",
+    tool="web_search",
+    ring=2  # restricted privilege ring
+)
+```
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│                        Agent Runtime                                 │
+├─────────────┬──────────────────┬──────────────────┬─────────────────┤
+│  Execution  │     Session      │      Saga        │    Liability    │
+│   Rings     │   Management     │  Orchestration   │    Tracking     │
+│             │                  │                  │                 │
+│  Ring 0:    │  Create/join     │  Multi-step      │  Attribution    │
+│   System    │  Consistency     │  Compensation    │  Vouching       │
+│  Ring 1:    │  Checkpoints     │  Rollback        │  Slashing       │
+│   Trusted   │  Merge/fork      │  Recovery        │  Quarantine     │
+│  Ring 2:    │                  │                  │                 │
+│   Standard  │                  │                  │                 │
+│  Ring 3:    │                  │                  │                 │
+│   Sandboxed │                  │                  │                 │
+└─────────────┴──────────────────┴──────────────────┴─────────────────┘
+```
+
+## Ecosystem
+
+Agent Runtime is one of 7 packages in the Agent Governance Toolkit:
+
+| Package | Role |
+|---------|------|
+| **Agent OS** | Policy engine — deterministic action evaluation |
+| **AgentMesh** | Trust infrastructure — identity, credentials, protocol bridges |
+| **AgentMesh Runtime** | Execution supervisor — rings, sessions, sagas *(this package)* |
+| **Agent SRE** | Reliability — SLOs, circuit breakers, chaos testing |
+| **Agent Compliance** | Regulatory compliance — GDPR, HIPAA, SOX frameworks |
+| **Agent Marketplace** | Plugin lifecycle — discover, install, verify, sign |
+| **Agent Lightning** | RL training governance — governed runners, policy rewards |
+
+## License
+
+MIT — see [LICENSE](../../LICENSE).

agentmesh_runtime-3.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+agent_runtime/__init__.py,sha256=41lO5_bT5jh4elELK1i0cDBSf-8aUu7el9w7PtbBU-A,3934
+agent_runtime/deploy.py,sha256=baKabHZ6cmsM9_hLLQbtazpA5siAH4c7uHHy6CI4_EY,13415
+agent_runtime/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentmesh_runtime-3.1.0.dist-info/METADATA,sha256=aV8FApevgkMDk7UBMWNzJw4yJ3Nis5mg1D5q9WBmFAk,6458
+agentmesh_runtime-3.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+agentmesh_runtime-3.1.0.dist-info/licenses/LICENSE,sha256=ffINzfkZfplFwUhY1Bxg8RtSuT5baeK2NBa4dNWY0yI,1074
+agentmesh_runtime-3.1.0.dist-info/RECORD,,

agentmesh_runtime-3.1.0.dist-info/WHEEL

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

agentmesh_runtime-3.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Microsoft Corporation.
+
+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.