agent-runtime-kit 0.1.0__py3-none-any.whl

agent_runtime_kit/testing/fakes.py

@@ -0,0 +1,164 @@
+"""Fake SDK fixtures for runtime adapter contract tests."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from typing import Any
+
+from agent_runtime_kit._errors import AgentRuntimeUnavailableError, UnsupportedTaskInputError
+from agent_runtime_kit._types import (
+    AgentCapabilities,
+    AgentResult,
+    AgentRuntimeKind,
+    AgentTask,
+    AvailabilityReason,
+    RuntimeAvailability,
+    ToolCallAudit,
+)
+from agent_runtime_kit.events import (
+    output_delta_event,
+    safe_emit,
+    task_completed_event,
+    task_failed_event,
+    task_started_event,
+    tool_completed_event,
+    tool_requested_event,
+    vendor_turn_event,
+)
+
+
+@dataclass(frozen=True)
+class FakeSDKScenario:
+    """Scripted fake SDK behavior used by adapter tests."""
+
+    output: str = "fake sdk output"
+    error: str | None = None
+    missing_dependency: bool = False
+    unsupported_fields: tuple[str, ...] = ()
+    timeout: bool = False
+    session_id: str | None = "fake-session"
+    structured_output: Any | None = None
+    tool_events: tuple[ToolCallAudit, ...] = ()
+    metadata: Mapping[str, Any] = field(default_factory=dict)
+
+
+class FakeSDKHarness:
+    """Credential-free fake SDK surface with scripted outcomes."""
+
+    def __init__(
+        self,
+        scenario: FakeSDKScenario | None = None,
+        *,
+        kind: AgentRuntimeKind = AgentRuntimeKind.FAKE,
+    ) -> None:
+        self.scenario = scenario or FakeSDKScenario()
+        self.kind = kind
+        self.calls: list[AgentTask] = []
+
+    async def invoke(self, task: AgentTask) -> AgentResult:
+        """Simulate one SDK invocation."""
+
+        self.calls.append(task)
+        scenario = self.scenario
+        if scenario.missing_dependency:
+            raise AgentRuntimeUnavailableError(self.kind, "fake SDK package is missing")
+        if scenario.timeout:
+            raise TimeoutError("fake SDK timeout")
+        if scenario.unsupported_fields:
+            field_name = scenario.unsupported_fields[0]
+            raise UnsupportedTaskInputError(self.kind, field_name, "scripted unsupported input")
+        if scenario.error is not None:
+            return AgentResult(
+                output="",
+                finish_reason="failed",
+                error=scenario.error,
+                session_id=scenario.session_id,
+                metadata=dict(scenario.metadata),
+            )
+        return AgentResult(
+            output=scenario.output,
+            parsed_output=scenario.structured_output,
+            tool_calls=scenario.tool_events,
+            session_id=scenario.session_id,
+            rounds=1,
+            metadata=dict(scenario.metadata),
+        )
+
+
+class FakeSDKRuntime:
+    """Runtime wrapper around ``FakeSDKHarness`` for contract tests."""
+
+    kind = AgentRuntimeKind.FAKE
+    capabilities = AgentCapabilities(
+        mcp_support=True,
+        working_directory=True,
+        session_resume=True,
+        structured_output=True,
+        streaming=True,
+        tool_audit=True,
+        cancellation=True,
+    )
+
+    def __init__(self, harness: FakeSDKHarness | None = None) -> None:
+        self.harness = harness or FakeSDKHarness()
+
+    def availability(self) -> RuntimeAvailability:
+        """Return fake availability based on the scripted scenario."""
+
+        if self.harness.scenario.missing_dependency:
+            return RuntimeAvailability.unavailable(
+                self.kind,
+                reason=AvailabilityReason.MISSING_PACKAGE,
+                message="fake SDK package is missing",
+                package="fake-sdk",
+            )
+        return RuntimeAvailability.ok(self.kind, package="fake-sdk", version="0.0.0")
+
+    async def run(self, task: AgentTask) -> AgentResult:
+        """Invoke the fake SDK and emit normalized events."""
+
+        await safe_emit(task, task_started_event(task, self.kind))
+        try:
+            result = await self.harness.invoke(task)
+        except Exception as exc:
+            await safe_emit(task, task_failed_event(task, self.kind, error=str(exc)))
+            raise
+        if result.error:
+            await safe_emit(task, task_failed_event(task, self.kind, error=result.error))
+            return result
+        await safe_emit(task, output_delta_event(task, self.kind, text=result.output))
+        for audit in result.tool_calls:
+            await safe_emit(
+                task,
+                tool_requested_event(
+                    task,
+                    self.kind,
+                    tool_name=audit.tool_name,
+                    arguments=audit.arguments,
+                ),
+            )
+            await safe_emit(task, tool_completed_event(task, self.kind, audit))
+        await safe_emit(
+            task,
+            vendor_turn_event(task, self.kind, payload={"scenario": "fake"}, turn_index=1),
+        )
+        await safe_emit(task, task_completed_event(task, self.kind, result))
+        return result
+
+    async def cancel(self, task_id: str) -> None:
+        """Fake cancellation is a no-op."""
+
+        del task_id
+
+
+class RecordingEventSink:
+    """In-memory event sink for tests."""
+
+    def __init__(self) -> None:
+        self.events: list[Mapping[str, Any]] = []
+
+    async def emit(self, event: Mapping[str, Any]) -> None:
+        """Record one event."""
+
+        self.events.append(event)

agent_runtime_kit-0.1.0.dist-info/METADATA

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: agent-runtime-kit
+Version: 0.1.0
+Summary: One typed runtime API for Claude, Codex, and Antigravity agent SDKs.
+Project-URL: Homepage, https://github.com/ebarti/agent-runtime-kit
+Project-URL: Repository, https://github.com/ebarti/agent-runtime-kit
+Project-URL: Issues, https://github.com/ebarti/agent-runtime-kit/issues
+Author: Eloi Barti
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,antigravity,claude,codex,sdk
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: all
+Requires-Dist: claude-agent-sdk>=0.2.87; extra == 'all'
+Requires-Dist: google-antigravity>=0.1.2; extra == 'all'
+Requires-Dist: openai-codex>=0.1.0b2; extra == 'all'
+Provides-Extra: antigravity
+Requires-Dist: google-antigravity>=0.1.2; extra == 'antigravity'
+Provides-Extra: claude
+Requires-Dist: claude-agent-sdk>=0.2.87; extra == 'claude'
+Provides-Extra: codex
+Requires-Dist: openai-codex>=0.1.0b2; extra == 'codex'
+Description-Content-Type: text/markdown
+
+# agent-runtime-kit
+
+`agent-runtime-kit` is a small Python runtime layer for agent SDKs. It gives
+applications one typed async API for dispatching an agentic task through Claude
+Agent SDK, OpenAI Codex SDK, or Google Antigravity SDK while keeping provider
+capabilities visible.
+
+The package is intentionally not a router, benchmark harness, queue, hosted
+service, or full agent framework. It is the reusable layer underneath those
+systems: task models, runtime capabilities, event sinks, availability
+diagnostics, and adapters.
+
+## Install
+
+Core only:
+
+```bash
+pip install agent-runtime-kit
+```
+
+Provider extras:
+
+```bash
+pip install "agent-runtime-kit[claude]"
+pip install "agent-runtime-kit[codex]"
+pip install "agent-runtime-kit[antigravity]"
+pip install "agent-runtime-kit[all]"
+```
+
+```python
+import asyncio
+
+from agent_runtime_kit import AgentTask, FakeAgentRuntime
+
+
+async def main() -> None:
+    runtime = FakeAgentRuntime(output="done")
+    result = await runtime.run(AgentTask(goal="Summarize this repository"))
+    print(result.output)
+
+
+asyncio.run(main())
+```
+
+The core package has no Claude, Codex, or Antigravity dependency. Vendor SDKs
+are added through optional extras.
+
+## Real Providers
+
+```python
+import asyncio
+
+from agent_runtime_kit import AgentTask
+from agent_runtime_kit.adapters import ClaudeAgentRuntime
+
+
+async def main() -> None:
+    runtime = ClaudeAgentRuntime(default_model="claude-sonnet-4-6")
+    diagnostic = runtime.availability()
+    if not diagnostic.available:
+        raise RuntimeError(diagnostic.message)
+    result = await runtime.run(AgentTask(goal="Summarize this repository"))
+    print(result.output)
+
+
+asyncio.run(main())
+```
+
+## Runtime Fields
+
+`AgentTask` supports goal, system prompt, working directory, permission profile,
+MCP stdio servers, session/resume handles, output schema, budget, metadata, and
+an async event sink.
+
+`AgentResult` returns output, finish reason, parsed structured output, usage,
+cost, session id, artifacts, tool-call audits, and provider metadata.
+
+## Docs
+
+- [Quickstart](docs/quickstart.md)
+- [Provider diagnostics](docs/providers.md)
+- [Capability matrix](docs/capability-matrix.md)
+- [Live smoke tests](docs/live-smoke.md)
+- [Mestre migration notes](docs/mestre-migration.md)
+- [Publish checklist](docs/publish-checklist.md)

agent_runtime_kit-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+agent_runtime_kit/__init__.py,sha256=S17yV13a9TAzBd6cLUZt-YkbTGdMXZD7qUxdR0jBreg,1694
+agent_runtime_kit/_errors.py,sha256=cLGB_zY0Wg_mupF4kSZW3G2gGXcGFHie0G6dLJ5wLzA,1247
+agent_runtime_kit/_runtime.py,sha256=cmNstQcVm1IuvV5DW747MRNh0enRiRyGeSdUS1YZBnU,4672
+agent_runtime_kit/_types.py,sha256=bUGsaQkVaxIfEVw-1-PxoPQyaQ8KACcTRs0NfjPoF44,6880
+agent_runtime_kit/events.py,sha256=Bn1s-l8kmkDeNuaBUj-ku8jGhIspqRnY73vzXnthPPo,6632
+agent_runtime_kit/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+agent_runtime_kit/registry.py,sha256=97eXOqzeooFalZ0lJe_OmHo5k4zuhbdZT8n_SbTQnXs,2653
+agent_runtime_kit/adapters/__init__.py,sha256=ZCp8S4qosJtpdP9VRdpWnQfXKhrOALS9TA7wtGAkx4Q,944
+agent_runtime_kit/adapters/_common.py,sha256=StdnoQgdn9X1o5kbtO37lUpBqcPNp1YSWtnfiOMC7lg,3607
+agent_runtime_kit/adapters/antigravity.py,sha256=U8GxjfwrAL5EInFW6JrgnvQPPZ6yAZL0xgdqkBgSZ9U,13279
+agent_runtime_kit/adapters/claude.py,sha256=85zQL__Bw8Lrv4gGrmdfU9hDYHDMg7AKZCaXlDV5yvY,11421
+agent_runtime_kit/adapters/codex.py,sha256=urjBwnHJy-OkJO6Qi-GdubkiyFhjgyLaWGdGOiH8ilw,10092
+agent_runtime_kit/adapters/diagnostics.py,sha256=23efPAPiriJQxDLktvzOmfcTzkgYFrAbGUfkPvdgcq4,640
+agent_runtime_kit/testing/__init__.py,sha256=xOBG9GW017qdFe6ZtpE38t5Ei_M5JZzhpEhlRchS7II,292
+agent_runtime_kit/testing/fakes.py,sha256=PlaRNzpHLbhemVIYpWk8CNRin1yxosA4oc_5FHtdErc,5355
+agent_runtime_kit-0.1.0.dist-info/METADATA,sha256=zcBRBmDaqdB3kjrBB5903QHqqIXfG2Kjk6HI-BslLp8,3686
+agent_runtime_kit-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+agent_runtime_kit-0.1.0.dist-info/licenses/LICENSE,sha256=HjqifLdd1ShCS_acCnCVQCXLrklPAdTzqXoLbUj3W_E,1067
+agent_runtime_kit-0.1.0.dist-info/RECORD,,

agent_runtime_kit-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

agent_runtime_kit-0.1.0.dist-info/licenses/LICENSE

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