fleetmesh-node 0.2.0__py3-none-any.whl

node/planes/services/compute/__init__.py

@@ -0,0 +1,160 @@
+"""compute/1.0: Compute offers, confidential asks, and bilateral job receipts.
+
+Implements the compute market protocol on the wire:
+- Kind 11803: Replaceable Compute Offer published by selling nodes.
+- Kind 30810: Addressable Compute Ask carrying blind SHA-256 commitments without
+  leaking module or input plaintexts.
+- Kind 30811: Addressable Compute Job Receipt carrying NIP-44 encrypted bilateral
+  settlement claims under a blinded job identifier.
+"""
+from __future__ import annotations
+
+from .common import (
+    ComputeError,
+    OFFER_KIND,
+    ASK_KIND,
+    RECEIPT_KIND,
+    WASI_PROFILE,
+    DEFAULT_EXPIRATION,
+    MAX_BLOB_FETCH_BYTES,
+    LLM_MAX_RESPONSE_BYTES,
+    resolve_blob,
+)
+from .market import (
+    build_offer,
+    validate_offer,
+    build_ask,
+    verify_ask,
+    parse_offer,
+    parse_ask,
+    match_ask_to_offers,
+    match_offer_to_asks,
+)
+from .sandbox import (
+    ComputeLimits,
+    NODE_MAX_TIMEOUT_S,
+    NODE_MAX_MEMORY_BYTES,
+    clamp_limits,
+    sandbox_limits,
+    _sandbox_available,
+    run_sandboxed,
+)
+from .executors import (
+    ComputeQuote,
+    ComputeExecutionResult,
+    ExecutorProtocol,
+    ComputeExecutor,
+    WASM_DEFAULT_MEMORY_BYTES,
+    WASM_MAX_OUTPUT_BYTES,
+    WASM_VIRTUAL_EPOCH_NS,
+    wasmtime_available,
+    _wasm_engine,
+    run_wasi_module,
+    WasmExecutor,
+    ZkGroth16Executor,
+    ZkVmExecutor,
+    ZkVmReceiptResult,
+    ZkVmVerifierProtocol,
+    ZkVmReceiptVerifier,
+    MockZkVmVerifier,
+    ZkProverResult,
+    ZkProverProtocol,
+    MockZkProverClient,
+    ZkProverExecutor,
+    LlmExecutor,
+    BacalhauExecutor,
+    AgentExecutor,
+    PROVIDER_PRESETS,
+    ProviderPreset,
+    LinkedProviderConfig,
+    OperatorProviderRouter,
+    AgentExecutionContext,
+    AgentToolProtocol,
+    AgentToolResult,
+    AgentDecision,
+    AgentBackendProtocol,
+    CalculatorTool,
+    Sha256Tool,
+    RegexSearchTool,
+    FetchBlobTool,
+    SubAskTool,
+    FinishTool,
+    ScriptedAgentBackend,
+    LlmAgentBackend,
+    AgentSkillModule,
+    HARNESS_SKILL_MODULES,
+    AgentProfileSpec,
+    BUILTIN_AGENT_PROFILES,
+    AgentHarnessRegistry,
+    McpToolSpec,
+    McpResourceSpec,
+    McpServerConfig,
+    McpToolAdapter,
+    McpClientBridge,
+    BacalhauClientProtocol,
+    BacalhauRestClient,
+    MockBacalhauClient,
+    BlossomMountBridge,
+    BlossomStagingResult,
+    BlossomUploadResult,
+    FfmpegTranscodeExecutor,
+    MEDIA_PROFILES,
+    FFMPEG_PROFILE_DIGEST,
+    DETERMINISTIC_FFMPEG_THREADS,
+    BITEXACT_MUX_FLAGS,
+    compute_deterministic_ffmpeg_job_key,
+    ffmpeg_available,
+    ExecutorRegistry,
+    DEFAULT_REGISTRY,
+)
+from .load import (
+    ComputeLoadMonitor,
+    DEFAULT_CPU_REFLECT_CEILING,
+)
+from .types import (
+    AgentSubAsk,
+    AgentTraceStep,
+    BacalhauJobSummary,
+    ComputeReceiptPayload,
+    JobRunResult,
+    OpenAIChatRequest,
+)
+from .jobs import run_job, build_receipt, open_receipt
+from .compartment import Compute
+from .. import compute_wire as wire
+
+
+__all__ = [
+    'ComputeError', 'OFFER_KIND', 'ASK_KIND', 'RECEIPT_KIND', 'WASI_PROFILE',
+    'DEFAULT_EXPIRATION', 'MAX_BLOB_FETCH_BYTES', 'LLM_MAX_RESPONSE_BYTES', 'resolve_blob',
+    'build_offer', 'validate_offer', 'build_ask', 'verify_ask', 'parse_offer', 'parse_ask',
+    'match_ask_to_offers', 'match_offer_to_asks',
+    'ComputeLimits', 'NODE_MAX_TIMEOUT_S', 'NODE_MAX_MEMORY_BYTES', 'clamp_limits',
+    'sandbox_limits', '_sandbox_available', 'run_sandboxed',
+    'ComputeQuote', 'ComputeExecutionResult', 'ExecutorProtocol', 'JobRunResult',
+    'ComputeExecutor', 'WASM_DEFAULT_MEMORY_BYTES', 'WASM_MAX_OUTPUT_BYTES',
+    'WASM_VIRTUAL_EPOCH_NS', 'wasmtime_available', '_wasm_engine', 'run_wasi_module',
+    'WasmExecutor', 'ZkGroth16Executor', 'ZkVmExecutor', 'ZkVmReceiptResult',
+    'ZkVmVerifierProtocol', 'ZkVmReceiptVerifier', 'MockZkVmVerifier',
+    'ZkProverResult', 'ZkProverProtocol', 'MockZkProverClient', 'ZkProverExecutor',
+    'LlmExecutor', 'BacalhauExecutor', 'AgentExecutor',
+    'PROVIDER_PRESETS', 'ProviderPreset', 'LinkedProviderConfig', 'OperatorProviderRouter',
+    'AgentExecutionContext', 'AgentToolProtocol', 'AgentToolResult', 'AgentDecision',
+    'AgentBackendProtocol', 'CalculatorTool', 'Sha256Tool', 'RegexSearchTool',
+    'FetchBlobTool', 'SubAskTool', 'FinishTool', 'ScriptedAgentBackend', 'LlmAgentBackend',
+    'AgentSkillModule', 'HARNESS_SKILL_MODULES', 'AgentProfileSpec',
+    'BUILTIN_AGENT_PROFILES', 'AgentHarnessRegistry',
+    'McpToolSpec', 'McpResourceSpec', 'McpServerConfig', 'McpToolAdapter', 'McpClientBridge',
+    'BacalhauClientProtocol', 'BacalhauRestClient', 'MockBacalhauClient',
+    'BlossomMountBridge', 'BlossomStagingResult', 'BlossomUploadResult',
+    'FfmpegTranscodeExecutor', 'MEDIA_PROFILES', 'FFMPEG_PROFILE_DIGEST',
+    'DETERMINISTIC_FFMPEG_THREADS', 'BITEXACT_MUX_FLAGS',
+    'compute_deterministic_ffmpeg_job_key', 'ffmpeg_available',
+    'ExecutorRegistry', 'DEFAULT_REGISTRY',
+    'ComputeLoadMonitor', 'DEFAULT_CPU_REFLECT_CEILING',
+    'run_job', 'build_receipt', 'open_receipt',
+    'Compute', 'wire',
+    'AgentSubAsk', 'AgentTraceStep', 'BacalhauJobSummary',
+    'ComputeReceiptPayload', 'OpenAIChatRequest',
+]
+

