docketeer-deepinfra 0.0.14__tar.gz

docketeer_deepinfra-0.0.14/.gitignore

@@ -0,0 +1,12 @@
+.venv/
+.envrc.private
+.claude/settings.local.json
+__pycache__/
+*.pyc
+*.egg-info/
+dist/
+build/
+workspace/
+.coverage
+.loq_cache
+.python-version

docketeer_deepinfra-0.0.14/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: docketeer-deepinfra
+Version: 0.0.14
+Summary: DeepInfra inference backend plugin for Docketeer
+Project-URL: Homepage, https://github.com/chrisguidry/docketeer
+Project-URL: Repository, https://github.com/chrisguidry/docketeer
+Project-URL: Issues, https://github.com/chrisguidry/docketeer/issues
+Author-email: Chris Guidry <guid@omg.lol>
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.12
+Requires-Dist: docketeer
+Requires-Dist: openai
+Description-Content-Type: text/markdown
+
+# docketeer-deepinfra
+
+DeepInfra inference backend plugin for Docketeer.
+
+This plugin provides inference through the DeepInfra native API.
+
+## Installation
+
+```bash
+pip install docketeer-deepinfra
+```
+
+## Configuration
+
+Configure the DeepInfra backend with environment variables:
+
+```bash
+# Required: Your DeepInfra API key
+export DOCKETEER_DEEPINFRA_API_KEY=your-api-key-here
+
+# Optional: Override the API base URL (defaults to https://api.deepinfra.com)
+export DOCKETEER_DEEPINFRA_BASE_URL=https://api.deepinfra.com
+
+# Optional: Set the default model (defaults to meta-llama/Llama-3.3-70B-Instruct)
+export DOCKETEER_DEEPINFRA_MODEL=meta-llama/Llama-3.3-70B-Instruct
+```
+
+Then configure Docketeer to use the DeepInfra inference plugin:
+
+```bash
+export DOCKETEER_INFERENCE=deepinfra
+```
+
+## Supported Models
+
+Any model available on DeepInfra can be used. Common models include:
+
+- `meta-llama/Llama-3.3-70B-Instruct` (default)
+- `meta-llama/Llama-3.1-405B-Instruct`
+- `Qwen/Qwen2.5-72B-Instruct`
+- `deepseek-ai/DeepSeek-V3`
+
+Set the model using `DOCKETEER_DEEPINFRA_MODEL` or by specifying the model in your Docketeer configuration.

docketeer_deepinfra-0.0.14/README.md

@@ -0,0 +1,43 @@
+# docketeer-deepinfra
+
+DeepInfra inference backend plugin for Docketeer.
+
+This plugin provides inference through the DeepInfra native API.
+
+## Installation
+
+```bash
+pip install docketeer-deepinfra
+```
+
+## Configuration
+
+Configure the DeepInfra backend with environment variables:
+
+```bash
+# Required: Your DeepInfra API key
+export DOCKETEER_DEEPINFRA_API_KEY=your-api-key-here
+
+# Optional: Override the API base URL (defaults to https://api.deepinfra.com)
+export DOCKETEER_DEEPINFRA_BASE_URL=https://api.deepinfra.com
+
+# Optional: Set the default model (defaults to meta-llama/Llama-3.3-70B-Instruct)
+export DOCKETEER_DEEPINFRA_MODEL=meta-llama/Llama-3.3-70B-Instruct
+```
+
+Then configure Docketeer to use the DeepInfra inference plugin:
+
+```bash
+export DOCKETEER_INFERENCE=deepinfra
+```
+
+## Supported Models
+
+Any model available on DeepInfra can be used. Common models include:
+
+- `meta-llama/Llama-3.3-70B-Instruct` (default)
+- `meta-llama/Llama-3.1-405B-Instruct`
+- `Qwen/Qwen2.5-72B-Instruct`
+- `deepseek-ai/DeepSeek-V3`
+
+Set the model using `DOCKETEER_DEEPINFRA_MODEL` or by specifying the model in your Docketeer configuration.

