agentcab 0.1.0__py3-none-any.whl

agentcab/__init__.py

@@ -0,0 +1,45 @@
+"""
+AgentCab Python SDK
+
+Official Python SDK for AgentCab - AI Agent API Marketplace
+"""
+
+__version__ = "0.1.0"
+
+from .provider import ProviderClient, ProviderWorker
+from .caller import CallerClient
+from .exceptions import (
+    AgentCabError,
+    AuthenticationError,
+    NotFoundError,
+    ValidationError,
+    RateLimitError,
+    ServerError,
+    NetworkError,
+    TimeoutError,
+)
+from .types import Skill, Call, Job, Wallet, Transaction, Withdrawal
+
+__all__ = [
+    # Provider
+    "ProviderClient",
+    "ProviderWorker",
+    # Caller
+    "CallerClient",
+    # Exceptions
+    "AgentCabError",
+    "AuthenticationError",
+    "NotFoundError",
+    "ValidationError",
+    "RateLimitError",
+    "ServerError",
+    "NetworkError",
+    "TimeoutError",
+    # Types
+    "Skill",
+    "Call",
+    "Job",
+    "Wallet",
+    "Transaction",
+    "Withdrawal",
+]

agentcab/caller.py

@@ -0,0 +1,159 @@
+"""AgentCab Caller SDK"""
+
+import time
+import logging
+from typing import Optional, Dict, Any, List
+
+from .client import BaseClient
+from .types import Skill, Call
+from .exceptions import AgentCabError, TimeoutError as SDKTimeoutError
+
+
+logger = logging.getLogger(__name__)
+
+
+class CallerClient(BaseClient):
+    """Client for Caller operations (call skills, check status, etc.)"""
+
+    def list_skills(
+        self,
+        query: Optional[str] = None,
+        category: Optional[str] = None,
+        status: str = "active",
+        page: int = 1,
+        page_size: int = 20,
+    ) -> Dict[str, Any]:
+        """
+        List available skills
+
+        Returns:
+            {
+                "items": [...],
+                "page": 1,
+                "page_size": 20,
+                "total": 100
+            }
+        """
+        params = {
+            "q": query,
+            "category": category,
+            "status_filter": status,
+            "page": page,
+            "page_size": page_size,
+        }
+        # Remove None values
+        params = {k: v for k, v in params.items() if v is not None}
+        return self.get("/skills", params=params)
+
+    def get_skill(self, skill_id: str) -> Skill:
+        """Get skill details"""
+        return self.get(f"/skills/{skill_id}")
+
+    def call_skill(
+        self,
+        skill_id: str,
+        input: Dict[str, Any],
+        max_cost: Optional[int] = None,
+        wait: bool = False,
+        wait_timeout: int = 60,
+        poll_interval: int = 2,
+    ) -> Call:
+        """
+        Call a skill
+
+        Args:
+            skill_id: Skill ID to call
+            input: Input data for the skill
+            max_cost: Maximum credits willing to pay (optional)
+            wait: Whether to wait for result (default: False)
+            wait_timeout: Maximum seconds to wait for result (default: 60)
+            poll_interval: Seconds between status checks (default: 2)
+
+        Returns:
+            Call object with status and output (if wait=True and completed)
+        """
+        payload = {"input": input}
+        if max_cost is not None:
+            payload["max_cost"] = max_cost
+
+        result = self.post(f"/skills/{skill_id}/call", json=payload)
+
+        if not wait:
+            return result
+
+        # Wait for result
+        call_id = result["call_id"]
+        start_time = time.time()
+
+        while time.time() - start_time < wait_timeout:
+            call = self.get_call(call_id)
+
+            if call["status"] in ["success", "failed", "timeout"]:
+                return call
+
+            time.sleep(poll_interval)
+
+        raise SDKTimeoutError(f"Call {call_id} did not complete within {wait_timeout}s")
+
+    def get_call(self, call_id: str) -> Call:
+        """Get call status and result"""
+        return self.get(f"/calls/{call_id}")
+
+    def list_my_calls(
+        self,
+        page: int = 1,
+        page_size: int = 20,
+    ) -> Dict[str, Any]:
+        """
+        List my calls
+
+        Returns:
+            {
+                "items": [...],
+                "page": 1,
+                "page_size": 20,
+                "total": 100
+            }
+        """
+        params = {"page": page, "page_size": page_size}
+        return self.get("/calls", params=params)
+
+    def get_wallet(self) -> Dict[str, Any]:
+        """Get wallet balance"""
+        return self.get("/wallet")
+
+    @classmethod
+    def from_credentials(
+        cls,
+        email: str,
+        password: str,
+        base_url: str = "https://www.agentcab.ai/v1",
+    ) -> "CallerClient":
+        """
+        Create client from email/password credentials
+
+        This will login and retrieve the API key.
+        Note: Using API key directly is recommended for security.
+        """
+        import requests
+
+        # Login to get token
+        response = requests.post(
+            f"{base_url}/auth/login",
+            json={"email": email, "password": password}
+        )
+        response.raise_for_status()
+        token = response.json()["data"]["access_token"]
+
+        # Get user info to retrieve API key
+        response = requests.get(
+            f"{base_url}/auth/me",
+            headers={"Authorization": f"Bearer {token}"}
+        )
+        response.raise_for_status()
+        user_data = response.json()["data"]
+
+        # Use API key if available, otherwise use token
+        api_key = user_data.get("api_key_hash") or token
+
+        return cls(api_key=api_key, base_url=base_url)

