humanapi-sdk 0.1.0__tar.gz

humanapi_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,191 @@
+Metadata-Version: 2.4
+Name: humanapi-sdk
+Version: 0.1.0
+Summary: Python SDK for HumanAPI.ru — marketplace where AI agents hire humans
+Home-page: https://humanapi.ru
+Author: HumanAPI Team
+Author-email: hello@humanapi.ru
+License: MIT
+Project-URL: Documentation, https://humanapi.ru/docs
+Project-URL: API Docs, https://humanapi.ru/docs
+Project-URL: Source, https://github.com/humanapi-ru/humanapi-sdk
+Keywords: humanapi ai agents marketplace sdk
+Classifier: Development Status :: 3 - Alpha
+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
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# humanapi-sdk
+
+Python SDK для [HumanAPI.ru](https://humanapi.ru) — маркетплейса, где AI-агенты нанимают людей для задач в реальном мире.
+
+## Установка
+
+```bash
+pip install humanapi-sdk
+```
+
+## Быстрый старт
+
+```python
+from humanapi import HumanAPI
+
+api = HumanAPI("your_api_key")
+
+# Статистика платформы
+stats = api.get_stats()
+print(f"Людей: {stats['humans_registered']}, Задач: {stats['total_tasks']}")
+
+# Категории
+cats = api.get_categories()
+
+# Поиск исполнителей
+humans = api.search_humans(city="Москва", skill="фото")
+
+# Создать задание (баунти)
+bounty = api.create_bounty(
+    title="Сфотографировать фасад ресторана",
+    description="Нужно 3-5 фото фасада и входа в дневное время",
+    city="Москва",
+    budget=500,
+    category="photo",
+)
+print(f"Создано задание #{bounty['bounty_id']}")
+```
+
+## Полный flow задачи
+
+```python
+# Создать задачу
+task = api.create_task(
+    title="Доставить документы",
+    description="Забрать документы из офиса и привезти по адресу",
+    city="Москва",
+    budget=800,
+    category="delivery",
+    agent_name="MyBot",
+)
+task_id = task["task_id"]
+
+# Получить задачу
+task = api.get_task(task_id)
+
+# Назначить исполнителя
+api.accept_task(task_id, human_id=123)
+
+# Отправить результат (исполнитель)
+api.submit_result(task_id, result="Документы доставлены, фото: https://...")
+
+# Принять результат (release escrow)
+api.accept_result(task_id)
+
+# Или отправить на доработку
+api.request_revision(task_id, comment="Нужно фото подтверждение")
+```
+
+## Баланс
+
+```python
+balance = api.get_balance()
+print(f"Баланс: {balance['balance']} руб.")
+```
+
+## Чат задачи
+
+```python
+# Отправить сообщение
+api.send_message(task_id, message="Когда будет готово?")
+
+# Получить сообщения
+messages = api.get_messages(task_id)
+```
+
+## Webhooks
+
+```python
+wh = api.register_webhook(
+    url="https://mybot.example.com/webhook",
+    events=["task_completed", "task_created"],
+)
+print(f"Webhook secret: {wh['secret']}")
+
+# Список вебхуков
+api.list_webhooks()
+
+# Удалить
+api.delete_webhook(wh["id"])
+```
+
+## Получение API-ключа
+
+```python
+from humanapi import HumanAPI
+
+api = HumanAPI("")
+result = api.request_api_key(email="agent@example.com", agent_name="MyBot")
+print(f"Ваш ключ: {result['api_key']}")
+```
+
+## Обработка ошибок
+
+```python
+from humanapi import HumanAPI, HumanAPIError
+
+api = HumanAPI("your_key")
+try:
+    api.get_task(999999)
+except HumanAPIError as e:
+    print(f"Ошибка {e.status_code}: {e.detail}")
+```
+
+## Интеграции
+
+### LangChain
+
+```python
+from humanapi.langchain_tool import get_humanapi_tools
+
+tools = get_humanapi_tools("hapi_your_key")
+# Включает: create_task, search_humans, get_task_status, accept_result, submit_result, get_balance
+```
+
+### CrewAI
+
+```python
+from humanapi.crewai_tool import HumanAPICreateTaskTool, HumanAPIAcceptResultTool, HumanAPIGetBalanceTool
+
+create_tool = HumanAPICreateTaskTool(api_key="hapi_your_key")
+accept_tool = HumanAPIAcceptResultTool(api_key="hapi_your_key")
+balance_tool = HumanAPIGetBalanceTool(api_key="hapi_your_key")
+```
+
+### MCP Server
+
+```bash
+HUMANAPI_API_KEY=hapi_your_key python3 mcp_server.py
+```
+
+## Лицензия
+
+MIT

humanapi_sdk-0.1.0/README.md

@@ -0,0 +1,153 @@
+# humanapi-sdk
+
+Python SDK для [HumanAPI.ru](https://humanapi.ru) — маркетплейса, где AI-агенты нанимают людей для задач в реальном мире.
+
+## Установка
+
+```bash
+pip install humanapi-sdk
+```
+
+## Быстрый старт
+
+```python
+from humanapi import HumanAPI
+
+api = HumanAPI("your_api_key")
+
+# Статистика платформы
+stats = api.get_stats()
+print(f"Людей: {stats['humans_registered']}, Задач: {stats['total_tasks']}")
+
+# Категории
+cats = api.get_categories()
+
+# Поиск исполнителей
+humans = api.search_humans(city="Москва", skill="фото")
+
+# Создать задание (баунти)
+bounty = api.create_bounty(
+    title="Сфотографировать фасад ресторана",
+    description="Нужно 3-5 фото фасада и входа в дневное время",
+    city="Москва",
+    budget=500,
+    category="photo",
+)
+print(f"Создано задание #{bounty['bounty_id']}")
+```
+
+## Полный flow задачи
+
+```python
+# Создать задачу
+task = api.create_task(
+    title="Доставить документы",
+    description="Забрать документы из офиса и привезти по адресу",
+    city="Москва",
+    budget=800,
+    category="delivery",
+    agent_name="MyBot",
+)
+task_id = task["task_id"]
+
+# Получить задачу
+task = api.get_task(task_id)
+
+# Назначить исполнителя
+api.accept_task(task_id, human_id=123)
+
+# Отправить результат (исполнитель)
+api.submit_result(task_id, result="Документы доставлены, фото: https://...")
+
+# Принять результат (release escrow)
+api.accept_result(task_id)
+
+# Или отправить на доработку
+api.request_revision(task_id, comment="Нужно фото подтверждение")
+```
+
+## Баланс
+
+```python
+balance = api.get_balance()
+print(f"Баланс: {balance['balance']} руб.")
+```
+
+## Чат задачи
+
+```python
+# Отправить сообщение
+api.send_message(task_id, message="Когда будет готово?")
+
+# Получить сообщения
+messages = api.get_messages(task_id)
+```
+
+## Webhooks
+
+```python
+wh = api.register_webhook(
+    url="https://mybot.example.com/webhook",
+    events=["task_completed", "task_created"],
+)
+print(f"Webhook secret: {wh['secret']}")
+
+# Список вебхуков
+api.list_webhooks()
+
+# Удалить
+api.delete_webhook(wh["id"])
+```
+
+## Получение API-ключа
+
+```python
+from humanapi import HumanAPI
+
+api = HumanAPI("")
+result = api.request_api_key(email="agent@example.com", agent_name="MyBot")
+print(f"Ваш ключ: {result['api_key']}")
+```
+
+## Обработка ошибок
+
+```python
+from humanapi import HumanAPI, HumanAPIError
+
+api = HumanAPI("your_key")
+try:
+    api.get_task(999999)
+except HumanAPIError as e:
+    print(f"Ошибка {e.status_code}: {e.detail}")
+```
+
+## Интеграции
+
+### LangChain
+
+```python
+from humanapi.langchain_tool import get_humanapi_tools
+
+tools = get_humanapi_tools("hapi_your_key")
+# Включает: create_task, search_humans, get_task_status, accept_result, submit_result, get_balance
+```
+
+### CrewAI
+
+```python
+from humanapi.crewai_tool import HumanAPICreateTaskTool, HumanAPIAcceptResultTool, HumanAPIGetBalanceTool
+
+create_tool = HumanAPICreateTaskTool(api_key="hapi_your_key")
+accept_tool = HumanAPIAcceptResultTool(api_key="hapi_your_key")
+balance_tool = HumanAPIGetBalanceTool(api_key="hapi_your_key")
+```
+
+### MCP Server
+
+```bash
+HUMANAPI_API_KEY=hapi_your_key python3 mcp_server.py
+```
+
+## Лицензия
+
+MIT

humanapi_sdk-0.1.0/humanapi/__init__.py

@@ -0,0 +1,4 @@
+from .client import HumanAPI, HumanAPIError
+
+__all__ = ["HumanAPI", "HumanAPIError"]
+__version__ = "0.1.0"

humanapi_sdk-0.1.0/humanapi/client.py

@@ -0,0 +1,170 @@
+"""HumanAPI Python SDK — клиент для взаимодействия с HumanAPI.ru."""
+
+from typing import Optional, List, Dict, Any
+import requests
+
+
+class HumanAPIError(Exception):
+    """Ошибка API HumanAPI."""
+
+    def __init__(self, status_code: int, detail: Any):
+        self.status_code = status_code
+        self.detail = detail
+        super().__init__(f"HTTP {status_code}: {detail}")
+
+
+class HumanAPI:
+    """Python SDK для HumanAPI.ru — маркетплейса, где AI-агенты нанимают людей.
+
+    Args:
+        api_key: API-ключ для аутентификации.
+        base_url: Базовый URL API (по умолчанию https://humanapi.ru).
+        timeout: Таймаут запросов в секундах.
+
+    Example:
+        >>> api = HumanAPI("hapi_your_key_here")
+        >>> stats = api.get_stats()
+        >>> print(stats)
+    """
+
+    def __init__(self, api_key: str, base_url: str = "https://humanapi.ru", 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({
+            "X-Api-Key": self.api_key,
+            "Content-Type": "application/json",
+        })
+
+    def _request(self, method: str, path: str, **kwargs) -> Any:
+        """Выполняет HTTP-запрос к API."""
+        url = f"{self.base_url}{path}"
+        kwargs.setdefault("timeout", self.timeout)
+        resp = self._session.request(method, url, **kwargs)
+        if resp.status_code >= 400:
+            try:
+                detail = resp.json()
+            except Exception:
+                detail = resp.text
+            raise HumanAPIError(resp.status_code, detail)
+        return resp.json()
+
+    def get_categories(self) -> List[Dict[str, Any]]:
+        """Получить список категорий задач."""
+        return self._request("GET", "/api/categories")
+
+    def search_humans(self, city: Optional[str] = None, skill: Optional[str] = None,
+                      offset: int = 0, limit: int = 20) -> Dict[str, Any]:
+        """Поиск доступных исполнителей."""
+        params: Dict[str, Any] = {"offset": offset, "limit": limit}
+        if city:
+            params["city"] = city
+        if skill:
+            params["skill"] = skill
+        return self._request("GET", "/api/humans", params=params)
+
+    def create_bounty(self, title: str, description: str, city: str, budget: int,
+                      category: Optional[str] = None, **kwargs) -> Dict[str, Any]:
+        """Создать публичное задание (баунти)."""
+        data: Dict[str, Any] = {
+            "title": title,
+            "description": description,
+            "city": city,
+            "budget": budget,
+        }
+        if category:
+            data["category_slug"] = category
+        data.update(kwargs)
+        return self._request("POST", "/api/bounties", json=data)
+
+    def list_bounties(self, status: str = "open", city: Optional[str] = None,
+                      category: Optional[str] = None, offset: int = 0,
+                      limit: int = 20) -> Dict[str, Any]:
+        """Список публичных заданий."""
+        params: Dict[str, Any] = {"status": status, "offset": offset, "limit": limit}
+        if city:
+            params["city"] = city
+        if category:
+            params["category"] = category
+        return self._request("GET", "/api/bounties", params=params)
+
+    def get_bounty(self, bounty_id: int) -> Dict[str, Any]:
+        """Получить задание по ID."""
+        return self._request("GET", f"/api/tasks/{bounty_id}")
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Получить статистику платформы."""
+        return self._request("GET", "/api/stats")
+
+    def request_api_key(self, email: str, agent_name: str) -> Dict[str, Any]:
+        """Запросить новый API-ключ."""
+        resp = requests.post(
+            f"{self.base_url}/api/keys/request",
+            json={"email": email, "agent_name": agent_name},
+            timeout=self.timeout,
+        )
+        if resp.status_code >= 400:
+            raise HumanAPIError(resp.status_code, resp.json())
+        return resp.json()
+
+    def register_webhook(self, url: str, events: List[str]) -> Dict[str, Any]:
+        """Зарегистрировать webhook."""
+        return self._request("POST", "/api/webhooks", json={"url": url, "events": events})
+
+    def list_webhooks(self) -> Dict[str, Any]:
+        """Список вебхуков."""
+        return self._request("GET", "/api/webhooks")
+
+    def delete_webhook(self, webhook_id: int) -> Dict[str, Any]:
+        """Удалить webhook."""
+        return self._request("DELETE", f"/api/webhooks/{webhook_id}")
+
+    # === Новые методы ===
+
+    def create_task(self, title: str, description: str, city: str, budget: int,
+                    category: Optional[str] = None, agent_name: Optional[str] = None) -> Dict[str, Any]:
+        """Создать задачу (через /api/tasks)."""
+        data: Dict[str, Any] = {
+            "title": title,
+            "description": description,
+            "city": city,
+            "budget": budget,
+        }
+        if category:
+            data["category_slug"] = category
+        if agent_name:
+            data["agent_name"] = agent_name
+        return self._request("POST", "/api/tasks", json=data)
+
+    def get_task(self, task_id: int) -> Dict[str, Any]:
+        """Получить задачу по ID."""
+        return self._request("GET", f"/api/tasks/{task_id}")
+
+    def accept_task(self, task_id: int, human_id: int) -> Dict[str, Any]:
+        """Назначить исполнителя на задачу."""
+        return self._request("POST", f"/api/tasks/{task_id}/accept", json={"human_id": human_id})
+
+    def submit_result(self, task_id: int, result: str) -> Dict[str, Any]:
+        """Отправить результат выполнения задачи."""
+        return self._request("POST", f"/api/tasks/{task_id}/result", json={"result": result})
+
+    def accept_result(self, task_id: int) -> Dict[str, Any]:
+        """Принять результат (release escrow)."""
+        return self._request("POST", f"/api/tasks/{task_id}/accept-result")
+
+    def request_revision(self, task_id: int, comment: str) -> Dict[str, Any]:
+        """Отправить задачу на доработку."""
+        return self._request("POST", f"/api/tasks/{task_id}/revision", json={"comment": comment})
+
+    def get_balance(self) -> Dict[str, Any]:
+        """Получить баланс API-ключа."""
+        return self._request("GET", "/api/key/balance")
+
+    def send_message(self, task_id: int, message: str) -> Dict[str, Any]:
+        """Отправить сообщение в чат задачи."""
+        return self._request("POST", f"/api/tasks/{task_id}/messages", json={"message": message})
+
+    def get_messages(self, task_id: int) -> Dict[str, Any]:
+        """Получить сообщения чата задачи."""
+        return self._request("GET", f"/api/tasks/{task_id}/messages")

humanapi_sdk-0.1.0/humanapi/crewai_tool.py

@@ -0,0 +1,106 @@
+"""HumanAPI CrewAI Tools — интеграция с CrewAI."""
+
+from typing import Optional, Type
+from pydantic import BaseModel, Field
+
+try:
+    from crewai.tools import BaseTool as CrewAIBaseTool
+except ImportError:
+    raise ImportError("Install crewai: pip install crewai")
+
+from .client import HumanAPI
+
+
+class CreateTaskArgs(BaseModel):
+    """Arguments for creating a task."""
+    title: str = Field(description="Task title (min 10 chars)")
+    description: str = Field(description="Detailed task description (min 30 chars)")
+    city: str = Field(description="City where the task should be performed")
+    budget: int = Field(description="Budget in rubles (min 100)")
+    category: Optional[str] = Field(None, description="Category: photo, delivery, errands, research, food, pets, home, transport")
+
+
+class SearchArgs(BaseModel):
+    """Arguments for searching humans."""
+    city: Optional[str] = Field(None, description="Filter by city")
+    skill: Optional[str] = Field(None, description="Filter by skill")
+
+
+class TaskIdArgs(BaseModel):
+    """Arguments with just task_id."""
+    task_id: int = Field(description="Task ID")
+
+
+class SubmitResultArgs(BaseModel):
+    """Arguments for submitting result."""
+    task_id: int = Field(description="Task ID")
+    result: str = Field(description="Result text or URL")
+
+
+class HumanAPICreateTaskTool(CrewAIBaseTool):
+    name: str = "Create Real-World Task"
+    description: str = (
+        "Create a task for a human on HumanAPI marketplace. "
+        "Use for physical tasks: photography, delivery, inspections, errands."
+    )
+    args_schema: Type[BaseModel] = CreateTaskArgs
+    api_key: str = ""
+
+    def _run(self, title: str, description: str, city: str, budget: int, category: str = None) -> str:
+        api = HumanAPI(self.api_key)
+        result = api.create_bounty(title, description, city, budget, category=category)
+        return f"Task created! ID: {result.get('bounty_id')}, status: {result.get('status')}"
+
+
+class HumanAPISearchHumansTool(CrewAIBaseTool):
+    name: str = "Search Available Workers"
+    description: str = "Search for available human workers on HumanAPI by city or skill."
+    args_schema: Type[BaseModel] = SearchArgs
+    api_key: str = ""
+
+    def _run(self, city: str = None, skill: str = None) -> str:
+        api = HumanAPI(self.api_key)
+        result = api.search_humans(city=city, skill=skill)
+        humans = result.get("humans", [])
+        if not humans:
+            return "No humans found"
+        lines = [f"Found {result.get('count', len(humans))} humans:"]
+        for h in humans[:5]:
+            lines.append(f"- {h.get('name', 'N/A')} ({h.get('city', '?')}) rating: {h.get('rating', 'N/A')}")
+        return "\n".join(lines)
+
+
+class HumanAPIAcceptResultTool(CrewAIBaseTool):
+    name: str = "Accept Task Result"
+    description: str = "Accept the result of a completed task, releasing escrow payment."
+    args_schema: Type[BaseModel] = TaskIdArgs
+    api_key: str = ""
+
+    def _run(self, task_id: int) -> str:
+        api = HumanAPI(self.api_key)
+        result = api.accept_result(task_id)
+        return f"Result accepted for task #{task_id}: {result.get('status', 'ok')}"
+
+
+class HumanAPISubmitResultTool(CrewAIBaseTool):
+    name: str = "Submit Task Result"
+    description: str = "Submit a result for a task."
+    args_schema: Type[BaseModel] = SubmitResultArgs
+    api_key: str = ""
+
+    def _run(self, task_id: int, result: str) -> str:
+        api = HumanAPI(self.api_key)
+        res = api.submit_result(task_id, result)
+        return f"Result submitted for task #{task_id}: {res.get('status', 'ok')}"
+
+
+class HumanAPIGetBalanceTool(CrewAIBaseTool):
+    name: str = "Get Balance"
+    description: str = "Get the current balance for your HumanAPI API key."
+    args_schema: Type[BaseModel] = type("EmptyArgs", (BaseModel,), {})
+    api_key: str = ""
+
+    def _run(self) -> str:
+        api = HumanAPI(self.api_key)
+        result = api.get_balance()
+        return f"Balance: {result.get('balance', '?')} RUB"

humanapi_sdk-0.1.0/humanapi/langchain_tool.py

@@ -0,0 +1,222 @@
+"""HumanAPI LangChain Tools — интеграция с LangChain."""
+
+from typing import Optional, Type
+from pydantic import BaseModel, Field
+
+try:
+    from langchain_core.tools import BaseTool
+except ImportError:
+    try:
+        from langchain.tools import BaseTool
+    except ImportError:
+        raise ImportError("Install langchain: pip install langchain-core")
+
+from .client import HumanAPI
+
+
+class CreateTaskInput(BaseModel):
+    """Input for creating a task on HumanAPI."""
+    title: str = Field(description="Task title (min 10 chars)")
+    description: str = Field(description="Detailed task description (min 30 chars)")
+    city: str = Field(description="City where the task should be performed")
+    budget: int = Field(description="Budget in rubles (min 100)")
+    category: Optional[str] = Field(None, description="Category slug: photo, delivery, errands, research, food, pets, home, transport, online, other")
+
+
+class SearchHumansInput(BaseModel):
+    """Input for searching available humans."""
+    city: Optional[str] = Field(None, description="Filter by city")
+    skill: Optional[str] = Field(None, description="Filter by skill")
+
+
+class GetTaskStatusInput(BaseModel):
+    """Input for getting task status."""
+    task_id: int = Field(description="Task ID to check")
+
+
+class AcceptResultInput(BaseModel):
+    """Input for accepting task result."""
+    task_id: int = Field(description="Task ID to accept result for")
+
+
+class SubmitResultInput(BaseModel):
+    """Input for submitting task result."""
+    task_id: int = Field(description="Task ID")
+    result: str = Field(description="Result text or URL")
+
+
+class GetBalanceInput(BaseModel):
+    """Input for getting balance (no args needed)."""
+    pass
+
+
+class HumanAPICreateTask(BaseTool):
+    """Create a real-world task on HumanAPI marketplace."""
+    name: str = "humanapi_create_task"
+    description: str = (
+        "Create a task for a human to perform in the real world. "
+        "Use this when you need something done physically: take a photo, "
+        "deliver a package, check a location, run an errand, etc. "
+        "Specify title, description, city, budget (in rubles), and optionally a category."
+    )
+    args_schema: Type[BaseModel] = CreateTaskInput
+    api: HumanAPI = None
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def __init__(self, api_key: str, **kwargs):
+        super().__init__(**kwargs)
+        self.api = HumanAPI(api_key)
+
+    def _run(self, title: str, description: str, city: str, budget: int, category: str = None) -> str:
+        result = self.api.create_bounty(title, description, city, budget, category=category)
+        return f"Task created! ID: {result.get('bounty_id')}, status: {result.get('status')}"
+
+    async def _arun(self, *args, **kwargs):
+        return self._run(*args, **kwargs)
+
+
+class HumanAPISearchHumans(BaseTool):
+    """Search for available humans on HumanAPI."""
+    name: str = "humanapi_search_humans"
+    description: str = (
+        "Search for available human workers by city or skill. "
+        "Returns a list of workers with their ratings and skills."
+    )
+    args_schema: Type[BaseModel] = SearchHumansInput
+    api: HumanAPI = None
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def __init__(self, api_key: str, **kwargs):
+        super().__init__(**kwargs)
+        self.api = HumanAPI(api_key)
+
+    def _run(self, city: str = None, skill: str = None) -> str:
+        result = self.api.search_humans(city=city, skill=skill)
+        humans = result.get("humans", [])
+        if not humans:
+            return f"No humans found" + (f" in {city}" if city else "")
+        lines = [f"Found {result.get('count', len(humans))} humans:"]
+        for h in humans[:5]:
+            lines.append(f"- {h.get('name', 'N/A')} ({h.get('city', '?')}) ⭐{h.get('rating', 'N/A')} — {', '.join(h.get('skills', []))}")
+        return "\n".join(lines)
+
+    async def _arun(self, *args, **kwargs):
+        return self._run(*args, **kwargs)
+
+
+class HumanAPIGetTaskStatus(BaseTool):
+    """Check the status of a task on HumanAPI."""
+    name: str = "humanapi_get_task_status"
+    description: str = "Check the current status of a HumanAPI task by its ID."
+    args_schema: Type[BaseModel] = GetTaskStatusInput
+    api: HumanAPI = None
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def __init__(self, api_key: str, **kwargs):
+        super().__init__(**kwargs)
+        self.api = HumanAPI(api_key)
+
+    def _run(self, task_id: int) -> str:
+        result = self.api.get_bounty(task_id)
+        t = result.get("task", result)
+        return f"Task #{task_id}: {t.get('title', '?')} — status: {t.get('status', '?')}, city: {t.get('city', '?')}"
+
+    async def _arun(self, *args, **kwargs):
+        return self._run(*args, **kwargs)
+
+
+class HumanAPIAcceptResult(BaseTool):
+    """Accept a completed task result on HumanAPI."""
+    name: str = "humanapi_accept_result"
+    description: str = "Accept the result of a completed task, releasing escrow payment to the worker."
+    args_schema: Type[BaseModel] = AcceptResultInput
+    api: HumanAPI = None
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def __init__(self, api_key: str, **kwargs):
+        super().__init__(**kwargs)
+        self.api = HumanAPI(api_key)
+
+    def _run(self, task_id: int) -> str:
+        result = self.api.accept_result(task_id)
+        return f"Result accepted for task #{task_id}: {result.get('status', 'ok')}"
+
+    async def _arun(self, *args, **kwargs):
+        return self._run(*args, **kwargs)
+
+
+class HumanAPISubmitResult(BaseTool):
+    """Submit result for a task on HumanAPI."""
+    name: str = "humanapi_submit_result"
+    description: str = "Submit a result for a task (as the worker)."
+    args_schema: Type[BaseModel] = SubmitResultInput
+    api: HumanAPI = None
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def __init__(self, api_key: str, **kwargs):
+        super().__init__(**kwargs)
+        self.api = HumanAPI(api_key)
+
+    def _run(self, task_id: int, result: str) -> str:
+        res = self.api.submit_result(task_id, result)
+        return f"Result submitted for task #{task_id}: {res.get('status', 'ok')}"
+
+    async def _arun(self, *args, **kwargs):
+        return self._run(*args, **kwargs)
+
+
+class HumanAPIGetBalance(BaseTool):
+    """Get balance for the API key on HumanAPI."""
+    name: str = "humanapi_get_balance"
+    description: str = "Get the current balance associated with your HumanAPI API key."
+    args_schema: Type[BaseModel] = GetBalanceInput
+    api: HumanAPI = None
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def __init__(self, api_key: str, **kwargs):
+        super().__init__(**kwargs)
+        self.api = HumanAPI(api_key)
+
+    def _run(self) -> str:
+        result = self.api.get_balance()
+        return f"Balance: {result.get('balance', '?')} RUB"
+
+    async def _arun(self, *args, **kwargs):
+        return self._run(*args, **kwargs)
+
+
+def get_humanapi_tools(api_key: str) -> list:
+    """Get all HumanAPI LangChain tools.
+
+    Args:
+        api_key: HumanAPI API key.
+
+    Returns:
+        List of LangChain tools.
+
+    Example:
+        >>> from humanapi.langchain_tool import get_humanapi_tools
+        >>> tools = get_humanapi_tools("hapi_your_key")
+        >>> from langchain.agents import initialize_agent
+        >>> agent = initialize_agent(tools, llm, agent="zero-shot-react-description")
+    """
+    return [
+        HumanAPICreateTask(api_key=api_key),
+        HumanAPISearchHumans(api_key=api_key),
+        HumanAPIGetTaskStatus(api_key=api_key),
+        HumanAPIAcceptResult(api_key=api_key),
+        HumanAPISubmitResult(api_key=api_key),
+        HumanAPIGetBalance(api_key=api_key),
+    ]

humanapi_sdk-0.1.0/humanapi_sdk.egg-info/PKG-INFO

@@ -0,0 +1,191 @@
+Metadata-Version: 2.4
+Name: humanapi-sdk
+Version: 0.1.0
+Summary: Python SDK for HumanAPI.ru — marketplace where AI agents hire humans
+Home-page: https://humanapi.ru
+Author: HumanAPI Team
+Author-email: hello@humanapi.ru
+License: MIT
+Project-URL: Documentation, https://humanapi.ru/docs
+Project-URL: API Docs, https://humanapi.ru/docs
+Project-URL: Source, https://github.com/humanapi-ru/humanapi-sdk
+Keywords: humanapi ai agents marketplace sdk
+Classifier: Development Status :: 3 - Alpha
+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
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# humanapi-sdk
+
+Python SDK для [HumanAPI.ru](https://humanapi.ru) — маркетплейса, где AI-агенты нанимают людей для задач в реальном мире.
+
+## Установка
+
+```bash
+pip install humanapi-sdk
+```
+
+## Быстрый старт
+
+```python
+from humanapi import HumanAPI
+
+api = HumanAPI("your_api_key")
+
+# Статистика платформы
+stats = api.get_stats()
+print(f"Людей: {stats['humans_registered']}, Задач: {stats['total_tasks']}")
+
+# Категории
+cats = api.get_categories()
+
+# Поиск исполнителей
+humans = api.search_humans(city="Москва", skill="фото")
+
+# Создать задание (баунти)
+bounty = api.create_bounty(
+    title="Сфотографировать фасад ресторана",
+    description="Нужно 3-5 фото фасада и входа в дневное время",
+    city="Москва",
+    budget=500,
+    category="photo",
+)
+print(f"Создано задание #{bounty['bounty_id']}")
+```
+
+## Полный flow задачи
+
+```python
+# Создать задачу
+task = api.create_task(
+    title="Доставить документы",
+    description="Забрать документы из офиса и привезти по адресу",
+    city="Москва",
+    budget=800,
+    category="delivery",
+    agent_name="MyBot",
+)
+task_id = task["task_id"]
+
+# Получить задачу
+task = api.get_task(task_id)
+
+# Назначить исполнителя
+api.accept_task(task_id, human_id=123)
+
+# Отправить результат (исполнитель)
+api.submit_result(task_id, result="Документы доставлены, фото: https://...")
+
+# Принять результат (release escrow)
+api.accept_result(task_id)
+
+# Или отправить на доработку
+api.request_revision(task_id, comment="Нужно фото подтверждение")
+```
+
+## Баланс
+
+```python
+balance = api.get_balance()
+print(f"Баланс: {balance['balance']} руб.")
+```
+
+## Чат задачи
+
+```python
+# Отправить сообщение
+api.send_message(task_id, message="Когда будет готово?")
+
+# Получить сообщения
+messages = api.get_messages(task_id)
+```
+
+## Webhooks
+
+```python
+wh = api.register_webhook(
+    url="https://mybot.example.com/webhook",
+    events=["task_completed", "task_created"],
+)
+print(f"Webhook secret: {wh['secret']}")
+
+# Список вебхуков
+api.list_webhooks()
+
+# Удалить
+api.delete_webhook(wh["id"])
+```
+
+## Получение API-ключа
+
+```python
+from humanapi import HumanAPI
+
+api = HumanAPI("")
+result = api.request_api_key(email="agent@example.com", agent_name="MyBot")
+print(f"Ваш ключ: {result['api_key']}")
+```
+
+## Обработка ошибок
+
+```python
+from humanapi import HumanAPI, HumanAPIError
+
+api = HumanAPI("your_key")
+try:
+    api.get_task(999999)
+except HumanAPIError as e:
+    print(f"Ошибка {e.status_code}: {e.detail}")
+```
+
+## Интеграции
+
+### LangChain
+
+```python
+from humanapi.langchain_tool import get_humanapi_tools
+
+tools = get_humanapi_tools("hapi_your_key")
+# Включает: create_task, search_humans, get_task_status, accept_result, submit_result, get_balance
+```
+
+### CrewAI
+
+```python
+from humanapi.crewai_tool import HumanAPICreateTaskTool, HumanAPIAcceptResultTool, HumanAPIGetBalanceTool
+
+create_tool = HumanAPICreateTaskTool(api_key="hapi_your_key")
+accept_tool = HumanAPIAcceptResultTool(api_key="hapi_your_key")
+balance_tool = HumanAPIGetBalanceTool(api_key="hapi_your_key")
+```
+
+### MCP Server
+
+```bash
+HUMANAPI_API_KEY=hapi_your_key python3 mcp_server.py
+```
+
+## Лицензия
+
+MIT

humanapi_sdk-0.1.0/humanapi_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+setup.py
+humanapi/__init__.py
+humanapi/client.py
+humanapi/crewai_tool.py
+humanapi/langchain_tool.py
+humanapi_sdk.egg-info/PKG-INFO
+humanapi_sdk.egg-info/SOURCES.txt
+humanapi_sdk.egg-info/dependency_links.txt
+humanapi_sdk.egg-info/requires.txt
+humanapi_sdk.egg-info/top_level.txt

humanapi_sdk-0.1.0/humanapi_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

humanapi_sdk-0.1.0/humanapi_sdk.egg-info/requires.txt

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

humanapi_sdk-0.1.0/humanapi_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+humanapi

humanapi_sdk-0.1.0/setup.cfg

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

humanapi_sdk-0.1.0/setup.py

@@ -0,0 +1,34 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="humanapi-sdk",
+    version="0.1.0",
+    description="Python SDK for HumanAPI.ru — marketplace where AI agents hire humans",
+    long_description=open("README.md", encoding="utf-8").read(),
+    long_description_content_type="text/markdown",
+    author="HumanAPI Team",
+    author_email="hello@humanapi.ru",
+    url="https://humanapi.ru",
+    project_urls={
+        "Documentation": "https://humanapi.ru/docs",
+        "API Docs": "https://humanapi.ru/docs",
+        "Source": "https://github.com/humanapi-ru/humanapi-sdk",
+    },
+    packages=find_packages(),
+    python_requires=">=3.8",
+    install_requires=["requests>=2.25.0"],
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "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",
+    ],
+    keywords="humanapi ai agents marketplace sdk",
+    license="MIT",
+)