agentstamp 1.1.0__tar.gz

agentstamp-1.1.0/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: agentstamp
+Version: 1.1.0
+Summary: Identity lifecycle SDK for Python AI agents — trust stamps, registry, heartbeats, auto-renewal
+Home-page: https://agentstamp.org
+Author: Vinay Bhosle
+Author-email: Vinay Bhosle <vinay@agentstamp.org>
+License: MIT
+Project-URL: Homepage, https://agentstamp.org
+Project-URL: Repository, https://github.com/AgentstampHQ/agentstamp-python
+Project-URL: Documentation, https://agentstamp.org
+Project-URL: npm SDK, https://www.npmjs.com/package/agentstamp-verify
+Keywords: agentstamp,ai-agents,crewai,autogen,langgraph,identity,trust,verification,x402,reputation
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Security
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.20.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+# agentstamp
+
+Identity lifecycle SDK for Python AI agents. Works with CrewAI, AutoGen, LangGraph, and any Python agent framework.
+
+Register your agent, mint trust stamps, send heartbeats, and auto-renew — in 3 lines.
+
+## Install
+
+```bash
+pip install agentstamp
+```
+
+## Quick Start
+
+```python
+from agentstamp_crewai import AgentStampLifecycle
+
+lifecycle = AgentStampLifecycle(
+    wallet_address="0xYourWalletAddress",
+    name="MyAgent",
+    description="What your agent does",
+    category="research",
+)
+lifecycle.start()  # stamps + registers + heartbeats + auto-renew
+```
+
+That's it. Your agent now has:
+- A cryptographic identity stamp (Ed25519)
+- A public registry listing
+- Heartbeat-based uptime reputation
+- Auto-renewal before expiry
+
+## Verify Other Agents
+
+```python
+trust = lifecycle.check_trust("0xOtherAgentWallet")
+if trust.get("trusted"):
+    print(f"Verified: {trust['agent']['name']} (score: {trust['reputation']['score']})")
+else:
+    print("Unverified agent — proceed with caution")
+```
+
+## Gate Functions Behind Verification
+
+```python
+from agentstamp_crewai import stamp_verified
+
+@stamp_verified(lifecycle)
+def sensitive_operation(data: str) -> str:
+    """Only runs if the agent is AgentStamp verified."""
+    return process(data)
+```
+
+## CrewAI Integration
+
+```python
+from crewai import Agent, Task, Crew
+from agentstamp_crewai import AgentStampLifecycle
+
+# Start lifecycle
+lifecycle = AgentStampLifecycle(
+    wallet_address="0x...",
+    name="ResearchBot",
+    description="Finds and summarizes papers",
+    category="research",
+)
+lifecycle.start()
+
+# Create CrewAI agent as normal
+agent = Agent(
+    role="Researcher",
+    goal="Find relevant papers",
+    backstory="Expert research assistant",
+)
+
+# Check trust before collaborating with other agents
+trust = lifecycle.check_trust("0xCollaboratorWallet")
+```
+
+## Configuration
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `wallet_address` | required | Your agent's wallet address (EVM or Solana) |
+| `name` | required | Agent display name |
+| `description` | required | What your agent does |
+| `category` | `"other"` | `research`, `trading`, `social`, `infrastructure`, etc. |
+| `heartbeat_interval` | `300` | Seconds between heartbeats |
+| `renew_before_days` | `2` | Days before expiry to auto-renew |
+| `verbose` | `True` | Print lifecycle logs |
+
+## Badge
+
+Add a trust badge to your README:
+
+```markdown
+![AgentStamp](https://agentstamp.org/api/v1/badge/0xYourWallet)
+```
+
+## Links
+
+- [AgentStamp](https://agentstamp.org) — Platform
+- [npm SDK](https://www.npmjs.com/package/agentstamp-verify) — TypeScript/Node.js SDK
+- [API Docs](https://agentstamp.org/api/v1/trust/check/0x...) — Trust check endpoint

agentstamp-1.1.0/README.md

@@ -0,0 +1,104 @@
+# agentstamp
+
+Identity lifecycle SDK for Python AI agents. Works with CrewAI, AutoGen, LangGraph, and any Python agent framework.
+
+Register your agent, mint trust stamps, send heartbeats, and auto-renew — in 3 lines.
+
+## Install
+
+```bash
+pip install agentstamp
+```
+
+## Quick Start
+
+```python
+from agentstamp_crewai import AgentStampLifecycle
+
+lifecycle = AgentStampLifecycle(
+    wallet_address="0xYourWalletAddress",
+    name="MyAgent",
+    description="What your agent does",
+    category="research",
+)
+lifecycle.start()  # stamps + registers + heartbeats + auto-renew
+```
+
+That's it. Your agent now has:
+- A cryptographic identity stamp (Ed25519)
+- A public registry listing
+- Heartbeat-based uptime reputation
+- Auto-renewal before expiry
+
+## Verify Other Agents
+
+```python
+trust = lifecycle.check_trust("0xOtherAgentWallet")
+if trust.get("trusted"):
+    print(f"Verified: {trust['agent']['name']} (score: {trust['reputation']['score']})")
+else:
+    print("Unverified agent — proceed with caution")
+```
+
+## Gate Functions Behind Verification
+
+```python
+from agentstamp_crewai import stamp_verified
+
+@stamp_verified(lifecycle)
+def sensitive_operation(data: str) -> str:
+    """Only runs if the agent is AgentStamp verified."""
+    return process(data)
+```
+
+## CrewAI Integration
+
+```python
+from crewai import Agent, Task, Crew
+from agentstamp_crewai import AgentStampLifecycle
+
+# Start lifecycle
+lifecycle = AgentStampLifecycle(
+    wallet_address="0x...",
+    name="ResearchBot",
+    description="Finds and summarizes papers",
+    category="research",
+)
+lifecycle.start()
+
+# Create CrewAI agent as normal
+agent = Agent(
+    role="Researcher",
+    goal="Find relevant papers",
+    backstory="Expert research assistant",
+)
+
+# Check trust before collaborating with other agents
+trust = lifecycle.check_trust("0xCollaboratorWallet")
+```
+
+## Configuration
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `wallet_address` | required | Your agent's wallet address (EVM or Solana) |
+| `name` | required | Agent display name |
+| `description` | required | What your agent does |
+| `category` | `"other"` | `research`, `trading`, `social`, `infrastructure`, etc. |
+| `heartbeat_interval` | `300` | Seconds between heartbeats |
+| `renew_before_days` | `2` | Days before expiry to auto-renew |
+| `verbose` | `True` | Print lifecycle logs |
+
+## Badge
+
+Add a trust badge to your README:
+
+```markdown
+![AgentStamp](https://agentstamp.org/api/v1/badge/0xYourWallet)
+```
+
+## Links
+
+- [AgentStamp](https://agentstamp.org) — Platform
+- [npm SDK](https://www.npmjs.com/package/agentstamp-verify) — TypeScript/Node.js SDK
+- [API Docs](https://agentstamp.org/api/v1/trust/check/0x...) — Trust check endpoint

agentstamp-1.1.0/agentstamp.egg-info/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: agentstamp
+Version: 1.1.0
+Summary: Identity lifecycle SDK for Python AI agents — trust stamps, registry, heartbeats, auto-renewal
+Home-page: https://agentstamp.org
+Author: Vinay Bhosle
+Author-email: Vinay Bhosle <vinay@agentstamp.org>
+License: MIT
+Project-URL: Homepage, https://agentstamp.org
+Project-URL: Repository, https://github.com/AgentstampHQ/agentstamp-python
+Project-URL: Documentation, https://agentstamp.org
+Project-URL: npm SDK, https://www.npmjs.com/package/agentstamp-verify
+Keywords: agentstamp,ai-agents,crewai,autogen,langgraph,identity,trust,verification,x402,reputation
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Security
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.20.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+# agentstamp
+
+Identity lifecycle SDK for Python AI agents. Works with CrewAI, AutoGen, LangGraph, and any Python agent framework.
+
+Register your agent, mint trust stamps, send heartbeats, and auto-renew — in 3 lines.
+
+## Install
+
+```bash
+pip install agentstamp
+```
+
+## Quick Start
+
+```python
+from agentstamp_crewai import AgentStampLifecycle
+
+lifecycle = AgentStampLifecycle(
+    wallet_address="0xYourWalletAddress",
+    name="MyAgent",
+    description="What your agent does",
+    category="research",
+)
+lifecycle.start()  # stamps + registers + heartbeats + auto-renew
+```
+
+That's it. Your agent now has:
+- A cryptographic identity stamp (Ed25519)
+- A public registry listing
+- Heartbeat-based uptime reputation
+- Auto-renewal before expiry
+
+## Verify Other Agents
+
+```python
+trust = lifecycle.check_trust("0xOtherAgentWallet")
+if trust.get("trusted"):
+    print(f"Verified: {trust['agent']['name']} (score: {trust['reputation']['score']})")
+else:
+    print("Unverified agent — proceed with caution")
+```
+
+## Gate Functions Behind Verification
+
+```python
+from agentstamp_crewai import stamp_verified
+
+@stamp_verified(lifecycle)
+def sensitive_operation(data: str) -> str:
+    """Only runs if the agent is AgentStamp verified."""
+    return process(data)
+```
+
+## CrewAI Integration
+
+```python
+from crewai import Agent, Task, Crew
+from agentstamp_crewai import AgentStampLifecycle
+
+# Start lifecycle
+lifecycle = AgentStampLifecycle(
+    wallet_address="0x...",
+    name="ResearchBot",
+    description="Finds and summarizes papers",
+    category="research",
+)
+lifecycle.start()
+
+# Create CrewAI agent as normal
+agent = Agent(
+    role="Researcher",
+    goal="Find relevant papers",
+    backstory="Expert research assistant",
+)
+
+# Check trust before collaborating with other agents
+trust = lifecycle.check_trust("0xCollaboratorWallet")
+```
+
+## Configuration
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `wallet_address` | required | Your agent's wallet address (EVM or Solana) |
+| `name` | required | Agent display name |
+| `description` | required | What your agent does |
+| `category` | `"other"` | `research`, `trading`, `social`, `infrastructure`, etc. |
+| `heartbeat_interval` | `300` | Seconds between heartbeats |
+| `renew_before_days` | `2` | Days before expiry to auto-renew |
+| `verbose` | `True` | Print lifecycle logs |
+
+## Badge
+
+Add a trust badge to your README:
+
+```markdown
+![AgentStamp](https://agentstamp.org/api/v1/badge/0xYourWallet)
+```
+
+## Links
+
+- [AgentStamp](https://agentstamp.org) — Platform
+- [npm SDK](https://www.npmjs.com/package/agentstamp-verify) — TypeScript/Node.js SDK
+- [API Docs](https://agentstamp.org/api/v1/trust/check/0x...) — Trust check endpoint

agentstamp-1.1.0/agentstamp.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+agentstamp_crewai.py
+pyproject.toml
+setup.py
+agentstamp.egg-info/PKG-INFO
+agentstamp.egg-info/SOURCES.txt
+agentstamp.egg-info/dependency_links.txt
+agentstamp.egg-info/requires.txt
+agentstamp.egg-info/top_level.txt

agentstamp-1.1.0/agentstamp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agentstamp-1.1.0/agentstamp.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.20.0

agentstamp-1.1.0/agentstamp.egg-info/top_level.txt

@@ -0,0 +1 @@
+agentstamp_crewai

agentstamp-1.1.0/agentstamp_crewai.py

@@ -0,0 +1,374 @@
+"""
+AgentStamp + CrewAI Integration
+
+Drop-in identity lifecycle for CrewAI agents.
+Auto-registers your agent on first run, sends heartbeats, and auto-renews.
+
+Install:
+    pip install requests
+
+Usage:
+    from agentstamp_crewai import AgentStampLifecycle, stamp_verified_tool
+
+    # Auto-register on startup
+    lifecycle = AgentStampLifecycle(
+        wallet_address="0x...",
+        name="MyResearchAgent",
+        description="Finds and summarizes research papers",
+        category="research",
+    )
+    lifecycle.start()  # stamps + registers + heartbeats + auto-renew
+
+    # Use as a CrewAI tool
+    @stamp_verified_tool
+    def my_api_call(query: str) -> str:
+        '''Makes an API call only if the caller is AgentStamp verified.'''
+        return do_the_thing(query)
+
+    # Or check trust manually
+    trust = lifecycle.check_trust("0x_other_agent_wallet")
+    if trust["trusted"]:
+        proceed()
+"""
+
+import json
+import time
+import threading
+from typing import Optional, Callable, Any
+import requests
+
+
+AGENTSTAMP_API = "https://agentstamp.org"
+
+
+class AgentStampLifecycle:
+    """
+    Manages the full AgentStamp identity lifecycle for a CrewAI agent.
+
+    - Auto-registers (free stamp + free directory listing) on first run
+    - Sends periodic heartbeats for uptime reputation
+    - Auto-renews stamps and registrations before they expire
+    """
+
+    def __init__(
+        self,
+        wallet_address: str,
+        name: str,
+        description: str,
+        category: str = "other",
+        capabilities: Optional[list] = None,
+        endpoint_url: Optional[str] = None,
+        base_url: str = AGENTSTAMP_API,
+        heartbeat_interval: int = 300,  # seconds
+        renew_before_days: int = 2,
+        renew_check_interval: int = 3600,  # seconds
+        verbose: bool = True,
+        on_registered: Optional[Callable] = None,
+        on_renewed: Optional[Callable] = None,
+        on_error: Optional[Callable] = None,
+    ):
+        self.wallet_address = wallet_address
+        self.name = name
+        self.description = description
+        self.category = category
+        self.capabilities = capabilities or []
+        self.endpoint_url = endpoint_url
+        self.base_url = base_url.rstrip("/")
+        self.heartbeat_interval = heartbeat_interval
+        self.renew_before_days = renew_before_days
+        self.renew_check_interval = renew_check_interval
+        self.verbose = verbose
+        self.on_registered = on_registered
+        self.on_renewed = on_renewed
+        self.on_error = on_error
+
+        # State
+        self.agent_id: Optional[str] = None
+        self.stamp_id: Optional[str] = None
+        self.stamp_expires_at: Optional[str] = None
+        self.registration_expires_at: Optional[str] = None
+        self.heartbeat_count: int = 0
+        self.initialized: bool = False
+
+        # Timers
+        self._heartbeat_timer: Optional[threading.Timer] = None
+        self._renew_timer: Optional[threading.Timer] = None
+        self._shutdown = False
+
+    def start(self) -> dict:
+        """Initialize + heartbeat + auto-renew in one call."""
+        state = self.initialize()
+        self.enable_heartbeat()
+        self.enable_auto_renew()
+        return state
+
+    def initialize(self) -> dict:
+        """Mint a free stamp and register if not already done."""
+        self._log("Initializing agent lifecycle...")
+
+        # Check if already registered
+        if self._check_existing():
+            self._log(f"Agent already registered: {self.agent_id}")
+            self.initialized = True
+            return self.get_state()
+
+        # Step 1: Mint free stamp
+        try:
+            self._log("Minting free stamp...")
+            resp = requests.post(
+                f"{self.base_url}/api/v1/stamp/mint/free",
+                json={"wallet_address": self.wallet_address},
+                headers={
+                    "x-wallet-address": self.wallet_address,
+                    "User-Agent": "agentstamp-crewai/1.0.0",
+                },
+                timeout=10,
+            )
+            data = resp.json()
+            if data.get("success") and data.get("stamp"):
+                self.stamp_id = data["stamp"]["id"]
+                self.stamp_expires_at = data["stamp"]["expires_at"]
+                self._log(f"Stamp minted: {self.stamp_id}")
+            elif "cooldown" in str(data.get("error", "")):
+                self._log("Free stamp cooldown active — already stamped")
+        except Exception as e:
+            self._handle_error(e, "mint_stamp")
+
+        # Step 2: Register in directory
+        try:
+            self._log("Registering agent in directory...")
+            resp = requests.post(
+                f"{self.base_url}/api/v1/registry/register/free",
+                json={
+                    "wallet_address": self.wallet_address,
+                    "name": self.name,
+                    "description": self.description,
+                    "category": self.category,
+                    "capabilities": self.capabilities,
+                    "endpoint_url": self.endpoint_url,
+                },
+                headers={
+                    "x-wallet-address": self.wallet_address,
+                    "User-Agent": "agentstamp-crewai/1.0.0",
+                },
+                timeout=10,
+            )
+            data = resp.json()
+            if data.get("success") and data.get("agent"):
+                self.agent_id = data["agent"]["id"]
+                self.registration_expires_at = data["agent"]["expires_at"]
+                self._log(f"Agent registered: {self.agent_id}")
+                if self.on_registered:
+                    self.on_registered({"agent_id": self.agent_id, "stamp_id": self.stamp_id})
+            elif "cooldown" in str(data.get("error", "")):
+                self._log("Free registration cooldown active — already registered")
+                self._check_existing()
+        except Exception as e:
+            self._handle_error(e, "register")
+
+        self.initialized = True
+        return self.get_state()
+
+    def enable_heartbeat(self, interval: Optional[int] = None) -> None:
+        """Send periodic heartbeats to maintain uptime score."""
+        if self._heartbeat_timer is not None:
+            return
+        interval = interval or self.heartbeat_interval
+        self._log(f"Heartbeat enabled (every {interval}s)")
+        self._send_heartbeat()
+        self._schedule_heartbeat(interval)
+
+    def enable_auto_renew(self, check_interval: Optional[int] = None) -> None:
+        """Periodically check and renew stamps/registrations before expiry."""
+        if self._renew_timer is not None:
+            return
+        interval = check_interval or self.renew_check_interval
+        self._log(f"Auto-renewal enabled (check every {interval}s)")
+        self._check_and_renew()
+        self._schedule_renew(interval)
+
+    def check_trust(self, wallet_address: str) -> dict:
+        """Check the trust status of another agent."""
+        try:
+            resp = requests.get(
+                f"{self.base_url}/api/v1/trust/check/{wallet_address}",
+                headers={"User-Agent": "agentstamp-crewai/1.0.0"},
+                timeout=5,
+            )
+            return resp.json()
+        except Exception as e:
+            return {"trusted": False, "error": str(e)}
+
+    def shutdown(self) -> None:
+        """Stop all background timers."""
+        self._shutdown = True
+        if self._heartbeat_timer:
+            self._heartbeat_timer.cancel()
+            self._heartbeat_timer = None
+        if self._renew_timer:
+            self._renew_timer.cancel()
+            self._renew_timer = None
+        self._log("Lifecycle shut down")
+
+    def get_state(self) -> dict:
+        return {
+            "initialized": self.initialized,
+            "agent_id": self.agent_id,
+            "stamp_id": self.stamp_id,
+            "stamp_expires_at": self.stamp_expires_at,
+            "registration_expires_at": self.registration_expires_at,
+            "heartbeat_count": self.heartbeat_count,
+        }
+
+    # --- Private ---
+
+    def _check_existing(self) -> bool:
+        try:
+            resp = requests.get(
+                f"{self.base_url}/api/v1/trust/check/{self.wallet_address}",
+                headers={"User-Agent": "agentstamp-crewai/1.0.0"},
+                timeout=5,
+            )
+            data = resp.json()
+            if data.get("agent"):
+                self.agent_id = data["agent"].get("id")
+            if data.get("stamp"):
+                self.stamp_id = data["stamp"].get("id")
+                self.stamp_expires_at = data["stamp"].get("expires_at")
+            return data.get("trusted", False) or data.get("agent") is not None
+        except Exception:
+            return False
+
+    def _send_heartbeat(self) -> None:
+        if not self.agent_id or self._shutdown:
+            return
+        try:
+            requests.post(
+                f"{self.base_url}/api/v1/registry/heartbeat/{self.agent_id}",
+                headers={"User-Agent": "agentstamp-crewai/1.0.0"},
+                timeout=5,
+            )
+            self.heartbeat_count += 1
+            self._log(f"Heartbeat #{self.heartbeat_count} sent")
+        except Exception as e:
+            self._handle_error(e, "heartbeat")
+
+    def _schedule_heartbeat(self, interval: int) -> None:
+        if self._shutdown:
+            return
+        self._heartbeat_timer = threading.Timer(interval, self._heartbeat_tick, [interval])
+        self._heartbeat_timer.daemon = True
+        self._heartbeat_timer.start()
+
+    def _heartbeat_tick(self, interval: int) -> None:
+        if self._shutdown:
+            return
+        self._send_heartbeat()
+        self._schedule_heartbeat(interval)
+
+    def _check_and_renew(self) -> None:
+        if self._shutdown:
+            return
+        now = time.time()
+        threshold = self.renew_before_days * 86400
+
+        # Check stamp
+        if self.stamp_expires_at:
+            try:
+                from datetime import datetime
+                expiry = datetime.fromisoformat(self.stamp_expires_at.replace("Z", "+00:00")).timestamp()
+                if expiry - now < threshold:
+                    self._log("Stamp expiring soon — renewing...")
+                    resp = requests.post(
+                        f"{self.base_url}/api/v1/stamp/mint/free",
+                        json={"wallet_address": self.wallet_address},
+                        headers={"x-wallet-address": self.wallet_address, "User-Agent": "agentstamp-crewai/1.0.0"},
+                        timeout=10,
+                    )
+                    data = resp.json()
+                    if data.get("success") and data.get("stamp"):
+                        self.stamp_id = data["stamp"]["id"]
+                        self.stamp_expires_at = data["stamp"]["expires_at"]
+                        self._log(f"Stamp renewed: {self.stamp_id}")
+                        if self.on_renewed:
+                            self.on_renewed({"type": "stamp", "expires_at": self.stamp_expires_at})
+            except Exception as e:
+                self._handle_error(e, "renew_stamp")
+
+        # Check registration
+        if self.registration_expires_at:
+            try:
+                from datetime import datetime
+                expiry = datetime.fromisoformat(self.registration_expires_at.replace("Z", "+00:00")).timestamp()
+                if expiry - now < threshold:
+                    self._log("Registration expiring soon — renewing...")
+                    resp = requests.post(
+                        f"{self.base_url}/api/v1/registry/register/free",
+                        json={
+                            "wallet_address": self.wallet_address,
+                            "name": self.name,
+                            "description": self.description,
+                            "category": self.category,
+                            "capabilities": self.capabilities,
+                        },
+                        headers={"x-wallet-address": self.wallet_address, "User-Agent": "agentstamp-crewai/1.0.0"},
+                        timeout=10,
+                    )
+                    data = resp.json()
+                    if data.get("success") and data.get("agent"):
+                        self.agent_id = data["agent"]["id"]
+                        self.registration_expires_at = data["agent"]["expires_at"]
+                        self._log(f"Registration renewed: {self.agent_id}")
+                        if self.on_renewed:
+                            self.on_renewed({"type": "registration", "expires_at": self.registration_expires_at})
+            except Exception as e:
+                self._handle_error(e, "renew_registration")
+
+    def _schedule_renew(self, interval: int) -> None:
+        if self._shutdown:
+            return
+        self._renew_timer = threading.Timer(interval, self._renew_tick, [interval])
+        self._renew_timer.daemon = True
+        self._renew_timer.start()
+
+    def _renew_tick(self, interval: int) -> None:
+        if self._shutdown:
+            return
+        self._check_and_renew()
+        self._schedule_renew(interval)
+
+    def _handle_error(self, err: Exception, context: str) -> None:
+        self._log(f"Error [{context}]: {err}", is_error=True)
+        if self.on_error:
+            self.on_error(err, context)
+
+    def _log(self, message: str, is_error: bool = False) -> None:
+        if self.verbose:
+            prefix = f"[AgentStamp:{self.name}]"
+            if is_error:
+                print(f"\033[91m{prefix} {message}\033[0m")
+            else:
+                print(f"\033[96m{prefix} {message}\033[0m")
+
+
+def stamp_verified(lifecycle: AgentStampLifecycle):
+    """
+    Decorator: only execute a function if the agent is AgentStamp verified.
+
+    Usage:
+        lifecycle = AgentStampLifecycle(...)
+        lifecycle.start()
+
+        @stamp_verified(lifecycle)
+        def my_tool(query: str) -> str:
+            return "result"
+    """
+    def decorator(func: Callable) -> Callable:
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            if not lifecycle.initialized or not lifecycle.agent_id:
+                return "Error: Agent not registered with AgentStamp. Call lifecycle.start() first."
+            return func(*args, **kwargs)
+        wrapper.__name__ = func.__name__
+        wrapper.__doc__ = func.__doc__
+        return wrapper
+    return decorator

agentstamp-1.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "agentstamp"
+version = "1.1.0"
+description = "Identity lifecycle SDK for Python AI agents — trust stamps, registry, heartbeats, auto-renewal"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.8"
+authors = [
+    {name = "Vinay Bhosle", email = "vinay@agentstamp.org"}
+]
+keywords = [
+    "agentstamp", "ai-agents", "crewai", "autogen", "langgraph",
+    "identity", "trust", "verification", "x402", "reputation"
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Security",
+]
+dependencies = ["requests>=2.20.0"]
+
+[project.urls]
+Homepage = "https://agentstamp.org"
+Repository = "https://github.com/AgentstampHQ/agentstamp-python"
+Documentation = "https://agentstamp.org"
+"npm SDK" = "https://www.npmjs.com/package/agentstamp-verify"

agentstamp-1.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

agentstamp-1.1.0/setup.py

@@ -0,0 +1,23 @@
+from setuptools import setup
+
+setup(
+    name="agentstamp",
+    version="1.1.0",
+    description="AgentStamp identity lifecycle for Python AI agents (CrewAI, AutoGen, etc.)",
+    long_description=open("README.md").read() if __import__("os").path.exists("README.md") else "",
+    long_description_content_type="text/markdown",
+    author="Vinay Bhosle",
+    author_email="vinay@agentstamp.org",
+    url="https://agentstamp.org",
+    py_modules=["agentstamp_crewai"],
+    install_requires=["requests>=2.20.0"],
+    python_requires=">=3.8",
+    license="MIT",
+    keywords=["agentstamp", "ai-agents", "crewai", "identity", "trust", "verification"],
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+    ],
+)