AbstractRuntime 0.0.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

abstractruntime/core/__init__.py

@@ -1,19 +1,26 @@
 """Core runtime primitives."""
 
-from .models import Effect, EffectType, RunState, RunStatus, StepPlan, WaitReason, WaitState
+from .config import RuntimeConfig
+from .models import Effect, EffectType, LimitWarning, RunState, RunStatus, StepPlan, WaitReason, WaitState
 from .runtime import Runtime
 from .spec import WorkflowSpec
+from .vars import LIMITS, ensure_limits, get_limits
 
 __all__ = [
     "Effect",
     "EffectType",
+    "LimitWarning",
+    "LIMITS",
     "RunState",
     "RunStatus",
+    "Runtime",
+    "RuntimeConfig",
     "StepPlan",
     "WaitReason",
     "WaitState",
     "WorkflowSpec",
-    "Runtime",
+    "ensure_limits",
+    "get_limits",
 ]
 
 

abstractruntime/core/config.py

@@ -0,0 +1,101 @@
+"""abstractruntime.core.config
+
+Runtime configuration for resource limits and model capabilities.
+
+This module provides a RuntimeConfig dataclass that centralizes configuration
+for runtime resource limits (iterations, tokens, history) and model capabilities.
+The config is used to initialize the `_limits` namespace in RunState.vars.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, Optional
+
+
+@dataclass(frozen=True)
+class RuntimeConfig:
+    """Configuration for runtime resource limits and model capabilities.
+
+    This configuration is used by the Runtime to:
+    1. Initialize the `_limits` namespace in RunState.vars when starting a run
+    2. Provide model capability information for resource tracking
+    3. Configure warning thresholds for proactive notifications
+
+    Attributes:
+        max_iterations: Maximum number of reasoning iterations (default: 25)
+        warn_iterations_pct: Percentage threshold for iteration warnings (default: 80)
+        max_tokens: Maximum context window tokens (None = use model capabilities)
+        max_output_tokens: Maximum tokens for LLM response (None = provider default)
+        warn_tokens_pct: Percentage threshold for token warnings (default: 80)
+        max_history_messages: Maximum conversation history messages (-1 = unlimited)
+        model_capabilities: Dict of model capabilities from LLM provider
+
+    Example:
+        >>> config = RuntimeConfig(max_iterations=50, max_tokens=65536)
+        >>> limits = config.to_limits_dict()
+        >>> limits["max_iterations"]
+        50
+    """
+
+    # Iteration control
+    max_iterations: int = 25
+    warn_iterations_pct: int = 80
+
+    # Token/context window management
+    max_tokens: Optional[int] = None  # None = query from model capabilities
+    max_output_tokens: Optional[int] = None  # None = use provider default
+    warn_tokens_pct: int = 80
+
+    # History management
+    max_history_messages: int = -1  # -1 = unlimited (send all messages)
+
+    # Model capabilities (populated from LLM client)
+    model_capabilities: Dict[str, Any] = field(default_factory=dict)
+
+    def to_limits_dict(self) -> Dict[str, Any]:
+        """Convert to _limits namespace dict for RunState.vars.
+
+        Returns:
+            Dict with canonical limit values for storage in RunState.vars["_limits"].
+            Uses model_capabilities as fallback for max_tokens if not explicitly set.
+        """
+        return {
+            # Iteration control
+            "max_iterations": self.max_iterations,
+            "current_iteration": 0,
+
+            # Token management
+            "max_tokens": self.max_tokens or self.model_capabilities.get("max_tokens", 32768),
+            "max_output_tokens": self.max_output_tokens,
+            "estimated_tokens_used": 0,
+
+            # History management
+            "max_history_messages": self.max_history_messages,
+
+            # Warning thresholds
+            "warn_iterations_pct": self.warn_iterations_pct,
+            "warn_tokens_pct": self.warn_tokens_pct,
+        }
+
+    def with_capabilities(self, capabilities: Dict[str, Any]) -> "RuntimeConfig":
+        """Create a new RuntimeConfig with updated model capabilities.
+
+        This is useful for merging model capabilities from an LLM client
+        into an existing configuration.
+
+        Args:
+            capabilities: Dict of model capabilities (e.g., from get_model_capabilities())
+
+        Returns:
+            New RuntimeConfig with merged capabilities
+        """
+        return RuntimeConfig(
+            max_iterations=self.max_iterations,
+            warn_iterations_pct=self.warn_iterations_pct,
+            max_tokens=self.max_tokens,
+            max_output_tokens=self.max_output_tokens,
+            warn_tokens_pct=self.warn_tokens_pct,
+            max_history_messages=self.max_history_messages,
+            model_capabilities=capabilities,
+        )

abstractruntime/core/models.py

@@ -130,10 +130,20 @@ class RunState:
 
     # Optional provenance fields
     actor_id: Optional[str] = None
+    session_id: Optional[str] = None
     parent_run_id: Optional[str] = None  # For subworkflow tracking
 
     @classmethod
-    def new(cls, *, workflow_id: str, entry_node: str, actor_id: Optional[str] = None, vars: Optional[Dict[str, Any]] = None, parent_run_id: Optional[str] = None) -> "RunState":
+    def new(
+        cls,
+        *,
+        workflow_id: str,
+        entry_node: str,
+        actor_id: Optional[str] = None,
+        session_id: Optional[str] = None,
+        vars: Optional[Dict[str, Any]] = None,
+        parent_run_id: Optional[str] = None,
+    ) -> "RunState":
         return cls(
             run_id=str(uuid.uuid4()),
             workflow_id=workflow_id,
@@ -141,6 +151,7 @@ class RunState:
             current_node=entry_node,
             vars=vars or {},
             actor_id=actor_id,
+            session_id=session_id,
             parent_run_id=parent_run_id,
         )
 
@@ -170,6 +181,7 @@ class StepRecord:
 
     # Optional provenance/integrity
     actor_id: Optional[str] = None
+    session_id: Optional[str] = None
 
     # Retry and idempotency fields
     attempt: int = 1  # Current attempt number (1-indexed)
@@ -201,6 +213,7 @@ class StepRecord:
                 "result_key": effect.result_key,
             } if effect else None,
             actor_id=run.actor_id,
+            session_id=getattr(run, "session_id", None),
             attempt=attempt,
             idempotency_key=idempotency_key,
         )
@@ -237,3 +250,33 @@ class StepRecord:
         return self
 
 
+@dataclass
+class LimitWarning:
+    """Warning about approaching or exceeding a runtime limit.
+
+    Generated by Runtime.check_limits() to proactively notify about
+    resource constraints before they cause failures.
+
+    Attributes:
+        limit_type: Type of limit ("iterations", "tokens", "history")
+        status: Warning status ("warning" at threshold, "exceeded" at limit)
+        current: Current value of the resource
+        maximum: Maximum allowed value
+        pct: Percentage of limit used (computed in __post_init__)
+
+    Example:
+        >>> warning = LimitWarning("iterations", "warning", 20, 25)
+        >>> warning.pct
+        80.0
+    """
+
+    limit_type: str  # "iterations", "tokens", "history"
+    status: str  # "warning", "exceeded"
+    current: int
+    maximum: int
+    pct: float = 0.0
+
+    def __post_init__(self) -> None:
+        if self.maximum > 0:
+            self.pct = round(self.current / self.maximum * 100, 1)
+

abstractruntime/core/runtime.py

@@ -23,9 +23,11 @@ from datetime import datetime, timezone
 from typing import Any, Callable, Dict, Optional
 import inspect
 
+from .config import RuntimeConfig
 from .models import (
     Effect,
     EffectType,
+    LimitWarning,
     RunState,
     RunStatus,
     StepPlan,
@@ -92,6 +94,7 @@ class Runtime:
         workflow_registry: Optional[Any] = None,
         artifact_store: Optional[Any] = None,
         effect_policy: Optional[EffectPolicy] = None,
+        config: Optional[RuntimeConfig] = None,
     ):
         self._run_store = run_store
         self._ledger_store = ledger_store
@@ -99,6 +102,7 @@ class Runtime:
         self._workflow_registry = workflow_registry
         self._artifact_store = artifact_store
         self._effect_policy: EffectPolicy = effect_policy or DefaultEffectPolicy()
+        self._config: RuntimeConfig = config or RuntimeConfig()
 
         self._handlers: Dict[EffectType, EffectHandler] = {}
         self._register_builtin_handlers()
@@ -146,8 +150,33 @@ class Runtime:
         """Set the effect policy for retry and idempotency."""
         self._effect_policy = policy
 
-    def start(self, *, workflow: WorkflowSpec, vars: Optional[Dict[str, Any]] = None, actor_id: Optional[str] = None, parent_run_id: Optional[str] = None) -> str:
-        run = RunState.new(workflow_id=workflow.workflow_id, entry_node=workflow.entry_node, vars=vars, actor_id=actor_id, parent_run_id=parent_run_id)
+    @property
+    def config(self) -> RuntimeConfig:
+        """Access the runtime configuration."""
+        return self._config
+
+    def start(
+        self,
+        *,
+        workflow: WorkflowSpec,
+        vars: Optional[Dict[str, Any]] = None,
+        actor_id: Optional[str] = None,
+        session_id: Optional[str] = None,
+        parent_run_id: Optional[str] = None,
+    ) -> str:
+        # Initialize vars with _limits from config if not already set
+        vars = dict(vars or {})
+        if "_limits" not in vars:
+            vars["_limits"] = self._config.to_limits_dict()
+
+        run = RunState.new(
+            workflow_id=workflow.workflow_id,
+            entry_node=workflow.entry_node,
+            vars=vars,
+            actor_id=actor_id,
+            session_id=session_id,
+            parent_run_id=parent_run_id,
+        )
         self._run_store.save(run)
         return run.run_id
 
@@ -189,6 +218,126 @@ class Runtime:
     def get_ledger(self, run_id: str) -> list[dict[str, Any]]:
         return self._ledger_store.list(run_id)
 
+    # ---------------------------------------------------------------------
+    # Limit Management
+    # ---------------------------------------------------------------------
+
+    def get_limit_status(self, run_id: str) -> Dict[str, Any]:
+        """Get current limit status for a run.
+
+        Returns a structured dict with information about iterations, tokens,
+        and history limits, including whether warning thresholds are reached.
+
+        Args:
+            run_id: The run to check
+
+        Returns:
+            Dict with "iterations", "tokens", and "history" status info
+
+        Raises:
+            KeyError: If run_id not found
+        """
+        run = self.get_state(run_id)
+        limits = run.vars.get("_limits", {})
+
+        def pct(current: int, maximum: int) -> float:
+            return round(current / maximum * 100, 1) if maximum > 0 else 0
+
+        current_iter = int(limits.get("current_iteration", 0) or 0)
+        max_iter = int(limits.get("max_iterations", 25) or 25)
+        tokens_used = int(limits.get("estimated_tokens_used", 0) or 0)
+        max_tokens = int(limits.get("max_tokens", 32768) or 32768)
+
+        return {
+            "iterations": {
+                "current": current_iter,
+                "max": max_iter,
+                "pct": pct(current_iter, max_iter),
+                "warning": pct(current_iter, max_iter) >= limits.get("warn_iterations_pct", 80),
+            },
+            "tokens": {
+                "estimated_used": tokens_used,
+                "max": max_tokens,
+                "pct": pct(tokens_used, max_tokens),
+                "warning": pct(tokens_used, max_tokens) >= limits.get("warn_tokens_pct", 80),
+            },
+            "history": {
+                "max_messages": limits.get("max_history_messages", -1),
+            },
+        }
+
+    def check_limits(self, run: RunState) -> list[LimitWarning]:
+        """Check if any limits are approaching or exceeded.
+
+        This is the hybrid enforcement model: the runtime provides warnings,
+        workflow nodes are responsible for enforcement decisions.
+
+        Args:
+            run: The RunState to check
+
+        Returns:
+            List of LimitWarning objects for any limits at warning threshold or exceeded
+        """
+        warnings: list[LimitWarning] = []
+        limits = run.vars.get("_limits", {})
+
+        # Check iterations
+        current = int(limits.get("current_iteration", 0) or 0)
+        max_iter = int(limits.get("max_iterations", 25) or 25)
+        warn_pct = int(limits.get("warn_iterations_pct", 80) or 80)
+
+        if max_iter > 0:
+            if current >= max_iter:
+                warnings.append(LimitWarning("iterations", "exceeded", current, max_iter))
+            elif (current / max_iter * 100) >= warn_pct:
+                warnings.append(LimitWarning("iterations", "warning", current, max_iter))
+
+        # Check tokens
+        tokens_used = int(limits.get("estimated_tokens_used", 0) or 0)
+        max_tokens = int(limits.get("max_tokens", 32768) or 32768)
+        warn_tokens_pct = int(limits.get("warn_tokens_pct", 80) or 80)
+
+        if max_tokens > 0 and tokens_used > 0:
+            if tokens_used >= max_tokens:
+                warnings.append(LimitWarning("tokens", "exceeded", tokens_used, max_tokens))
+            elif (tokens_used / max_tokens * 100) >= warn_tokens_pct:
+                warnings.append(LimitWarning("tokens", "warning", tokens_used, max_tokens))
+
+        return warnings
+
+    def update_limits(self, run_id: str, updates: Dict[str, Any]) -> None:
+        """Update limits for a running workflow.
+
+        This allows mid-session updates (e.g., from /max-tokens command).
+        Only allowed limit keys are updated; unknown keys are ignored.
+
+        Args:
+            run_id: The run to update
+            updates: Dict of limit updates (e.g., {"max_tokens": 65536})
+
+        Raises:
+            KeyError: If run_id not found
+        """
+        run = self.get_state(run_id)
+        limits = run.vars.setdefault("_limits", {})
+
+        allowed_keys = {
+            "max_iterations",
+            "max_tokens",
+            "max_output_tokens",
+            "max_history_messages",
+            "warn_iterations_pct",
+            "warn_tokens_pct",
+            "estimated_tokens_used",
+            "current_iteration",
+        }
+
+        for key, value in updates.items():
+            if key in allowed_keys:
+                limits[key] = value
+
+        self._run_store.save(run)
+
     def tick(self, *, workflow: WorkflowSpec, run_id: str, max_steps: int = 100) -> RunState:
         run = self.get_state(run_id)
         if run.status in (RunStatus.COMPLETED, RunStatus.FAILED):
@@ -399,18 +548,25 @@ class Runtime:
         # correct resume semantics for waiting effects without duplicating payload fields.
         try:
             sig = inspect.signature(handler)
+        except (TypeError, ValueError):
+            sig = None
+
+        if sig is not None:
             params = list(sig.parameters.values())
             has_varargs = any(p.kind == inspect.Parameter.VAR_POSITIONAL for p in params)
             if has_varargs or len(params) >= 3:
                 return handler(run, effect, default_next_node)
             return handler(run, effect)
-        except Exception:
-            # If signature inspection fails, fall back to attempting the new call form,
-            # then the legacy form.
-            try:
-                return handler(run, effect, default_next_node)
-            except TypeError:
+
+        # If signature inspection fails, fall back to attempting the new call form,
+        # then the legacy form (only for arity-mismatch TypeError).
+        try:
+            return handler(run, effect, default_next_node)
+        except TypeError as e:
+            msg = str(e)
+            if "positional" in msg and "argument" in msg and ("given" in msg or "required" in msg):
                 return handler(run, effect)
+            raise
 
     def _apply_resume_payload(self, run: RunState, *, payload: Dict[str, Any], override_node: Optional[str]) -> None:
         run.status = RunStatus.RUNNING
@@ -515,6 +671,7 @@ class Runtime:
             workflow=sub_workflow,
             vars=sub_vars,
             actor_id=run.actor_id,  # Inherit actor from parent
+            session_id=getattr(run, "session_id", None),  # Inherit session from parent
             parent_run_id=run.run_id,  # Track parent for hierarchy
         )
 
@@ -577,5 +734,3 @@ def _set_nested(target: Dict[str, Any], dotted_key: str, value: Any) -> None:
             cur[p] = nxt
         cur = nxt
     cur[parts[-1]] = value
-
-

abstractruntime/core/vars.py

@@ -0,0 +1,94 @@
+"""RunState.vars namespacing helpers.
+
+AbstractRuntime treats `RunState.vars` as JSON-serializable user/workflow state.
+To avoid key collisions and to clarify ownership, we use a simple convention:
+
+- `context`: user-facing context (task, conversation, inputs)
+- `scratchpad`: agent/workflow working memory (iteration counters, plans)
+- `_runtime`: runtime/host-managed metadata (tool specs, inbox, etc.)
+- `_temp`: ephemeral step-to-step values (llm_response, tool_results, etc.)
+- `_limits`: runtime resource limits (max_iterations, max_tokens, etc.)
+
+This is a convention, not a strict schema; helpers here are intentionally small.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+
+CONTEXT = "context"
+SCRATCHPAD = "scratchpad"
+RUNTIME = "_runtime"
+TEMP = "_temp"
+LIMITS = "_limits"  # Canonical storage for runtime resource limits
+
+
+def ensure_namespaces(vars: Dict[str, Any]) -> Dict[str, Any]:
+    """Ensure the four canonical namespaces exist and are dicts."""
+    for key in (CONTEXT, SCRATCHPAD, RUNTIME, TEMP):
+        current = vars.get(key)
+        if not isinstance(current, dict):
+            vars[key] = {}
+    return vars
+
+
+def get_namespace(vars: Dict[str, Any], key: str) -> Dict[str, Any]:
+    ensure_namespaces(vars)
+    return vars[key]  # type: ignore[return-value]
+
+
+def get_context(vars: Dict[str, Any]) -> Dict[str, Any]:
+    return get_namespace(vars, CONTEXT)
+
+
+def get_scratchpad(vars: Dict[str, Any]) -> Dict[str, Any]:
+    return get_namespace(vars, SCRATCHPAD)
+
+
+def get_runtime(vars: Dict[str, Any]) -> Dict[str, Any]:
+    return get_namespace(vars, RUNTIME)
+
+
+def get_temp(vars: Dict[str, Any]) -> Dict[str, Any]:
+    return get_namespace(vars, TEMP)
+
+
+def clear_temp(vars: Dict[str, Any]) -> None:
+    get_temp(vars).clear()
+
+
+def get_limits(vars: Dict[str, Any]) -> Dict[str, Any]:
+    """Get the _limits namespace, creating with defaults if missing."""
+    if LIMITS not in vars or not isinstance(vars.get(LIMITS), dict):
+        vars[LIMITS] = _default_limits()
+    return vars[LIMITS]  # type: ignore[return-value]
+
+
+def ensure_limits(vars: Dict[str, Any]) -> Dict[str, Any]:
+    """Ensure _limits namespace exists with defaults.
+
+    This is the canonical location for runtime resource limits:
+    - max_iterations / current_iteration: Iteration control
+    - max_tokens / estimated_tokens_used: Token/context window management
+    - max_history_messages: Conversation history limit (-1 = unlimited)
+    - warn_*_pct: Warning thresholds for proactive notifications
+
+    Returns:
+        The _limits dict (mutable reference into vars)
+    """
+    return get_limits(vars)
+
+
+def _default_limits() -> Dict[str, Any]:
+    """Return default limits dict."""
+    return {
+        "max_iterations": 25,
+        "current_iteration": 0,
+        "max_tokens": 32768,
+        "max_output_tokens": None,
+        "max_history_messages": -1,
+        "estimated_tokens_used": 0,
+        "warn_iterations_pct": 80,
+        "warn_tokens_pct": 80,
+    }
+

