akumi 0.1.0__tar.gz

akumi-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,39 @@
+name: Publish to PyPI
+
+# Fires on the vX.Y.Z tag that the control-plane sdk-python.yml workflow
+# auto-pushes. Sets pyproject.toml to the tag version, builds, and uploads to
+# PyPI via Trusted Publishing (OIDC, no stored token). Skips cleanly until the
+# PYPI_PUBLISH repo variable is set to 'true', so early tags do not fail.
+on:
+  push:
+    tags: ['v*']
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Set version from the tag
+        run: sed -i -E "s/^version = \".*\"/version = \"${GITHUB_REF_NAME#v}\"/" pyproject.toml
+
+      - name: Build wheel and sdist
+        run: |
+          python -m pip install --upgrade build
+          python -m build
+
+      - name: Publish to PyPI (Trusted Publishing)
+        if: vars.PYPI_PUBLISH == 'true'
+        uses: pypa/gh-action-pypi-publish@release/v1
+
+      - name: Publishing skipped
+        if: vars.PYPI_PUBLISH != 'true'
+        run: echo "PyPI publishing not enabled; set repo variable PYPI_PUBLISH=true after configuring Trusted Publishing."

akumi-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.pyc
+dist/
+build/
+.mypy_cache/
+.ruff_cache/
+*.egg-info/

