"""ExecutorRegistry: which runtime answers which job kind, and the default set."""
from __future__ import annotations
from typing import Any, Mapping, Optional
from .base import ExecutorProtocol
from .media import FfmpegTranscodeExecutor
from .nondet import AgentExecutor, BacalhauExecutor, LlmExecutor, LlmAgentBackend
from .providers import PROVIDER_PRESETS, LinkedProviderConfig, OperatorProviderRouter
from .wasm import WasmExecutor
from .zk import ZkGroth16Executor, ZkProverExecutor, ZkVmExecutor
[docs]class ExecutorRegistry:
"""Registry managing available compute runtime execution drivers."""
[docs] def __init__(self, blob_store: Optional[Any] = None, mock_mode: bool = False,
media_cache_dir: Optional[str] = None,
provider_router: Optional[OperatorProviderRouter] = None) -> None:
# blob_store: where WASM modules/inputs named by hash are looked up
# when the job itself does not carry one (e.g. a job received over
# the compute wire, which cannot carry a live store).
# mock_mode: build the LLM/Bacalhau/agent drivers as deterministic
# fixtures. Off by default so a node never ships fixture output as a
# paid result; tests and demos opt in explicitly.
self.blob_store: Optional[Any] = blob_store
self.mock_mode: bool = mock_mode
self.provider_router: OperatorProviderRouter = provider_router or OperatorProviderRouter()
wasm = WasmExecutor()
llm = LlmExecutor(mock_mode=mock_mode, provider_router=self.provider_router)
bacalhau = BacalhauExecutor(mock_mode=mock_mode)
agent_backend = LlmAgentBackend(provider_router=self.provider_router) if self.provider_router.runnable_providers() else None
agent = AgentExecutor(mock_mode=mock_mode, backend=agent_backend)
zkvm = ZkVmExecutor(mock_mode=mock_mode)
zk_prover = ZkProverExecutor(mock_mode=mock_mode)
ffmpeg = FfmpegTranscodeExecutor(mock_mode=mock_mode, cache_dir=media_cache_dir)
self.executors: dict[str, ExecutorProtocol] = {
'wasmtime': wasm,
'wasm': wasm,
'wasmer': wasm,
'zk-verify-groth16': ZkGroth16Executor(),
'zkvm': zkvm,
'zkvm-risc0': zkvm,
'zkvm-sp1': zkvm,
'zk-prove-groth16': zk_prover,
'zk-prove-risc0': zk_prover,
'llm': llm,
'vllm': llm,
'ollama': llm,
'bacalhau': bacalhau,
'container': bacalhau,
'docker': bacalhau,
'agent': agent,
'react': agent,
'fleetmesh-react-v1': agent,
'ffmpeg': ffmpeg,
'media-transcode': ffmpeg,
'video-transcode': ffmpeg,
'transcode': ffmpeg,
}
[docs] def register(self, executor: ExecutorProtocol, *aliases: str) -> None:
for name in (executor.engine_id, *aliases):
self.executors[name] = executor
[docs] def get(self, engine_id: str) -> Optional[ExecutorProtocol]:
return self.executors.get(engine_id)
[docs] def runnable_engines(self) -> list[str]:
"""Engine ids that can actually complete a job on this node.
Queries is_live_runnable() polymorphically across all registered
executors. Executors reporting False (e.g. unconfigured backends outside
mock_mode, or WasmExecutor when wasmtime is not installed) are excluded
so Kind 11803 compute offers only advertise truly runnable capabilities.
"""
out: list[str] = []
for eid, ex in self.executors.items():
if hasattr(ex, 'is_live_runnable'):
if not ex.is_live_runnable():
continue
out.append(eid)
return out
[docs] def select_for_job(self, job_payload: Mapping[str, Any]) -> ExecutorProtocol:
job_exec = job_payload.get('executor')
if job_exec and job_exec in self.executors:
return self.executors[job_exec]
if job_exec and str(job_exec).lower() in PROVIDER_PRESETS:
return self.executors['llm']
mod = job_payload.get('module') or {}
mod_type = mod.get('type') or mod.get('runtime')
if mod_type and mod_type in self.executors:
return self.executors[mod_type]
if job_payload.get('engine') in ('ffmpeg', 'media-transcode', 'video-transcode', 'transcode'):
return self.executors['ffmpeg']
if 'messages' in job_payload or 'model' in job_payload or 'prompt' in job_payload:
return self.executors['llm']
if 'storage_mounts' in job_payload or job_payload.get('engine') in ('docker', 'bacalhau'):
return self.executors['bacalhau']
if 'max_steps' in job_payload or 'tools' in job_payload or 'agent' in job_payload or 'task' in job_payload:
return self.executors['agent']
inp = job_payload.get('input', {})
if isinstance(inp, dict):
if 'source_url' in inp or 'source_path' in inp or ('profile' in inp and ('vod_id' in inp or 'duration_sec' in inp)):
return self.executors['ffmpeg']
if inp.get('action') == 'prove' or 'witness' in inp or 'private_inputs' in inp:
return self.executors.get('zk-prove-groth16', self.executors['zk-verify-groth16'])
if 'image_id' in inp or 'journal' in inp or str(job_payload.get('proof_system', '')).startswith(('risc0', 'sp1', 'zkvm')):
return self.executors.get('zkvm-risc0', self.executors['zk-verify-groth16'])
if 'proof' in inp or 'vk_sha256' in inp:
return self.executors['zk-verify-groth16']
return self.executors['wasmtime']
DEFAULT_REGISTRY: ExecutorRegistry = ExecutorRegistry()