@hivemind-os/collective-daemon 0.2.0

package/dist/chunk-57QD6553.js

@@ -0,0 +1,803 @@
+import {
+  RelayClient
+} from "./chunk-BJW47ZD5.js";
+
+// src/provider/adapters/echo.ts
+import { createHash } from "crypto";
+var decoder = new TextDecoder("utf-8", { fatal: true });
+var encoder = new TextEncoder();
+var EchoAdapter = class {
+  name = "echo";
+  async execute(params) {
+    const result = {
+      echo: decodeInput(params.inputData),
+      taskId: params.taskId,
+      capability: params.capability,
+      timestamp: Date.now(),
+      inputHash: createHash("sha256").update(params.inputData).digest("hex")
+    };
+    return {
+      resultData: encoder.encode(JSON.stringify(result))
+    };
+  }
+};
+function decodeInput(input) {
+  try {
+    return decoder.decode(input);
+  } catch {
+    return Buffer.from(input).toString("hex");
+  }
+}
+
+// src/provider/adapters/local-fn.ts
+var LocalFunctionAdapter = class {
+  constructor(fn) {
+    this.fn = fn;
+  }
+  fn;
+  name = "local-function";
+  async execute(params) {
+    return {
+      resultData: await this.fn(params.inputData, params.metadata)
+    };
+  }
+};
+
+// src/provider/adapters/mcp-sampling.ts
+var DEFAULT_MAX_TOKENS = 4096;
+var decoder2 = new TextDecoder("utf-8", { fatal: true });
+var encoder2 = new TextEncoder();
+var McpSamplingAdapter = class {
+  constructor(config, sample) {
+    this.sample = sample;
+    if (!config.appName || config.appName.trim().length === 0) {
+      throw new Error("MCP sampling adapter requires a non-empty appName");
+    }
+    if (!config.systemPrompt || config.systemPrompt.trim().length === 0) {
+      throw new Error("MCP sampling adapter requires a non-empty systemPrompt");
+    }
+    this.appName = config.appName.trim();
+    this.systemPrompt = config.systemPrompt;
+    this.maxTokens = config.maxTokens ?? DEFAULT_MAX_TOKENS;
+    this.modelHint = config.modelHint;
+  }
+  sample;
+  name = "mcp-sampling";
+  appName;
+  systemPrompt;
+  maxTokens;
+  modelHint;
+  async execute(params) {
+    let inputText;
+    try {
+      inputText = decoder2.decode(params.inputData);
+    } catch {
+      throw new Error("MCP sampling adapter requires valid UTF-8 input");
+    }
+    const samplingParams = {
+      messages: [
+        {
+          role: "user",
+          content: { type: "text", text: inputText }
+        }
+      ],
+      systemPrompt: this.systemPrompt,
+      maxTokens: this.maxTokens,
+      ...this.modelHint ? { modelPreferences: { hints: [{ name: this.modelHint }] } } : {}
+    };
+    const result = await this.sample(this.appName, samplingParams);
+    const text = extractTextContent(result);
+    if (text === void 0) {
+      throw new Error("MCP sampling response contained no text content");
+    }
+    return {
+      resultData: encoder2.encode(text),
+      metadata: {
+        model: result.model,
+        ...result.stopReason ? { stopReason: result.stopReason } : {}
+      }
+    };
+  }
+};
+function extractTextContent(result) {
+  const content = result.content;
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      if (block.type === "text") {
+        return block.text;
+      }
+    }
+    return void 0;
+  }
+  if (content.type === "text") {
+    return content.text;
+  }
+  return void 0;
+}
+
+// src/provider/adapters/subprocess.ts
+import { spawn } from "child_process";
+var DEFAULT_TIMEOUT_MS = 6e4;
+var DEFAULT_MAX_OUTPUT_BYTES = 10 * 1024 * 1024;
+var SubprocessAdapter = class {
+  name = "subprocess";
+  command;
+  args;
+  cwd;
+  env;
+  timeoutMs;
+  maxOutputBytes;
+  constructor(config) {
+    if (!config.command || config.command.trim().length === 0) {
+      throw new Error("Subprocess adapter requires a non-empty command");
+    }
+    this.command = config.command;
+    this.args = config.args ?? [];
+    this.cwd = config.cwd;
+    this.env = { ...config.env };
+    this.timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.maxOutputBytes = config.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
+  }
+  async execute(params) {
+    return new Promise((resolve, reject) => {
+      const child = spawn(this.command, this.args, {
+        cwd: this.cwd,
+        shell: false,
+        stdio: ["pipe", "pipe", "pipe"],
+        env: {
+          ...process.env,
+          ...this.env,
+          COLLECTIVE_TASK_ID: params.taskId,
+          COLLECTIVE_CAPABILITY: params.capability
+        }
+      });
+      const stdout = [];
+      const stderr = [];
+      let stdoutSize = 0;
+      let stderrSize = 0;
+      let settled = false;
+      const settle = (fn) => {
+        if (!settled) {
+          settled = true;
+          clearTimeout(timer);
+          fn();
+        }
+      };
+      const timer = setTimeout(() => {
+        settle(() => {
+          child.kill("SIGKILL");
+          reject(new Error(`Subprocess timed out after ${this.timeoutMs}ms`));
+        });
+      }, this.timeoutMs);
+      child.stdout.on("data", (chunk) => {
+        stdoutSize += chunk.length;
+        if (stdoutSize > this.maxOutputBytes) {
+          settle(() => {
+            child.kill("SIGKILL");
+            reject(new Error(`Subprocess stdout exceeded ${this.maxOutputBytes} byte limit`));
+          });
+          return;
+        }
+        stdout.push(chunk);
+      });
+      child.stderr.on("data", (chunk) => {
+        stderrSize += chunk.length;
+        if (stderrSize <= 64 * 1024) {
+          stderr.push(chunk);
+        }
+      });
+      child.on("error", (error) => {
+        settle(() => reject(new Error(`Subprocess failed to start: ${error.message}`)));
+      });
+      child.on("close", (code) => {
+        settle(() => {
+          if (code !== 0) {
+            const stderrText = Buffer.concat(stderr).toString("utf-8").trim();
+            const truncated = stderrText.length > 1024 ? stderrText.slice(0, 1024) + "..." : stderrText;
+            reject(new Error(`Subprocess exited with code ${code ?? "null"}${truncated ? `: ${truncated}` : ""}`));
+            return;
+          }
+          resolve({
+            resultData: new Uint8Array(Buffer.concat(stdout))
+          });
+        });
+      });
+      child.stdin.on("error", (error) => {
+        settle(() => reject(new Error(`Subprocess stdin error: ${error.message}`)));
+      });
+      child.stdin.end(Buffer.from(params.inputData));
+    });
+  }
+};
+
+// src/provider/adapters/webhook.ts
+var DEFAULT_TIMEOUT_MS2 = 3e4;
+var DEFAULT_MAX_RESPONSE_BYTES = 10 * 1024 * 1024;
+var BODY_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH"]);
+var WebhookAdapter = class {
+  name = "webhook";
+  url;
+  method;
+  headers;
+  timeoutMs;
+  maxResponseBytes;
+  constructor(config) {
+    this.url = parseUrl(config.url);
+    this.method = (config.method ?? "POST").toUpperCase();
+    if (!BODY_METHODS.has(this.method)) {
+      throw new Error(`Webhook method must be one of POST, PUT, PATCH (got ${this.method})`);
+    }
+    this.headers = { ...config.headers };
+    this.timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+    this.maxResponseBytes = config.maxResponseBytes ?? DEFAULT_MAX_RESPONSE_BYTES;
+  }
+  async execute(params) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const response = await fetch(this.url, {
+        method: this.method,
+        headers: {
+          "Content-Type": "application/octet-stream",
+          "X-Mesh-Task-Id": params.taskId,
+          "X-Mesh-Capability": params.capability,
+          ...this.headers
+        },
+        body: params.inputData,
+        signal: controller.signal,
+        redirect: "manual"
+      });
+      if (response.status >= 300 && response.status < 400) {
+        throw new Error(`Webhook returned redirect (HTTP ${response.status}) which is not followed for security`);
+      }
+      if (!response.ok) {
+        const body = await response.text().catch(() => "");
+        const truncated = body.length > 256 ? body.slice(0, 256) + "..." : body;
+        throw new Error(`Webhook returned HTTP ${response.status}: ${truncated}`);
+      }
+      const resultData = await readLimitedResponse(response, this.maxResponseBytes);
+      return { resultData };
+    } catch (error) {
+      if (error instanceof DOMException && error.name === "AbortError") {
+        throw new Error(`Webhook timed out after ${this.timeoutMs}ms`);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+async function readLimitedResponse(response, maxBytes) {
+  const contentLength = response.headers.get("content-length");
+  if (contentLength && Number(contentLength) > maxBytes) {
+    throw new Error(`Webhook response too large: ${contentLength} bytes (max ${maxBytes})`);
+  }
+  const chunks = [];
+  let total = 0;
+  if (!response.body) {
+    return new Uint8Array(0);
+  }
+  for await (const chunk of response.body) {
+    total += chunk.byteLength;
+    if (total > maxBytes) {
+      throw new Error(`Webhook response exceeded ${maxBytes} byte limit`);
+    }
+    chunks.push(chunk);
+  }
+  const result = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return result;
+}
+function parseUrl(input) {
+  let url;
+  try {
+    url = new URL(input);
+  } catch {
+    throw new Error(`Invalid webhook URL: ${input}`);
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error(`Webhook URL must use http or https: ${input}`);
+  }
+  return url;
+}
+
+// src/provider/capabilities.ts
+function loadProviderConfig(config) {
+  if (!config.provider) {
+    return null;
+  }
+  return {
+    enabled: config.provider.enabled,
+    capabilities: config.provider.capabilities.map((capability) => ({
+      name: capability.name,
+      description: capability.description,
+      version: capability.version,
+      priceMist: capability.priceMist,
+      currency: capability.currency,
+      adapter: capability.adapter,
+      adapterConfig: capability.adapterConfig
+    })),
+    maxConcurrency: Math.max(1, config.provider.maxConcurrency ?? 1),
+    autoRegister: config.provider.autoRegister ?? false
+  };
+}
+
+// src/provider/runtime.ts
+import { randomUUID } from "crypto";
+import pino from "pino";
+import {
+  EventSubscription,
+  SqliteCursorStore,
+  UsageMeter,
+  createMeteredResultEnvelope,
+  parseEncryptedPayload,
+  parseRawEvent,
+  serializeMeteredResultEnvelope,
+  splitIntoMeteringUnits
+} from "@hivemind-os/collective-core";
+import { PaymentRail, PaymentScheme } from "@hivemind-os/collective-types";
+
+// src/provider/task-queue.ts
+var TaskQueue = class {
+  constructor(maxConcurrency = 1) {
+    this.maxConcurrency = maxConcurrency;
+  }
+  maxConcurrency;
+  running = /* @__PURE__ */ new Map();
+  async enqueue(taskId, work) {
+    if (this.isFull || this.running.has(taskId)) {
+      return false;
+    }
+    const runPromise = Promise.resolve().then(work).finally(() => {
+      this.running.delete(taskId);
+    });
+    this.running.set(taskId, runPromise);
+    return true;
+  }
+  get activeCount() {
+    return this.running.size;
+  }
+  get isFull() {
+    return this.activeCount >= this.maxConcurrency;
+  }
+  async drain() {
+    while (this.running.size > 0) {
+      await Promise.allSettled(this.running.values());
+    }
+  }
+};
+
+// src/provider/runtime.ts
+var logger = pino({ name: "@hivemind-os/collective-daemon:provider" });
+var encoder3 = new TextEncoder();
+var decoder3 = new TextDecoder();
+var ProviderRuntime = class {
+  constructor(params) {
+    this.params = params;
+    this.taskQueue = new TaskQueue(params.providerConfig.maxConcurrency);
+  }
+  params;
+  subscription;
+  cursorStore;
+  taskQueue;
+  adapters = /* @__PURE__ */ new Map();
+  capabilityConfigs = /* @__PURE__ */ new Map();
+  relayClients = [];
+  registeredCapabilities = [];
+  chainOperations = Promise.resolve();
+  ownAgentCardId;
+  async start() {
+    if (this.subscription) {
+      return;
+    }
+    this.initializeAdapters();
+    await this.connectRelays();
+    if (this.params.providerConfig.autoRegister) {
+      await this.registerAgentCard();
+    }
+    await this.resolveOwnAgentCardId();
+    const eventType = `${this.params.state.network.packageId}::task::TaskPosted`;
+    this.cursorStore = new SqliteCursorStore(this.params.cursorDbPath);
+    this.subscription = new EventSubscription({
+      suiClient: this.params.state.suiClient,
+      eventType,
+      cursorStore: this.cursorStore,
+      pollIntervalMs: 2e3,
+      onEvent: async (event) => {
+        await this.handleRawEvent(event);
+      },
+      onError: (error) => {
+        logger.error({ err: error }, "Provider subscription polling failed");
+      }
+    });
+    this.subscription.start();
+  }
+  async stop() {
+    this.subscription?.stop();
+    this.subscription = void 0;
+    await Promise.all(this.relayClients.splice(0).map((client) => client.disconnect()));
+    await this.taskQueue.drain();
+    this.cursorStore?.close();
+    this.cursorStore = void 0;
+  }
+  async connectRelays() {
+    const relayConfig = this.params.relayConfig;
+    if (!relayConfig?.enabled || !relayConfig.providerMode || !relayConfig.autoConnect) {
+      return;
+    }
+    const factory = this.params.relayClientFactory ?? ((config, identity) => new RelayClient(config, identity));
+    for (const endpoint of relayConfig.endpoints) {
+      const client = factory(
+        {
+          relayUrl: endpoint.url,
+          relayDid: endpoint.relayDid,
+          reconnectIntervalMs: relayConfig.reconnectIntervalMs,
+          heartbeatIntervalMs: relayConfig.heartbeatIntervalMs
+        },
+        this.params.state.relayAuthProvider
+      );
+      client.onTaskRequest(async (request) => {
+        await client.sendProgress(request.taskId ?? "relay-task", 0.1, "Task accepted by provider runtime");
+        const resultData = await this.executeLocalTask(
+          request.taskId ?? randomUUID(),
+          request.capability,
+          encodeRelayInput(request.input)
+        );
+        await client.sendProgress(request.taskId ?? "relay-task", 1, "Task completed");
+        return {
+          taskId: request.taskId ?? randomUUID(),
+          providerDid: this.params.state.did,
+          sequence: 0,
+          result: parseExecutionResult(resultData)
+        };
+      });
+      await client.connect(this.registeredCapabilities);
+      this.relayClients.push(client);
+    }
+  }
+  async handleRawEvent(event) {
+    const parsed = parseRawEvent(event, this.params.state.network.packageId);
+    if (parsed?.type !== "task.posted") {
+      return;
+    }
+    await this.handleTaskPosted(parsed);
+  }
+  async handleTaskPosted(event) {
+    const capabilityKey = normalizeCapability(event.task.capability);
+    if (!this.registeredCapabilities.some((registered) => normalizeCapability(registered) === capabilityKey)) {
+      return;
+    }
+    if (this.taskQueue.isFull) {
+      logger.warn({ taskId: event.task.id, capability: event.task.capability }, "Provider queue is full");
+      return;
+    }
+    this.params.broadcastNotification?.("notifications/mesh/inbound_task", {
+      taskId: event.task.id,
+      capability: event.task.capability,
+      requester: event.task.requester,
+      priceMist: event.task.price.toString()
+    });
+    const queued = await this.taskQueue.enqueue(event.task.id, async () => {
+      try {
+        await this.processTask(event.task);
+      } catch (error) {
+        logger.error({ err: error, taskId: event.task.id }, "Task processing failed");
+      }
+    });
+    if (!queued) {
+      logger.warn({ taskId: event.task.id }, "Task was not queued");
+    }
+  }
+  async processTask(task) {
+    const encryption = this.params.state.encryption ?? { enabled: false, requireEncryption: false };
+    await this.runChainOperation(async () => {
+      await this.params.state.taskClient.acceptTask({
+        taskId: task.id,
+        keypair: this.params.state.keypair
+      });
+    });
+    const rawInput = await this.params.state.blobStore.fetch(task.inputBlobId);
+    if (!rawInput) {
+      throw new Error(`Input blob ${task.inputBlobId} was not found.`);
+    }
+    const encryptedInput = parseEncryptedPayload(rawInput);
+    if (encryption.requireEncryption && !encryptedInput) {
+      throw new Error(`Task ${task.id} is missing an encrypted input payload.`);
+    }
+    const inputData = encryptedInput ? await fetchDecryptedPayload(this.params.state.blobStore, task.inputBlobId) : rawInput;
+    const result = await this.executeLocalTask(task.id, task.capability, inputData);
+    const requesterCard = await this.params.state.registryClient.getAgentCardByOwner(task.requester);
+    const requesterEncryptionKey = decodeHexKey(requesterCard?.encryptionPublicKey);
+    if (encryption.requireEncryption && !requesterEncryptionKey) {
+      throw new Error(`Task ${task.id} requester does not publish an encryption key.`);
+    }
+    const completionPayload = prepareCompletionPayload(task, result);
+    const storedResult = encryption.enabled && requesterEncryptionKey ? await storeEncryptedPayload(this.params.state.blobStore, completionPayload.resultData, requesterEncryptionKey) : await this.params.state.blobStore.store(completionPayload.resultData);
+    await this.runChainOperation(async () => {
+      if (completionPayload.metered) {
+        await this.params.state.taskClient.completeMeteredTask({
+          taskId: task.id,
+          resultBlobId: storedResult.blobId,
+          meteredUnits: completionPayload.metered.actualUnits,
+          verificationHash: completionPayload.metered.verificationHash,
+          keypair: this.params.state.keypair,
+          providerCardId: this.ownAgentCardId
+        });
+        return;
+      }
+      await this.params.state.taskClient.completeTask({
+        taskId: task.id,
+        resultBlobId: storedResult.blobId,
+        keypair: this.params.state.keypair,
+        providerCardId: this.ownAgentCardId
+      });
+    });
+  }
+  async executeLocalTask(taskId, capability, inputData) {
+    const adapter = this.adapters.get(normalizeCapability(capability));
+    if (!adapter) {
+      throw new Error(`No adapter configured for capability ${capability}.`);
+    }
+    const result = await adapter.execute({
+      taskId,
+      capability,
+      inputData
+    });
+    return result.resultData;
+  }
+  async runChainOperation(operation) {
+    const pending = this.chainOperations.then(operation, operation);
+    this.chainOperations = pending.then(
+      () => void 0,
+      () => void 0
+    );
+    return pending;
+  }
+  initializeAdapters() {
+    this.adapters.clear();
+    this.capabilityConfigs.clear();
+    this.registeredCapabilities = [];
+    const deps = {
+      mcpSamplingFn: this.params.mcpSamplingFn
+    };
+    for (const capability of this.params.providerConfig.capabilities) {
+      try {
+        const key = normalizeCapability(capability.name);
+        const adapter = createAdapter(capability, deps);
+        this.adapters.set(key, adapter);
+        this.capabilityConfigs.set(key, capability);
+        this.registeredCapabilities.push(capability.name);
+      } catch (error) {
+        logger.warn({ err: error, capability: capability.name }, "Skipping invalid provider capability");
+      }
+    }
+  }
+  async registerAgentCard() {
+    const encryption = this.params.state.encryption ?? { enabled: false, requireEncryption: false };
+    const capabilities = this.params.providerConfig.capabilities.filter((capability) => this.capabilityConfigs.has(normalizeCapability(capability.name))).map((capability) => toCapability(capability, this.hasRelaySupport));
+    if (capabilities.length === 0) {
+      logger.warn("Skipping auto-registration because no provider capabilities are available");
+      return;
+    }
+    try {
+      const registration = await this.params.state.registryClient.registerAgent({
+        name: "Agentic Mesh Provider",
+        description: `Auto-registered provider for ${this.params.state.did}`,
+        did: this.params.state.did,
+        capabilities,
+        endpoint: this.registrationEndpoint,
+        encryptionPublicKey: encryption.enabled ? this.params.state.encryptionKeyPair?.publicKey : void 0,
+        keypair: this.params.state.keypair
+      });
+      this.ownAgentCardId = registration.agentCardId;
+      const card = await this.params.state.registryClient.getAgentCard(registration.agentCardId);
+      if (card) {
+        this.params.state.agentCache.upsertAgent({
+          ...card,
+          endpoint: this.registrationEndpoint,
+          relayEndpoints: this.relayMetadata,
+          capabilities
+        });
+      }
+      logger.info({ agentCardId: registration.agentCardId }, "Provider agent card registered");
+    } catch (error) {
+      logger.error({ err: error }, "Provider auto-registration failed");
+    }
+  }
+  async resolveOwnAgentCardId() {
+    const cached = this.params.state.agentCache.getAgentByDID?.(this.params.state.did);
+    if (cached?.id) {
+      this.ownAgentCardId = cached.id;
+      return;
+    }
+    const discovered = await this.params.state.registryClient.findAgentByDid?.(this.params.state.did);
+    if (discovered?.id) {
+      this.ownAgentCardId = discovered.id;
+      this.params.state.agentCache.upsertAgent(discovered);
+    }
+  }
+  get hasRelaySupport() {
+    return this.relayClients.length > 0 && this.relayMetadata.length > 0;
+  }
+  get relayMetadata() {
+    const relayConfig = this.params.relayConfig;
+    if (!relayConfig?.enabled || !relayConfig.providerMode) {
+      return [];
+    }
+    return relayConfig.endpoints.map(
+      (endpoint) => ({
+        relayDid: endpoint.relayDid,
+        endpoint: endpoint.url,
+        modes: ["sync", "streaming", "fallback"]
+      })
+    );
+  }
+  get registrationEndpoint() {
+    const relay = this.relayMetadata[0];
+    if (!relay) {
+      return `mesh://agent/${this.params.state.did}`;
+    }
+    return relay.endpoint.replace(/^wss:/i, "https:").replace(/^ws:/i, "http:").replace(/\/v1\/ws$/i, "");
+  }
+};
+function createAdapter(capability, deps) {
+  const config = capability.adapterConfig ?? {};
+  switch (capability.adapter) {
+    case "echo":
+      return new EchoAdapter();
+    case "local-function": {
+      const fnCandidate = config.fn ?? config.function;
+      if (typeof fnCandidate !== "function") {
+        throw new Error(`Capability ${capability.name} is missing a local function adapter.`);
+      }
+      return new LocalFunctionAdapter(fnCandidate);
+    }
+    case "webhook":
+      return new WebhookAdapter({
+        url: requireString(config.url, "webhook url"),
+        method: optionalString(config.method),
+        headers: optionalStringRecord(config.headers),
+        timeoutMs: optionalNumber(config.timeoutMs),
+        maxResponseBytes: optionalNumber(config.maxResponseBytes)
+      });
+    case "subprocess":
+      return new SubprocessAdapter({
+        command: requireString(config.command, "subprocess command"),
+        args: optionalStringArray(config.args),
+        cwd: optionalString(config.cwd),
+        env: optionalStringRecord(config.env),
+        timeoutMs: optionalNumber(config.timeoutMs),
+        maxOutputBytes: optionalNumber(config.maxOutputBytes)
+      });
+    case "mcp-sampling": {
+      if (!deps.mcpSamplingFn) {
+        throw new Error("MCP sampling adapter requires an active IPC server with sampling support.");
+      }
+      return new McpSamplingAdapter(
+        {
+          appName: requireString(config.appName, "mcp-sampling appName"),
+          systemPrompt: requireString(config.systemPrompt, "mcp-sampling systemPrompt"),
+          maxTokens: optionalNumber(config.maxTokens),
+          modelHint: optionalString(config.modelHint)
+        },
+        deps.mcpSamplingFn
+      );
+    }
+    default:
+      throw new Error(`Unsupported execution adapter: ${capability.adapter}`);
+  }
+}
+function requireString(value, label) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`Missing required config field: ${label}`);
+  }
+  return value;
+}
+function optionalString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function optionalNumber(value) {
+  return typeof value === "number" ? value : void 0;
+}
+function optionalStringArray(value) {
+  if (!Array.isArray(value)) return void 0;
+  return value.filter((item) => typeof item === "string");
+}
+function optionalStringRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const result = {};
+  for (const [k, v] of Object.entries(value)) {
+    if (typeof v === "string") result[k] = v;
+  }
+  return result;
+}
+function toCapability(capability, hasRelaySupport) {
+  return {
+    name: capability.name,
+    description: capability.description,
+    version: capability.version,
+    pricing: {
+      rail: PaymentRail.SUI_ESCROW,
+      amount: BigInt(capability.priceMist),
+      currency: capability.currency ?? "MIST"
+    },
+    executionMode: hasRelaySupport ? "sync" : "async",
+    paymentRails: hasRelaySupport ? [PaymentRail.SUI_TRANSFER, PaymentRail.X402_BASE, PaymentRail.SUI_ESCROW] : [PaymentRail.SUI_ESCROW]
+  };
+}
+function normalizeCapability(capability) {
+  return capability.trim().toLowerCase();
+}
+function prepareCompletionPayload(task, resultData) {
+  if (task.paymentScheme !== PaymentScheme.UPTO && task.paymentScheme !== PaymentScheme.STREAM) {
+    return { resultData };
+  }
+  const meter = new UsageMeter({
+    taskId: task.id,
+    maxPrice: task.maxPrice ?? task.price,
+    unitPrice: task.unitPrice ?? 0n
+  });
+  for (const unit of splitIntoMeteringUnits(resultData)) {
+    meter.recordUnit(unit);
+  }
+  const envelope = createMeteredResultEnvelope(resultData, meter.getProof());
+  return {
+    resultData: serializeMeteredResultEnvelope(envelope),
+    metered: {
+      actualUnits: meter.getActualUnits(),
+      verificationHash: meter.getVerificationHash()
+    }
+  };
+}
+function encodeRelayInput(input) {
+  return encoder3.encode(typeof input === "string" ? input : JSON.stringify(input));
+}
+function isEncryptedBlobStore(blobStore) {
+  return typeof blobStore.storeEncrypted === "function" && typeof blobStore.fetchDecrypted === "function";
+}
+async function fetchDecryptedPayload(blobStore, blobId) {
+  if (!isEncryptedBlobStore(blobStore)) {
+    throw new Error("Encrypted payloads require an encrypted blobstore.");
+  }
+  const data = await blobStore.fetchDecrypted(blobId);
+  if (!data) {
+    throw new Error(`Input blob ${blobId} was not found.`);
+  }
+  return data;
+}
+async function storeEncryptedPayload(blobStore, data, recipientPublicKey) {
+  if (!isEncryptedBlobStore(blobStore)) {
+    throw new Error("Encrypted payloads require an encrypted blobstore.");
+  }
+  return await blobStore.storeEncrypted(data, recipientPublicKey);
+}
+function decodeHexKey(value) {
+  if (!value || value.length !== 64 || !/^[a-f0-9]+$/i.test(value)) {
+    return null;
+  }
+  return new Uint8Array(Buffer.from(value, "hex"));
+}
+function parseExecutionResult(resultData) {
+  const text = decoder3.decode(resultData);
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+export {
+  EchoAdapter,
+  LocalFunctionAdapter,
+  McpSamplingAdapter,
+  SubprocessAdapter,
+  WebhookAdapter,
+  loadProviderConfig,
+  TaskQueue,
+  ProviderRuntime
+};
+//# sourceMappingURL=chunk-57QD6553.js.map