agentcab/client.py

@@ -0,0 +1,98 @@
+"""AgentCab Base HTTP Client"""
+
+import requests
+from typing import Optional, Dict, Any
+from .exceptions import (
+    AuthenticationError,
+    NotFoundError,
+    ValidationError,
+    RateLimitError,
+    ServerError,
+    NetworkError,
+    TimeoutError as SDKTimeoutError,
+)
+
+
+class BaseClient:
+    """Base HTTP client for AgentCab API"""
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = "https://www.agentcab.ai/v1",
+        timeout: int = 30,
+    ):
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.session = requests.Session()
+        self.session.headers.update({
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+        })
+
+    def _handle_response(self, response: requests.Response) -> Dict[str, Any]:
+        """Handle API response and raise appropriate exceptions"""
+        try:
+            data = response.json()
+        except ValueError:
+            data = {"message": response.text}
+
+        if response.status_code == 200:
+            return data.get("data", data)
+        elif response.status_code == 401:
+            raise AuthenticationError(data.get("message", "Authentication failed"))
+        elif response.status_code == 404:
+            raise NotFoundError(data.get("message", "Resource not found"))
+        elif response.status_code == 400:
+            raise ValidationError(data.get("message", "Validation failed"))
+        elif response.status_code == 429:
+            raise RateLimitError(data.get("message", "Rate limit exceeded"))
+        elif response.status_code >= 500:
+            raise ServerError(data.get("message", f"Server error: {response.status_code}"))
+        else:
+            raise Exception(f"Unexpected status code: {response.status_code}")
+
+    def get(self, path: str, params: Optional[Dict] = None) -> Dict[str, Any]:
+        """Make GET request"""
+        url = f"{self.base_url}{path}"
+        try:
+            response = self.session.get(url, params=params, timeout=self.timeout)
+            return self._handle_response(response)
+        except requests.exceptions.Timeout:
+            raise SDKTimeoutError(f"Request timeout: {url}")
+        except requests.exceptions.ConnectionError as e:
+            raise NetworkError(f"Connection error: {e}")
+
+    def post(self, path: str, json: Optional[Dict] = None) -> Dict[str, Any]:
+        """Make POST request"""
+        url = f"{self.base_url}{path}"
+        try:
+            response = self.session.post(url, json=json, timeout=self.timeout)
+            return self._handle_response(response)
+        except requests.exceptions.Timeout:
+            raise SDKTimeoutError(f"Request timeout: {url}")
+        except requests.exceptions.ConnectionError as e:
+            raise NetworkError(f"Connection error: {e}")
+
+    def put(self, path: str, json: Optional[Dict] = None) -> Dict[str, Any]:
+        """Make PUT request"""
+        url = f"{self.base_url}{path}"
+        try:
+            response = self.session.put(url, json=json, timeout=self.timeout)
+            return self._handle_response(response)
+        except requests.exceptions.Timeout:
+            raise SDKTimeoutError(f"Request timeout: {url}")
+        except requests.exceptions.ConnectionError as e:
+            raise NetworkError(f"Connection error: {e}")
+
+    def delete(self, path: str) -> Dict[str, Any]:
+        """Make DELETE request"""
+        url = f"{self.base_url}{path}"
+        try:
+            response = self.session.delete(url, timeout=self.timeout)
+            return self._handle_response(response)
+        except requests.exceptions.Timeout:
+            raise SDKTimeoutError(f"Request timeout: {url}")
+        except requests.exceptions.ConnectionError as e:
+            raise NetworkError(f"Connection error: {e}")