docketeer_deepinfra-0.0.14/pyproject.toml

@@ -0,0 +1,62 @@
+[project]
+name = "docketeer-deepinfra"
+dynamic = ["version"]
+description = "DeepInfra inference backend plugin for Docketeer"
+readme = "README.md"
+authors = [
+    { name = "Chris Guidry", email = "guid@omg.lol" }
+]
+license = "MIT"
+requires-python = ">=3.12"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "openai",
+    "docketeer",
+]
+
+[project.urls]
+Homepage = "https://github.com/chrisguidry/docketeer"
+Repository = "https://github.com/chrisguidry/docketeer"
+Issues = "https://github.com/chrisguidry/docketeer/issues"
+
+[project.entry-points."docketeer.inference"]
+deepinfra = "docketeer_deepinfra:create_backend"
+
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options.root = ".."
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/docketeer_deepinfra"]
+
+[tool.uv.sources]
+docketeer = { workspace = true }
+
+[tool.pytest_env]
+DOCKETEER_DEEPINFRA_API_KEY = "test-key"
+DOCKETEER_DEEPINFRA_BASE_URL = "https://api.deepinfra.com/v1"
+
+[tool.pytest.ini_options]
+minversion = "9.0"
+timeout = 1
+addopts = [
+    "--import-mode=importlib",
+    "--cov=docketeer_deepinfra",
+    "--cov=tests",
+    "--cov-branch",
+    "--cov-report=term-missing",
+    "--cov-fail-under=100",
+]
+asyncio_mode = "auto"
+filterwarnings = [
+    "error",
+]

docketeer_deepinfra-0.0.14/src/docketeer_deepinfra/__init__.py

