AbstractRuntime 0.4.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

@@ -60,11 +60,12 @@ def create_local_runtime(
     run_store: Optional[RunStore] = None,
     ledger_store: Optional[LedgerStore] = None,
     tool_executor: Optional[ToolExecutor] = None,
-    tool_timeout_s: float = DEFAULT_TOOL_TIMEOUT_S,
+    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.
 
@@ -92,23 +93,39 @@ def create_local_runtime(
     if artifact_store is None:
         artifact_store = InMemoryArtifactStore()
 
-    # Runtime authority: default LLM timeout for orchestrated workflows.
+    # Runtime authority: choose default timeouts for orchestrated workflows.
     #
-    # We set this here (in the runtime layer) rather than relying on AbstractCore global config,
-    # so workflow behavior is consistent and controlled by the orchestrator.
+    # 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", DEFAULT_LLM_TIMEOUT_S)
+    effective_llm_kwargs.setdefault("timeout", float(default_llm_timeout_s))
 
     llm_client = MultiLocalAbstractCoreLLMClient(provider=provider, model=model, llm_kwargs=effective_llm_kwargs)
-    tools = tool_executor or AbstractCoreToolExecutor(timeout_s=tool_timeout_s)
+    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(tool_timeout_s)
+            setter(resolved_tool_timeout_s)
     except Exception:
         pass
-    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)
+    if extra_effect_handlers:
+        handlers.update(dict(extra_effect_handlers))
 
     # Query model capabilities and merge into config
     capabilities = llm_client.get_model_capabilities()
@@ -130,7 +147,7 @@ def create_local_runtime(
         max_output_tokens=config.max_output_tokens if config.max_output_tokens is not None else -1,
     )
 
-    return Runtime(
+    rt = Runtime(
         run_store=run_store,
         ledger_store=ledger_store,
         effect_handlers=handlers,
@@ -140,6 +157,13 @@ def create_local_runtime(
         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(
@@ -147,7 +171,7 @@ def create_remote_runtime(
     server_base_url: str,
     model: str,
     headers: Optional[Dict[str, str]] = None,
-    timeout_s: float = DEFAULT_LLM_TIMEOUT_S,
+    timeout_s: Optional[float] = None,
     run_store: Optional[RunStore] = None,
     ledger_store: Optional[LedgerStore] = None,
     tool_executor: Optional[ToolExecutor] = None,
@@ -161,14 +185,23 @@ def create_remote_runtime(
     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,
@@ -184,8 +217,8 @@ def create_hybrid_runtime(
     server_base_url: str,
     model: str,
     headers: Optional[Dict[str, str]] = None,
-    timeout_s: float = DEFAULT_LLM_TIMEOUT_S,
-    tool_timeout_s: float = DEFAULT_TOOL_TIMEOUT_S,
+    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,
@@ -200,20 +233,35 @@ def create_hybrid_runtime(
     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(timeout_s=tool_timeout_s)
+    tools = AbstractCoreToolExecutor(timeout_s=resolved_tool_timeout_s)
     try:
         setter = getattr(tools, "set_timeout_s", None)
         if callable(setter):
-            setter(tool_timeout_s)
+            setter(resolved_tool_timeout_s)
     except Exception:
         pass
-    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,
@@ -232,7 +280,7 @@ def create_local_file_runtime(
     llm_kwargs: Optional[Dict[str, Any]] = None,
     context: Optional[Any] = None,
     config: Optional[RuntimeConfig] = None,
-    tool_timeout_s: float = DEFAULT_TOOL_TIMEOUT_S,
+    tool_timeout_s: Optional[float] = None,
 ) -> Runtime:
     run_store, ledger_store = _default_file_stores(base_dir=base_dir)
     artifact_store = FileArtifactStore(base_dir)
@@ -255,7 +303,7 @@ def create_remote_file_runtime(
     server_base_url: str,
     model: str,
     headers: Optional[Dict[str, str]] = None,
-    timeout_s: float = DEFAULT_LLM_TIMEOUT_S,
+    timeout_s: Optional[float] = None,
     context: Optional[Any] = None,
 ) -> Runtime:
     run_store, ledger_store = _default_file_stores(base_dir=base_dir)