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

abstractruntime/integrations/abstractcore/embeddings_client.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, List, Sequence
+
+
+@dataclass(frozen=True)
+class EmbeddingsResult:
+    provider: str
+    model: str
+    embeddings: List[List[float]]
+    dimension: int
+
+
+class AbstractCoreEmbeddingsClient:
+    """Thin adapter around AbstractCore's EmbeddingManager.
+
+    Notes:
+    - AbstractCore is an optional dependency of AbstractRuntime; importing this module is an explicit opt-in.
+    - The embedding provider/model should be treated as a runtime-instance property (singleton) so all vectors
+      live in the same embedding space.
+    """
+
+    def __init__(
+        self,
+        *,
+        provider: str,
+        model: str,
+        manager_kwargs: dict[str, Any] | None = None,
+    ) -> None:
+        # Monorepo import hygiene:
+        # When running from the repo root, `abstractcore/` (project folder) can be imported as a
+        # namespace package and shadow the real python package at `abstractcore/abstractcore/`.
+        # In that situation, `abstractcore.embeddings.manager` may not resolve even though the
+        # implementation exists. Prefer the public import, but fall back to the concrete path.
+        try:
+            from abstractcore.embeddings.manager import EmbeddingManager  # type: ignore
+        except Exception:  # pragma: no cover
+            from abstractcore.abstractcore.embeddings.manager import EmbeddingManager  # type: ignore
+
+        prov = str(provider or "").strip().lower()
+        mod = str(model or "").strip()
+        if not prov:
+            raise ValueError("provider is required for embeddings")
+        if not mod:
+            raise ValueError("model is required for embeddings")
+
+        self._provider = prov
+        self._model = mod
+        self._mgr = EmbeddingManager(provider=prov, model=mod, **(manager_kwargs or {}))
+
+    @property
+    def provider(self) -> str:
+        return self._provider
+
+    @property
+    def model(self) -> str:
+        return self._model
+
+    def embed_texts(self, texts: Sequence[str]) -> EmbeddingsResult:
+        items = [str(t or "") for t in texts]
+        embeddings = self._mgr.embed_batch(items)
+        dim = int(self._mgr.get_dimension() or 0)
+        return EmbeddingsResult(
+            provider=self._provider,
+            model=self._model,
+            embeddings=embeddings,
+            dimension=dim,
+        )

abstractruntime/integrations/abstractcore/factory.py

@@ -20,10 +20,14 @@ from ...core.runtime import Runtime
 from ...storage.in_memory import InMemoryLedgerStore, InMemoryRunStore
 from ...storage.json_files import JsonFileRunStore, JsonlLedgerStore
 from ...storage.base import LedgerStore, RunStore
+from ...storage.artifacts import FileArtifactStore, InMemoryArtifactStore, ArtifactStore
+from ...storage.observable import ObservableLedgerStore, ObservableLedgerStoreProtocol
 
 from .effect_handlers import build_effect_handlers
-from .llm_client import LocalAbstractCoreLLMClient, RemoteAbstractCoreLLMClient
+from .llm_client import MultiLocalAbstractCoreLLMClient, RemoteAbstractCoreLLMClient
 from .tool_executor import AbstractCoreToolExecutor, PassthroughToolExecutor, ToolExecutor
+from .summarizer import AbstractCoreChatSummarizer
+from .constants import DEFAULT_LLM_TIMEOUT_S, DEFAULT_TOOL_TIMEOUT_S
 
 
 def _default_in_memory_stores() -> tuple[RunStore, LedgerStore]:
