cubeloop 0.14.0__py3-none-any.whl

cubeloop/__init__.py

@@ -0,0 +1,142 @@
+"""cubepi — Pythonic async-native agent framework."""
+
+from importlib.metadata import PackageNotFoundError, version as _pkg_version
+
+try:
+    __version__ = _pkg_version("cubeloop")
+except PackageNotFoundError:  # pragma: no cover — non-installed checkout
+    __version__ = "0.0.0+unknown"
+
+
+from cubeloop.agent import (
+    Agent,
+    AgentState,
+    AgentTool,
+    AgentToolResult,
+    run_agent_loop,
+    run_agent_loop_continue,
+    tool,
+)
+from cubeloop.middleware import Middleware, compose_middleware
+from cubeloop.providers import (
+    AssistantMessage,
+    BaseProvider,
+    BoundModel,
+    DEFAULT_TRIGGER_ERRORS,
+    FallbackBoundModel,
+    Message,
+    MessageStream,
+    Model,
+    Provider,
+    ReasoningControl,
+    ReasoningEffort,
+    ReasoningMode,
+    ReasoningSummary,
+    StreamEvent,
+    StreamOptions,
+    TextContent,
+    ToolCall,
+    ToolDefinition,
+    ToolResultMessage,
+    UserMessage,
+    is_synthetic_message,
+    synthetic_user_message,
+)
+from cubeloop.errors import (
+    ContentFiltered,
+    ContextLengthExceeded,
+    ModelNotFound,
+    ProviderAuthFailed,
+    ProviderBadRequest,
+    ProviderError,
+    ProviderUnavailable,
+    RateLimited,
+)
+from cubeloop.providers.capability import (
+    CapabilityDescriptor,
+    CapabilityWarning,
+    PayloadPreview,
+    ReasoningCapability,
+    TemperatureSpec,
+    apply_reasoning_control,
+    lint_capability,
+    preview_payload,
+)
+from cubeloop.providers.images import (
+    AssistantImages,
+    BaseImagesProvider,
+    ImagesAborted,
+    ImagesCapabilityDescriptor,
+    ImagesContext,
+    ImagesCost,
+    ImagesModel,
+    ImagesOptions,
+    ImagesProvider,
+    SizeSpec,
+)
+from cubeloop.types import JsonObject, JsonValue, StructuredObject, StructuredValue
+
+__all__ = [
+    "__version__",
+    "Agent",
+    "AgentState",
+    "AgentTool",
+    "AgentToolResult",
+    "AssistantImages",
+    "AssistantMessage",
+    "BaseImagesProvider",
+    "BaseProvider",
+    "BoundModel",
+    "CapabilityDescriptor",
+    "ContentFiltered",
+    "ContextLengthExceeded",
+    "DEFAULT_TRIGGER_ERRORS",
+    "FallbackBoundModel",
+    "ImagesAborted",
+    "ImagesCapabilityDescriptor",
+    "ImagesContext",
+    "ImagesCost",
+    "ImagesModel",
+    "ImagesOptions",
+    "ImagesProvider",
+    "JsonObject",
+    "JsonValue",
+    "Message",
+    "MessageStream",
+    "Middleware",
+    "Model",
+    "ModelNotFound",
+    "Provider",
+    "ProviderAuthFailed",
+    "ProviderBadRequest",
+    "ProviderError",
+    "ProviderUnavailable",
+    "RateLimited",
+    "ReasoningCapability",
+    "ReasoningControl",
+    "ReasoningEffort",
+    "ReasoningMode",
+    "ReasoningSummary",
+    "SizeSpec",
+    "StreamEvent",
+    "StreamOptions",
+    "StructuredObject",
+    "StructuredValue",
+    "TemperatureSpec",
+    "TextContent",
+    "ToolCall",
+    "ToolDefinition",
+    "ToolResultMessage",
+    "UserMessage",
+    "CapabilityWarning",
+    "PayloadPreview",
+    "apply_reasoning_control",
+    "is_synthetic_message",
+    "lint_capability",
+    "preview_payload",
+    "synthetic_user_message",
+    "compose_middleware",
+    "run_agent_loop",
+    "run_agent_loop_continue",
+    "tool",
+]

cubeloop/agent/__init__.py