@@ -0,0 +1,55 @@
+"""DeepInfra inference backend plugin for Docketeer."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from docketeer import environment
+from docketeer.executor import CommandExecutor
+
+if TYPE_CHECKING:
+    from docketeer.brain.backend import InferenceBackend
+
+log = logging.getLogger(__name__)
+
+DEFAULT_MODEL = "MiniMaxAI/MiniMax-M2.5"
+
+# Tier to max tokens mapping
+TIER_MAX_TOKENS = {
+    "smart": 128_000,
+    "balanced": 64_000,
+    "fast": 16_000,
+}
+
+
+def create_backend(executor: CommandExecutor | None) -> InferenceBackend:
+    """Factory function to create a DeepInfra backend.
+
+    This function is the entry point for the docketeer.inference plugin.
+    It creates a DeepInfra API backend.
+
+    Configuration (environment variables):
+        DEEPINFRA_API_KEY: Required. Your DeepInfra API key.
+        DEEPINFRA_BASE_URL: Optional. Defaults to https://api.deepinfra.com/v1/openai
+        DEEPINFRA_MODEL: Optional. Default model ID. Defaults to MiniMaxAI/MiniMax-M2.5
+
+    Args:
+        executor: CommandExecutor instance (unused for API backend)
+
+    Returns:
+        An InferenceBackend implementation
+
+    Raises:
+        KeyError: If API key is not configured
+    """
+    from docketeer_deepinfra.api_backend import DeepInfraAPIBackend
+
+    api_key = environment.get_str("DEEPINFRA_API_KEY")
+    base_url = environment.get_str(
+        "DEEPINFRA_BASE_URL", "https://api.deepinfra.com/v1/openai"
+    )
+    default_model = environment.get_str("DEEPINFRA_MODEL", DEFAULT_MODEL)
+    return DeepInfraAPIBackend(
+        api_key=api_key, base_url=base_url, default_model=default_model
+    )

docketeer_deepinfra-0.0.14/src/docketeer_deepinfra/api_backend.py

@@ -0,0 +1,124 @@
+"""DeepInfraAPIBackend: InferenceBackend backed by DeepInfra via OpenAI SDK."""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from openai import APIError, AsyncOpenAI, AuthenticationError, RateLimitError
+
+from docketeer import environment
+from docketeer.brain.backend import (
+    BackendAuthError,
+    BackendError,
+    ContextTooLargeError,
+    InferenceBackend,
+)
+from docketeer.brain.core import InferenceModel
+from docketeer_deepinfra import TIER_MAX_TOKENS
+from docketeer_deepinfra.loop import _serialize_messages, agentic_loop
+
+if TYPE_CHECKING:
+    from docketeer.brain.core import ProcessCallbacks
+    from docketeer.prompt import MessageParam, SystemBlock
+    from docketeer.tools import ToolContext, ToolDefinition
+
+log = logging.getLogger(__name__)
+
+DEFAULT_MODEL = "MiniMaxAI/MiniMax-M2.5"
+
+
+class DeepInfraAPIBackend(InferenceBackend):
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = "https://api.deepinfra.com/v1",
+        default_model: str = DEFAULT_MODEL,
+    ) -> None:
+        self._api_key = api_key
+        self._base_url = base_url.rstrip("/")
+        self._default_model = default_model
+        self._client = AsyncOpenAI(
+            base_url=self._base_url,
+            api_key=api_key,
+            max_retries=0,
+            timeout=300.0,
+        )
+
+    async def __aexit__(self, *exc: object) -> None:
+        await self._client.close()
+
+    async def run_agentic_loop(
+        self,
+        tier: str,
+        system: list[SystemBlock],
+        messages: list[MessageParam],
+        tools: list[ToolDefinition],
+        tool_context: ToolContext,
+        audit_path: Path,
+        usage_path: Path,
+        callbacks: ProcessCallbacks | None,
+        *,
+        thinking: bool = False,
+    ) -> str:
+        # Resolve tier to InferenceModel using environment variables
+        model_id = environment.get_str(
+            f"DEEPINFRA_MODEL_{tier.upper()}", self._default_model
+        )
+        max_tokens = TIER_MAX_TOKENS.get(tier, 64_000)
+        model = InferenceModel(model_id=model_id, max_output_tokens=max_tokens)
+
+        try:
+            return await agentic_loop(
+                self._client,
+                model,
+                system,
+                messages,
+                tools,
+                tool_context,
+                audit_path,
+                usage_path,
+                callbacks.on_first_text if callbacks else None,
+                callbacks.on_text if callbacks else None,
+                callbacks.on_tool_start if callbacks else None,
+                callbacks.on_tool_end if callbacks else None,
+                callbacks.interrupted if callbacks else None,
+                default_model=self._default_model,
+            )
+        except RateLimitError as exc:
+            raise BackendAuthError(str(exc)) from exc
+        except AuthenticationError as exc:
+            raise BackendAuthError(str(exc)) from exc
+        except APIError as exc:
+            msg = str(exc).lower()
+            if "413" in msg or "payload too large" in msg or "context length" in msg:
+                raise ContextTooLargeError(str(exc)) from exc
+            raise BackendError(str(exc)) from exc
+
+    async def count_tokens(
+        self,
+        model_id: str,
+        system: list[SystemBlock],
+        tools: list[ToolDefinition],
+        messages: list[MessageParam],
+    ) -> int:
+        serialized = _serialize_messages(system, messages)
+        return len(json.dumps(serialized)) // 4
+
+    async def utility_complete(
+        self,
+        prompt: str,
+        *,
+        max_tokens: int = 1024,
+    ) -> str:
+        try:
+            response = await self._client.chat.completions.create(
+                model=self._default_model,
+                messages=[{"role": "user", "content": prompt}],
+                max_tokens=max_tokens,
+            )
+            return response.choices[0].message.content or ""
+        except APIError as exc:
+            raise BackendError(str(exc)) from exc