navaia-forge 0.1.0__tar.gz

navaia_forge-0.1.0/.gitignore

@@ -0,0 +1,46 @@
+# ── Python ──────────────────────────────────────────────────
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+*.egg
+dist/
+build/
+.eggs/
+*.whl
+.venv/
+venv/
+env/
+.mypy_cache/
+.ruff_cache/
+.pytest_cache/
+htmlcov/
+.coverage
+.coverage.*
+*.cover
+
+# ── Node.js / TypeScript ───────────────────────────────────
+node_modules/
+dist/
+*.tsbuildinfo
+.turbo/
+.next/
+coverage/
+*.js.map
+
+# ── IDE / Editor ───────────────────────────────────────────
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+Thumbs.db
+
+# ── Environment / Secrets ──────────────────────────────────
+.env
+.env.*
+!.env.example
+*.pem
+*.key
+credentials.json

navaia_forge-0.1.0/LICENSE

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

navaia_forge-0.1.0/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: navaia-forge
+Version: 0.1.0
+Summary: Python SDK for the NavaiaForge AI workforce platform
+Project-URL: Homepage, https://github.com/NavaiaSolutions/navaia-forge-sdk
+Project-URL: Repository, https://github.com/NavaiaSolutions/navaia-forge-sdk
+Project-URL: Documentation, https://github.com/NavaiaSolutions/navaia-forge-sdk#readme
+Project-URL: Issues, https://github.com/NavaiaSolutions/navaia-forge-sdk/issues
+Author-email: Navaia <dev@navaia.com>
+License: MIT
+License-File: LICENSE
+Keywords: agents,ai,orchestration,sdk,workforce
+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.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic>=2.6
+Requires-Dist: websockets>=12.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.13.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest-httpx>=0.30.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# NavaiaForge Python SDK
+
+Official Python client for the [NavaiaForge](https://navaia.com) AI workforce platform — a typed, real-time client for building **multi-agent AI workforces** that work like teams.
+
+Use it **standalone** (scripts, services, CI, notebooks) or **alongside the NavaiaForge dashboard**. Both speak to the same backend, so anything created in code shows up in the UI and vice versa.
+
+## Why a workforce, not just an agent?
+
+A single LLM call solves a single prompt; real work rarely is. NavaiaForge models work the way teams do:
+
+- **Many specialized agents** with their own roles, instructions, and models — not one generalist.
+- **Edges** route work between them (reviewer → tester → deployer).
+- **Shared knowledge bases** ground every agent in the same facts via RAG.
+- **Shared tools** (HTTP, MCP, code executors, plugins) give the team hands.
+- **One coordinator** — submit a task to the workforce, not to a specific agent.
+
+The SDK exposes every primitive directly.
+
+## Installation
+
+```bash
+pip install navaia-forge
+```
+
+## Quickstart
+
+```python
+from navaia_forge import NavaiaForgeClient
+
+client = NavaiaForgeClient(base_url="http://localhost:8000", api_key="nf_...")
+
+# Build the team
+wf = client.workforces.create(name="Code Review Team")
+reviewer = client.agents.create(workforce_id=wf.id, name="Reviewer", role="review",
+                                instructions="Review PRs for correctness and security.",
+                                model_provider="anthropic", model_name="sonnet")
+tester   = client.agents.create(workforce_id=wf.id, name="Tester", role="qa",
+                                instructions="Generate and run tests for approved diffs.",
+                                model_provider="anthropic", model_name="sonnet")
+
+# Wire reviewer → tester
+client.workforces.create_edge(workforce_id=wf.id,
+                              source_agent_id=reviewer.id,
+                              target_agent_id=tester.id)
+
+# Hand work to the team
+task  = client.tasks.create(workforce_id=wf.id, title="Review PR #482 and add tests")
+final = client.tasks.wait_for_completion(task.id)
+print(final.status, final.result)
+```
+
+All resource methods return typed [Pydantic v2](https://docs.pydantic.dev/) models. Errors raise `navaia_forge.NavaiaForgeError` (or a subclass: `NotFoundError`, `RateLimitError`, `ValidationError`, `AuthenticationError`, `PermissionError`, `ServerError`, `TimeoutError`).
+
+## Real-time events
+
+```python
+from navaia_forge import NavaiaForgeWs, HttpConfig
+
+ws = NavaiaForgeWs(HttpConfig(base_url="http://localhost:8000", api_key="nf_..."))
+ws.on("task:status",  lambda e: print("task:",  e["task_id"], e["status"]))
+ws.on("agent:status", lambda e: print("agent:", e["agent_id"], e["status"]))
+ws.on("chat:message", lambda e: print(e["role"], e["content"]))
+ws.connect()
+ws.run_forever()
+```
+
+Channels: `task:status`, `agent:status`, `chat:message`, `system:*`.
+
+## What you can do
+
+| Namespace | What it does | Why you'd use it |
+|---|---|---|
+| `client.workforces` | CRUD; manage edges; link tools / knowledge bases | Define the team and how work flows through it |
+| `client.agents` | CRUD; `list_featured`, `clone`, `export`; attach/detach to workforces | Compose specialists with their own models and instructions |
+| `client.tasks` | `create`, `approve`, `reject`, `retry`, logs, `wait_for_completion` | Hand work to the team, sync or async |
+| `client.conversations` | Open chats, send messages targeted at agents | Build chat UIs / interactive assistants |
+| `client.knowledge` | Knowledge bases, document upload, semantic `search`, `featured`, `download` | Ground agents in your data via RAG |
+| `client.templates` | Workforce templates + `templates.agents` for agent templates | Don't rebuild the same team twice |
+| `client.tools` | Full CRUD, `featured`, attach/detach to workforces | Give the team hands (HTTP, MCP, code-exec, custom) |
+| `client.integrations` | `list`, `list_plugins`, CRUD | Connect Slack / GitHub / Linear / other plugins |
+| `client.setup` | `options`, `validate`, `complete` | First-run onboarding / provider configuration |
+| `client.observability` | `summary`, `cost`, `agent_metrics`, `agent_evaluations`, `log_token_usage` | See what the team is doing and what it costs |
+| `client.auth` | `me`, `register`, `login`, `refresh`, `create_key`, `validate`, OAuth URL helpers | Build your own UI on top of NavaiaForge |
+
+## Standalone or with the UI
+
+- **Standalone:** the SDK is sufficient on its own — no dashboard required. Drive everything from Python: scripts, services, Airflow / Prefect tasks, Jupyter, custom CLIs, internal tools.
+- **Alongside the dashboard:** anything you create programmatically appears in the NavaiaForge UI immediately, and anything created in the UI is reachable from `client.*`. Two views over one backend.
+
+## Development
+
+```bash
+python3.12 -m venv .venv
+source .venv/bin/activate
+pip install -e ".[dev]"
+pytest --cov=navaia_forge
+ruff check navaia_forge tests
+```
+
+## License
+
+[MIT](./LICENSE) © NavaiaSolutions

navaia_forge-0.1.0/README.md

@@ -0,0 +1,102 @@
+# NavaiaForge Python SDK
+
+Official Python client for the [NavaiaForge](https://navaia.com) AI workforce platform — a typed, real-time client for building **multi-agent AI workforces** that work like teams.
+
+Use it **standalone** (scripts, services, CI, notebooks) or **alongside the NavaiaForge dashboard**. Both speak to the same backend, so anything created in code shows up in the UI and vice versa.
+
+## Why a workforce, not just an agent?
+
+A single LLM call solves a single prompt; real work rarely is. NavaiaForge models work the way teams do:
+
+- **Many specialized agents** with their own roles, instructions, and models — not one generalist.
+- **Edges** route work between them (reviewer → tester → deployer).
+- **Shared knowledge bases** ground every agent in the same facts via RAG.
+- **Shared tools** (HTTP, MCP, code executors, plugins) give the team hands.
+- **One coordinator** — submit a task to the workforce, not to a specific agent.
+
+The SDK exposes every primitive directly.
+
+## Installation
+
+```bash
+pip install navaia-forge
+```
+
+## Quickstart
+
+```python
+from navaia_forge import NavaiaForgeClient
+
+client = NavaiaForgeClient(base_url="http://localhost:8000", api_key="nf_...")
+
+# Build the team
+wf = client.workforces.create(name="Code Review Team")
+reviewer = client.agents.create(workforce_id=wf.id, name="Reviewer", role="review",
+                                instructions="Review PRs for correctness and security.",
+                                model_provider="anthropic", model_name="sonnet")
+tester   = client.agents.create(workforce_id=wf.id, name="Tester", role="qa",
+                                instructions="Generate and run tests for approved diffs.",
+                                model_provider="anthropic", model_name="sonnet")
+
+# Wire reviewer → tester
+client.workforces.create_edge(workforce_id=wf.id,
+                              source_agent_id=reviewer.id,
+                              target_agent_id=tester.id)
+
+# Hand work to the team
+task  = client.tasks.create(workforce_id=wf.id, title="Review PR #482 and add tests")
+final = client.tasks.wait_for_completion(task.id)
+print(final.status, final.result)
+```
+
+All resource methods return typed [Pydantic v2](https://docs.pydantic.dev/) models. Errors raise `navaia_forge.NavaiaForgeError` (or a subclass: `NotFoundError`, `RateLimitError`, `ValidationError`, `AuthenticationError`, `PermissionError`, `ServerError`, `TimeoutError`).
+
+## Real-time events
+
+```python
+from navaia_forge import NavaiaForgeWs, HttpConfig
+
+ws = NavaiaForgeWs(HttpConfig(base_url="http://localhost:8000", api_key="nf_..."))
+ws.on("task:status",  lambda e: print("task:",  e["task_id"], e["status"]))
+ws.on("agent:status", lambda e: print("agent:", e["agent_id"], e["status"]))
+ws.on("chat:message", lambda e: print(e["role"], e["content"]))
+ws.connect()
+ws.run_forever()
+```
+
+Channels: `task:status`, `agent:status`, `chat:message`, `system:*`.
+
+## What you can do
+
+| Namespace | What it does | Why you'd use it |
+|---|---|---|
+| `client.workforces` | CRUD; manage edges; link tools / knowledge bases | Define the team and how work flows through it |
+| `client.agents` | CRUD; `list_featured`, `clone`, `export`; attach/detach to workforces | Compose specialists with their own models and instructions |
+| `client.tasks` | `create`, `approve`, `reject`, `retry`, logs, `wait_for_completion` | Hand work to the team, sync or async |
+| `client.conversations` | Open chats, send messages targeted at agents | Build chat UIs / interactive assistants |
+| `client.knowledge` | Knowledge bases, document upload, semantic `search`, `featured`, `download` | Ground agents in your data via RAG |
+| `client.templates` | Workforce templates + `templates.agents` for agent templates | Don't rebuild the same team twice |
+| `client.tools` | Full CRUD, `featured`, attach/detach to workforces | Give the team hands (HTTP, MCP, code-exec, custom) |
+| `client.integrations` | `list`, `list_plugins`, CRUD | Connect Slack / GitHub / Linear / other plugins |
+| `client.setup` | `options`, `validate`, `complete` | First-run onboarding / provider configuration |
+| `client.observability` | `summary`, `cost`, `agent_metrics`, `agent_evaluations`, `log_token_usage` | See what the team is doing and what it costs |
+| `client.auth` | `me`, `register`, `login`, `refresh`, `create_key`, `validate`, OAuth URL helpers | Build your own UI on top of NavaiaForge |
+
+## Standalone or with the UI
+
+- **Standalone:** the SDK is sufficient on its own — no dashboard required. Drive everything from Python: scripts, services, Airflow / Prefect tasks, Jupyter, custom CLIs, internal tools.
+- **Alongside the dashboard:** anything you create programmatically appears in the NavaiaForge UI immediately, and anything created in the UI is reachable from `client.*`. Two views over one backend.
+
+## Development
+
+```bash
+python3.12 -m venv .venv
+source .venv/bin/activate
+pip install -e ".[dev]"
+pytest --cov=navaia_forge
+ruff check navaia_forge tests
+```
+
+## License
+
+[MIT](./LICENSE) © NavaiaSolutions

navaia_forge-0.1.0/navaia_forge/__init__.py

@@ -0,0 +1,155 @@
+"""NavaiaForge Python SDK.
+
+Public surface::
+
+    from navaia_forge import NavaiaForgeClient
+    from navaia_forge import Workforce, Agent, Task, Edge   # typed models
+    from navaia_forge import NavaiaForgeError, NotFoundError  # exceptions
+    from navaia_forge import NavaiaForgeWs                   # real-time WS client
+
+Quickstart::
+
+    client = NavaiaForgeClient(base_url="http://localhost:8000", api_key="nf_...")
+    workforces = client.workforces.list()
+    task = client.tasks.create(workforce_id=workforces[0].id, title="Review PR")
+    final = client.tasks.wait_for_completion(task.id)
+"""
+
+from .client import NavaiaForgeClient
+from .errors import (
+    AuthenticationError,
+    NavaiaForgeError,
+    NotFoundError,
+    PermissionError,
+    RateLimitError,
+    ServerError,
+    TimeoutError,
+    ValidationError,
+)
+from .http import HttpClient, HttpConfig
+from .types import (
+    Agent,
+    AgentConfig,
+    AgentCostBreakdown,
+    AgentCreate,
+    AgentMetrics,
+    AgentTemplate,
+    AgentTemplateCreate,
+    AgentUpdate,
+    AgentVariable,
+    ApiKeyCreated,
+    ApiKeyValidation,
+    AvailablePlugin,
+    Conversation,
+    CostSummary,
+    Edge,
+    Integration,
+    KnowledgeBase,
+    KnowledgeDocument,
+    Message,
+    MetricsSummary,
+    ModelCostBreakdown,
+    PaginatedResponse,
+    RLEvaluation,
+    SearchResponse,
+    SearchResult,
+    SetupOptions,
+    SetupValidateResult,
+    Task,
+    TaskCreate,
+    TaskLog,
+    Template,
+    TemplateInstantiateResult,
+    TokenPair,
+    TokenUsage,
+    Tool,
+    ToolCall,
+    ToolCreate,
+    ToolUpdate,
+    User,
+    Workforce,
+    WorkforceCreate,
+    WorkforceFull,
+    WorkforceKnowledgeBaseLink,
+    WorkforceMember,
+    WorkforceTemplate,
+    WorkforceTemplateCreate,
+    WorkforceToolLink,
+    WorkforceUpdate,
+    WsAgentStatusEvent,
+    WsChatEvent,
+    WsEvent,
+    WsSystemEvent,
+    WsTaskEvent,
+)
+from .websocket import NavaiaForgeWs
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Agent",
+    "AgentConfig",
+    "AgentCostBreakdown",
+    "AgentCreate",
+    "AgentMetrics",
+    "AgentTemplate",
+    "AgentTemplateCreate",
+    "AgentUpdate",
+    "AgentVariable",
+    "ApiKeyCreated",
+    "ApiKeyValidation",
+    "AuthenticationError",
+    "AvailablePlugin",
+    "Conversation",
+    "CostSummary",
+    "Edge",
+    "HttpClient",
+    "HttpConfig",
+    "Integration",
+    "KnowledgeBase",
+    "KnowledgeDocument",
+    "Message",
+    "MetricsSummary",
+    "ModelCostBreakdown",
+    "NavaiaForgeClient",
+    "NavaiaForgeError",
+    "NavaiaForgeWs",
+    "NotFoundError",
+    "PaginatedResponse",
+    "PermissionError",
+    "RLEvaluation",
+    "RateLimitError",
+    "SearchResponse",
+    "SearchResult",
+    "ServerError",
+    "SetupOptions",
+    "SetupValidateResult",
+    "Task",
+    "TaskCreate",
+    "TaskLog",
+    "Template",
+    "TemplateInstantiateResult",
+    "TimeoutError",
+    "TokenPair",
+    "TokenUsage",
+    "Tool",
+    "ToolCall",
+    "ToolCreate",
+    "ToolUpdate",
+    "User",
+    "ValidationError",
+    "Workforce",
+    "WorkforceCreate",
+    "WorkforceFull",
+    "WorkforceKnowledgeBaseLink",
+    "WorkforceMember",
+    "WorkforceTemplate",
+    "WorkforceTemplateCreate",
+    "WorkforceToolLink",
+    "WorkforceUpdate",
+    "WsAgentStatusEvent",
+    "WsChatEvent",
+    "WsEvent",
+    "WsSystemEvent",
+    "WsTaskEvent",
+]

navaia_forge-0.1.0/navaia_forge/client.py

@@ -0,0 +1,112 @@
+"""NavaiaForge Python SDK client.
+
+The client is intentionally thin: it owns an :class:`HttpClient` instance and
+exposes resource namespaces (``client.workforces``, ``client.agents``, ...).
+
+Example::
+
+    from navaia_forge import NavaiaForgeClient
+
+    client = NavaiaForgeClient(
+        base_url="http://localhost:8000",
+        api_key="nf_...",
+    )
+
+    workforces = client.workforces.list()
+    task = client.tasks.create(workforce_id=workforces[0].id, title="Review PR")
+    completed = client.tasks.wait_for_completion(task.id)
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from .http import HttpClient, HttpConfig
+from .resources import (
+    AgentsResource,
+    AuthResource,
+    ConversationsResource,
+    IntegrationsResource,
+    KnowledgeResource,
+    ObservabilityResource,
+    SetupResource,
+    TasksResource,
+    TemplatesResource,
+    ToolsResource,
+    WorkforcesResource,
+)
+
+
+class NavaiaForgeClient:
+    """Top-level entry point to the NavaiaForge SDK."""
+
+    def __init__(
+        self,
+        base_url: str = "http://localhost:8000",
+        api_key: str = "",
+        timeout: float = 60.0,
+        *,
+        http: HttpClient | None = None,
+    ) -> None:
+        self._config = HttpConfig(
+            base_url=base_url,
+            api_key=api_key,
+            timeout=timeout,
+        )
+        self._http = http if http is not None else HttpClient(self._config)
+
+        # Resource namespaces.
+        self.workforces = WorkforcesResource(self._http)
+        self.agents = AgentsResource(self._http)
+        self.tasks = TasksResource(self._http)
+        self.conversations = ConversationsResource(self._http)
+        self.knowledge = KnowledgeResource(self._http)
+        self.observability = ObservabilityResource(self._http)
+        self.templates = TemplatesResource(self._http)
+        self.integrations = IntegrationsResource(self._http)
+        self.tools = ToolsResource(self._http)
+        self.setup = SetupResource(self._http)
+        self.auth = AuthResource(self._http)
+
+    # ── Configuration accessors ───────────────────────────────
+
+    @property
+    def base_url(self) -> str:
+        return self._config.base_url
+
+    @property
+    def api_key(self) -> str:
+        return self._config.api_key
+
+    @property
+    def timeout(self) -> float:
+        return self._config.timeout
+
+    @property
+    def http(self) -> HttpClient:
+        """Underlying HTTP transport (escape hatch for advanced calls)."""
+        return self._http
+
+    # ── Lifecycle ─────────────────────────────────────────────
+
+    def close(self) -> None:
+        """Close the underlying HTTP client."""
+        self._http.close()
+
+    def __enter__(self) -> NavaiaForgeClient:
+        return self
+
+    def __exit__(self, *_: object) -> None:
+        self.close()
+
+    # ── Misc ──────────────────────────────────────────────────
+
+    def health(self) -> dict[str, Any]:
+        """Check API health (hits ``/health``, not ``/api/v1/health``)."""
+        url = f"{self._config.base_url.rstrip('/')}/health"
+        with httpx.Client(timeout=self._config.timeout) as client:
+            response = client.get(url)
+        response.raise_for_status()
+        return response.json()

navaia_forge-0.1.0/navaia_forge/errors.py

@@ -0,0 +1,83 @@
+"""Exception hierarchy for the NavaiaForge SDK.
+
+All SDK errors derive from :class:`NavaiaForgeError` so callers can catch them
+with a single ``except NavaiaForgeError`` clause. HTTP status codes are mapped
+to specific subclasses by :func:`error_from_status`.
+"""
+
+from __future__ import annotations
+
+
+class NavaiaForgeError(Exception):
+    """Base exception for all NavaiaForge SDK errors."""
+
+    def __init__(self, status_code: int, message: str) -> None:
+        self.status_code = status_code
+        self.message = message
+        super().__init__(f"HTTP {status_code}: {message}" if status_code else message)
+
+
+class AuthenticationError(NavaiaForgeError):
+    """Raised when authentication fails (HTTP 401)."""
+
+    def __init__(self, message: str = "Invalid or missing API key") -> None:
+        super().__init__(401, message)
+
+
+class PermissionError(NavaiaForgeError):
+    """Raised when the caller lacks permission (HTTP 403)."""
+
+    def __init__(self, message: str = "Permission denied") -> None:
+        super().__init__(403, message)
+
+
+class NotFoundError(NavaiaForgeError):
+    """Raised when a resource is not found (HTTP 404)."""
+
+    def __init__(self, message: str = "Resource not found") -> None:
+        super().__init__(404, message)
+
+
+class ValidationError(NavaiaForgeError):
+    """Raised when the server rejects a request body (HTTP 422)."""
+
+    def __init__(self, message: str = "Validation failed") -> None:
+        super().__init__(422, message)
+
+
+class RateLimitError(NavaiaForgeError):
+    """Raised when the rate limit is exceeded (HTTP 429)."""
+
+    def __init__(self, message: str = "Rate limit exceeded") -> None:
+        super().__init__(429, message)
+
+
+class ServerError(NavaiaForgeError):
+    """Raised on 5xx server errors."""
+
+    def __init__(self, status_code: int, message: str = "Server error") -> None:
+        super().__init__(status_code, message)
+
+
+class TimeoutError(NavaiaForgeError):
+    """Raised when a polling operation exceeds its timeout."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(0, message)
+
+
+def error_from_status(status_code: int, message: str) -> NavaiaForgeError:
+    """Map an HTTP status code to the appropriate :class:`NavaiaForgeError` subclass."""
+    if status_code == 401:
+        return AuthenticationError(message)
+    if status_code == 403:
+        return PermissionError(message)
+    if status_code == 404:
+        return NotFoundError(message)
+    if status_code == 422:
+        return ValidationError(message)
+    if status_code == 429:
+        return RateLimitError(message)
+    if 500 <= status_code < 600:
+        return ServerError(status_code, message)
+    return NavaiaForgeError(status_code, message)