abstractruntime/integrations/abstractcore/__init__.py

@@ -7,16 +7,18 @@ Provides:
 - Tool executors (executed + passthrough)
 - Effect handlers wiring
 - Convenience runtime factories for local/remote/hybrid modes
+- RuntimeConfig for limits and model capabilities
 
 Importing this module is the explicit opt-in to an AbstractCore dependency.
 """
 
+from ...core.config import RuntimeConfig
 from .llm_client import (
     AbstractCoreLLMClient,
     LocalAbstractCoreLLMClient,
     RemoteAbstractCoreLLMClient,
 )
-from .tool_executor import AbstractCoreToolExecutor, PassthroughToolExecutor, ToolExecutor
+from .tool_executor import AbstractCoreToolExecutor, MappingToolExecutor, PassthroughToolExecutor, ToolExecutor
 from .effect_handlers import build_effect_handlers
 from .factory import (
     create_hybrid_runtime,
@@ -30,9 +32,12 @@ __all__ = [
     "AbstractCoreLLMClient",
     "LocalAbstractCoreLLMClient",
     "RemoteAbstractCoreLLMClient",
+    "RuntimeConfig",
     "ToolExecutor",
+    "MappingToolExecutor",
     "AbstractCoreToolExecutor",
     "PassthroughToolExecutor",
+
     "build_effect_handlers",
     "create_local_runtime",
     "create_remote_runtime",
@@ -40,4 +45,3 @@ __all__ = [
     "create_local_file_runtime",
     "create_remote_file_runtime",
 ]
-

abstractruntime/integrations/abstractcore/effect_handlers.py

@@ -22,6 +22,18 @@ from .logging import get_logger
 logger = get_logger(__name__)
 
 
+def _trace_context(run: RunState) -> Dict[str, str]:
+    ctx: Dict[str, str] = {"run_id": run.run_id}
+    if run.actor_id:
+        ctx["actor_id"] = str(run.actor_id)
+    session_id = getattr(run, "session_id", None)
+    if session_id:
+        ctx["session_id"] = str(session_id)
+    if run.parent_run_id:
+        ctx["parent_run_id"] = str(run.parent_run_id)
+    return ctx
+
+
 def make_llm_call_handler(*, llm: AbstractCoreLLMClient) -> EffectHandler:
     def _handler(run: RunState, effect: Effect, default_next_node: Optional[str]) -> EffectOutcome:
         payload = dict(effect.payload or {})
@@ -29,7 +41,15 @@ def make_llm_call_handler(*, llm: AbstractCoreLLMClient) -> EffectHandler:
         messages = payload.get("messages")
         system_prompt = payload.get("system_prompt")
         tools = payload.get("tools")
-        params = payload.get("params")
+        raw_params = payload.get("params")
+        params = dict(raw_params) if isinstance(raw_params, dict) else {}
+
+        # Propagate durable trace context into AbstractCore calls.
+        trace_metadata = params.get("trace_metadata")
+        if not isinstance(trace_metadata, dict):
+            trace_metadata = {}
+        trace_metadata.update(_trace_context(run))
+        params["trace_metadata"] = trace_metadata
 
         if not prompt and not messages:
             return EffectOutcome.failed("llm_call requires payload.prompt or payload.messages")
@@ -50,13 +70,24 @@ def make_llm_call_handler(*, llm: AbstractCoreLLMClient) -> EffectHandler:
     return _handler
 
 
-def make_tool_calls_handler(*, tools: ToolExecutor) -> EffectHandler:
+def make_tool_calls_handler(*, tools: Optional[ToolExecutor] = None) -> EffectHandler:
+    """Create a TOOL_CALLS effect handler.
+
+    Tool execution is performed exclusively via the host-configured ToolExecutor.
+    This keeps `RunState.vars` and ledger payloads JSON-safe (durable execution).
+    """
     def _handler(run: RunState, effect: Effect, default_next_node: Optional[str]) -> EffectOutcome:
         payload = dict(effect.payload or {})
         tool_calls = payload.get("tool_calls")
         if not isinstance(tool_calls, list):
             return EffectOutcome.failed("tool_calls requires payload.tool_calls (list)")
 
+        if tools is None:
+            return EffectOutcome.failed(
+                "TOOL_CALLS requires a ToolExecutor; configure Runtime with "
+                "MappingToolExecutor/AbstractCoreToolExecutor/PassthroughToolExecutor."
+            )
+
         try:
             result = tools.execute(tool_calls=tool_calls)
         except Exception as e:
@@ -81,9 +112,8 @@ def make_tool_calls_handler(*, tools: ToolExecutor) -> EffectHandler:
     return _handler
 
 
-def build_effect_handlers(*, llm: AbstractCoreLLMClient, tools: ToolExecutor) -> Dict[EffectType, Any]:
+def build_effect_handlers(*, llm: AbstractCoreLLMClient, tools: ToolExecutor = None) -> Dict[EffectType, Any]:
     return {
         EffectType.LLM_CALL: make_llm_call_handler(llm=llm),
         EffectType.TOOL_CALLS: make_tool_calls_handler(tools=tools),
     }
-

abstractruntime/integrations/abstractcore/factory.py

@@ -15,6 +15,7 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Any, Dict, Optional
 
+from ...core.config import RuntimeConfig
 from ...core.runtime import Runtime
 from ...storage.in_memory import InMemoryLedgerStore, InMemoryRunStore
 from ...storage.json_files import JsonFileRunStore, JsonlLedgerStore
@@ -45,7 +46,27 @@ def create_local_runtime(
     tool_executor: Optional[ToolExecutor] = None,
     context: Optional[Any] = None,
     effect_policy: Optional[Any] = None,
+    config: Optional[RuntimeConfig] = None,
 ) -> Runtime:
+    """Create a runtime with local LLM execution via AbstractCore.
+
+    Args:
+        provider: LLM provider (e.g., "ollama", "openai")
+        model: Model name
+        llm_kwargs: Additional kwargs for LLM client
+        run_store: Storage for run state (default: in-memory)
+        ledger_store: Storage for ledger (default: in-memory)
+        tool_executor: Optional custom tool executor. If not provided, defaults
+            to `AbstractCoreToolExecutor()` (AbstractCore global tool registry).
+        context: Optional context object
+        effect_policy: Optional effect policy (retry, etc.)
+        config: Optional RuntimeConfig for limits and model capabilities.
+            If not provided, model capabilities are queried from the LLM client.
+
+    Note:
+        For durable execution, tool callables should never be stored in `RunState.vars`
+        or passed in effect payloads. Prefer `MappingToolExecutor.from_tools([...])`.
+    """
     if run_store is None or ledger_store is None:
         run_store, ledger_store = _default_in_memory_stores()
 
@@ -53,7 +74,22 @@ def create_local_runtime(
     tools = tool_executor or AbstractCoreToolExecutor()
     handlers = build_effect_handlers(llm=llm_client, tools=tools)
 
-    return Runtime(run_store=run_store, ledger_store=ledger_store, effect_handlers=handlers, context=context, effect_policy=effect_policy)
+    # Query model capabilities and merge into config
+    capabilities = llm_client.get_model_capabilities()
+    if config is None:
+        config = RuntimeConfig(model_capabilities=capabilities)
+    else:
+        # Merge capabilities into provided config
+        config = config.with_capabilities(capabilities)
+
+    return Runtime(
+        run_store=run_store,
+        ledger_store=ledger_store,
+        effect_handlers=handlers,
+        context=context,
+        effect_policy=effect_policy,
+        config=config,
+    )
 
 
 def create_remote_runtime(
@@ -116,6 +152,7 @@ def create_local_file_runtime(
     model: str,
     llm_kwargs: Optional[Dict[str, Any]] = None,
     context: Optional[Any] = None,
+    config: Optional[RuntimeConfig] = None,
 ) -> Runtime:
     run_store, ledger_store = _default_file_stores(base_dir=base_dir)
     return create_local_runtime(
@@ -125,6 +162,7 @@ def create_local_file_runtime(
         run_store=run_store,
         ledger_store=ledger_store,
         context=context,
+        config=config,
     )
 
 
@@ -147,4 +185,3 @@ def create_remote_file_runtime(
         ledger_store=ledger_store,
         context=context,
     )
-

abstractruntime/integrations/abstractcore/llm_client.py

@@ -13,14 +13,21 @@ Remote mode is the preferred way to support per-request dynamic routing (e.g. `b
 
 from __future__ import annotations
 
-from dataclasses import asdict, is_dataclass
-from typing import Any, Dict, List, Optional, Protocol
+import json
+from dataclasses import asdict, dataclass, is_dataclass
+from typing import Any, Dict, List, Optional, Protocol, Tuple
 
 from .logging import get_logger
 
 logger = get_logger(__name__)
 
 
+@dataclass(frozen=True)
+class HttpResponse:
+    body: Dict[str, Any]
+    headers: Dict[str, str]
+
+
 class RequestSender(Protocol):
     def post(
         self,
@@ -29,7 +36,7 @@ class RequestSender(Protocol):
         headers: Dict[str, str],
         json: Dict[str, Any],
         timeout: float,
-    ) -> Dict[str, Any]: ...
+    ) -> Any: ...
 
 
 class AbstractCoreLLMClient(Protocol):
@@ -81,7 +88,12 @@ def _normalize_local_response(resp: Any) -> Dict[str, Any]:
 
     # Dict-like already
     if isinstance(resp, dict):
-        return _jsonable(resp)
+        out = _jsonable(resp)
+        if isinstance(out, dict):
+            meta = out.get("metadata")
+            if isinstance(meta, dict) and "trace_id" in meta and "trace_id" not in out:
+                out["trace_id"] = meta["trace_id"]
+        return out
 
     # Pydantic structured output
     if hasattr(resp, "model_dump") or hasattr(resp, "dict"):
@@ -92,6 +104,8 @@ def _normalize_local_response(resp: Any) -> Dict[str, Any]:
             "usage": None,
             "model": None,
             "finish_reason": None,
+            "metadata": None,
+            "trace_id": None,
         }
 
     # AbstractCore GenerateResponse
@@ -100,6 +114,12 @@ def _normalize_local_response(resp: Any) -> Dict[str, Any]:
     usage = getattr(resp, "usage", None)
     model = getattr(resp, "model", None)
     finish_reason = getattr(resp, "finish_reason", None)
+    metadata = getattr(resp, "metadata", None)
+    trace_id: Optional[str] = None
+    if isinstance(metadata, dict):
+        raw = metadata.get("trace_id")
+        if raw is not None:
+            trace_id = str(raw)
 
     return {
         "content": content,
@@ -108,6 +128,8 @@ def _normalize_local_response(resp: Any) -> Dict[str, Any]:
         "usage": _jsonable(usage) if usage is not None else None,
         "model": model,
         "finish_reason": finish_reason,
+        "metadata": _jsonable(metadata) if metadata is not None else None,
+        "trace_id": trace_id,
     }
 
 
@@ -126,7 +148,11 @@ class LocalAbstractCoreLLMClient:
 
         self._provider = provider
         self._model = model
-        self._llm = create_llm(provider, model=model, **(llm_kwargs or {}))
+        kwargs = dict(llm_kwargs or {})
+        kwargs.setdefault("enable_tracing", True)
+        if kwargs.get("enable_tracing"):
+            kwargs.setdefault("max_traces", 0)
+        self._llm = create_llm(provider, model=model, **kwargs)
         self._tool_handler = UniversalToolHandler(model)
 
     def generate(
@@ -144,41 +170,75 @@ class LocalAbstractCoreLLMClient:
         # do not create new providers per call unless the host explicitly chooses to.
         params.pop("base_url", None)
 
-        # If tools provided, use UniversalToolHandler to format them into prompt
-        # This works for models without native tool support
-        effective_prompt = prompt
-        if tools:
+        capabilities: List[str] = []
+        get_capabilities = getattr(self._llm, "get_capabilities", None)
+        if callable(get_capabilities):
+            try:
+                capabilities = list(get_capabilities())
+            except Exception:
+                capabilities = []
+        supports_tools = "tools" in set(c.lower() for c in capabilities)
+
+        if tools and not supports_tools:
+            # Fallback tool calling via prompting for providers/models without native tool support.
             from abstractcore.tools import ToolDefinition
-            tool_defs = []
-            for t in tools:
-                tool_defs.append(ToolDefinition(
+
+            tool_defs = [
+                ToolDefinition(
                     name=t.get("name", ""),
                     description=t.get("description", ""),
                     parameters=t.get("parameters", {}),
-                ))
+                )
+                for t in tools
+            ]
             tools_prompt = self._tool_handler.format_tools_prompt(tool_defs)
             effective_prompt = f"{tools_prompt}\n\nUser request: {prompt}"
 
+            resp = self._llm.generate(
+                prompt=effective_prompt,
+                messages=messages,
+                system_prompt=system_prompt,
+                stream=False,
+                **params,
+            )
+            result = _normalize_local_response(resp)
+
+            # Parse tool calls from response content.
+            if result.get("content"):
+                parsed = self._tool_handler.parse_response(result["content"], mode="prompted")
+                if parsed.tool_calls:
+                    result["tool_calls"] = [
+                        {"name": tc.name, "arguments": tc.arguments, "call_id": tc.call_id}
+                        for tc in parsed.tool_calls
+                    ]
+            return result
+
         resp = self._llm.generate(
-            prompt=effective_prompt,
+            prompt=str(prompt or ""),
             messages=messages,
             system_prompt=system_prompt,
+            tools=tools,
             stream=False,
             **params,
         )
-        
-        result = _normalize_local_response(resp)
-        
-        # Parse tool calls from response if tools were provided
-        if tools and result.get("content"):
-            parsed = self._tool_handler.parse_response(result["content"], mode="prompted")
-            if parsed.tool_calls:
-                result["tool_calls"] = [
-                    {"name": tc.name, "arguments": tc.arguments, "call_id": tc.call_id}
-                    for tc in parsed.tool_calls
-                ]
-        
-        return result
+        return _normalize_local_response(resp)
+
+    def get_model_capabilities(self) -> Dict[str, Any]:
+        """Get model capabilities including max_tokens, vision_support, etc.
+
+        Uses AbstractCore's architecture detection system to query model limits
+        and features. This allows the runtime to be aware of model constraints
+        for resource tracking and warnings.
+
+        Returns:
+            Dict with model capabilities. Always includes 'max_tokens' (default 32768).
+        """
+        try:
+            from abstractcore.architectures.detection import get_model_capabilities
+            return get_model_capabilities(self._model)
+        except Exception:
+            # Safe fallback if detection fails
+            return {"max_tokens": 32768}
 
 
 class HttpxRequestSender:
@@ -196,10 +256,28 @@ class HttpxRequestSender:
         headers: Dict[str, str],
         json: Dict[str, Any],
         timeout: float,
-    ) -> Dict[str, Any]:
+    ) -> HttpResponse:
         resp = self._httpx.post(url, headers=headers, json=json, timeout=timeout)
         resp.raise_for_status()
-        return resp.json()
+        return HttpResponse(body=resp.json(), headers=dict(resp.headers))
+
+
+def _unwrap_http_response(value: Any) -> Tuple[Dict[str, Any], Dict[str, str]]:
+    if isinstance(value, dict):
+        return value, {}
+    body = getattr(value, "body", None)
+    headers = getattr(value, "headers", None)
+    if isinstance(body, dict) and isinstance(headers, dict):
+        return body, headers
+    json_fn = getattr(value, "json", None)
+    hdrs = getattr(value, "headers", None)
+    if callable(json_fn) and hdrs is not None:
+        try:
+            payload = json_fn()
+        except Exception:
+            payload = {}
+        return payload if isinstance(payload, dict) else {"data": _jsonable(payload)}, dict(hdrs)
+    return {"data": _jsonable(value)}, {}
 
 
 class RemoteAbstractCoreLLMClient:
@@ -230,6 +308,23 @@ class RemoteAbstractCoreLLMClient:
         params: Optional[Dict[str, Any]] = None,
     ) -> Dict[str, Any]:
         params = dict(params or {})
+        req_headers = dict(self._headers)
+
+        trace_metadata = params.pop("trace_metadata", None)
+        if isinstance(trace_metadata, dict) and trace_metadata:
+            req_headers["X-AbstractCore-Trace-Metadata"] = json.dumps(
+                trace_metadata, ensure_ascii=False, separators=(",", ":")
+            )
+            header_map = {
+                "actor_id": "X-AbstractCore-Actor-Id",
+                "session_id": "X-AbstractCore-Session-Id",
+                "run_id": "X-AbstractCore-Run-Id",
+                "parent_run_id": "X-AbstractCore-Parent-Run-Id",
+            }
+            for key, header in header_map.items():
+                val = trace_metadata.get(key)
+                if val is not None and header not in req_headers:
+                    req_headers[header] = str(val)
 
         # Build OpenAI-like messages for AbstractCore server.
         out_messages: List[Dict[str, str]] = []
@@ -268,7 +363,10 @@ class RemoteAbstractCoreLLMClient:
             body["tools"] = tools
 
         url = f"{self._server_base_url}/v1/chat/completions"
-        resp = self._sender.post(url, headers=self._headers, json=body, timeout=self._timeout_s)
+        raw = self._sender.post(url, headers=req_headers, json=body, timeout=self._timeout_s)
+        resp, resp_headers = _unwrap_http_response(raw)
+        lower_headers = {str(k).lower(): str(v) for k, v in resp_headers.items()}
+        trace_id = lower_headers.get("x-abstractcore-trace-id") or lower_headers.get("x-trace-id")
 
         # Normalize OpenAI-like response.
         try:
@@ -281,6 +379,8 @@ class RemoteAbstractCoreLLMClient:
                 "usage": _jsonable(resp.get("usage")) if resp.get("usage") is not None else None,
                 "model": resp.get("model"),
                 "finish_reason": choice0.get("finish_reason"),
+                "metadata": {"trace_id": trace_id} if trace_id else None,
+                "trace_id": trace_id,
             }
         except Exception:
             # Fallback: return the raw response in JSON-safe form.
@@ -292,5 +392,6 @@ class RemoteAbstractCoreLLMClient:
                 "usage": None,
                 "model": resp.get("model") if isinstance(resp, dict) else None,
                 "finish_reason": None,
+                "metadata": {"trace_id": trace_id} if trace_id else None,
+                "trace_id": trace_id,
             }
-

abstractruntime/integrations/abstractcore/tool_executor.py

@@ -13,7 +13,7 @@ pause until the host resumes with the tool results.
 from __future__ import annotations
 
 from dataclasses import asdict, is_dataclass
-from typing import Any, Dict, List, Optional, Protocol
+from typing import Any, Callable, Dict, List, Optional, Protocol, Sequence
 
 from .logging import get_logger
 
@@ -24,6 +24,85 @@ class ToolExecutor(Protocol):
     def execute(self, *, tool_calls: List[Dict[str, Any]]) -> Dict[str, Any]: ...
 
 
+class MappingToolExecutor:
+    """Executes tool calls using an explicit {tool_name -> callable} mapping.
+
+    This is the recommended durable execution path: the mapping is held by the
+    host/runtime process and is never persisted inside RunState.
+    """
+
+    def __init__(self, tool_map: Dict[str, Callable[..., Any]]):
+        self._tool_map = dict(tool_map)
+
+    @classmethod
+    def from_tools(cls, tools: Sequence[Callable[..., Any]]) -> "MappingToolExecutor":
+        tool_map: Dict[str, Callable[..., Any]] = {}
+        for t in tools:
+            tool_def = getattr(t, "_tool_definition", None)
+            if tool_def is not None:
+                name = str(getattr(tool_def, "name", "") or "")
+                func = getattr(tool_def, "function", None) or t
+            else:
+                name = str(getattr(t, "__name__", "") or "")
+                func = t
+
+            if not name:
+                raise ValueError("Tool is missing a name")
+            if not callable(func):
+                raise ValueError(f"Tool '{name}' is not callable")
+            if name in tool_map:
+                raise ValueError(f"Duplicate tool name '{name}'")
+
+            tool_map[name] = func
+
+        return cls(tool_map)
+
+    def execute(self, *, tool_calls: List[Dict[str, Any]]) -> Dict[str, Any]:
+        results: List[Dict[str, Any]] = []
+
+        for tc in tool_calls:
+            name = str(tc.get("name", "") or "")
+            arguments = dict(tc.get("arguments") or {})
+            call_id = str(tc.get("call_id") or "")
+
+            func = self._tool_map.get(name)
+            if func is None:
+                results.append(
+                    {
+                        "call_id": call_id,
+                        "name": name,
+                        "success": False,
+                        "output": None,
+                        "error": f"Tool '{name}' not found",
+                    }
+                )
+                continue
+
+            try:
+                output = func(**arguments)
+                results.append(
+                    {
+                        "call_id": call_id,
+                        "name": name,
+                        "success": True,
+                        "output": _jsonable(output),
+                        "error": None,
+                    }
+                )
+            except Exception as e:
+                results.append(
+                    {
+                        "call_id": call_id,
+                        "name": name,
+                        "success": False,
+                        "output": None,
+                        "error": str(e),
+                    }
+                )
+
+        return {"mode": "executed", "results": results}
+
+
 def _jsonable(value: Any) -> Any:
     if value is None:
         return None
@@ -65,10 +144,11 @@ class AbstractCoreToolExecutor:
 
         results = execute_tools(calls)
         normalized = []
-        for r in results:
+        for call, r in zip(calls, results):
             normalized.append(
                 {
                     "call_id": getattr(r, "call_id", ""),
+                    "name": getattr(call, "name", ""),
                     "success": bool(getattr(r, "success", False)),
                     "output": _jsonable(getattr(r, "output", None)),
                     "error": getattr(r, "error", None),
@@ -86,4 +166,3 @@ class PassthroughToolExecutor:
 
     def execute(self, *, tool_calls: List[Dict[str, Any]]) -> Dict[str, Any]:
         return {"mode": self._mode, "tool_calls": _jsonable(tool_calls)}
-

abstractruntime/storage/artifacts.py

@@ -221,6 +221,37 @@ class ArtifactStore(ABC):
                 count += 1
         return count
 
+    def search(
+        self,
+        *,
+        run_id: Optional[str] = None,
+        content_type: Optional[str] = None,
+        tags: Optional[Dict[str, str]] = None,
+        limit: int = 1000,
+    ) -> List[ArtifactMetadata]:
+        """Filter artifacts by simple metadata fields.
+
+        This is intentionally a *metadata filter*, not semantic search. Semantic/embedding
+        retrieval belongs in AbstractMemory or higher-level components.
+        """
+        if run_id is None:
+            candidates = list(self.list_all(limit=limit))
+        else:
+            candidates = list(self.list_by_run(run_id))
+
+        if content_type is not None:
+            candidates = [m for m in candidates if m.content_type == content_type]
+
+        if tags:
+            candidates = [
+                m
+                for m in candidates
+                if all((m.tags or {}).get(k) == v for k, v in tags.items())
+            ]
+
+        candidates.sort(key=lambda m: m.created_at, reverse=True)
+        return candidates[:limit]
+
     # Convenience methods
 
     def store_text(

abstractruntime/storage/json_files.py

@@ -88,6 +88,7 @@ class JsonFileRunStore(RunStore):
             created_at=data.get("created_at"),
             updated_at=data.get("updated_at"),
             actor_id=data.get("actor_id"),
+            session_id=data.get("session_id"),
             parent_run_id=data.get("parent_run_id"),
         )
 
@@ -205,4 +206,3 @@ class JsonlLedgerStore(LedgerStore):
                 out.append(json.loads(line))
         return out
 
-

{abstractruntime-0.0.1.dist-info → abstractruntime-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractRuntime
-Version: 0.0.1
+Version: 0.2.0
 Summary: AbstractRuntime: a durable graph runner designed to pair with AbstractCore.
 Project-URL: AbstractCore (website), https://www.abstractcore.ai/
 Project-URL: AbstractCore (GitHub), https://github.com/lpalbou/abstractruntime

{abstractruntime-0.0.1.dist-info → abstractruntime-0.2.0.dist-info}/RECORD

@@ -1,30 +1,32 @@
 abstractruntime/__init__.py,sha256=oobR5VlwZgxJKWr7hmjwVEGgYakHQt4oJNrdxcj6Nsc,2547
-abstractruntime/core/__init__.py,sha256=X15NaswmuhT9DcGksOkbmJ2cFcWsBCUH4s-Hx_nHnBo,353
-abstractruntime/core/models.py,sha256=7Qvosfc91ylHeCFt1SrEQFfHZp8Gnl2aq5cdfprvLj4,6923
+abstractruntime/core/__init__.py,sha256=msUcfYjAwjkiEgvi-twteo1H11oBclYJFXqYVWlf8JQ,547
+abstractruntime/core/config.py,sha256=dQnWCpGL5fFV2y_KOhTjLVu5fzhcOfUnbLjd3uMcRCs,3922
+abstractruntime/core/models.py,sha256=JmuDpM8jjzcr6lc0yv7oBTSrzCtID4Pz21eVDDcQnKk,8142
 abstractruntime/core/policy.py,sha256=C8tmxaY8YCTvs8_5-5Ns6tsFdCVE_G2vHBOiEckeg9Y,5115
-abstractruntime/core/runtime.py,sha256=U2GgFJry7fJYXS4Lu4460BGwJal-Ak1zaBakYCJYb0Y,22170
+abstractruntime/core/runtime.py,sha256=ZPERZuvtVCBEhWPKXTO2K_7mwnBZd1FAjubp5uiV-Ck,27653
 abstractruntime/core/spec.py,sha256=SBxAFaaIe9eJTRDMEgDub-GaF2McHTDkEgIl3L-DXbE,1461
+abstractruntime/core/vars.py,sha256=ghe9WkjlOuVbIgN86V2RXRVqpd0D9qNmoBz_Xf30hqw,2995
 abstractruntime/identity/__init__.py,sha256=aV_aA6lfqsIQMPE2S0B0AKi0rnb-_vmKYpgv1wWoaq8,119
 abstractruntime/identity/fingerprint.py,sha256=axQFEHSJFsrYGNkikkfEVhNNQxdR8wBmv4TuVbTs0lM,1748
 abstractruntime/integrations/__init__.py,sha256=CnhKNxeT-rCeJRURWOXT8YBZ7HJPOESJROV5cnEwJoQ,408
-abstractruntime/integrations/abstractcore/__init__.py,sha256=BRoXxUGJYAVYu8zI3_1m21K01yvDE1ZTS4p-23kEl0w,1142
-abstractruntime/integrations/abstractcore/effect_handlers.py,sha256=_5NRvnx7UIrtw4BuWBEY0PBEuLALdCqIGdbl4HSPsd4,3221
-abstractruntime/integrations/abstractcore/factory.py,sha256=OQP77JFJmYKhL2rMWqgAp66S_VCnESr0wE0O9cO5WxI,4857
-abstractruntime/integrations/abstractcore/llm_client.py,sha256=jTyNfKWnbIqLMA6OOt51biZ0tTzlqG_fv4de9kUdINs,9440
+abstractruntime/integrations/abstractcore/__init__.py,sha256=txcjiJD7ETRyQMjQQ8zeSrlxpAHAsRjObU7fGLIoNbg,1302
+abstractruntime/integrations/abstractcore/effect_handlers.py,sha256=Zwl5-v6HKgdCUdfuiXOCU3LphKsAL_LxfdSIG4PKudg,4467
+abstractruntime/integrations/abstractcore/factory.py,sha256=r7ZtojoDLObe16gKsp0h04EliVAlbFl8aeXcuw6o9sw,6339
+abstractruntime/integrations/abstractcore/llm_client.py,sha256=KA-GDb8yhcOA93tbNugrtdOPITJQYPsds5IFLe6JdIk,13654
 abstractruntime/integrations/abstractcore/logging.py,sha256=iYmibudvLXs83hhF-dpbgEoyUdzTo8tnT4dV-cC6uyE,683
-abstractruntime/integrations/abstractcore/tool_executor.py,sha256=fLq-YX6EDiSzMKHC2b3KqFt28D46cOnbpRV5auDM4MU,2720
+abstractruntime/integrations/abstractcore/tool_executor.py,sha256=yZq3txNlm00Xa-m7KfUN3_6ACKXGOZLnyslAI-CA-fs,5528
 abstractruntime/scheduler/__init__.py,sha256=ZwFJQrBN3aQOv7xuGXsURXEEBJAHV6qVQy13DYvbhqw,337
 abstractruntime/scheduler/convenience.py,sha256=Rremvw_P3JMQ-NOkwn7ATlD5HPkKxRtSGJRfBkimyJY,10278
 abstractruntime/scheduler/registry.py,sha256=0iqcTcCV0bYmhw-T7n8TFoZXVkhBRZt89AebXz_Z5fc,2969
 abstractruntime/scheduler/scheduler.py,sha256=Z3dIwz0e7bP7c_S_VoclgY1Fjw7NxFez_wsst-dYVT8,13535
 abstractruntime/storage/__init__.py,sha256=KSg4V-0Ge_BWFnm_a-XsKezNdtUhUBUuvfsvRKUiDUo,702
-abstractruntime/storage/artifacts.py,sha256=IyVWOVqe76xjYSjleQC6kG-H92FKRzbzWf6qWzEhImE,14542
+abstractruntime/storage/artifacts.py,sha256=xIWR2Es4W4j3w3GJj1L4qrrRG4mkgiUagFucV_Cggio,15570
 abstractruntime/storage/base.py,sha256=QkNjtHRhqRHHg5FbEP9CVNjL97RTFcy4y8vNRPtVVvc,2758
 abstractruntime/storage/in_memory.py,sha256=baSlhu5ZPEFS82PvYwW89n0PbK7JmS1H07qlrPf40rI,3534
-abstractruntime/storage/json_files.py,sha256=o-xfPPupDB5ZwgaAWgQbHdpLySLuoNzdOz5Moqm9H_Q,6908
+abstractruntime/storage/json_files.py,sha256=txj3deVXlhK2fXFquUEvPfhGCc5k4pxIKVR9FXJIugU,6954
 abstractruntime/storage/ledger_chain.py,sha256=TnAWacQ9e58RAg2vKP8OU6WN8Re1PdqN72g574A2CGA,4717
 abstractruntime/storage/snapshots.py,sha256=-IUlZ40Vxcyl3hKzKk_IxYxm9zumBhkSAzrcL9WpmcU,6481
-abstractruntime-0.0.1.dist-info/METADATA,sha256=cUa0Tmy-8jmuP2VR1EJwoQxC_d8i6RnVTQUr6-KkfOA,4997
-abstractruntime-0.0.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-abstractruntime-0.0.1.dist-info/licenses/LICENSE,sha256=6rL4UIO5IdK59THf7fx0q6Hmxp5grSFi7-kWLcczseA,1083
-abstractruntime-0.0.1.dist-info/RECORD,,
+abstractruntime-0.2.0.dist-info/METADATA,sha256=eeIBiGaa-l8bYfUj1pqMNKnQGOT08xZ3d41zRDahZ1Q,4997
+abstractruntime-0.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+abstractruntime-0.2.0.dist-info/licenses/LICENSE,sha256=6rL4UIO5IdK59THf7fx0q6Hmxp5grSFi7-kWLcczseA,1083
+abstractruntime-0.2.0.dist-info/RECORD,,