agentcab/exceptions.py

@@ -0,0 +1,41 @@
+"""AgentCab SDK Exceptions"""
+
+
+class AgentCabError(Exception):
+    """Base exception for AgentCab SDK"""
+    pass
+
+
+class AuthenticationError(AgentCabError):
+    """Authentication failed (invalid API key)"""
+    pass
+
+
+class NotFoundError(AgentCabError):
+    """Resource not found"""
+    pass
+
+
+class ValidationError(AgentCabError):
+    """Request validation failed"""
+    pass
+
+
+class RateLimitError(AgentCabError):
+    """Rate limit exceeded"""
+    pass
+
+
+class ServerError(AgentCabError):
+    """Server error (5xx)"""
+    pass
+
+
+class NetworkError(AgentCabError):
+    """Network connection error"""
+    pass
+
+
+class TimeoutError(AgentCabError):
+    """Request timeout"""
+    pass

agentcab/provider.py

@@ -0,0 +1,254 @@
+"""AgentCab Provider SDK"""
+
+import time
+import signal
+import logging
+import subprocess
+from typing import Optional, Callable, Dict, Any, List
+from multiprocessing import Process
+
+import requests
+
+from .client import BaseClient
+from .types import Skill, Job, Wallet, Transaction, Withdrawal
+from .exceptions import AgentCabError
+
+
+logger = logging.getLogger(__name__)
+
+
+class ProviderClient(BaseClient):
+    """Client for Provider operations (skill management, wallet, etc.)"""
+
+    def create_skill(
+        self,
+        name: str,
+        description: str,
+        input_schema: dict,
+        output_schema: dict,
+        price_credits: int,
+        category: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        max_concurrent_jobs: int = 5,
+    ) -> Skill:
+        """Create a new skill"""
+        data = {
+            "name": name,
+            "description": description,
+            "input_schema": input_schema,
+            "output_schema": output_schema,
+            "price_credits": price_credits,
+            "category": category,
+            "tags": tags,
+            "max_concurrent_jobs": max_concurrent_jobs,
+            "callback_url": "pull://",
+        }
+        return self.post("/skills", json=data)
+
+    def update_skill(self, skill_id: str, **kwargs) -> Skill:
+        """Update skill information"""
+        return self.put(f"/skills/{skill_id}", json=kwargs)
+
+    def delete_skill(self, skill_id: str) -> bool:
+        """Delete a skill"""
+        result = self.delete(f"/skills/{skill_id}")
+        return result.get("deleted", False)
+
+    def list_my_skills(self) -> List[Skill]:
+        """List my skills"""
+        result = self.get("/skills/my")
+        return result if isinstance(result, list) else result.get("items", [])
+
+    def get_skill(self, skill_id: str) -> Skill:
+        """Get skill details"""
+        return self.get(f"/skills/{skill_id}")
+
+    def get_wallet(self) -> Wallet:
+        """Get wallet balance"""
+        return self.get("/wallet")
+
+    def list_transactions(self) -> List[Transaction]:
+        """List transactions"""
+        result = self.get("/wallet/transactions")
+        return result if isinstance(result, list) else result.get("items", [])
+
+    def create_withdrawal(self, amount_credits: int) -> Withdrawal:
+        """Create withdrawal request"""
+        return self.post("/withdrawals", json={"amount_credits": amount_credits})
+
+
+class ProviderWorker:
+    """Worker for processing jobs from AgentCab platform"""
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = "https://www.agentcab.ai/v1",
+        process_fn: Optional[Callable[[Dict], Dict]] = None,
+        agent_url: Optional[str] = None,
+        command: Optional[str] = None,
+        poll_interval: int = 5,
+        max_workers: int = 1,
+        timeout: int = 30,
+    ):
+        """
+        Initialize Provider Worker
+
+        Args:
+            api_key: AgentCab API key
+            base_url: API base URL
+            process_fn: Python function to process jobs (input_data -> output_data)
+            agent_url: HTTP URL to forward jobs to
+            command: Shell command to execute for each job
+            poll_interval: Seconds between polling for new jobs
+            max_workers: Number of concurrent workers
+            timeout: Request timeout in seconds
+        """
+        if not any([process_fn, agent_url, command]):
+            raise ValueError("Must provide one of: process_fn, agent_url, command")
+
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.process_fn = process_fn
+        self.agent_url = agent_url
+        self.command = command
+        self.poll_interval = poll_interval
+        self.max_workers = max_workers
+        self.timeout = timeout
+        self.running = True
+
+        # Setup signal handlers for graceful shutdown
+        signal.signal(signal.SIGINT, self._shutdown)
+        signal.signal(signal.SIGTERM, self._shutdown)
+
+        self.client = BaseClient(api_key, base_url, timeout)
+
+    def _shutdown(self, signum, frame):
+        """Handle shutdown signals"""
+        logger.info("Shutting down gracefully...")
+        self.running = False
+
+    def get_next_job(self) -> Optional[Job]:
+        """Poll for next available job"""
+        try:
+            result = self.client.get("/provider/jobs/next")
+            return result if result else None
+        except AgentCabError as e:
+            logger.error(f"Error getting next job: {e}")
+            return None
+
+    def submit_result(
+        self,
+        call_id: str,
+        output: Optional[Dict] = None,
+        output_ref: Optional[str] = None,
+        error_message: Optional[str] = None,
+    ):
+        """Submit job result"""
+        payload = {}
+        if output:
+            payload["output"] = output
+        if output_ref:
+            payload["output_ref"] = output_ref
+        if error_message:
+            payload["error_message"] = error_message
+
+        try:
+            self.client.post(f"/provider/jobs/{call_id}/result", json=payload)
+            logger.info(f"✓ Job {call_id} completed")
+        except AgentCabError as e:
+            logger.error(f"✗ Failed to submit result for {call_id}: {e}")
+
+    def process_job(self, job: Job) -> Dict:
+        """Process a job using configured method"""
+        input_data = job["input"]
+
+        if self.process_fn:
+            # Python function mode
+            return self.process_fn(input_data)
+
+        elif self.agent_url:
+            # HTTP proxy mode
+            response = requests.post(
+                self.agent_url,
+                json=input_data,
+                timeout=self.timeout
+            )
+            response.raise_for_status()
+            return response.json()
+
+        elif self.command:
+            # Command line mode
+            import json
+            process = subprocess.Popen(
+                self.command,
+                shell=True,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+            stdout, stderr = process.communicate(
+                input=json.dumps(input_data).encode(),
+                timeout=self.timeout
+            )
+            if process.returncode != 0:
+                raise Exception(f"Command failed: {stderr.decode()}")
+            return json.loads(stdout.decode())
+
+    def _worker_loop(self, worker_id: int):
+        """Main worker loop"""
+        logger.info(f"Worker {worker_id} started")
+
+        while self.running:
+            try:
+                # Poll for next job
+                job = self.get_next_job()
+
+                if not job:
+                    # No jobs available, wait and retry
+                    time.sleep(self.poll_interval)
+                    continue
+
+                call_id = job["call_id"]
+                logger.info(f"Worker {worker_id} processing job {call_id}")
+
+                try:
+                    # Process job
+                    output = self.process_job(job)
+
+                    # Submit success result
+                    self.submit_result(call_id, output=output)
+
+                except Exception as e:
+                    # Submit error result
+                    logger.error(f"Worker {worker_id} job {call_id} failed: {e}")
+                    self.submit_result(call_id, error_message=str(e))
+
+            except KeyboardInterrupt:
+                break
+            except Exception as e:
+                logger.error(f"Worker {worker_id} error: {e}")
+                time.sleep(10)
+
+        logger.info(f"Worker {worker_id} stopped")
+
+    def run(self):
+        """Start worker(s)"""
+        logger.info(f"Starting {self.max_workers} worker(s)...")
+
+        if self.max_workers == 1:
+            # Single worker mode (no multiprocessing)
+            self._worker_loop(0)
+        else:
+            # Multi-worker mode
+            workers = []
+            for i in range(self.max_workers):
+                p = Process(target=self._worker_loop, args=(i,))
+                p.start()
+                workers.append(p)
+
+            # Wait for all workers
+            for p in workers:
+                p.join()
+
+        logger.info("All workers stopped")

agentcab/types.py

@@ -0,0 +1,78 @@
+"""AgentCab SDK Type Definitions"""
+
+from typing import TypedDict, Optional, List, Any
+from datetime import datetime
+
+
+class Skill(TypedDict):
+    """Skill information"""
+    id: str
+    agent_id: str
+    name: str
+    description: Optional[str]
+    input_schema: dict
+    output_schema: dict
+    price_credits: int
+    category: Optional[str]
+    tags: Optional[List[str]]
+    callback_url: Optional[str]
+    max_concurrent_jobs: int
+    status: str
+    call_count: int
+    success_count: int
+    rating: float
+    created_at: str
+    updated_at: Optional[str]
+
+
+class Call(TypedDict):
+    """Call information"""
+    id: str
+    skill_id: str
+    caller_id: str
+    input_data: dict
+    output_data: Optional[dict]
+    credits_cost: int
+    status: str
+    error_message: Optional[str]
+    started_at: str
+    completed_at: Optional[str]
+    duration_ms: Optional[int]
+
+
+class Job(TypedDict):
+    """Provider job information"""
+    call_id: str
+    skill_id: str
+    input: dict
+    output_schema: dict
+    status: str
+    started_at: str
+
+
+class Wallet(TypedDict):
+    """Wallet information"""
+    user_id: str
+    credits: float
+    frozen_credits: float
+
+
+class Transaction(TypedDict):
+    """Transaction information"""
+    id: str
+    from_wallet_id: Optional[str]
+    to_wallet_id: Optional[str]
+    credits: float
+    tx_type: str
+    call_id: Optional[str]
+    created_at: str
+
+
+class Withdrawal(TypedDict):
+    """Withdrawal information"""
+    id: str
+    user_id: str
+    amount_credits: int
+    status: str
+    created_at: str
+    processed_at: Optional[str]

agentcab-0.1.0.dist-info/METADATA

@@ -0,0 +1,390 @@
+Metadata-Version: 2.4
+Name: agentcab
+Version: 0.1.0
+Summary: Official Python SDK for AgentCab - AI Agent API Marketplace
+Home-page: https://github.com/moyaForHY/agenthub
+Author: AgentCab
+Author-email: support@agentcab.ai
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+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
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=3.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: flake8>=4.0.0; extra == "dev"
+Requires-Dist: mypy>=0.950; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# AgentCab Python SDK
+
+Official Python SDK for [AgentCab](https://www.agentcab.ai) - AI Agent API Marketplace
+
+## Installation
+
+### Install from GitHub (Recommended for now)
+
+```bash
+pip install git+https://github.com/yourusername/agentcab.git#subdirectory=sdk
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/yourusername/agentcab.git
+cd agentcab/sdk
+pip install -e .
+```
+
+### Install from PyPI (Coming soon)
+
+```bash
+pip install agentcab
+```
+
+## Quick Start
+
+### For Providers (Earn by providing AI services)
+
+```python
+from agentcab import ProviderWorker
+
+def my_agent(input_data):
+    # Your AI agent logic here
+    text = input_data["text"]
+    result = process_text(text)  # Your processing
+    return {"result": result}
+
+# Start worker to process jobs
+worker = ProviderWorker(
+    api_key="your_api_key",
+    process_fn=my_agent,
+    poll_interval=5,
+    max_workers=3
+)
+worker.run()
+```
+
+### For Callers (Use AI services)
+
+```python
+from agentcab import CallerClient
+
+client = CallerClient(api_key="your_api_key")
+
+# List available skills
+skills = client.list_skills()
+
+# Call a skill
+result = client.call_skill(
+    skill_id="skill-uuid",
+    input={"text": "Hello, world!"},
+    wait=True  # Wait for result
+)
+
+print(result["output_data"])
+```
+
+## Provider SDK
+
+### Publishing a Skill
+
+```python
+from agentcab import ProviderClient
+
+provider = ProviderClient(api_key="your_api_key")
+
+skill = provider.create_skill(
+    name="Text Summarizer",
+    description="Summarize long text using AI",
+    category="nlp",
+    price_credits=50,
+    max_concurrent_jobs=5,
+    input_schema={
+        "type": "object",
+        "properties": {
+            "text": {"type": "string"}
+        },
+        "required": ["text"]
+    },
+    output_schema={
+        "type": "object",
+        "properties": {
+            "summary": {"type": "string"}
+        },
+        "required": ["summary"]
+    }
+)
+
+print(f"Skill created: {skill['id']}")
+```
+
+### Processing Jobs
+
+#### Method 1: Python Function (Recommended)
+
+```python
+from agentcab import ProviderWorker
+
+def process(input_data):
+    # Your logic here
+    return {"result": "processed"}
+
+worker = ProviderWorker(
+    api_key="your_api_key",
+    process_fn=process
+)
+worker.run()
+```
+
+#### Method 2: HTTP Service
+
+```python
+from agentcab import ProviderWorker
+
+# Forward jobs to your existing HTTP service
+worker = ProviderWorker(
+    api_key="your_api_key",
+    agent_url="http://localhost:8080/process"
+)
+worker.run()
+```
+
+#### Method 3: Command Line
+
+```python
+from agentcab import ProviderWorker
+
+# Execute a command for each job
+worker = ProviderWorker(
+    api_key="your_api_key",
+    command="python my_agent.py"  # Reads JSON from stdin, writes to stdout
+)
+worker.run()
+```
+
+### Using Claude API
+
+```python
+from agentcab import ProviderWorker
+from anthropic import Anthropic
+
+claude = Anthropic(api_key="your_claude_key")
+
+def process_with_claude(input_data):
+    message = claude.messages.create(
+        model="claude-3-5-sonnet-20241022",
+        max_tokens=1024,
+        messages=[{"role": "user", "content": input_data["prompt"]}]
+    )
+    return {"result": message.content[0].text}
+
+worker = ProviderWorker(
+    api_key="your_agentcab_key",
+    process_fn=process_with_claude,
+    max_workers=3
+)
+worker.run()
+```
+
+### Multi-Worker Concurrency
+
+```python
+worker = ProviderWorker(
+    api_key="your_api_key",
+    process_fn=my_agent,
+    max_workers=5  # Process 5 jobs concurrently
+)
+worker.run()
+```
+
+## Caller SDK
+
+### Listing Skills
+
+```python
+from agentcab import CallerClient
+
+client = CallerClient(api_key="your_api_key")
+
+# List all skills
+result = client.list_skills(page=1, page_size=20)
+for skill in result["items"]:
+    print(f"{skill['name']}: {skill['price_credits']} credits")
+
+# Search skills
+result = client.list_skills(query="summarize", category="nlp")
+
+# Get skill details
+skill = client.get_skill(skill_id="skill-uuid")
+```
+
+### Calling Skills
+
+#### Synchronous (Wait for Result)
+
+```python
+result = client.call_skill(
+    skill_id="skill-uuid",
+    input={"text": "Hello"},
+    wait=True,
+    wait_timeout=60
+)
+
+if result["status"] == "success":
+    print(result["output_data"])
+else:
+    print(f"Error: {result['error_message']}")
+```
+
+#### Asynchronous (Poll Later)
+
+```python
+# Start call
+call = client.call_skill(
+    skill_id="skill-uuid",
+    input={"text": "Hello"},
+    wait=False
+)
+
+call_id = call["call_id"]
+
+# Poll for result later
+import time
+while True:
+    result = client.get_call(call_id)
+    if result["status"] in ["success", "failed", "timeout"]:
+        break
+    time.sleep(2)
+
+print(result["output_data"])
+```
+
+### Wallet Management
+
+```python
+# Check balance
+wallet = client.get_wallet()
+print(f"Credits: {wallet['credits']}")
+
+# List calls
+calls = client.list_my_calls(page=1, page_size=10)
+```
+
+## Provider Wallet Management
+
+```python
+from agentcab import ProviderClient
+
+provider = ProviderClient(api_key="your_api_key")
+
+# Check earnings
+wallet = provider.get_wallet()
+print(f"Earnings: {wallet['credits']} credits")
+
+# List transactions
+transactions = provider.list_transactions()
+
+# Request withdrawal
+withdrawal = provider.create_withdrawal(amount_credits=1000)
+print(f"Withdrawal requested: {withdrawal['id']}")
+```
+
+## Error Handling
+
+```python
+from agentcab import (
+    CallerClient,
+    AuthenticationError,
+    NotFoundError,
+    ValidationError,
+    RateLimitError,
+    ServerError,
+    NetworkError,
+    TimeoutError
+)
+
+client = CallerClient(api_key="your_api_key")
+
+try:
+    result = client.call_skill(skill_id="invalid", input={})
+except AuthenticationError:
+    print("Invalid API key")
+except NotFoundError:
+    print("Skill not found")
+except ValidationError as e:
+    print(f"Invalid input: {e}")
+except RateLimitError:
+    print("Rate limit exceeded")
+except TimeoutError:
+    print("Request timeout")
+except ServerError:
+    print("Server error")
+except NetworkError:
+    print("Network error")
+```
+
+## Configuration
+
+### Environment Variables
+
+```bash
+export AGENTCAB_API_KEY=your_api_key
+export AGENTCAB_BASE_URL=https://www.agentcab.ai/v1  # Optional
+```
+
+### Custom Base URL
+
+```python
+from agentcab import CallerClient
+
+client = CallerClient(
+    api_key="your_api_key",
+    base_url="https://custom.agentcab.ai/v1"
+)
+```
+
+## Examples
+
+See the `examples/` directory for complete examples:
+
+- `provider_simple.py` - Simple text processing provider
+- `provider_claude.py` - Provider using Claude API
+- `provider_http.py` - Provider forwarding to HTTP service
+- `caller_example.py` - Caller using skills
+
+## Documentation
+
+- [AgentCab Documentation](https://www.agentcab.ai/docs)
+- [API Reference](https://www.agentcab.ai/api-docs)
+- [Pull Mode Architecture](https://github.com/agentcab/agentcab/blob/main/PULL_MODE_ARCHITECTURE.md)
+
+## Support
+
+- GitHub Issues: https://github.com/agentcab/agentcab-python/issues
+- Email: support@agentcab.ai
+- Discord: https://discord.gg/agentcab
+
+## License
+
+MIT License - see LICENSE file for details

agentcab-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+agentcab/__init__.py,sha256=N5tw823mC5xZrKzmUm_-rLU4ATaC8JL1BbZJQvyEabw,849
+agentcab/caller.py,sha256=ahui-nCCDTDlZlN0h9VB0fPNf2UJcqHvhIMf7pdoink,4443
+agentcab/client.py,sha256=yRn8IWp2y4OajNZ6qZD0oidhvSpWgSGF9z1nyB6i0HQ,3848
+agentcab/exceptions.py,sha256=8PdrqxiIkcnkzxcDpF4hmwglk4JBQwV_D6G6-AEBXRM,684
+agentcab/provider.py,sha256=T6hw9nKqaKbW4jz-v_WBQWcAOvuIO_Trcx8aqQsHWKQ,8227
+agentcab/types.py,sha256=vJ-Xz3VwIr7hty8BwdiNVrv7yQzgJxGbIE9XbDmQi3M,1570
+agentcab-0.1.0.dist-info/licenses/LICENSE,sha256=TbHNxYu8sVgN3A8lvTDkDmhEDSa4x8LV4ExDfSVr30g,1065
+agentcab-0.1.0.dist-info/METADATA,sha256=w_KW3_0kNn0pM402FxwjLip2EPpIyvj1DgKBrbav-R0,8273
+agentcab-0.1.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+agentcab-0.1.0.dist-info/top_level.txt,sha256=fAyJwQgglmr1bCms2lcIi86GOn0RJ0YZFlnaxXfEMic,9
+agentcab-0.1.0.dist-info/RECORD,,

agentcab-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

agentcab-0.1.0.dist-info/licenses/LICENSE

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

agentcab-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+agentcab