@@ -0,0 +1,57 @@
+from cubeloop.agent.agent import Agent, AgentState
+from cubeloop.agent.loop import run_agent_loop, run_agent_loop_continue
+from cubeloop.agent.tool_decorator import tool
+from cubeloop.agent.tools import execute_tool_calls
+from cubeloop.agent.types import (
+    AfterToolCallContext,
+    AfterToolCallResult,
+    AgentContext,
+    AgentEndEvent,
+    AgentEvent,
+    AgentListener,
+    AgentStartEvent,
+    AgentTool,
+    AgentToolResult,
+    BeforeToolCallContext,
+    BeforeToolCallResult,
+    MessageEndEvent,
+    MessageStartEvent,
+    MessageUpdateEvent,
+    ShouldStopAfterTurnContext,
+    ToolExecutionEndEvent,
+    ToolExecutionStartEvent,
+    ToolExecutionUpdateEvent,
+    TurnEndEvent,
+    TurnStartEvent,
+)
+from cubeloop.utils import emit_event
+
+__all__ = [
+    "Agent",
+    "AgentState",
+    "run_agent_loop",
+    "run_agent_loop_continue",
+    "execute_tool_calls",
+    "AfterToolCallContext",
+    "AfterToolCallResult",
+    "AgentContext",
+    "AgentEndEvent",
+    "AgentEvent",
+    "AgentListener",
+    "AgentStartEvent",
+    "AgentTool",
+    "AgentToolResult",
+    "BeforeToolCallContext",
+    "BeforeToolCallResult",
+    "MessageEndEvent",
+    "MessageStartEvent",
+    "MessageUpdateEvent",
+    "ShouldStopAfterTurnContext",
+    "ToolExecutionEndEvent",
+    "ToolExecutionStartEvent",
+    "ToolExecutionUpdateEvent",
+    "TurnEndEvent",
+    "TurnStartEvent",
+    "emit_event",
+    "tool",
+]

cubeloop/agent/_outcome.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from typing import Literal
+
+RunOutcome = Literal["complete", "suspended", "incomplete", "abandoned"]

cubeloop/agent/_tool_cycle.py

@@ -0,0 +1,77 @@
+"""Pre-completion tool-cycle invariant — spec §3.6.2.
+
+For each AssistantMessage with ToolCall blocks {c1..cK}, the K-message
+window immediately following MUST be all ToolResultMessages whose
+tool_call_id MULTISET equals {c1..cK} — no extras, no missing, no
+duplicates beyond what the assistant emitted, and no other
+AssistantMessage or UserMessage may appear in that window.
+"""
+
+from __future__ import annotations
+
+from collections import Counter
+
+from cubeloop.providers.base import (
+    AssistantMessage,
+    Message,
+    ToolCall,
+    ToolResultMessage,
+)
+
+
+class ToolCycleViolation(ValueError):
+    def __init__(
+        self,
+        *,
+        kind: str,
+        assistant_index: int,
+        expected: Counter,
+        got: Counter,
+    ) -> None:
+        super().__init__(
+            f"tool-cycle violation [{kind}] at assistant index "
+            f"{assistant_index}: expected {dict(expected)}, "
+            f"got {dict(got)}"
+        )
+        self.kind = kind
+        self.assistant_index = assistant_index
+        self.expected = expected
+        self.got = got
+
+
+def check_tool_cycle(messages: list[Message]) -> None:
+    for i, m in enumerate(messages):
+        if not isinstance(m, AssistantMessage):
+            continue
+        call_ids = [c.id for c in m.content if isinstance(c, ToolCall)]
+        if not call_ids:
+            continue
+        expected = Counter(call_ids)
+        k = len(call_ids)
+        window = messages[i + 1 : i + 1 + k]
+        if len(window) < k:
+            raise ToolCycleViolation(
+                kind="incomplete-window",
+                assistant_index=i,
+                expected=expected,
+                got=Counter(),
+            )
+        for w in window:
+            if not isinstance(w, ToolResultMessage):
+                raise ToolCycleViolation(
+                    kind="non-tool-result-in-window",
+                    assistant_index=i,
+                    expected=expected,
+                    got=Counter(),
+                )
+        got = Counter(
+            w.tool_call_id for w in window if isinstance(w, ToolResultMessage)
+        )
+        # Multiset equality — catches duplicates the spec rejects.
+        if got != expected:
+            raise ToolCycleViolation(
+                kind="multiset-mismatch",
+                assistant_index=i,
+                expected=expected,
+                got=got,
+            )