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

abstractruntime/__init__.py

@@ -32,9 +32,27 @@ from .core.policy import (
 from .storage.base import QueryableRunStore
 from .storage.in_memory import InMemoryLedgerStore, InMemoryRunStore
 from .storage.json_files import JsonFileRunStore, JsonlLedgerStore
+from .storage.sqlite import (
+    SqliteCommandCursorStore,
+    SqliteCommandStore,
+    SqliteDatabase,
+    SqliteLedgerStore,
+    SqliteRunStore,
+)
+from .storage.commands import (
+    CommandAppendResult,
+    CommandCursorStore,
+    CommandRecord,
+    CommandStore,
+    InMemoryCommandCursorStore,
+    InMemoryCommandStore,
+    JsonFileCommandCursorStore,
+    JsonlCommandStore,
+)
 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.offloading import OffloadingLedgerStore, OffloadingRunStore, offload_large_values
 from .storage.artifacts import (
     Artifact,
     ArtifactMetadata,
@@ -56,6 +74,28 @@ from .scheduler import (
     create_scheduled_runtime,
 )
 from .memory import ActiveContextPolicy, TimeRange
+from .workflow_bundle import (
+    WORKFLOW_BUNDLE_FORMAT_VERSION_V1,
+    InstalledWorkflowBundle,
+    WorkflowBundle,
+    WorkflowBundleEntrypoint,
+    WorkflowBundleError,
+    WorkflowBundleManifest,
+    WorkflowBundleRegistry,
+    WorkflowBundleRegistryError,
+    WorkflowEntrypointRef,
+    default_workflow_bundles_dir,
+    open_workflow_bundle,
+    sanitize_bundle_id,
+    sanitize_bundle_version,
+    workflow_bundle_manifest_from_dict,
+    workflow_bundle_manifest_to_dict,
+)
+from .history_bundle import (
+    RUN_HISTORY_BUNDLE_VERSION_V1,
+    export_run_history_bundle,
+    persist_workflow_snapshot,
+)
 
 __all__ = [
     # Core models
@@ -81,10 +121,26 @@ __all__ = [
     "InMemoryLedgerStore",
     "JsonFileRunStore",
     "JsonlLedgerStore",
+    "SqliteDatabase",
+    "SqliteRunStore",
+    "SqliteLedgerStore",
+    "CommandRecord",
+    "CommandAppendResult",
+    "CommandStore",
+    "CommandCursorStore",
+    "InMemoryCommandStore",
+    "JsonlCommandStore",
+    "InMemoryCommandCursorStore",
+    "JsonFileCommandCursorStore",
+    "SqliteCommandStore",
+    "SqliteCommandCursorStore",
     "HashChainedLedgerStore",
     "verify_ledger_chain",
     "ObservableLedgerStore",
     "ObservableLedgerStoreProtocol",
+    "OffloadingRunStore",
+    "OffloadingLedgerStore",
+    "offload_large_values",
     "Snapshot",
     "SnapshotStore",
     "InMemorySnapshotStore",
@@ -111,5 +167,24 @@ __all__ = [
     # Memory
     "ActiveContextPolicy",
     "TimeRange",
+    # WorkflowBundles (portable distribution unit)
+    "WORKFLOW_BUNDLE_FORMAT_VERSION_V1",
+    "WorkflowBundleError",
+    "WorkflowBundleEntrypoint",
+    "WorkflowBundleManifest",
+    "WorkflowBundle",
+    "InstalledWorkflowBundle",
+    "WorkflowBundleRegistry",
+    "WorkflowBundleRegistryError",
+    "WorkflowEntrypointRef",
+    "default_workflow_bundles_dir",
+    "sanitize_bundle_id",
+    "sanitize_bundle_version",
+    "workflow_bundle_manifest_from_dict",
+    "workflow_bundle_manifest_to_dict",
+    "open_workflow_bundle",
+    # Run history bundle (portable replay)
+    "RUN_HISTORY_BUNDLE_VERSION_V1",
+    "export_run_history_bundle",
+    "persist_workflow_snapshot",
 ]
-

abstractruntime/core/config.py

@@ -12,6 +12,13 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import Any, Dict, Optional
 
+from .vars import DEFAULT_MAX_TOKENS
+
+# Truncation policy: keep mechanisms, but default to disabled.
+# A positive value enables a conservative auto-cap for `max_input_tokens` when callers do not
+# explicitly set an input budget. `-1` disables this cap (no automatic truncation).
+DEFAULT_RECOMMENDED_MAX_INPUT_TOKENS = -1
+
 
 @dataclass(frozen=True)
 class RuntimeConfig:
@@ -47,6 +54,7 @@ class RuntimeConfig:
     # Token/context window management
     max_tokens: Optional[int] = None  # None = query from model capabilities
     max_output_tokens: Optional[int] = None  # None = use provider default
+    max_input_tokens: Optional[int] = None  # None = auto-calculate from max_tokens/max_output_tokens
     warn_tokens_pct: int = 80
 
     # History management
@@ -66,19 +74,77 @@ 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_tokens = self.max_tokens
+        if max_tokens is None:
+            max_tokens = self.model_capabilities.get("max_tokens")
+        if max_tokens is None:
+            max_tokens = DEFAULT_MAX_TOKENS
+
         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")
+        # If capabilities are unavailable and max_output_tokens is unset, keep it as None
+        # (meaning: provider default). Do not force a conservative output cap here.
+
+        # ADR-0008 alignment:
+        # - max_tokens: total context window size
+        # - max_output_tokens: output budget
+        # - max_input_tokens: explicit or derived input budget (may be smaller than max_tokens-max_output_tokens)
+        #
+        # Constraint: max_input_tokens + max_output_tokens + delta <= max_tokens
+        delta = 256
+        effective_max_input_tokens = self.max_input_tokens
+
+        try:
+            max_tokens_int = int(max_tokens) if max_tokens is not None else None
+        except Exception:
+            max_tokens_int = None
+        try:
+            max_output_int = int(max_output_tokens) if max_output_tokens is not None else None
+        except Exception:
+            max_output_int = None
+
+        if (
+            max_tokens_int is not None
+            and max_tokens_int > 0
+            and max_output_int is not None
+            and max_output_int >= 0
+            and effective_max_input_tokens is not None
+        ):
+            # If callers explicitly set max_input_tokens, clamp it to the context-window constraint.
+            max_allowed_in = max(0, int(max_tokens_int) - int(max_output_int) - int(delta))
+            try:
+                effective_max_input_tokens = int(effective_max_input_tokens)
+            except Exception:
+                effective_max_input_tokens = max_allowed_in
+            if effective_max_input_tokens < 0:
+                effective_max_input_tokens = 0
+            if effective_max_input_tokens > max_allowed_in:
+                effective_max_input_tokens = max_allowed_in
+
+        # Optional conservative auto-cap (disabled by default with -1).
+        if (
+            self.max_input_tokens is None
+            and effective_max_input_tokens is not None
+            and isinstance(DEFAULT_RECOMMENDED_MAX_INPUT_TOKENS, int)
+            and DEFAULT_RECOMMENDED_MAX_INPUT_TOKENS > 0
+        ):
+            try:
+                effective_max_input_tokens = min(int(effective_max_input_tokens), int(DEFAULT_RECOMMENDED_MAX_INPUT_TOKENS))
+            except Exception:
+                pass
+
         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_tokens": max_tokens,
             "max_output_tokens": max_output_tokens,
+            "max_input_tokens": effective_max_input_tokens,
             "estimated_tokens_used": 0,
 
             # History management
@@ -106,6 +172,7 @@ class RuntimeConfig:
             warn_iterations_pct=self.warn_iterations_pct,
             max_tokens=self.max_tokens,
             max_output_tokens=self.max_output_tokens,
+            max_input_tokens=self.max_input_tokens,
             warn_tokens_pct=self.warn_tokens_pct,
             max_history_messages=self.max_history_messages,
             provider=self.provider,

abstractruntime/core/models.py

@@ -60,6 +60,11 @@ class EffectType(str, Enum):
     MEMORY_NOTE = "memory_note"
     MEMORY_REHYDRATE = "memory_rehydrate"
 
+    # Semantic / KG memory (host-provided handlers)
+    MEMORY_KG_ASSERT = "memory_kg_assert"
+    MEMORY_KG_QUERY = "memory_kg_query"
+    MEMORY_KG_RESOLVE = "memory_kg_resolve"
+
     # Debug / inspection (schema-only tools -> runtime effects)
     VARS_QUERY = "vars_query"
 

abstractruntime/core/policy.py

@@ -15,7 +15,76 @@ import json
 from dataclasses import dataclass
 from typing import Any, Dict, Optional, Protocol
 
-from .models import Effect, RunState
+from .models import Effect, EffectType, RunState
+
+
+def _loads_dict_like(value: Any) -> Optional[Dict[str, Any]]:
+    if value is None:
+        return None
+    if isinstance(value, dict):
+        return dict(value)
+    if not isinstance(value, str):
+        return None
+    text = value.strip()
+    if not text:
+        return None
+    try:
+        parsed = json.loads(text)
+    except Exception:
+        return None
+    return parsed if isinstance(parsed, dict) else None
+
+
+def _normalize_tool_call_for_idempotency(value: Any) -> Any:
+    if not isinstance(value, dict):
+        return value
+
+    out = dict(value)
+    # Provider/model-emitted IDs are not semantic; remove them from the idempotency hash.
+    for k in ("call_id", "id", "runtime_call_id", "model_call_id", "idempotency_key"):
+        out.pop(k, None)
+
+    name = out.get("name")
+    if isinstance(name, str):
+        out["name"] = name.strip()
+
+    args = out.get("arguments")
+    if isinstance(args, str):
+        parsed = _loads_dict_like(args)
+        out["arguments"] = parsed if isinstance(parsed, dict) else {}
+    elif not isinstance(args, dict):
+        out["arguments"] = {}
+
+    func = out.get("function")
+    if isinstance(func, dict):
+        # Some callers pass OpenAI-style shapes; preserve semantics, but strip IDs.
+        out["function"] = _normalize_tool_call_for_idempotency(func)
+
+    return out
+
+
+def _normalize_effect_payload_for_idempotency(effect: Effect) -> Dict[str, Any]:
+    if not isinstance(effect.payload, dict):
+        return {}
+    payload = dict(effect.payload)
+
+    if effect.type != EffectType.TOOL_CALLS:
+        return payload
+
+    tool_calls = payload.get("tool_calls")
+    if isinstance(tool_calls, list):
+        payload["tool_calls"] = [_normalize_tool_call_for_idempotency(tc) for tc in tool_calls]
+
+    allowed_tools = payload.get("allowed_tools")
+    if isinstance(allowed_tools, list):
+        uniq = {
+            str(t).strip()
+            for t in allowed_tools
+            if isinstance(t, str) and t.strip()
+        }
+        payload["allowed_tools"] = sorted(uniq)
+
+    return payload
 
 
 class EffectPolicy(Protocol):
@@ -110,11 +179,12 @@ class DefaultEffectPolicy:
         This ensures the same effect at the same point in the same run
         gets the same key, enabling deduplication on restart.
         """
+        normalized_payload = _normalize_effect_payload_for_idempotency(effect)
         key_data = {
             "run_id": run.run_id,
             "node_id": node_id,
             "effect_type": effect.type.value,
-            "effect_payload": effect.payload,
+            "effect_payload": normalized_payload,
         }
         key_json = json.dumps(key_data, sort_keys=True, separators=(",", ":"))
         return hashlib.sha256(key_json.encode()).hexdigest()[:32]
@@ -156,11 +226,12 @@ def compute_idempotency_key(
     
     Useful when you need to compute a key without a full policy.
     """
+    normalized_payload = _normalize_effect_payload_for_idempotency(effect)
     key_data = {
         "run_id": run_id,
         "node_id": node_id,
         "effect_type": effect.type.value,
-        "effect_payload": effect.payload,
+        "effect_payload": normalized_payload,
     }
     key_json = json.dumps(key_data, sort_keys=True, separators=(",", ":"))
     return hashlib.sha256(key_json.encode()).hexdigest()[:32]