AbstractRuntime 0.2.0__tar.gz → 0.4.0__tar.gz

{abstractruntime-0.2.0 → abstractruntime-0.4.0}/CHANGELOG.md

@@ -5,6 +5,114 @@ All notable changes to AbstractRuntime will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+### Added
+- **Durable prompt metadata for EVENT waits**:
+  - `WAIT_EVENT` effects may include optional `prompt`, `choices`, and `allow_free_text` fields.
+  - The runtime persists these fields onto `WaitState` so hosts (including remote/thin clients) can render a durable ask+wait UX without relying on in-process callbacks.
+- **Rendering utilities** (`abstractruntime.rendering`):
+  - `stringify_json(...)` + `JsonStringifyMode` to render JSON/JSON-ish values into strings with `none|beautify|minified` modes.
+  - `render_agent_trace_markdown(...)` to render runtime-owned `node_traces` scratchpads into a complete, review-friendly Markdown timeline (tool args + results untruncated).
+
+## [0.4.0] - 2025-01-06
+
+### Added
+
+- **Active Memory System** (`abstractruntime.memory.active_memory`): Complete MemAct agent memory module
+  - Runtime-owned `ACTIVE_MEMORY_DELTA` effect for structured Active Memory updates (used by agents via `active_memory_delta` tool)
+  - JSON-safe durable storage in `run.vars["_runtime"]["active_memory"]`
+  - Memory modules: MY PERSONA, RELATIONSHIPS, MEMORY BLUEPRINTS, CURRENT TASKS, CURRENT CONTEXT, CRITICAL INSIGHTS, REFERENCES, HISTORY
+  - Active Memory v9 format with natural-language markdown rendering (not YAML) to reduce syntax contamination
+  - All components render into system prompt by default (prevents user-role pollution on native-tool providers)
+
+- **MCP Worker** (`abstractruntime-mcp-worker`): Standalone stdio-based MCP server for AbstractRuntime tools
+  - Exposes AbstractRuntime's default toolsets as MCP tools via stdio transport
+  - Human-friendly logging to stderr with ANSI color support
+  - Security: allowlist-based command execution safety (`TOOL_WAIT` effect for dangerous commands)
+  - New optional dependency: `abstractruntime[mcp-worker]` (includes `abstractcore[tools]`)
+  - Entry point: `abstractruntime-mcp-worker` CLI script
+
+- **Evidence Capture System** (`abstractruntime.evidence.recorder`): Always-on provenance-first evidence recording
+  - Automatically records evidence for external-boundary tools: `web_search`, `fetch_url`, `execute_command`
+  - Evidence stored as artifact-backed records indexed as `kind="evidence"` in `RunState.vars["_runtime"]["memory_spans"]`
+  - Runtime helpers: `Runtime.list_evidence(run_id)` and `Runtime.load_evidence(evidence_id)`
+  - Keeps RunState JSON-safe by storing large payloads in ArtifactStore with refs
+
+- **Ledger Subscriptions**: Real-time step append events via `Runtime.subscribe_ledger()`
+  - `create_local_runtime`, `create_remote_runtime`, `create_hybrid_runtime` now wrap LedgerStore with `ObservableLedgerStore` by default
+  - Hosts can receive real-time notifications when steps are appended to ledger
+
+- **Durable Custom Events (Signals)**:
+  - `EMIT_EVENT` effect to dispatch events and resume matching `WAIT_EVENT` runs
+  - Extended `WAIT_EVENT` to accept `{scope, name}` payloads (runtime computes stable `wait_key`)
+  - `Scheduler.emit_event(...)` host API for external event delivery (session-scoped by default)
+
+- **Orchestrator-Owned Timeouts** (AbstractCore integration):
+  - Default **LLM timeout**: 7200s per `LLM_CALL` (not per-workflow), enforced by `create_*_runtime` factories
+  - Default **tool execution timeout**: 7200s per tool call (not per-workflow), enforced by ToolExecutor implementations
+
+- **Tool Executor Enhancements** (`MappingToolExecutor`):
+  - **Argument canonicalization**: Maps common parameter name variations (e.g., `file_path`/`filepath`/`path`) to canonical names
+  - **Filename aliases**: Supports `target_file`, `file_path`, `filepath`, `path` as aliases for file operations
+  - **Error output detection**: Detects structured error responses (`{"success": false, ...}`) from tools
+  - **Argument sanitization**: Cleans and validates tool call arguments
+  - **Timeout support**: Per-tool execution timeouts with configurable limits
+
+- **Memory Query Enhancements** (`MEMORY_QUERY` effect):
+  - Tag filters with **AND/OR** modes (`tags_mode=all|any`) and **multi-value** keys (`tags.person=["alice","bob"]`)
+  - Metadata filters for **authors** (`created_by`) and **locations** (`location`, `tags.location`)
+  - Span records now capture `created_by` for `conversation_span`, `active_memory_span`, `memory_note` when `actor_id` available
+  - `MEMORY_NOTE` accepts optional `location` field
+  - `MEMORY_NOTE` supports `keep_in_context=true` flag to immediately rehydrate stored note into `context.messages`
+
+- **Package Dependencies**:
+  - New optional dependency: `abstractruntime[abstractcore]` (enables `abstractruntime.integrations.abstractcore.*`)
+  - New optional dependency: `abstractruntime[mcp-worker]` (includes `abstractcore[tools]>=2.6.8`)
+
+### Changed
+
+- **LLM Client Enhancements**:
+  - Tool call parsing refactored for better robustness and error handling
+  - Streaming support with timing metrics (TTFT, generation time)
+  - Response normalization preserves JSON-safe `raw_response` for debugging
+  - Always attaches exact provider request payload under `result.metadata._provider_request` for every `LLM_CALL` step
+
+- **Runtime Core** (902 lines changed):
+  - Enhanced resume handling for paused/cancelled runs
+  - Improved subworkflow execution with async+wait support
+  - Better observable ledger integration
+
+### Fixed
+
+- **Cancellation is Terminal**: `Runtime.tick()` now treats `RunStatus.CANCELLED` as terminal and will not progress cancelled runs
+- **Control-Plane Safety**: `Runtime.tick()` stops without overwriting externally persisted pause/cancel state (used by AbstractFlow Web)
+- **Atomic Run Checkpoints**: `JsonFileRunStore.save()` writes via temp file + atomic rename to prevent partial/corrupt JSON under concurrent writes
+- **START_SUBWORKFLOW async+wait**: Support for `async=true` + `wait=true` to start child run without blocking parent tick, while keeping parent in durable SUBWORKFLOW wait
+- **ArtifactStore Run-Scoped Addressing**: Artifact IDs namespaced to run when `run_id` provided (prevents cross-run collisions, preserves purge-by-run semantics)
+- **AbstractCore Integration Imports**: `LocalAbstractCoreLLMClient` imports `create_llm` robustly in monorepo namespace-package layouts
+- **Token Limit Metadata**: `_limits.max_output_tokens` falls back to model capabilities when not configured (runtime surfaces explicit per-step output budget)
+- **Token-Cap Normalization Boundary**: Removed local `max_tokens → max_output_tokens` aliasing from AbstractRuntime's AbstractCore client (AbstractCore providers own this mapping)
+
+### Testing
+
+- **25 new/modified test files** covering:
+  - Active Memory functionality
+  - MCP worker (logging, security, stdio communication)
+  - Evidence recorder
+  - Memory query rich filters
+  - Tool executor (canonicalization, filename aliases, timeouts, error detection)
+  - LLM client tool call parsing
+  - Runtime configuration and subworkflow handling
+  - Packaging extras validation
+
+### Statistics
+
+- **33 commits** improving memory systems, MCP integration, evidence capture, and tool execution
+- **45 files changed**: 5,788 insertions, 286 deletions
+- **6,074 total lines changed** across the codebase
+- **3 new modules**: `active_memory.py`, `evidence/recorder.py`, `mcp_worker.py`
+
 ## [0.2.0] - 2025-12-17
 
 ### Added

