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

abstractruntime/__init__.py

@@ -33,6 +33,7 @@ from .storage.base import QueryableRunStore
 from .storage.in_memory import InMemoryLedgerStore, InMemoryRunStore
 from .storage.json_files import JsonFileRunStore, JsonlLedgerStore
 from .storage.ledger_chain import HashChainedLedgerStore, verify_ledger_chain
+from .storage.observable import ObservableLedgerStore, ObservableLedgerStoreProtocol
 from .storage.snapshots import Snapshot, SnapshotStore, InMemorySnapshotStore, JsonSnapshotStore
 from .storage.artifacts import (
     Artifact,
@@ -54,6 +55,7 @@ from .scheduler import (
     ScheduledRuntime,
     create_scheduled_runtime,
 )
+from .memory import ActiveContextPolicy, TimeRange
 
 __all__ = [
     # Core models
@@ -81,6 +83,8 @@ __all__ = [
     "JsonlLedgerStore",
     "HashChainedLedgerStore",
     "verify_ledger_chain",
+    "ObservableLedgerStore",
+    "ObservableLedgerStoreProtocol",
     "Snapshot",
     "SnapshotStore",
     "InMemorySnapshotStore",
@@ -104,7 +108,8 @@ __all__ = [
     "RetryPolicy",
     "NoRetryPolicy",
     "compute_idempotency_key",
+    # Memory
+    "ActiveContextPolicy",
+    "TimeRange",
 ]
 
-
-

abstractruntime/core/config.py

@@ -29,6 +29,8 @@ class RuntimeConfig:
         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)
+        provider: Default provider id for this Runtime (best-effort; used for run metadata)
+        model: Default model id for this Runtime (best-effort; used for run metadata)
         model_capabilities: Dict of model capabilities from LLM provider
 
     Example:
@@ -50,6 +52,10 @@ class RuntimeConfig:
     # History management
     max_history_messages: int = -1  # -1 = unlimited (send all messages)
 
+    # Default routing metadata (optional; depends on how the Runtime was constructed)
+    provider: Optional[str] = None
+    model: Optional[str] = None
+
     # Model capabilities (populated from LLM client)
     model_capabilities: Dict[str, Any] = field(default_factory=dict)
 
@@ -60,6 +66,11 @@ class RuntimeConfig:
             Dict with canonical limit values for storage in RunState.vars["_limits"].
             Uses model_capabilities as fallback for max_tokens if not explicitly set.
         """
+        max_output_tokens = self.max_output_tokens
+        if max_output_tokens is None:
+            # Best-effort: persist the provider/model default so agent logic can reason about
+            # output-size constraints (e.g., chunk large tool arguments like file contents).
+            max_output_tokens = self.model_capabilities.get("max_output_tokens")
         return {
             # Iteration control
             "max_iterations": self.max_iterations,
@@ -67,7 +78,7 @@ class RuntimeConfig:
 
             # Token management
             "max_tokens": self.max_tokens or self.model_capabilities.get("max_tokens", 32768),
-            "max_output_tokens": self.max_output_tokens,
+            "max_output_tokens": max_output_tokens,
             "estimated_tokens_used": 0,
 
             # History management
@@ -97,5 +108,7 @@ class RuntimeConfig:
             max_output_tokens=self.max_output_tokens,
             warn_tokens_pct=self.warn_tokens_pct,
             max_history_messages=self.max_history_messages,
+            provider=self.provider,
+            model=self.model,
             model_capabilities=capabilities,
         )

abstractruntime/core/event_keys.py

@@ -0,0 +1,62 @@
+"""abstractruntime.core.event_keys
+
+Durable event key conventions.
+
+Why this exists:
+- `WAIT_EVENT` needs a stable `wait_key` that external hosts can compute.
+- Visual editors and other hosts (AbstractCode, servers) must agree on the same
+  key format without importing UI-specific code.
+
+We keep this module dependency-light (stdlib only).
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+
+def build_event_wait_key(
+    *,
+    scope: str,
+    name: str,
+    session_id: Optional[str] = None,
+    workflow_id: Optional[str] = None,
+    run_id: Optional[str] = None,
+) -> str:
+    """Build a durable wait_key for event-driven workflows.
+
+    Format:
+        evt:{scope}:{scope_id}:{name}
+
+    Scopes:
+    - session: `scope_id` is the workflow instance/session identifier (recommended default)
+    - workflow: `scope_id` is the workflow_id
+    - run: `scope_id` is the run_id
+    - global: `scope_id` is the literal string "global"
+    """
+    scope_norm = str(scope or "session").strip().lower()
+    name_norm = str(name or "").strip()
+    if not name_norm:
+        raise ValueError("event name is required")
+
+    scope_id: Optional[str]
+    if scope_norm == "session":
+        scope_id = str(session_id or "").strip() if session_id is not None else ""
+    elif scope_norm == "workflow":
+        scope_id = str(workflow_id or "").strip() if workflow_id is not None else ""
+    elif scope_norm == "run":
+        scope_id = str(run_id or "").strip() if run_id is not None else ""
+    elif scope_norm == "global":
+        scope_id = "global"
+    else:
+        raise ValueError(f"unknown event scope: {scope!r}")
+
+    if not scope_id:
+        raise ValueError(f"missing scope id for scope={scope_norm!r}")
+
+    return f"evt:{scope_norm}:{scope_id}:{name_norm}"
+
+
+
+
+

abstractruntime/core/models.py

@@ -46,10 +46,22 @@ class EffectType(str, Enum):
     WAIT_EVENT = "wait_event"
     WAIT_UNTIL = "wait_until"
     ASK_USER = "ask_user"
+    ANSWER_USER = "answer_user"
+
+    # Eventing
+    EMIT_EVENT = "emit_event"
 
     # Integrations (implemented via pluggable handlers)
     LLM_CALL = "llm_call"
     TOOL_CALLS = "tool_calls"
+    MEMORY_QUERY = "memory_query"
+    MEMORY_TAG = "memory_tag"
+    MEMORY_COMPACT = "memory_compact"
+    MEMORY_NOTE = "memory_note"
+    MEMORY_REHYDRATE = "memory_rehydrate"
+
+    # Debug / inspection (schema-only tools -> runtime effects)
+    VARS_QUERY = "vars_query"
 
     # Composition
     START_SUBWORKFLOW = "start_subworkflow"
@@ -279,4 +291,3 @@ class LimitWarning:
     def __post_init__(self) -> None:
         if self.maximum > 0:
             self.pct = round(self.current / self.maximum * 100, 1)
-