akumi-0.1.0/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: akumi
+Version: 0.1.0
+Summary: Official Python SDK for the Akumi EU-sovereign inference API.
+License-Expression: MIT
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.27
+Provides-Extra: dev
+Requires-Dist: mypy>=1.11; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Akumi Python SDK
+
+The official Python client for [Akumi](https://akumi.cloud), the EU-sovereign,
+OpenAI-compatible inference API. Built on httpx, with both a synchronous and an
+asynchronous client. One `base_url` for every model, governed and metered, with
+your regulated data kept in the EU.
+
+- **Drop-in OpenAI-compatible.** Chat completions, embeddings, and models under one key.
+- **EU-sovereign by default.** The egress guard fails closed on non-EU routing.
+- **Governed, not just hosted.** PII firewall, per-request residency, and a metadata-only audit trail on every call.
+- **Sync and async.** Streaming and automatic retries in both clients.
+
+## Requirements
+
+Python 3.9 or newer.
+
+## Install
+
+```bash
+pip install akumi
+```
+
+## Quickstart
+
+Create an API key under app.akumi.cloud -> Platform -> API keys:
+
+```python
+from akumi import Akumi
+
+client = Akumi.from_api_key("mk_...")
+
+result = client.chat.create(params={
+    "model": "mistral/mistral-large-latest",
+    "messages": [
+        {"role": "user", "content": "Explain EU data residency in one sentence."},
+    ],
+})
+
+print(result["choices"][0]["message"]["content"])
+```
+
+## Streaming
+
+```python
+for chunk in client.chat.create_streamed(params={
+    "model": "mistral/mistral-large-latest",
+    "messages": [{"role": "user", "content": "Write a haiku about Frankfurt."}],
+}):
+    print(chunk["choices"][0]["delta"].get("content", ""), end="")
+```
+
+## Async
+
+```python
+import asyncio
+from akumi import AsyncAkumi
+
+async def main():
+    client = AsyncAkumi.from_api_key("mk_...")
+    result = await client.chat.create(params={
+        "model": "mistral/mistral-large-latest",
+        "messages": [{"role": "user", "content": "Hello from the EU."}],
+    })
+    print(result["choices"][0]["message"]["content"])
+
+asyncio.run(main())
+```
+
+## Embeddings
+
+```python
+embeddings = client.embeddings.create(params={
+    "model": "mistral/mistral-embed",
+    "input": "The quarterly report is ready for review.",
+})
+
+vector = embeddings["data"][0]["embedding"]
+```
+
+## More resources
+
+- `client.models.list()` lists the models available to your key.
+- `client.memory.forget(...)` and `client.memoryThreads.list()` manage long-term memory and threads.
+- `client.auditLogs.list()` reads your metadata-only audit trail.
+
+## Configuration
+
+`from_api_key()` connects to `https://api.akumi.cloud/v1` and retries transient
+failures (429, 502, 503, 504). Pass `base_url=` to target another host.
+
+## Documentation
+
+- Guides: https://akumi.cloud/docs
+- API reference: https://akumi.cloud/docs/api-reference
+
+## About
+
+Generated from the Akumi OpenAPI specification, so it tracks the API
+automatically. Issues: https://github.com/akumi-cloud/python-sdk.
+
+MIT licensed.

akumi-0.1.0/README.md

@@ -0,0 +1,101 @@
+# Akumi Python SDK
+
+The official Python client for [Akumi](https://akumi.cloud), the EU-sovereign,
+OpenAI-compatible inference API. Built on httpx, with both a synchronous and an
+asynchronous client. One `base_url` for every model, governed and metered, with
+your regulated data kept in the EU.
+
+- **Drop-in OpenAI-compatible.** Chat completions, embeddings, and models under one key.
+- **EU-sovereign by default.** The egress guard fails closed on non-EU routing.
+- **Governed, not just hosted.** PII firewall, per-request residency, and a metadata-only audit trail on every call.
+- **Sync and async.** Streaming and automatic retries in both clients.
+
+## Requirements
+
+Python 3.9 or newer.
+
+## Install
+
+```bash
+pip install akumi
+```
+
+## Quickstart
+
+Create an API key under app.akumi.cloud -> Platform -> API keys:
+
+```python
+from akumi import Akumi
+
+client = Akumi.from_api_key("mk_...")
+
+result = client.chat.create(params={
+    "model": "mistral/mistral-large-latest",
+    "messages": [
+        {"role": "user", "content": "Explain EU data residency in one sentence."},
+    ],
+})
+
+print(result["choices"][0]["message"]["content"])
+```
+
+## Streaming
+
+```python
+for chunk in client.chat.create_streamed(params={
+    "model": "mistral/mistral-large-latest",
+    "messages": [{"role": "user", "content": "Write a haiku about Frankfurt."}],
+}):
+    print(chunk["choices"][0]["delta"].get("content", ""), end="")
+```
+
+## Async
+
+```python
+import asyncio
+from akumi import AsyncAkumi
+
+async def main():
+    client = AsyncAkumi.from_api_key("mk_...")
+    result = await client.chat.create(params={
+        "model": "mistral/mistral-large-latest",
+        "messages": [{"role": "user", "content": "Hello from the EU."}],
+    })
+    print(result["choices"][0]["message"]["content"])
+
+asyncio.run(main())
+```
+
+## Embeddings
+
+```python
+embeddings = client.embeddings.create(params={
+    "model": "mistral/mistral-embed",
+    "input": "The quarterly report is ready for review.",
+})
+
+vector = embeddings["data"][0]["embedding"]
+```
+
+## More resources
+
+- `client.models.list()` lists the models available to your key.
+- `client.memory.forget(...)` and `client.memoryThreads.list()` manage long-term memory and threads.
+- `client.auditLogs.list()` reads your metadata-only audit trail.
+
+## Configuration
+
+`from_api_key()` connects to `https://api.akumi.cloud/v1` and retries transient
+failures (429, 502, 503, 504). Pass `base_url=` to target another host.
+
+## Documentation
+
+- Guides: https://akumi.cloud/docs
+- API reference: https://akumi.cloud/docs/api-reference
+
+## About
+
+Generated from the Akumi OpenAPI specification, so it tracks the API
+automatically. Issues: https://github.com/akumi-cloud/python-sdk.
+
+MIT licensed.

akumi-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "akumi"
+version = "0.1.0"
+description = "Official Python SDK for the Akumi EU-sovereign inference API."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.9"
+dependencies = ["httpx>=0.27"]
+
+[project.optional-dependencies]
+dev = ["mypy>=1.11", "ruff>=0.6"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/akumi"]
+
+[tool.ruff]
+target-version = "py39"
+
+[tool.ruff.lint]
+# The transport's __enter__/__aenter__ return the concrete transport type rather
+# than Self, which on Python < 3.11 would pull in typing_extensions just for an
+# annotation. PYI034 is a stylistic preference, so ignore it and keep the runtime
+# dependency-free. All other lint rules are auto-fixed in CI (ruff check --fix).
+ignore = ["PYI034"]
+
+[tool.mypy]
+python_version = "3.9"
+ignore_missing_imports = true

akumi-0.1.0/src/akumi/__init__.py

@@ -0,0 +1,48 @@
+# AUTO-GENERATED by akumi/codegen. Do not edit by hand.
+from __future__ import annotations
+
+from ._async_client import AsyncAkumi
+from ._client import Akumi
+from ._config import ClientConfig
+from ._errors import (
+    AkumiError,
+    ApiError,
+    AuthenticationError,
+    InvalidRequestError,
+    RateLimitError,
+)
+from .models import (
+    AuditLogApiResource,
+    ChatCompletionsRequest,
+    EmbeddingsRequest,
+    IngestDocumentRequest,
+    RememberFactRequest,
+    SearchDocumentsRequest,
+    SearchFactsRequest,
+    SearchRequest,
+    StoreCollectionRequest,
+    ThreadMessageViewModel,
+    ThreadViewModel,
+)
+
+__all__ = [
+    "Akumi",
+    "AkumiError",
+    "ApiError",
+    "AsyncAkumi",
+    "AuditLogApiResource",
+    "AuthenticationError",
+    "ChatCompletionsRequest",
+    "ClientConfig",
+    "EmbeddingsRequest",
+    "IngestDocumentRequest",
+    "InvalidRequestError",
+    "RateLimitError",
+    "RememberFactRequest",
+    "SearchDocumentsRequest",
+    "SearchFactsRequest",
+    "SearchRequest",
+    "StoreCollectionRequest",
+    "ThreadMessageViewModel",
+    "ThreadViewModel",
+]

akumi-0.1.0/src/akumi/_async_client.py

@@ -0,0 +1,33 @@
+# AUTO-GENERATED by akumi/codegen. Do not edit by hand.
+from __future__ import annotations
+
+from ._config import ClientConfig
+from ._transport import AsyncTransport
+from .resources.auditLogs_async import AsyncAuditLogsResource
+from .resources.chat_async import AsyncChatResource
+from .resources.embeddings_async import AsyncEmbeddingsResource
+from .resources.models_async import AsyncModelsResource
+from .resources.recall_async import AsyncRecallResource
+
+
+class AsyncAkumi:
+    def __init__(
+        self,
+        *,
+        api_key: str,
+        base_url: str = "https://api.akumi.cloud/v1",
+        max_retries: int = 2,
+    ) -> None:
+        config = ClientConfig(
+            api_key=api_key, base_url=base_url, max_retries=max_retries
+        )
+        self._transport = AsyncTransport(config)
+        self.recall = AsyncRecallResource(self._transport)
+        self.auditLogs = AsyncAuditLogsResource(self._transport)
+        self.chat = AsyncChatResource(self._transport)
+        self.embeddings = AsyncEmbeddingsResource(self._transport)
+        self.models = AsyncModelsResource(self._transport)
+
+    @classmethod
+    def from_api_key(cls, api_key: str) -> AsyncAkumi:
+        return cls(api_key=api_key)

akumi-0.1.0/src/akumi/_client.py

@@ -0,0 +1,33 @@
+# AUTO-GENERATED by akumi/codegen. Do not edit by hand.
+from __future__ import annotations
+
+from ._config import ClientConfig
+from ._transport import SyncTransport
+from .resources.auditLogs_sync import AuditLogsResource
+from .resources.chat_sync import ChatResource
+from .resources.embeddings_sync import EmbeddingsResource
+from .resources.models_sync import ModelsResource
+from .resources.recall_sync import RecallResource
+
+
+class Akumi:
+    def __init__(
+        self,
+        *,
+        api_key: str,
+        base_url: str = "https://api.akumi.cloud/v1",
+        max_retries: int = 2,
+    ) -> None:
+        config = ClientConfig(
+            api_key=api_key, base_url=base_url, max_retries=max_retries
+        )
+        self._transport = SyncTransport(config)
+        self.recall = RecallResource(self._transport)
+        self.auditLogs = AuditLogsResource(self._transport)
+        self.chat = ChatResource(self._transport)
+        self.embeddings = EmbeddingsResource(self._transport)
+        self.models = ModelsResource(self._transport)
+
+    @classmethod
+    def from_api_key(cls, api_key: str) -> Akumi:
+        return cls(api_key=api_key)

akumi-0.1.0/src/akumi/_config.py

@@ -0,0 +1,16 @@
+# AUTO-GENERATED runtime, copied by akumi/codegen. Do not edit by hand.
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True)
+class ClientConfig:
+    """Immutable client configuration. The api_key is sent only on the
+    Authorization header by the transport and is never logged or placed in a
+    query string."""
+
+    api_key: str
+    base_url: str = "https://api.akumi.cloud/v1"
+    max_retries: int = 2
+    retry_on: tuple[int, ...] = field(default_factory=lambda: (429, 500, 502, 503, 504))

akumi-0.1.0/src/akumi/_errors.py

@@ -0,0 +1,52 @@
+# AUTO-GENERATED runtime, copied by akumi/codegen. Do not edit by hand.
+from __future__ import annotations
+
+from typing import Any
+
+
+class AkumiError(Exception):
+    """Base class for every error raised by the SDK."""
+
+
+class ApiError(AkumiError):
+    """An error returned by the API. Carries the HTTP status and decoded body."""
+
+    def __init__(
+        self, message: str, status: int, body: dict[str, Any] | None = None
+    ) -> None:
+        super().__init__(message)
+        self.status = status
+        self.body: dict[str, Any] = body if body is not None else {}
+
+
+class AuthenticationError(ApiError):
+    """Raised on a 401 or 403 response."""
+
+
+class RateLimitError(ApiError):
+    """Raised on a 429 response."""
+
+
+class InvalidRequestError(ApiError):
+    """Raised on a 4xx response that is not 401, 403, or 429."""
+
+
+def _message_for(status: int, body: dict[str, Any]) -> str:
+    error = body.get("error")
+    if isinstance(error, dict):
+        message = error.get("message")
+        if isinstance(message, str):
+            return message
+    return f"HTTP {status}"
+
+
+def map_error(status: int, body: dict[str, Any]) -> ApiError:
+    """Map an HTTP status and decoded body onto the matching typed exception."""
+    message = _message_for(status, body)
+    if status in (401, 403):
+        return AuthenticationError(message, status, body)
+    if status == 429:
+        return RateLimitError(message, status, body)
+    if 400 <= status < 500:
+        return InvalidRequestError(message, status, body)
+    return ApiError(message, status, body)

akumi-0.1.0/src/akumi/_sse.py

@@ -0,0 +1,21 @@
+# AUTO-GENERATED runtime, copied by akumi/codegen. Do not edit by hand.
+from __future__ import annotations
+
+import json
+from typing import Any
+
+DONE_SENTINEL = "[DONE]"
+
+
+def parse_sse_line(line: str) -> dict[str, Any] | None:
+    """Decode a single SSE line. Returns the parsed event object, or None when
+    the line is not a data line, is blank, or is the [DONE] sentinel."""
+    if not line.startswith("data:"):
+        return None
+
+    data = line[len("data:") :].strip()
+    if data == "" or data == DONE_SENTINEL:
+        return None
+
+    decoded = json.loads(data)
+    return decoded if isinstance(decoded, dict) else None

akumi-0.1.0/src/akumi/_transport.py

@@ -0,0 +1,219 @@
+# AUTO-GENERATED runtime, copied by akumi/codegen. Do not edit by hand.
+from __future__ import annotations
+
+import asyncio
+import json
+import time
+from collections.abc import AsyncGenerator, Generator
+from typing import Any
+
+import httpx
+
+from ._config import ClientConfig
+from ._errors import map_error
+from ._sse import parse_sse_line
+
+
+def _build_url(base_url: str, path: str, query: dict[str, Any] | None) -> str:
+    url = base_url.rstrip("/") + path
+    if query:
+        pairs = {key: value for key, value in query.items() if value is not None}
+        if pairs:
+            url = url + "?" + str(httpx.QueryParams(pairs))
+    return url
+
+
+def _decode(text: str) -> dict[str, Any]:
+    if text == "":
+        return {}
+    decoded = json.loads(text)
+    return decoded if isinstance(decoded, dict) else {}
+
+
+def _error_body(text: str) -> dict[str, Any]:
+    if text == "":
+        return {}
+    try:
+        decoded = json.loads(text)
+    except json.JSONDecodeError:
+        return {}
+    return decoded if isinstance(decoded, dict) else {}
+
+
+class SyncTransport:
+    """Synchronous HTTP transport: bearer auth, JSON, retries with backoff,
+    status-to-exception mapping, and incremental SSE reads. The api_key is sent
+    only on the Authorization header and is never logged."""
+
+    def __init__(self, config: ClientConfig) -> None:
+        self._config = config
+        self._client = httpx.Client()
+
+    def close(self) -> None:
+        self._client.close()
+
+    def __enter__(self) -> SyncTransport:
+        return self
+
+    def __exit__(self, exc_type: object, exc_val: object, exc_tb: object) -> None:
+        self.close()
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        query: dict[str, Any] | None,
+        body: dict[str, Any] | None,
+    ) -> dict[str, Any]:
+        response = self._dispatch(method, path, query, body)
+        return _decode(response.text)
+
+    def stream(
+        self,
+        method: str,
+        path: str,
+        body: dict[str, Any] | None,
+    ) -> Generator[dict[str, Any], None, None]:
+        url = _build_url(self._config.base_url, path, None)
+        headers = {
+            "Authorization": f"Bearer {self._config.api_key}",
+            "Accept": "text/event-stream",
+        }
+        content = json.dumps(body) if body is not None else None
+        if content is not None:
+            headers["Content-Type"] = "application/json"
+        with self._client.stream(
+            method, url, headers=headers, content=content
+        ) as response:
+            if response.status_code >= 400:
+                response.read()
+                raise map_error(response.status_code, _error_body(response.text))
+            for line in response.iter_lines():
+                event = parse_sse_line(line)
+                if event is not None:
+                    yield event
+
+    def _dispatch(
+        self,
+        method: str,
+        path: str,
+        query: dict[str, Any] | None,
+        body: dict[str, Any] | None,
+    ) -> httpx.Response:
+        url = _build_url(self._config.base_url, path, query)
+        headers = {
+            "Authorization": f"Bearer {self._config.api_key}",
+            "Accept": "application/json",
+        }
+        content = json.dumps(body) if body is not None else None
+        if content is not None:
+            headers["Content-Type"] = "application/json"
+
+        attempt = 0
+        while True:
+            response = self._client.request(
+                method, url, headers=headers, content=content
+            )
+            if response.status_code < 400:
+                return response
+
+            should_retry = (
+                attempt < self._config.max_retries
+                and response.status_code in self._config.retry_on
+            )
+            if should_retry:
+                attempt += 1
+                time.sleep(0.25 * (2 ** (attempt - 1)))
+                continue
+
+            raise map_error(response.status_code, _error_body(response.text))
+
+
+class AsyncTransport:
+    """Asynchronous HTTP transport. Same behavior as SyncTransport over
+    httpx.AsyncClient. The api_key is sent only on the Authorization header."""
+
+    def __init__(self, config: ClientConfig) -> None:
+        self._config = config
+        self._client = httpx.AsyncClient()
+
+    async def aclose(self) -> None:
+        await self._client.aclose()
+
+    async def __aenter__(self) -> AsyncTransport:
+        return self
+
+    async def __aexit__(
+        self, exc_type: object, exc_val: object, exc_tb: object
+    ) -> None:
+        await self.aclose()
+
+    async def arequest(
+        self,
+        method: str,
+        path: str,
+        query: dict[str, Any] | None,
+        body: dict[str, Any] | None,
+    ) -> dict[str, Any]:
+        response = await self._adispatch(method, path, query, body)
+        return _decode(response.text)
+
+    async def astream(
+        self,
+        method: str,
+        path: str,
+        body: dict[str, Any] | None,
+    ) -> AsyncGenerator[dict[str, Any], None]:
+        url = _build_url(self._config.base_url, path, None)
+        headers = {
+            "Authorization": f"Bearer {self._config.api_key}",
+            "Accept": "text/event-stream",
+        }
+        content = json.dumps(body) if body is not None else None
+        if content is not None:
+            headers["Content-Type"] = "application/json"
+        async with self._client.stream(
+            method, url, headers=headers, content=content
+        ) as response:
+            if response.status_code >= 400:
+                await response.aread()
+                raise map_error(response.status_code, _error_body(response.text))
+            async for line in response.aiter_lines():
+                event = parse_sse_line(line)
+                if event is not None:
+                    yield event
+
+    async def _adispatch(
+        self,
+        method: str,
+        path: str,
+        query: dict[str, Any] | None,
+        body: dict[str, Any] | None,
+    ) -> httpx.Response:
+        url = _build_url(self._config.base_url, path, query)
+        headers = {
+            "Authorization": f"Bearer {self._config.api_key}",
+            "Accept": "application/json",
+        }
+        content = json.dumps(body) if body is not None else None
+        if content is not None:
+            headers["Content-Type"] = "application/json"
+
+        attempt = 0
+        while True:
+            response = await self._client.request(
+                method, url, headers=headers, content=content
+            )
+            if response.status_code < 400:
+                return response
+
+            should_retry = (
+                attempt < self._config.max_retries
+                and response.status_code in self._config.retry_on
+            )
+            if should_retry:
+                attempt += 1
+                await asyncio.sleep(0.25 * (2 ** (attempt - 1)))
+                continue
+
+            raise map_error(response.status_code, _error_body(response.text))

akumi-0.1.0/src/akumi/models.py

@@ -0,0 +1,210 @@
+# AUTO-GENERATED by akumi/codegen. Do not edit by hand.
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class AuditLogApiResource:
+    id: str
+    component: str
+    action: str
+    actorId: int | None
+    ipAddress: str | None
+    userAgent: str | None
+    target: Any | None
+    metadata: list[Any] | None
+    createdAt: str
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> AuditLogApiResource:
+        return cls(
+            id=data["id"],
+            component=data["component"],
+            action=data["action"],
+            actorId=data["actorId"],
+            ipAddress=data["ipAddress"],
+            userAgent=data["userAgent"],
+            target=data["target"],
+            metadata=data["metadata"],
+            createdAt=data["createdAt"],
+        )
+
+
+@dataclass
+class ChatCompletionsRequest:
+    model: str
+    messages: list[Any]
+    temperature: float | None = None
+    max_tokens: int | None = None
+    stream: bool | None = None
+    firewall: bool | None = None
+    rag: str | None = None
+    user: str | None = None
+    thread: str | None = None
+    top_p: float | None = None
+    presence_penalty: float | None = None
+    frequency_penalty: float | None = None
+    n: int | None = None
+    seed: int | None = None
+    logprobs: bool | None = None
+    top_logprobs: int | None = None
+    max_completion_tokens: int | None = None
+    tool_choice: str | None = None
+    parallel_tool_calls: bool | None = None
+    cache: bool | None = None
+    stop: list[str] | None = None
+    logit_bias: list[float] | None = None
+    response_format: Any | None = None
+    tools: list[Any] | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> ChatCompletionsRequest:
+        return cls(
+            model=data["model"],
+            messages=data["messages"],
+            temperature=data.get("temperature"),
+            max_tokens=data.get("max_tokens"),
+            stream=data.get("stream"),
+            firewall=data.get("firewall"),
+            rag=data.get("rag"),
+            user=data.get("user"),
+            thread=data.get("thread"),
+            top_p=data.get("top_p"),
+            presence_penalty=data.get("presence_penalty"),
+            frequency_penalty=data.get("frequency_penalty"),
+            n=data.get("n"),
+            seed=data.get("seed"),
+            logprobs=data.get("logprobs"),
+            top_logprobs=data.get("top_logprobs"),
+            max_completion_tokens=data.get("max_completion_tokens"),
+            tool_choice=data.get("tool_choice"),
+            parallel_tool_calls=data.get("parallel_tool_calls"),
+            cache=data.get("cache"),
+            stop=data.get("stop"),
+            logit_bias=data.get("logit_bias"),
+            response_format=data.get("response_format"),
+            tools=data.get("tools"),
+        )
+
+
+@dataclass
+class EmbeddingsRequest:
+    model: str
+    input: list[str]
+    encoding_format: str | None = None
+    dimensions: int | None = None
+    user: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> EmbeddingsRequest:
+        return cls(
+            model=data["model"],
+            input=data["input"],
+            encoding_format=data.get("encoding_format"),
+            dimensions=data.get("dimensions"),
+            user=data.get("user"),
+        )
+
+
+@dataclass
+class IngestDocumentRequest:
+    title: str
+    text: str
+    source: str | None = None
+    collection: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> IngestDocumentRequest:
+        return cls(
+            title=data["title"],
+            text=data["text"],
+            source=data.get("source"),
+            collection=data.get("collection"),
+        )
+
+
+@dataclass
+class RememberFactRequest:
+    content: str
+    user_ref: str
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> RememberFactRequest:
+        return cls(
+            content=data["content"],
+            user_ref=data["user_ref"],
+        )
+
+
+@dataclass
+class SearchDocumentsRequest:
+    query: str
+    collection: str
+    user_ref: str | None = None
+    limit: int | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> SearchDocumentsRequest:
+        return cls(
+            query=data["query"],
+            collection=data["collection"],
+            user_ref=data.get("user_ref"),
+            limit=data.get("limit"),
+        )
+
+
+@dataclass
+class SearchFactsRequest:
+    query: str
+    user_ref: str | None = None
+    limit: int | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> SearchFactsRequest:
+        return cls(
+            query=data["query"],
+            user_ref=data.get("user_ref"),
+            limit=data.get("limit"),
+        )
+
+
+@dataclass
+class SearchRequest:
+    query: str
+    user_ref: str | None = None
+    limit: int | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> SearchRequest:
+        return cls(
+            query=data["query"],
+            user_ref=data.get("user_ref"),
+            limit=data.get("limit"),
+        )
+
+
+@dataclass
+class StoreCollectionRequest:
+    name: str
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> StoreCollectionRequest:
+        return cls(
+            name=data["name"],
+        )
+
+
+@dataclass
+class ThreadMessageViewModel:
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> ThreadMessageViewModel:
+        return cls()
+
+
+@dataclass
+class ThreadViewModel:
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> ThreadViewModel:
+        return cls()

akumi-0.1.0/src/akumi/resources/auditLogs_async.py

@@ -0,0 +1,17 @@
+# AUTO-GENERATED by akumi/codegen. Do not edit by hand.
+from __future__ import annotations
+
+from typing import Any
+
+from .._transport import AsyncTransport
+
+
+class AsyncAuditLogsResource:
+    def __init__(self, transport: AsyncTransport) -> None:
+        self._transport = transport
+
+    async def list(self, query: dict[str, Any] | None = None) -> dict[str, Any]:
+        return await self._transport.arequest("GET", "/audit-logs", query, None)
+
+    async def get(self, uuid: str) -> dict[str, Any]:
+        return await self._transport.arequest("GET", f"/audit-logs/{uuid}", None, None)

akumi-0.1.0/src/akumi/resources/auditLogs_sync.py

@@ -0,0 +1,17 @@
+# AUTO-GENERATED by akumi/codegen. Do not edit by hand.
+from __future__ import annotations
+
+from typing import Any
+
+from .._transport import SyncTransport
+
+
+class AuditLogsResource:
+    def __init__(self, transport: SyncTransport) -> None:
+        self._transport = transport
+
+    def list(self, query: dict[str, Any] | None = None) -> dict[str, Any]:
+        return self._transport.request("GET", "/audit-logs", query, None)
+
+    def get(self, uuid: str) -> dict[str, Any]:
+        return self._transport.request("GET", f"/audit-logs/{uuid}", None, None)

akumi-0.1.0/src/akumi/resources/chat_async.py

@@ -0,0 +1,21 @@
+# AUTO-GENERATED by akumi/codegen. Do not edit by hand.
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+from typing import Any
+
+from .._transport import AsyncTransport
+
+
+class AsyncChatResource:
+    def __init__(self, transport: AsyncTransport) -> None:
+        self._transport = transport
+
+    async def create(self, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        return await self._transport.arequest("POST", "/chat/completions", None, params)
+
+    async def create_streamed(
+        self, params: dict[str, Any] | None = None
+    ) -> AsyncIterator[dict[str, Any]]:
+        async for event in self._transport.astream("POST", "/chat/completions", params):
+            yield event

akumi-0.1.0/src/akumi/resources/chat_sync.py

@@ -0,0 +1,20 @@
+# AUTO-GENERATED by akumi/codegen. Do not edit by hand.
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import Any
+
+from .._transport import SyncTransport
+
+
+class ChatResource:
+    def __init__(self, transport: SyncTransport) -> None:
+        self._transport = transport
+
+    def create(self, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        return self._transport.request("POST", "/chat/completions", None, params)
+
+    def create_streamed(
+        self, params: dict[str, Any] | None = None
+    ) -> Iterator[dict[str, Any]]:
+        yield from self._transport.stream("POST", "/chat/completions", params)

akumi-0.1.0/src/akumi/resources/embeddings_async.py

@@ -0,0 +1,14 @@
+# AUTO-GENERATED by akumi/codegen. Do not edit by hand.
+from __future__ import annotations
+
+from typing import Any
+
+from .._transport import AsyncTransport
+
+
+class AsyncEmbeddingsResource:
+    def __init__(self, transport: AsyncTransport) -> None:
+        self._transport = transport
+
+    async def create(self, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        return await self._transport.arequest("POST", "/embeddings", None, params)

akumi-0.1.0/src/akumi/resources/embeddings_sync.py

@@ -0,0 +1,14 @@
+# AUTO-GENERATED by akumi/codegen. Do not edit by hand.
+from __future__ import annotations
+
+from typing import Any
+
+from .._transport import SyncTransport
+
+
+class EmbeddingsResource:
+    def __init__(self, transport: SyncTransport) -> None:
+        self._transport = transport
+
+    def create(self, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        return self._transport.request("POST", "/embeddings", None, params)

akumi-0.1.0/src/akumi/resources/models_async.py

@@ -0,0 +1,14 @@
+# AUTO-GENERATED by akumi/codegen. Do not edit by hand.
+from __future__ import annotations
+
+from typing import Any
+
+from .._transport import AsyncTransport
+
+
+class AsyncModelsResource:
+    def __init__(self, transport: AsyncTransport) -> None:
+        self._transport = transport
+
+    async def list(self) -> dict[str, Any]:
+        return await self._transport.arequest("GET", "/models", None, None)

akumi-0.1.0/src/akumi/resources/models_sync.py

@@ -0,0 +1,14 @@
+# AUTO-GENERATED by akumi/codegen. Do not edit by hand.
+from __future__ import annotations
+
+from typing import Any
+
+from .._transport import SyncTransport
+
+
+class ModelsResource:
+    def __init__(self, transport: SyncTransport) -> None:
+        self._transport = transport
+
+    def list(self) -> dict[str, Any]:
+        return self._transport.request("GET", "/models", None, None)

akumi-0.1.0/src/akumi/resources/recall_async.py

@@ -0,0 +1,110 @@
+# AUTO-GENERATED by akumi/codegen. Do not edit by hand.
+from __future__ import annotations
+
+from typing import Any
+
+from .._transport import AsyncTransport
+
+
+class AsyncRecallResource:
+    def __init__(self, transport: AsyncTransport) -> None:
+        self._transport = transport
+
+    async def listThreads(self, query: dict[str, Any] | None = None) -> dict[str, Any]:
+        return await self._transport.arequest("GET", "/recall/threads", query, None)
+
+    async def createThread(self) -> dict[str, Any]:
+        return await self._transport.arequest("POST", "/recall/threads", None, None)
+
+    async def getThread(self, thread: str) -> dict[str, Any]:
+        return await self._transport.arequest(
+            "GET", f"/recall/threads/{thread}", None, None
+        )
+
+    async def deleteThread(self, thread: str) -> dict[str, Any]:
+        return await self._transport.arequest(
+            "DELETE", f"/recall/threads/{thread}", None, None
+        )
+
+    async def search(self, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        return await self._transport.arequest("POST", "/recall/search", None, params)
+
+    async def searchFacts(self, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        return await self._transport.arequest(
+            "POST", "/recall/facts/search", None, params
+        )
+
+    async def listFacts(self, query: dict[str, Any] | None = None) -> dict[str, Any]:
+        return await self._transport.arequest("GET", "/recall/facts", query, None)
+
+    async def rememberFact(
+        self, params: dict[str, Any] | None = None
+    ) -> dict[str, Any]:
+        return await self._transport.arequest("POST", "/recall/facts", None, params)
+
+    async def forgetFact(self, id: str) -> dict[str, Any]:
+        return await self._transport.arequest(
+            "DELETE", f"/recall/facts/{id}", None, None
+        )
+
+    async def export(self, query: dict[str, Any] | None = None) -> dict[str, Any]:
+        return await self._transport.arequest("GET", "/recall/export", query, None)
+
+    async def erase(self) -> dict[str, Any]:
+        return await self._transport.arequest("DELETE", "/recall", None, None)
+
+    async def searchDocuments(
+        self, params: dict[str, Any] | None = None
+    ) -> dict[str, Any]:
+        return await self._transport.arequest(
+            "POST", "/recall/documents/search", None, params
+        )
+
+    async def listDocuments(
+        self, query: dict[str, Any] | None = None
+    ) -> dict[str, Any]:
+        return await self._transport.arequest("GET", "/recall/documents", query, None)
+
+    async def ingestDocument(
+        self, params: dict[str, Any] | None = None
+    ) -> dict[str, Any]:
+        return await self._transport.arequest("POST", "/recall/documents", None, params)
+
+    async def getDocument(self, document: str) -> dict[str, Any]:
+        return await self._transport.arequest(
+            "GET", f"/recall/documents/{document}", None, None
+        )
+
+    async def deleteDocument(self, document: str) -> dict[str, Any]:
+        return await self._transport.arequest(
+            "DELETE", f"/recall/documents/{document}", None, None
+        )
+
+    async def listCollections(
+        self, query: dict[str, Any] | None = None
+    ) -> dict[str, Any]:
+        return await self._transport.arequest("GET", "/recall/collections", query, None)
+
+    async def createCollection(
+        self, params: dict[str, Any] | None = None
+    ) -> dict[str, Any]:
+        return await self._transport.arequest(
+            "POST", "/recall/collections", None, params
+        )
+
+    async def getCollection(self, slug: str) -> dict[str, Any]:
+        return await self._transport.arequest(
+            "GET", f"/recall/collections/{slug}", None, None
+        )
+
+    async def deleteCollection(self, slug: str) -> dict[str, Any]:
+        return await self._transport.arequest(
+            "DELETE", f"/recall/collections/{slug}", None, None
+        )
+
+    async def updateCollection(
+        self, slug: str, params: dict[str, Any] | None = None
+    ) -> dict[str, Any]:
+        return await self._transport.arequest(
+            "PATCH", f"/recall/collections/{slug}", None, params
+        )

akumi-0.1.0/src/akumi/resources/recall_sync.py

@@ -0,0 +1,86 @@
+# AUTO-GENERATED by akumi/codegen. Do not edit by hand.
+from __future__ import annotations
+
+from typing import Any
+
+from .._transport import SyncTransport
+
+
+class RecallResource:
+    def __init__(self, transport: SyncTransport) -> None:
+        self._transport = transport
+
+    def listThreads(self, query: dict[str, Any] | None = None) -> dict[str, Any]:
+        return self._transport.request("GET", "/recall/threads", query, None)
+
+    def createThread(self) -> dict[str, Any]:
+        return self._transport.request("POST", "/recall/threads", None, None)
+
+    def getThread(self, thread: str) -> dict[str, Any]:
+        return self._transport.request("GET", f"/recall/threads/{thread}", None, None)
+
+    def deleteThread(self, thread: str) -> dict[str, Any]:
+        return self._transport.request(
+            "DELETE", f"/recall/threads/{thread}", None, None
+        )
+
+    def search(self, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        return self._transport.request("POST", "/recall/search", None, params)
+
+    def searchFacts(self, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        return self._transport.request("POST", "/recall/facts/search", None, params)
+
+    def listFacts(self, query: dict[str, Any] | None = None) -> dict[str, Any]:
+        return self._transport.request("GET", "/recall/facts", query, None)
+
+    def rememberFact(self, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        return self._transport.request("POST", "/recall/facts", None, params)
+
+    def forgetFact(self, id: str) -> dict[str, Any]:
+        return self._transport.request("DELETE", f"/recall/facts/{id}", None, None)
+
+    def export(self, query: dict[str, Any] | None = None) -> dict[str, Any]:
+        return self._transport.request("GET", "/recall/export", query, None)
+
+    def erase(self) -> dict[str, Any]:
+        return self._transport.request("DELETE", "/recall", None, None)
+
+    def searchDocuments(self, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        return self._transport.request("POST", "/recall/documents/search", None, params)
+
+    def listDocuments(self, query: dict[str, Any] | None = None) -> dict[str, Any]:
+        return self._transport.request("GET", "/recall/documents", query, None)
+
+    def ingestDocument(self, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        return self._transport.request("POST", "/recall/documents", None, params)
+
+    def getDocument(self, document: str) -> dict[str, Any]:
+        return self._transport.request(
+            "GET", f"/recall/documents/{document}", None, None
+        )
+
+    def deleteDocument(self, document: str) -> dict[str, Any]:
+        return self._transport.request(
+            "DELETE", f"/recall/documents/{document}", None, None
+        )
+
+    def listCollections(self, query: dict[str, Any] | None = None) -> dict[str, Any]:
+        return self._transport.request("GET", "/recall/collections", query, None)
+
+    def createCollection(self, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        return self._transport.request("POST", "/recall/collections", None, params)
+
+    def getCollection(self, slug: str) -> dict[str, Any]:
+        return self._transport.request("GET", f"/recall/collections/{slug}", None, None)
+
+    def deleteCollection(self, slug: str) -> dict[str, Any]:
+        return self._transport.request(
+            "DELETE", f"/recall/collections/{slug}", None, None
+        )
+
+    def updateCollection(
+        self, slug: str, params: dict[str, Any] | None = None
+    ) -> dict[str, Any]:
+        return self._transport.request(
+            "PATCH", f"/recall/collections/{slug}", None, params
+        )