forktex-intelligence 0.2.3__py3-none-any.whl

forktex_intelligence/client/generated/__init__.py

@@ -0,0 +1,623 @@
+# Copyright (C) 2026 FORKTEX S.R.L.
+#
+# SPDX-License-Identifier: AGPL-3.0-or-later OR LicenseRef-ForkTex-Commercial
+#
+# This file is part of forktex-intelligence.
+#
+# For commercial licensing -- including use in proprietary products, SaaS
+# deployments, or any context where AGPL obligations cannot be met -- you
+# MUST obtain a commercial license from FORKTEX S.R.L. (info@forktex.com).
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+"""Auto-generated Pydantic models from the ForkTex Intelligence API OpenAPI spec.
+
+DO NOT EDIT — regenerate with: make codegen
+
+Source: GET /api/openapi.json
+API version: 0.3.0
+Spec hash: 16c8ac59984d62f3
+"""
+from __future__ import annotations
+
+
+SPEC_VERSION = "0.3.0"
+SPEC_HASH = "16c8ac59984d62f3"
+
+
+from typing import Annotated, Any
+from uuid import UUID
+
+from pydantic import AwareDatetime, BaseModel, Field
+
+
+class APIKeyCreateRequest(BaseModel):
+    label: Annotated[str | None, Field(max_length=128, title="Label")] = ""
+
+
+class APIKeyCreateResponse(BaseModel):
+    created_at: Annotated[AwareDatetime, Field(title="Created At")]
+    id: Annotated[UUID, Field(title="Id")]
+    label: Annotated[str, Field(title="Label")]
+    raw_key: Annotated[str, Field(title="Raw Key")]
+
+
+class APIKeyResponse(BaseModel):
+    created_at: Annotated[AwareDatetime, Field(title="Created At")]
+    id: Annotated[UUID, Field(title="Id")]
+    is_active: Annotated[bool, Field(title="Is Active")]
+    label: Annotated[str, Field(title="Label")]
+
+
+class BodyExtractApiOrgOrgIdExtractPost(BaseModel):
+    chunk_overlap: Annotated[int | None, Field(title="Chunk Overlap")] = 32
+    chunk_size: Annotated[int | None, Field(title="Chunk Size")] = 256
+    file: Annotated[str, Field(title="File")]
+
+
+class BodyUploadDocApiOrgOrgIdCollectionsCollectionIdDocumentsPost(BaseModel):
+    file: Annotated[str, Field(title="File")]
+
+
+class ChunkResult(BaseModel):
+    index: Annotated[int, Field(title="Index")]
+    text: Annotated[str, Field(title="Text")]
+    token_count: Annotated[int, Field(title="Token Count")]
+
+
+class CollectionCreateRequest(BaseModel):
+    distance_metric: Annotated[str | None, Field(title="Distance Metric")] = "cosine"
+    embedding_model: Annotated[str | None, Field(title="Embedding Model")] = (
+        "all-MiniLM-L6-v2"
+    )
+    name: Annotated[str, Field(max_length=256, min_length=1, title="Name")]
+
+
+class CollectionResponse(BaseModel):
+    created_at: Annotated[AwareDatetime, Field(title="Created At")]
+    dimensions: Annotated[int, Field(title="Dimensions")]
+    distance_metric: Annotated[str, Field(title="Distance Metric")]
+    document_count: Annotated[int, Field(title="Document Count")]
+    embedding_model: Annotated[str, Field(title="Embedding Model")]
+    id: Annotated[UUID, Field(title="Id")]
+    name: Annotated[str, Field(title="Name")]
+    updated_at: Annotated[AwareDatetime, Field(title="Updated At")]
+
+
+class CrossCollectionSearchRequest(BaseModel):
+    collection_ids: Annotated[list[UUID] | None, Field(title="Collection Ids")] = None
+    query: Annotated[str, Field(min_length=1, title="Query")]
+    rerank: Annotated[bool | None, Field(title="Rerank")] = False
+    rerank_top_k: Annotated[int | None, Field(ge=1, le=100, title="Rerank Top K")] = 5
+    top_k: Annotated[int | None, Field(ge=1, le=100, title="Top K")] = 10
+
+
+class DocumentResponse(BaseModel):
+    chunk_count: Annotated[int, Field(title="Chunk Count")]
+    collection_id: Annotated[UUID, Field(title="Collection Id")]
+    content_type: Annotated[str, Field(title="Content Type")]
+    created_at: Annotated[AwareDatetime, Field(title="Created At")]
+    error_message: Annotated[str | None, Field(title="Error Message")]
+    file_size_bytes: Annotated[int, Field(title="File Size Bytes")]
+    filename: Annotated[str, Field(title="Filename")]
+    id: Annotated[UUID, Field(title="Id")]
+    meta: Annotated[dict[str, Any] | None, Field(title="Meta")] = None
+    status: Annotated[str, Field(title="Status")]
+    updated_at: Annotated[AwareDatetime, Field(title="Updated At")]
+
+
+class DocumentUploadResponse(BaseModel):
+    id: Annotated[UUID, Field(title="Id")]
+    message: Annotated[str | None, Field(title="Message")] = (
+        "Document accepted for processing"
+    )
+    status: Annotated[str, Field(title="Status")]
+
+
+class EmbedRequest(BaseModel):
+    """
+    POST /api/v1/embed
+    """
+
+    input: Annotated[list[str], Field(max_length=256, min_length=1, title="Input")]
+    model: Annotated[str | None, Field(title="Model")] = "all-MiniLM-L6-v2"
+    normalize: Annotated[bool | None, Field(title="Normalize")] = True
+
+
+class EmbeddingData(BaseModel):
+    """
+    Single embedding result.
+    """
+
+    embedding: Annotated[list[float], Field(title="Embedding")]
+    index: Annotated[int, Field(title="Index")]
+
+
+class ExtractResponse(BaseModel):
+    chunks: Annotated[list[ChunkResult], Field(title="Chunks")]
+    content_type: Annotated[str, Field(title="Content Type")]
+    filename: Annotated[str, Field(title="Filename")]
+    metadata: Annotated[dict[str, Any] | None, Field(title="Metadata")] = None
+    text: Annotated[str, Field(title="Text")]
+
+
+class HealthResponse(BaseModel):
+    status: Annotated[str, Field(title="Status")]
+    timestamp: Annotated[AwareDatetime, Field(title="Timestamp")]
+    version: Annotated[str, Field(title="Version")]
+
+
+class LoginRequest(BaseModel):
+    email: Annotated[
+        str, Field(pattern="^[^@\\s]+@[^@\\s]+\\.[^@\\s]+$", title="Email")
+    ]
+    password: Annotated[str, Field(title="Password")]
+
+
+class MCPInfo(BaseModel):
+    description: Annotated[str, Field(title="Description")]
+    """
+    Human-readable summary
+    """
+    endpoint: Annotated[str, Field(title="Endpoint")]
+    """
+    HTTP path of the MCP JSON-RPC transport
+    """
+    protocol: Annotated[str, Field(title="Protocol")]
+    """
+    Protocol identifier
+    """
+    spec_url: Annotated[str, Field(title="Spec Url")]
+    """
+    Link to the MCP specification
+    """
+    version: Annotated[str, Field(title="Version")]
+    """
+    MCP protocol version this server targets
+    """
+
+
+class ModelInfo(BaseModel):
+    aliases: Annotated[list[str] | None, Field(title="Aliases")] = None
+    capabilities: Annotated[list[str] | None, Field(title="Capabilities")] = None
+    context_window: Annotated[int | None, Field(title="Context Window")] = 0
+    description: Annotated[str | None, Field(title="Description")] = ""
+    id: Annotated[str, Field(title="Id")]
+    modality: Annotated[str | None, Field(title="Modality")] = "chat"
+
+
+class ModelsResponse(BaseModel):
+    models: Annotated[list[ModelInfo], Field(title="Models")]
+
+
+class OrgCreateRequest(BaseModel):
+    name: Annotated[str, Field(max_length=128, min_length=1, title="Name")]
+    slug: Annotated[
+        str,
+        Field(
+            max_length=128, min_length=1, pattern="^[a-z0-9][a-z0-9\\-]*$", title="Slug"
+        ),
+    ]
+
+
+class OrgResponse(BaseModel):
+    created_at: Annotated[AwareDatetime, Field(title="Created At")]
+    id: Annotated[UUID, Field(title="Id")]
+    name: Annotated[str, Field(title="Name")]
+    slug: Annotated[str, Field(title="Slug")]
+
+
+class RegisterRequest(BaseModel):
+    email: Annotated[
+        str, Field(pattern="^[^@\\s]+@[^@\\s]+\\.[^@\\s]+$", title="Email")
+    ]
+    password: Annotated[str, Field(max_length=128, min_length=8, title="Password")]
+
+
+class RerankRequest(BaseModel):
+    """
+    POST /api/v1/rerank
+    """
+
+    documents: Annotated[
+        list[str], Field(max_length=256, min_length=1, title="Documents")
+    ]
+    model: Annotated[str | None, Field(title="Model")] = "all-MiniLM-L6-v2"
+    query: Annotated[str, Field(title="Query")]
+    top_k: Annotated[int | None, Field(title="Top K")] = None
+
+
+class RerankResult(BaseModel):
+    """
+    Single rerank result.
+    """
+
+    index: Annotated[int, Field(title="Index")]
+    score: Annotated[float, Field(title="Score")]
+    text: Annotated[str, Field(title="Text")]
+
+
+class SearchRequest(BaseModel):
+    query: Annotated[str, Field(min_length=1, title="Query")]
+    rerank: Annotated[bool | None, Field(title="Rerank")] = False
+    rerank_top_k: Annotated[int | None, Field(ge=1, le=100, title="Rerank Top K")] = 5
+    top_k: Annotated[int | None, Field(ge=1, le=100, title="Top K")] = 10
+
+
+class SearchResult(BaseModel):
+    chunk_id: Annotated[UUID, Field(title="Chunk Id")]
+    collection_id: Annotated[UUID, Field(title="Collection Id")]
+    document_id: Annotated[UUID, Field(title="Document Id")]
+    metadata: Annotated[dict[str, Any] | None, Field(title="Metadata")] = None
+    score: Annotated[float, Field(title="Score")]
+    text: Annotated[str, Field(title="Text")]
+
+
+class TokenResponse(BaseModel):
+    access_token: Annotated[str, Field(title="Access Token")]
+    token_type: Annotated[str | None, Field(title="Token Type")] = "bearer"
+
+
+class ToolCallInfo(BaseModel):
+    arguments: Annotated[dict[str, Any], Field(title="Arguments")]
+    id: Annotated[str, Field(title="Id")]
+    name: Annotated[str, Field(title="Name")]
+
+
+class UsageAggregation(BaseModel):
+    avg_latency_ms: Annotated[float | None, Field(title="Avg Latency Ms")] = 0.0
+    by_api_key: Annotated[
+        dict[str, dict[str, Any]] | None, Field(title="By Api Key")
+    ] = None
+    by_endpoint: Annotated[dict[str, int] | None, Field(title="By Endpoint")] = None
+    by_model: Annotated[dict[str, int] | None, Field(title="By Model")] = None
+    by_user: Annotated[dict[str, dict[str, Any]] | None, Field(title="By User")] = None
+    currency: Annotated[str | None, Field(title="Currency")] = "usd"
+    period_end: Annotated[AwareDatetime | None, Field(title="Period End")] = None
+    period_start: Annotated[AwareDatetime | None, Field(title="Period Start")] = None
+    total_calls: Annotated[int | None, Field(title="Total Calls")] = 0
+    total_cost: Annotated[float | None, Field(title="Total Cost")] = 0.0
+    total_input_tokens: Annotated[int | None, Field(title="Total Input Tokens")] = 0
+    total_output_tokens: Annotated[int | None, Field(title="Total Output Tokens")] = 0
+    total_tokens: Annotated[int | None, Field(title="Total Tokens")] = 0
+
+
+class UsageInfo(BaseModel):
+    input_tokens: Annotated[int | None, Field(title="Input Tokens")] = 0
+    model: Annotated[str | None, Field(title="Model")] = ""
+    output_tokens: Annotated[int | None, Field(title="Output Tokens")] = 0
+    timestamp: Annotated[float | None, Field(title="Timestamp")] = None
+    total_tokens: Annotated[int | None, Field(title="Total Tokens")] = 0
+
+
+class UsageLogEntry(BaseModel):
+    api_key_id: Annotated[UUID | None, Field(title="Api Key Id")] = None
+    cost: Annotated[float | None, Field(title="Cost")] = None
+    created_at: Annotated[AwareDatetime, Field(title="Created At")]
+    currency: Annotated[str | None, Field(title="Currency")] = None
+    endpoint: Annotated[str, Field(title="Endpoint")]
+    error: Annotated[str | None, Field(title="Error")]
+    id: Annotated[UUID, Field(title="Id")]
+    input_tokens: Annotated[int, Field(title="Input Tokens")]
+    latency_ms: Annotated[int, Field(title="Latency Ms")]
+    method: Annotated[str, Field(title="Method")]
+    model: Annotated[str | None, Field(title="Model")]
+    output_tokens: Annotated[int, Field(title="Output Tokens")]
+    status_code: Annotated[int, Field(title="Status Code")]
+    user_id: Annotated[UUID | None, Field(title="User Id")] = None
+
+
+class UsageLogResponse(BaseModel):
+    entries: Annotated[list[UsageLogEntry], Field(title="Entries")]
+    limit: Annotated[int, Field(title="Limit")]
+    offset: Annotated[int, Field(title="Offset")]
+    total: Annotated[int, Field(title="Total")]
+
+
+class UserResponse(BaseModel):
+    created_at: Annotated[AwareDatetime, Field(title="Created At")]
+    email: Annotated[str, Field(title="Email")]
+    id: Annotated[UUID, Field(title="Id")]
+    is_active: Annotated[bool, Field(title="Is Active")]
+
+
+class ValidationError(BaseModel):
+    ctx: Annotated[dict[str, Any] | None, Field(title="Context")] = None
+    input: Annotated[Any | None, Field(title="Input")] = None
+    loc: Annotated[list[str | int], Field(title="Location")]
+    msg: Annotated[str, Field(title="Message")]
+    type: Annotated[str, Field(title="Error Type")]
+
+
+class ChatMessage(BaseModel):
+    """
+    Single message in the API request.
+    """
+
+    content: Annotated[str, Field(title="Content")]
+    role: Annotated[str, Field(title="Role")]
+    tool_call_id: Annotated[str | None, Field(title="Tool Call Id")] = None
+    tool_calls: Annotated[list[ToolCallInfo] | None, Field(title="Tool Calls")] = None
+
+
+class ChatRequest(BaseModel):
+    """
+    POST /api/v1/chat
+    """
+
+    max_tokens: Annotated[int | None, Field(title="Max Tokens")] = None
+    messages: Annotated[list[ChatMessage], Field(title="Messages")]
+    model: Annotated[str | None, Field(title="Model")] = None
+    stream: Annotated[bool | None, Field(title="Stream")] = True
+    system: Annotated[str | None, Field(title="System")] = None
+    temperature: Annotated[float | None, Field(title="Temperature")] = None
+    tools: Annotated[list[dict[str, Any]] | None, Field(title="Tools")] = None
+
+
+class ChatResponse(BaseModel):
+    """
+    Non-streaming chat response.
+    """
+
+    content: Annotated[str, Field(title="Content")]
+    model: Annotated[str, Field(title="Model")]
+    tool_calls: Annotated[list[ToolCallInfo] | None, Field(title="Tool Calls")] = None
+    usage: UsageInfo
+
+
+class CollectionListResponse(BaseModel):
+    collections: Annotated[list[CollectionResponse], Field(title="Collections")]
+    total: Annotated[int, Field(title="Total")]
+
+
+class DocumentListResponse(BaseModel):
+    documents: Annotated[list[DocumentResponse], Field(title="Documents")]
+    total: Annotated[int, Field(title="Total")]
+
+
+class EmbedResponse(BaseModel):
+    """
+    Embedding response — compatible with OpenAI format.
+    """
+
+    data: Annotated[list[EmbeddingData], Field(title="Data")]
+    dimensions: Annotated[int, Field(title="Dimensions")]
+    model: Annotated[str, Field(title="Model")]
+    usage: Annotated[dict[str, int] | None, Field(title="Usage")] = None
+
+
+class HTTPValidationError(BaseModel):
+    detail: Annotated[list[ValidationError] | None, Field(title="Detail")] = None
+
+
+class RerankResponse(BaseModel):
+    data: Annotated[list[RerankResult], Field(title="Data")]
+    model: Annotated[str, Field(title="Model")]
+
+
+class SearchResponse(BaseModel):
+    query: Annotated[str, Field(title="Query")]
+    results: Annotated[list[SearchResult], Field(title="Results")]
+    total: Annotated[int, Field(title="Total")]
+
+
+class StructuredChatRequest(BaseModel):
+    """
+    POST /api/v1/chat/structured
+    """
+
+    messages: Annotated[list[ChatMessage], Field(title="Messages")]
+    model: Annotated[str | None, Field(title="Model")] = None
+    response_schema: Annotated[
+        dict[str, Any] | None, Field(title="Response Schema")
+    ] = None
+    system: Annotated[str | None, Field(title="System")] = None
+
+
+class StructuredChatResponse(BaseModel):
+    """
+    Structured (JSON-mode) response.
+    """
+
+    content: Annotated[str, Field(title="Content")]
+    model: Annotated[str, Field(title="Model")]
+    usage: UsageInfo
+
+
+class UserMeResponse(BaseModel):
+    orgs: Annotated[list[OrgResponse], Field(title="Orgs")]
+    user: UserResponse
+
+# ── Generated async operations ──────────────────────────────────────
+#
+# One method per OpenAPI operation, typed with the generated Pydantic
+# models above. Subclasses must implement ``_request``.
+
+class _GeneratedOperations:
+    """Async method-per-operation client surface generated from openapi.json."""
+
+    async def _request(
+        self, method: str, path: str, *, params: dict[str, Any] | None = None,
+        json: Any = None,
+    ) -> Any:
+        raise NotImplementedError
+
+    async def login(self, body: LoginRequest) -> TokenResponse:
+        """Login"""
+        _resp = await self._request("POST", '/api/auth/login', json=body.model_dump(mode="json", exclude_unset=True) if body is not None else None)
+        return TokenResponse.model_validate(_resp)
+
+    async def register(self, body: RegisterRequest) -> None:
+        """Register"""
+        _resp = await self._request("POST", '/api/auth/register', json=body.model_dump(mode="json", exclude_unset=True) if body is not None else None)
+        return None
+
+    async def health(self) -> HealthResponse:
+        """Health"""
+        _resp = await self._request("GET", '/api/health')
+        return HealthResponse.model_validate(_resp)
+
+    async def health_ready(self) -> None:
+        """Health Ready"""
+        _resp = await self._request("GET", '/api/health/ready')
+        return None
+
+    async def mcp_info(self) -> MCPInfo:
+        """Mcp Info"""
+        _resp = await self._request("GET", '/api/mcp/info')
+        return MCPInfo.model_validate(_resp)
+
+    async def me(self) -> UserMeResponse:
+        """Me"""
+        _resp = await self._request("GET", '/api/me')
+        return UserMeResponse.model_validate(_resp)
+
+    async def list_models(self) -> ModelsResponse:
+        """List Models"""
+        _resp = await self._request("GET", '/api/models')
+        return ModelsResponse.model_validate(_resp)
+
+    async def list_keys(self, org_id: UUID) -> list[APIKeyResponse]:
+        """List Keys"""
+        _resp = await self._request("GET", f'/api/org/{org_id}/api-keys')
+        return [APIKeyResponse.model_validate(_x) for _x in _resp]
+
+    async def create_key(self, org_id: UUID, body: APIKeyCreateRequest) -> APIKeyCreateResponse:
+        """Create Key"""
+        _resp = await self._request("POST", f'/api/org/{org_id}/api-keys', json=body.model_dump(mode="json", exclude_unset=True) if body is not None else None)
+        return APIKeyCreateResponse.model_validate(_resp)
+
+    async def delete_key(self, org_id: UUID, key_id: UUID) -> None:
+        """Delete Key"""
+        _resp = await self._request("DELETE", f'/api/org/{org_id}/api-keys/{key_id}')
+        return None
+
+    async def chat(self, org_id: UUID, body: ChatRequest) -> ChatResponse:
+        """Chat"""
+        _resp = await self._request("POST", f'/api/org/{org_id}/chat', json=body.model_dump(mode="json", exclude_unset=True) if body is not None else None)
+        return ChatResponse.model_validate(_resp)
+
+    async def chat_structured(self, org_id: UUID, body: StructuredChatRequest) -> StructuredChatResponse:
+        """Chat Structured"""
+        _resp = await self._request("POST", f'/api/org/{org_id}/chat/structured', json=body.model_dump(mode="json", exclude_unset=True) if body is not None else None)
+        return StructuredChatResponse.model_validate(_resp)
+
+    async def list_colls(self, org_id: UUID) -> CollectionListResponse:
+        """List Colls"""
+        _resp = await self._request("GET", f'/api/org/{org_id}/collections')
+        return CollectionListResponse.model_validate(_resp)
+
+    async def create_coll(self, org_id: UUID, body: CollectionCreateRequest) -> CollectionResponse:
+        """Create Coll"""
+        _resp = await self._request("POST", f'/api/org/{org_id}/collections', json=body.model_dump(mode="json", exclude_unset=True) if body is not None else None)
+        return CollectionResponse.model_validate(_resp)
+
+    async def delete_coll(self, org_id: UUID, collection_id: UUID) -> None:
+        """Delete Coll"""
+        _resp = await self._request("DELETE", f'/api/org/{org_id}/collections/{collection_id}')
+        return None
+
+    async def get_coll(self, org_id: UUID, collection_id: UUID) -> CollectionResponse:
+        """Get Coll"""
+        _resp = await self._request("GET", f'/api/org/{org_id}/collections/{collection_id}')
+        return CollectionResponse.model_validate(_resp)
+
+    async def list_docs(self, org_id: UUID, collection_id: UUID) -> DocumentListResponse:
+        """List Docs"""
+        _resp = await self._request("GET", f'/api/org/{org_id}/collections/{collection_id}/documents')
+        return DocumentListResponse.model_validate(_resp)
+
+    async def upload_doc(self, org_id: UUID, collection_id: UUID) -> DocumentUploadResponse:
+        """Upload Doc"""
+        _resp = await self._request("POST", f'/api/org/{org_id}/collections/{collection_id}/documents')
+        return DocumentUploadResponse.model_validate(_resp)
+
+    async def delete_doc(self, org_id: UUID, collection_id: UUID, document_id: UUID) -> None:
+        """Delete Doc"""
+        _resp = await self._request("DELETE", f'/api/org/{org_id}/collections/{collection_id}/documents/{document_id}')
+        return None
+
+    async def get_doc(self, org_id: UUID, collection_id: UUID, document_id: UUID) -> DocumentResponse:
+        """Get Doc"""
+        _resp = await self._request("GET", f'/api/org/{org_id}/collections/{collection_id}/documents/{document_id}')
+        return DocumentResponse.model_validate(_resp)
+
+    async def search_single(self, org_id: UUID, collection_id: UUID, body: SearchRequest) -> SearchResponse:
+        """Search Single"""
+        _resp = await self._request("POST", f'/api/org/{org_id}/collections/{collection_id}/search', json=body.model_dump(mode="json", exclude_unset=True) if body is not None else None)
+        return SearchResponse.model_validate(_resp)
+
+    async def embed(self, org_id: UUID, body: EmbedRequest) -> EmbedResponse:
+        """Embed"""
+        _resp = await self._request("POST", f'/api/org/{org_id}/embed', json=body.model_dump(mode="json", exclude_unset=True) if body is not None else None)
+        return EmbedResponse.model_validate(_resp)
+
+    async def rerank(self, org_id: UUID, body: RerankRequest) -> RerankResponse:
+        """Rerank"""
+        _resp = await self._request("POST", f'/api/org/{org_id}/embed/rerank', json=body.model_dump(mode="json", exclude_unset=True) if body is not None else None)
+        return RerankResponse.model_validate(_resp)
+
+    async def extract(self, org_id: UUID) -> ExtractResponse:
+        """Extract"""
+        _resp = await self._request("POST", f'/api/org/{org_id}/extract')
+        return ExtractResponse.model_validate(_resp)
+
+    async def search_cross(self, org_id: UUID, body: CrossCollectionSearchRequest) -> SearchResponse:
+        """Search Cross"""
+        _resp = await self._request("POST", f'/api/org/{org_id}/search', json=body.model_dump(mode="json", exclude_unset=True) if body is not None else None)
+        return SearchResponse.model_validate(_resp)
+
+    async def usage_stats(self, org_id: UUID, since: AwareDatetime | None = None, until: AwareDatetime | None = None) -> UsageAggregation:
+        """Usage Stats"""
+        _q: dict[str, Any] = {}
+        if since is not None:
+            _q['since'] = since
+        if until is not None:
+            _q['until'] = until
+        _resp = await self._request("GET", f'/api/org/{org_id}/usage', params=_q or None)
+        return UsageAggregation.model_validate(_resp)
+
+    async def usage_log(self, org_id: UUID, offset: int | None = None, limit: int | None = None, since: AwareDatetime | None = None, until: AwareDatetime | None = None, api_key_id: UUID | None = None, user_id: UUID | None = None) -> UsageLogResponse:
+        """Usage Log"""
+        _q: dict[str, Any] = {}
+        if offset is not None:
+            _q['offset'] = offset
+        if limit is not None:
+            _q['limit'] = limit
+        if since is not None:
+            _q['since'] = since
+        if until is not None:
+            _q['until'] = until
+        if api_key_id is not None:
+            _q['api_key_id'] = api_key_id
+        if user_id is not None:
+            _q['user_id'] = user_id
+        _resp = await self._request("GET", f'/api/org/{org_id}/usage/log', params=_q or None)
+        return UsageLogResponse.model_validate(_resp)
+
+    async def list_orgs(self) -> list[OrgResponse]:
+        """List Orgs"""
+        _resp = await self._request("GET", '/api/orgs')
+        return [OrgResponse.model_validate(_x) for _x in _resp]
+
+    async def create_org_endpoint(self, body: OrgCreateRequest) -> OrgResponse:
+        """Create Org Endpoint"""
+        _resp = await self._request("POST", '/api/orgs', json=body.model_dump(mode="json", exclude_unset=True) if body is not None else None)
+        return OrgResponse.model_validate(_resp)
+
+    async def whoami(self) -> None:
+        """Whoami"""
+        _resp = await self._request("GET", '/api/whoami')
+        return None
+

forktex_intelligence/config.py

@@ -0,0 +1,43 @@
+# Copyright (C) 2026 FORKTEX S.R.L.
+#
+# SPDX-License-Identifier: AGPL-3.0-or-later OR LicenseRef-ForkTex-Commercial
+#
+# This file is part of forktex-intelligence.
+#
+# For commercial licensing -- including use in proprietary products, SaaS
+# deployments, or any context where AGPL obligations cannot be met -- you
+# MUST obtain a commercial license from FORKTEX S.R.L. (info@forktex.com).
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+"""Intelligence configuration model.
+
+Pure data model — no filesystem I/O.  The host application (e.g. forktex-py)
+is responsible for discovering, loading, and persisting settings.
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class IntelligenceSettings(BaseModel):
+    """Configuration for the ForkTex Intelligence API client."""
+
+    endpoint: str = "https://intelligence.forktex.com/api"
+    api_key: str = ""
+
+    @property
+    def is_configured(self) -> bool:
+        return bool(self.endpoint and self.api_key)