@@ -35,6 +39,18 @@ def _default_file_stores(*, base_dir: str | Path) -> tuple[RunStore, LedgerStore
     base.mkdir(parents=True, exist_ok=True)
     return JsonFileRunStore(base), JsonlLedgerStore(base)
 
+def _ensure_observable_ledger(ledger_store: LedgerStore) -> LedgerStore:
+    """Wrap a LedgerStore so Runtime.subscribe_ledger() is available (in-process).
+
+    Why:
+    - Real-time UI/UX often needs "step started" signals *before* a blocking effect
+      (LLM/tool HTTP) returns.
+    - The runtime kernel stays transport-agnostic; this is an optional decorator.
+    """
+    if isinstance(ledger_store, ObservableLedgerStoreProtocol):
+        return ledger_store
+    return ObservableLedgerStore(ledger_store)
+
 
 def create_local_runtime(
     *,
@@ -44,9 +60,12 @@ def create_local_runtime(
     run_store: Optional[RunStore] = None,
     ledger_store: Optional[LedgerStore] = None,
     tool_executor: Optional[ToolExecutor] = None,
+    tool_timeout_s: Optional[float] = None,
     context: Optional[Any] = None,
     effect_policy: Optional[Any] = None,
     config: Optional[RuntimeConfig] = None,
+    artifact_store: Optional[ArtifactStore] = None,
+    extra_effect_handlers: Optional[Dict[Any, Any]] = None,
 ) -> Runtime:
     """Create a runtime with local LLM execution via AbstractCore.
 
@@ -69,27 +88,82 @@ def create_local_runtime(
     """
     if run_store is None or ledger_store is None:
         run_store, ledger_store = _default_in_memory_stores()
+    ledger_store = _ensure_observable_ledger(ledger_store)
+
+    if artifact_store is None:
+        artifact_store = InMemoryArtifactStore()
+
+    # Runtime authority: choose default timeouts for orchestrated workflows.
+    #
+    # Note: local providers may ignore timeouts (e.g. MLX) and should warn explicitly when doing so.
+    # We still pass a timeout through the runtime for future-proofing and consistent orchestration
+    # policy across providers.
+    default_llm_timeout_s: float = DEFAULT_LLM_TIMEOUT_S
+    default_tool_timeout_s: float = DEFAULT_TOOL_TIMEOUT_S
+    try:
+        from abstractcore.config.manager import get_config_manager  # type: ignore
+
+        cfg_mgr = get_config_manager()
+        default_llm_timeout_s = float(cfg_mgr.get_default_timeout())
+        default_tool_timeout_s = float(cfg_mgr.get_tool_timeout())
+    except Exception:
+        pass
+
+    resolved_tool_timeout_s = float(tool_timeout_s) if tool_timeout_s is not None else float(default_tool_timeout_s)
+
+    effective_llm_kwargs: Dict[str, Any] = dict(llm_kwargs or {})
+    effective_llm_kwargs.setdefault("timeout", float(default_llm_timeout_s))
 
-    llm_client = LocalAbstractCoreLLMClient(provider=provider, model=model, llm_kwargs=llm_kwargs)
-    tools = tool_executor or AbstractCoreToolExecutor()
-    handlers = build_effect_handlers(llm=llm_client, tools=tools)
+    llm_client = MultiLocalAbstractCoreLLMClient(provider=provider, model=model, llm_kwargs=effective_llm_kwargs)
+    tools = tool_executor or AbstractCoreToolExecutor(timeout_s=resolved_tool_timeout_s)
+    # Orchestrator policy: enforce tool execution timeout at the runtime layer.
+    try:
+        setter = getattr(tools, "set_timeout_s", None)
+        if callable(setter):
+            setter(resolved_tool_timeout_s)
+    except Exception:
+        pass
+    handlers = build_effect_handlers(llm=llm_client, tools=tools, artifact_store=artifact_store, run_store=run_store)
+    if extra_effect_handlers:
+        handlers.update(dict(extra_effect_handlers))
 
     # Query model capabilities and merge into config
     capabilities = llm_client.get_model_capabilities()
     if config is None:
-        config = RuntimeConfig(model_capabilities=capabilities)
+        config = RuntimeConfig(
+            provider=str(provider).strip() if isinstance(provider, str) and str(provider).strip() else None,
+            model=str(model).strip() if isinstance(model, str) and str(model).strip() else None,
+            model_capabilities=capabilities,
+        )
     else:
         # Merge capabilities into provided config
         config = config.with_capabilities(capabilities)
 
-    return Runtime(
+    # Create chat summarizer with token limits from config
+    # This enables adaptive chunking during MEMORY_COMPACT
+    summarizer = AbstractCoreChatSummarizer(
+        llm=llm_client._llm,  # Use the underlying AbstractCore LLM instance
+        max_tokens=config.max_tokens if config.max_tokens is not None else -1,
+        max_output_tokens=config.max_output_tokens if config.max_output_tokens is not None else -1,
+    )
+
+    rt = Runtime(
         run_store=run_store,
         ledger_store=ledger_store,
         effect_handlers=handlers,
         context=context,
         effect_policy=effect_policy,
         config=config,
+        artifact_store=artifact_store,
+        chat_summarizer=summarizer,
     )
+    # Best-effort: expose the underlying LLM client for host-side control planes (e.g. gateway cache ops).
+    # This stays an internal attribute to avoid hard API commitments on Runtime itself.
+    try:  # pragma: no cover
+        setattr(rt, "_abstractcore_llm_client", llm_client)
+    except Exception:
+        pass
+    return rt
 
 
 def create_remote_runtime(
@@ -97,25 +171,45 @@ def create_remote_runtime(
     server_base_url: str,
     model: str,
     headers: Optional[Dict[str, str]] = None,
-    timeout_s: float = 60.0,
+    timeout_s: Optional[float] = None,
     run_store: Optional[RunStore] = None,
     ledger_store: Optional[LedgerStore] = None,
     tool_executor: Optional[ToolExecutor] = None,
     context: Optional[Any] = None,
+    artifact_store: Optional[ArtifactStore] = None,
 ) -> Runtime:
     if run_store is None or ledger_store is None:
         run_store, ledger_store = _default_in_memory_stores()
+    ledger_store = _ensure_observable_ledger(ledger_store)
+
+    if artifact_store is None:
+        artifact_store = InMemoryArtifactStore()
+
+    resolved_timeout_s = float(timeout_s) if timeout_s is not None else float(DEFAULT_LLM_TIMEOUT_S)
+    if timeout_s is None:
+        try:
+            from abstractcore.config.manager import get_config_manager  # type: ignore
+
+            resolved_timeout_s = float(get_config_manager().get_default_timeout())
+        except Exception:
+            pass
 
     llm_client = RemoteAbstractCoreLLMClient(
         server_base_url=server_base_url,
         model=model,
         headers=headers,
-        timeout_s=timeout_s,
+        timeout_s=resolved_timeout_s,
     )
     tools = tool_executor or PassthroughToolExecutor()
-    handlers = build_effect_handlers(llm=llm_client, tools=tools)
+    handlers = build_effect_handlers(llm=llm_client, tools=tools, artifact_store=artifact_store, run_store=run_store)
 
-    return Runtime(run_store=run_store, ledger_store=ledger_store, effect_handlers=handlers, context=context)
+    return Runtime(
+        run_store=run_store,
+        ledger_store=ledger_store,
+        effect_handlers=handlers,
+        context=context,
+        artifact_store=artifact_store,
+    )
 
 
 def create_hybrid_runtime(
@@ -123,26 +217,59 @@ def create_hybrid_runtime(
     server_base_url: str,
     model: str,
     headers: Optional[Dict[str, str]] = None,
-    timeout_s: float = 60.0,
+    timeout_s: Optional[float] = None,
+    tool_timeout_s: Optional[float] = None,
     run_store: Optional[RunStore] = None,
     ledger_store: Optional[LedgerStore] = None,
     context: Optional[Any] = None,
+    artifact_store: Optional[ArtifactStore] = None,
 ) -> Runtime:
     """Remote LLM via AbstractCore server, local tool execution."""
 
     if run_store is None or ledger_store is None:
         run_store, ledger_store = _default_in_memory_stores()
+    ledger_store = _ensure_observable_ledger(ledger_store)
+
+    if artifact_store is None:
+        artifact_store = InMemoryArtifactStore()
+
+    default_llm_timeout_s = float(DEFAULT_LLM_TIMEOUT_S)
+    default_tool_timeout_s = float(DEFAULT_TOOL_TIMEOUT_S)
+    if timeout_s is None or tool_timeout_s is None:
+        try:
+            from abstractcore.config.manager import get_config_manager  # type: ignore
+
+            cfg_mgr = get_config_manager()
+            default_llm_timeout_s = float(cfg_mgr.get_default_timeout())
+            default_tool_timeout_s = float(cfg_mgr.get_tool_timeout())
+        except Exception:
+            pass
+
+    resolved_timeout_s = float(timeout_s) if timeout_s is not None else float(default_llm_timeout_s)
+    resolved_tool_timeout_s = float(tool_timeout_s) if tool_timeout_s is not None else float(default_tool_timeout_s)
 
     llm_client = RemoteAbstractCoreLLMClient(
         server_base_url=server_base_url,
         model=model,
         headers=headers,
-        timeout_s=timeout_s,
+        timeout_s=resolved_timeout_s,
     )
-    tools = AbstractCoreToolExecutor()
-    handlers = build_effect_handlers(llm=llm_client, tools=tools)
+    tools = AbstractCoreToolExecutor(timeout_s=resolved_tool_timeout_s)
+    try:
+        setter = getattr(tools, "set_timeout_s", None)
+        if callable(setter):
+            setter(resolved_tool_timeout_s)
+    except Exception:
+        pass
+    handlers = build_effect_handlers(llm=llm_client, tools=tools, artifact_store=artifact_store, run_store=run_store)
 
-    return Runtime(run_store=run_store, ledger_store=ledger_store, effect_handlers=handlers, context=context)
+    return Runtime(
+        run_store=run_store,
+        ledger_store=ledger_store,
+        effect_handlers=handlers,
+        context=context,
+        artifact_store=artifact_store,
+    )
 
 
 def create_local_file_runtime(
@@ -153,8 +280,10 @@ def create_local_file_runtime(
     llm_kwargs: Optional[Dict[str, Any]] = None,
     context: Optional[Any] = None,
     config: Optional[RuntimeConfig] = None,
+    tool_timeout_s: Optional[float] = None,
 ) -> Runtime:
     run_store, ledger_store = _default_file_stores(base_dir=base_dir)
+    artifact_store = FileArtifactStore(base_dir)
     return create_local_runtime(
         provider=provider,
         model=model,
@@ -163,6 +292,8 @@ def create_local_file_runtime(
         ledger_store=ledger_store,
         context=context,
         config=config,
+        artifact_store=artifact_store,
+        tool_timeout_s=tool_timeout_s,
     )
 
 
@@ -172,10 +303,11 @@ def create_remote_file_runtime(
     server_base_url: str,
     model: str,
     headers: Optional[Dict[str, str]] = None,
-    timeout_s: float = 60.0,
+    timeout_s: Optional[float] = None,
     context: Optional[Any] = None,
 ) -> Runtime:
     run_store, ledger_store = _default_file_stores(base_dir=base_dir)
+    artifact_store = FileArtifactStore(base_dir)
     return create_remote_runtime(
         server_base_url=server_base_url,
         model=model,
@@ -184,4 +316,5 @@ def create_remote_file_runtime(
         run_store=run_store,
         ledger_store=ledger_store,
         context=context,
+        artifact_store=artifact_store,
     )