{abstractruntime-0.2.0 → abstractruntime-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractRuntime
-Version: 0.2.0
+Version: 0.4.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
@@ -18,6 +18,10 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.10
+Provides-Extra: abstractcore
+Requires-Dist: abstractcore>=2.6.8; extra == 'abstractcore'
+Provides-Extra: mcp-worker
+Requires-Dist: abstractcore[tools]>=2.6.8; extra == 'mcp-worker'
 Description-Content-Type: text/markdown
 
 ## AbstractRuntime

abstractruntime-0.4.0/docs/architecture.md

@@ -0,0 +1,165 @@
+# AbstractRuntime — Architecture (Current)
+
+> Updated: 2026-01-07  
+> Scope: this describes **what is implemented today** in this monorepo.
+
+AbstractRuntime is the **durable execution kernel** of the AbstractFramework. It runs workflow graphs as a persisted state machine:
+- **tick** a run forward until it completes or blocks
+- persist **checkpoints** (RunState) + an append-only **ledger** (StepRecord)
+- represent blocking as durable **WaitState** (USER / EVENT / UNTIL / SUBWORKFLOW)
+- resume with an external payload (human input, event envelope, job completion)
+
+AbstractRuntime is intentionally dependency-light in the core (`abstractruntime/core/*`):
+- higher-level integrations (LLM providers, tool execution, event bus bridging) live in `abstractruntime/integrations/*`
+
+## High-level runtime loop (data flow)
+
+```
+WorkflowSpec (in-memory handlers)
+   │
+   ▼
+Runtime.tick(run_id)
+   │ loads + updates
+   ▼
+RunStore  (checkpoint RunState.vars + waiting)
+   │ append
+   ▼
+LedgerStore (StepRecords: started/completed/waiting/failed)
+   │ large payloads
+   ▼
+ArtifactStore (JSON blobs referenced from vars/ledger)
+```
+
+## Core Types (Durable, JSON-Safe)
+
+Defined in `abstractruntime/src/abstractruntime/core/models.py`:
+
+- `WorkflowSpec`
+  - `workflow_id`, `entry_node`, `nodes: Dict[node_id, handler]`
+- `RunState`
+  - `run_id`, `workflow_id`, `status`, `current_node`
+  - `vars` (**JSON-safe** dictionary, persisted by RunStore)
+  - `waiting: WaitState | None`
+  - `output` / `error`
+  - optional provenance: `actor_id`, `session_id`, `parent_run_id`
+- `StepPlan`
+  - returned by node handlers: `{effect?, next_node?, complete_output?}`
+- `Effect` + `EffectType`
+  - requests for side effects / waits (LLM_CALL, TOOL_CALLS, ASK_USER, WAIT_EVENT, …)
+- `WaitState` + `WaitReason`
+  - durable blocking representation
+- `StepRecord`
+  - append-only audit log entries (STARTED/COMPLETED/WAITING/FAILED)
+
+## Runtime Semantics (start / tick / resume)
+
+Implemented in `abstractruntime/src/abstractruntime/core/runtime.py`:
+
+- `Runtime.start(workflow, vars, actor_id?, session_id?, parent_run_id?) -> run_id`
+  - creates a `RunState` checkpoint (RUNNING, current_node=entry)
+- `Runtime.tick(workflow, run_id, max_steps=...) -> RunState`
+  - executes node handlers in a loop:
+    - handler returns `StepPlan`
+    - if `StepPlan.effect` exists → dispatch to the effect handler registry
+    - if effect outcome blocks → persist `RunState.waiting` and return WAITING
+    - if `next_node` exists → advance cursor and continue
+    - if `complete_output` exists → set run output and finish
+- `Runtime.resume(workflow, run_id, wait_key, payload, max_steps=...) -> RunState`
+  - validates the run is waiting for `wait_key`
+  - writes `payload` to the waiting node’s `result_key`
+  - clears `waiting`, transitions to RUNNING, continues via `tick`
+
+### Run Control (pause/resume/cancel)
+Run control is runtime-owned (also in `abstractruntime/core/runtime.py`):
+- pause uses a synthetic WAIT_USER (`wait_key = pause:<run_id>`) and a durable flag in `vars["_runtime"]["control"]["paused"]`
+- resume clears the pause wait and continues ticking
+- cancel marks the run CANCELLED (and can cancel subflows via host orchestration)
+
+## Persistence Layer (RunStore / LedgerStore / ArtifactStore)
+
+Storage interfaces are defined in `abstractruntime/src/abstractruntime/storage/base.py` and implemented in:
+- `abstractruntime/src/abstractruntime/storage/in_memory.py` (in-memory stores)
+- `abstractruntime/src/abstractruntime/storage/json_files.py` (file-based stores)
+  - `JsonFileRunStore`: `run_<run_id>.json`
+  - `JsonlLedgerStore`: `ledger_<run_id>.jsonl`
+- `abstractruntime/src/abstractruntime/storage/artifacts.py`
+  - `ArtifactStore` + `FileArtifactStore` + helpers (`artifact_ref`, `resolve_artifact`, …)
+- `abstractruntime/src/abstractruntime/storage/observable.py`
+  - `ObservableLedgerStore` adds subscriptions for live UI streaming
+
+**Key invariant:** `RunState.vars` must remain JSON-safe. Large payloads should be stored in `ArtifactStore` and referenced.
+
+## Effect System (Handlers)
+
+The runtime executes side effects by dispatching `EffectType` to handler callables. The core runtime ships with the effect protocol; hosts wire concrete handlers.
+
+### Memory effects (runtime-owned, durable)
+The runtime ships a small, provenance-first memory surface (no embeddings):
+- `EffectType.MEMORY_COMPACT`: archive older `context.messages` into an artifact + insert a summary handle
+- `EffectType.MEMORY_NOTE`: store a durable note with tags + sources
+  - supports `payload.scope = run|session|global` (scope is routing: it selects the index-owner run)
+- `EffectType.MEMORY_QUERY`: recall spans/notes by id/tags/time/query
+  - supports `payload.scope = run|session|global|all`
+  - supports `payload.return = rendered|meta|both` (meta enables deterministic workflows without parsing text)
+- `EffectType.MEMORY_TAG`: apply/merge tags onto existing span index entries
+- `EffectType.MEMORY_REHYDRATE`: rehydrate archived `conversation_span` artifacts into `context.messages` deterministically (deduped)
+
+Global scope uses a stable run id (default `global_memory`, override via `ABSTRACTRUNTIME_GLOBAL_MEMORY_RUN_ID`, validated as filesystem-safe).
+
+### AbstractCore Integration (LLM + Tools)
+`abstractruntime/src/abstractruntime/integrations/abstractcore/*` provides:
+- an AbstractCore-backed LLM client (`llm_client.py`)
+- tool execution boundary (`tool_executor.py`)
+  - `MappingToolExecutor` (recommended)
+  - `AbstractCoreToolExecutor` (legacy adapter path)
+  - `PassthroughToolExecutor` (host executes tools externally)
+- effect handler wiring (`effect_handlers.py`)
+- convenience factories (`factory.py`)
+  - `create_local_runtime(...)` (local execution)
+  - `create_remote_runtime(...)` (passthrough tools / host-mediated)
+
+This keeps the kernel independent of AbstractCore while enabling LLM/tool workflows when a host opts in.
+
+## Observability (Ledger + Runtime-Owned Node Traces)
+
+### Ledger (Source of Truth)
+Every node transition produces `StepRecord` entries appended to the `LedgerStore`.
+When using `ObservableLedgerStore`, hosts can subscribe to appends for real-time UI updates.
+
+### Runtime-Owned Node Traces
+In addition to the ledger, the runtime stores bounded, JSON-safe per-node traces under:
+`run.vars["_runtime"]["node_traces"]` (see `abstractruntime/src/abstractruntime/core/runtime.py:_record_node_trace` and helpers in `abstractruntime/src/abstractruntime/core/vars.py`).
+
+These traces support host UX needs (scratchpad/trace views) without inventing host-specific persistence formats.
+
+### Optional Event Bus Bridge
+`abstractruntime.integrations.abstractcore.observability` can bridge ledger events to `abstractcore.events.GlobalEventBus` when desired.
+
+## Scheduling (Time-Based Waits)
+
+Time-based waits (`WAIT_UNTIL`) are durable. To advance them, a host needs to tick due runs. AbstractRuntime provides:
+- `create_scheduled_runtime(...)` and a `Scheduler` (`abstractruntime/src/abstractruntime/scheduler/*`)
+
+Hosts can run a scheduler loop to periodically:
+- query due `WAIT_UNTIL` runs (requires a queryable run store)
+- tick them forward
+
+## Eventing (WAIT_EVENT / EMIT_EVENT)
+
+Custom eventing is implemented as:
+- listeners block on `WAIT_EVENT` (`WaitReason.EVENT`)
+- emitters request `EffectType.EMIT_EVENT`, handled by the runtime (`Runtime._handle_emit_event`) which resumes matching `WAIT_EVENT` runs via `Runtime.resume(...)`
+  - requires a `QueryableRunStore` to find waiting runs and a `workflow_registry` to load target `WorkflowSpec`s
+
+Notes:
+- The emitted event **payload is normalized to a dict** for network-safe stability. If a non-dict is provided, it is wrapped as `{ "value": <payload> }`.
+- `WAIT_EVENT` waits can optionally include UX metadata (`prompt`, `choices`, `allow_free_text`) so hosts can render interactive prompts while remaining fully durable.
+
+For **host-driven external signals**, use the scheduler API:
+- `Scheduler.emit_event(...)` (finds waiting runs and resumes them)
+
+Event envelopes (scope/session/workflow) are encoded via stable wait keys (see `abstractruntime/src/abstractruntime/core/event_keys.py`).
+
+## Deviations / near-term work
+- **Client-agnostic run history contract**: today, some hosts implement bespoke “ledger → UI events” replay logic. A runtime-owned, versioned `RunHistoryBundle` contract (planned: backlog 311) should become the shared format so any client can render consistent history and achieve stronger reproducibility.
+

{abstractruntime-0.2.0 → abstractruntime-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "AbstractRuntime"
-version = "0.2.0"
+version = "0.4.0"
 description = "AbstractRuntime: a durable graph runner designed to pair with AbstractCore."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -33,6 +33,20 @@ classifiers = [
   "Programming Language :: Python :: 3.13",
 ]
 
+[project.optional-dependencies]
+# Enables `abstractruntime.integrations.abstractcore.*` imports.
+abstractcore = [
+  "abstractcore>=2.6.8",
+]
+
+# Enables `abstractruntime-mcp-worker` with the default toolsets (includes bs4/lxml).
+mcp-worker = [
+  "abstractcore[tools]>=2.6.8",
+]
+
+[project.scripts]
+abstractruntime-mcp-worker = "abstractruntime.integrations.abstractcore.mcp_worker:main"
+
 [project.urls]
 "AbstractCore (website)" = "https://www.abstractcore.ai/"
 "AbstractCore (GitHub)" = "https://github.com/lpalbou/abstractruntime"
@@ -41,5 +55,3 @@ classifiers = [
 packages = ["src/abstractruntime"]
 
 
-
-

{abstractruntime-0.2.0 → abstractruntime-0.4.0}/src/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-0.2.0 → abstractruntime-0.4.0}/src/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-0.4.0/src/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-0.2.0 → abstractruntime-0.4.0}/src/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)
-