node/planes/services/compute/common.py

@@ -0,0 +1,134 @@
+"""Kinds, size ceilings, ComputeError and blob resolution shared by the compute package.
+
+Separate so every other compute module can import the shared vocabulary without pulling in the market or executor code.
+"""
+from __future__ import annotations
+
+import hashlib
+from typing import Any, Mapping, Optional, Sequence
+
+from node.transport import netfetch
+
+OFFER_KIND: int = 11803
+ASK_KIND: int = 30810
+RECEIPT_KIND: int = 30811
+
+WASI_PROFILE: str = 'fleetmesh-wasi-v1'
+DEFAULT_EXPIRATION: int = 86400 * 7
+
+# Ceiling on any module/input fetched over the network on a job's behalf when
+# the caller does not pass a tighter one (a Blossom server's upload cap is
+# 64 MiB, so the same figure keeps the two planes consistent).
+MAX_BLOB_FETCH_BYTES: int = 64 * 1024 * 1024
+
+# Cap on a chat-completions response body from the operator's LLM backend; a
+# misbehaving backend must not be able to exhaust node memory either.
+LLM_MAX_RESPONSE_BYTES: int = 16 * 1024 * 1024
+
+
+class ComputeError(Exception):
+    """Raised when an ask, offer, or receipt fails cryptographic or wire validation."""
+
+
+def resolve_blob(
+    spec: object,
+    blob_store: Optional[Any] = None,
+    blossom_servers: Optional[Sequence[str]] = None,
+    max_bytes: Optional[int] = None,
+) -> Optional[bytes]:
+    """Resolve blob bytes from local store, or peer Blossom servers via BUD-01/04.
+
+    ``max_bytes`` bounds anything fetched over the network (a job's blob or
+    upload limit); it defaults to MAX_BLOB_FETCH_BYTES.
+    """
+    if not isinstance(spec, Mapping):
+        return None
+
+    sha256_hex = spec.get('sha256') or spec.get('hash')
+    if sha256_hex and str(sha256_hex).startswith('baf'):
+        # A CID in the sha256 slot must decode; if it does not, we have no
+        # digest to verify against and must not fall through to a fetch that
+        # would then be accepted unverified.
+        from node.protocols.nostr import blobstore
+        try:
+            sha256_hex = blobstore.cid_to_sha256(str(sha256_hex))
+        except Exception as e:
+            raise ComputeError('invalid CID in blob spec: %s' % e)
+    elif not sha256_hex and spec.get('cid'):
+        from node.protocols.nostr import blobstore
+        try:
+            sha256_hex = blobstore.cid_to_sha256(spec['cid'])
+        except Exception as e:
+            raise ComputeError('invalid CID in blob spec: %s' % e)
+
+    if not sha256_hex:
+        raw = spec.get('raw') or spec.get('data')
+        if isinstance(raw, (bytes, bytearray)):
+            return bytes(raw)
+        if isinstance(raw, str):
+            return raw.encode('utf-8')
+        return None
+
+    sha256_hex = str(sha256_hex).lower()
+
+    if blob_store is not None:
+        if hasattr(blob_store, 'get_blob'):
+            data = blob_store.get_blob(sha256_hex)
+        elif hasattr(blob_store, 'get'):
+            data = blob_store.get(sha256_hex)
+        else:
+            data = None
+        if data is not None:
+            return data
+
+    if spec.get('raw'):
+        raw = spec['raw']
+        data = raw if isinstance(raw, (bytes, bytearray)) else str(raw).encode('utf-8')
+        if hashlib.sha256(data).hexdigest().lower() == sha256_hex:
+            if blob_store is not None:
+                if hasattr(blob_store, 'store_blob'):
+                    blob_store.store_blob(bytes(data))
+                elif hasattr(blob_store, 'put'):
+                    blob_store.put(data)
+            return bytes(data)
+
+    from node.protocols.nostr import blossom
+    servers = list(blossom_servers or [])
+    if spec.get('url'):
+        # The URL is chosen by the requester. netfetch refuses non-http(s)
+        # schemes and private/loopback/metadata destinations, and caps the
+        # body: a job may name a public origin for its module, not turn the
+        # node into a proxy into its own LAN. The cap is the caller's blob
+        # limit (falls back to MAX_BLOB_FETCH_BYTES), and the bytes are only
+        # accepted if they hash to what the job committed to.
+        try:
+            data, _ = netfetch.fetch(
+                str(spec['url']),
+                max_bytes=int(max_bytes or MAX_BLOB_FETCH_BYTES),
+                timeout=10.0,
+                headers={'User-Agent': 'fleetmesh-compute/1.0'},
+            )
+            if hashlib.sha256(data).hexdigest().lower() == sha256_hex:
+                if blob_store is not None:
+                    if hasattr(blob_store, 'store_blob'):
+                        blob_store.store_blob(bytes(data))
+                    elif hasattr(blob_store, 'put'):
+                        blob_store.put(data)
+                return data
+        except netfetch.FetchError:
+            pass
+
+    for srv in servers:
+        try:
+            data = blossom.BlossomClient.get_blob(srv, sha256_hex, timeout=5.0,
+                                                  max_bytes=int(max_bytes or MAX_BLOB_FETCH_BYTES))
+            if blob_store is not None:
+                if hasattr(blob_store, 'store_blob'):
+                    blob_store.store_blob(bytes(data))
+                elif hasattr(blob_store, 'put'):
+                    blob_store.put(data)
+            return data
+        except Exception:
+            continue
+
+    return None