tada-core 0.2.0__py3-none-any.whl

tada_core/__init__.py

@@ -0,0 +1,57 @@
+"""Public SDK surface for tada-core."""
+
+from tada_core.contracts.budget import BudgetLimits
+from tada_core.contracts.compaction import (
+    CompactionConfig,
+    CompactionMode,
+    CompactionStrategy,
+    ModelSummaryCompaction,
+    NeverCompact,
+    StructuredSummaryCompaction,
+    ToolResultPruningConfig,
+    TruncateCompaction,
+)
+from tada_core.contracts.events import Event
+from tada_core.contracts.messages import ContentBlock, ConversationMessage, MessageRole
+from tada_core.contracts.model import StopReason
+from tada_core.contracts.models import ModelSpec
+from tada_core.contracts.session import SessionState
+from tada_core.contracts.tokenization import CharacterTokenEstimator, TokenEstimator
+from tada_core.contracts.tools import ChainedToolExecutor, ToolResult
+from tada_core.loop import AgentLoop, AnthropicModelClient
+from tada_core.loop.retry import RetryingModelClient, RetryPolicy
+from tada_core.providers import build_model_client
+from tada_core.utils.content_normalizer import ContentNormalizerConfig, normalize_messages
+
+__version__ = "0.2.0"
+
+__all__ = [
+    "AgentLoop",
+    "AnthropicModelClient",
+    "BudgetLimits",
+    "CharacterTokenEstimator",
+    "ChainedToolExecutor",
+    "CompactionConfig",
+    "CompactionMode",
+    "CompactionStrategy",
+    "ContentNormalizerConfig",
+    "ContentBlock",
+    "ConversationMessage",
+    "Event",
+    "MessageRole",
+    "ModelSpec",
+    "ModelSummaryCompaction",
+    "NeverCompact",
+    "SessionState",
+    "StopReason",
+    "StructuredSummaryCompaction",
+    "TokenEstimator",
+    "ToolResult",
+    "ToolResultPruningConfig",
+    "TruncateCompaction",
+    "RetryPolicy",
+    "RetryingModelClient",
+    "build_model_client",
+    "normalize_messages",
+    "__version__",
+]

tada_core/cli/harness.py

@@ -0,0 +1,36 @@
+"""Minimal echo-only CLI harness for manual smoke tests."""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+
+from tada_core.contracts.session import SessionState
+from tada_core.loop import AgentLoop
+from tada_core.loop.model_client import OpenAICompatibleModelClient, make_echo_transport
+
+
+def main(argv: list[str] | None = None) -> None:
+    import argparse
+
+    p = argparse.ArgumentParser(
+        prog="tada-core-smoke",
+        description="Manual smoke harness for the tada-core AgentLoop",
+    )
+    p.add_argument("--text", default="hello", help="user message")
+    p.add_argument("--stream", action="store_true", help="use streaming transport")
+    args = p.parse_args(argv)
+
+    model = OpenAICompatibleModelClient(make_echo_transport(), streaming=args.stream)
+    loop = AgentLoop(model)
+    state = SessionState()
+
+    async def _run() -> None:
+        async for ev in loop.run_turn(state, args.text):
+            print(ev.model_dump_json())
+
+    asyncio.run(_run())
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

tada_core/contracts/__init__.py

@@ -0,0 +1,9 @@
+from tada_core.contracts.events import Event
+from tada_core.contracts.messages import ContentBlock, ConversationMessage, MessageRole
+
+__all__ = [
+    "Event",
+    "ContentBlock",
+    "ConversationMessage",
+    "MessageRole",
+]

tada_core/contracts/budget.py

@@ -0,0 +1,43 @@
+"""Runtime budget controls for AgentLoop.
+
+Budgets are provider-agnostic execution limits. They intentionally do not
+contain provider prices, routing priorities, quota accounts, or OAuth details.
+Hosts may translate token usage into cost externally and feed a derived limit
+back into this contract later.
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from tada_core.contracts.session import TokenUsage
+
+
+class BudgetLimits(BaseModel):
+    """Simple per-turn/session budget limits enforced by AgentLoop."""
+
+    max_input_tokens: int | None = None
+    max_output_tokens: int | None = None
+    max_total_tokens: int | None = None
+    max_iterations: int | None = None
+    max_tool_calls: int | None = None
+
+    def check_usage(self, usage: TokenUsage) -> str | None:
+        if self.max_input_tokens is not None and usage.input_tokens > self.max_input_tokens:
+            return f"input token budget exceeded: {usage.input_tokens} > {self.max_input_tokens}"
+        if self.max_output_tokens is not None and usage.output_tokens > self.max_output_tokens:
+            return f"output token budget exceeded: {usage.output_tokens} > {self.max_output_tokens}"
+        total = usage.input_tokens + usage.output_tokens
+        if self.max_total_tokens is not None and total > self.max_total_tokens:
+            return f"total token budget exceeded: {total} > {self.max_total_tokens}"
+        return None
+
+    def check_iteration(self, iterations_used: int) -> str | None:
+        if self.max_iterations is not None and iterations_used >= self.max_iterations:
+            return f"iteration budget exceeded: {iterations_used} >= {self.max_iterations}"
+        return None
+
+    def check_tool_calls(self, tool_calls_used: int) -> str | None:
+        if self.max_tool_calls is not None and tool_calls_used > self.max_tool_calls:
+            return f"tool call budget exceeded: {tool_calls_used} > {self.max_tool_calls}"
+        return None