@hivemind-os/collective-mcp-server 0.2.0

package/dist/index.js

@@ -0,0 +1,2129 @@
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+
+// src/resources/index.ts
+import {
+  ListResourcesRequestSchema,
+  ListResourceTemplatesRequestSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/resources/agent.ts
+var meshAgentResourceTemplate = {
+  uriTemplate: "mesh://agent/{did}",
+  name: "Agent Profile",
+  description: "Resolve a mesh agent profile by DID",
+  mimeType: "application/json"
+};
+async function readAgentResource(did, context) {
+  const cached = context.agentCache.getAgentByDID(did);
+  if (cached) {
+    return cached;
+  }
+  const discovered = await findAgentByDidOnChain(did, context);
+  if (!discovered) {
+    throw new Error(`Agent ${did} was not found.`);
+  }
+  context.agentCache.upsertAgent(discovered);
+  return discovered;
+}
+async function findAgentByDidOnChain(did, context) {
+  const eventType = `${context.networkConfig.packageId}::registry::AgentRegistered`;
+  let cursor = null;
+  while (true) {
+    const page = await context.suiClient.queryEvents(eventType, cursor, 50);
+    for (const event of page.events) {
+      if (!isRecord(event.parsedJson)) {
+        continue;
+      }
+      if (!stringEquals(readString(event.parsedJson.did), did)) {
+        continue;
+      }
+      const cardId = readString(event.parsedJson.id, event.parsedJson.card_id, event.parsedJson.cardId);
+      if (!cardId) {
+        continue;
+      }
+      const card = await context.registryClient.getAgentCard(cardId);
+      if (card) {
+        return card;
+      }
+    }
+    if (!page.hasMore || !page.nextCursor) {
+      break;
+    }
+    cursor = page.nextCursor;
+  }
+  return null;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function readString(...values) {
+  const match = values.find((value) => typeof value === "string");
+  return typeof match === "string" ? match : "";
+}
+function stringEquals(left, right) {
+  return left.toLowerCase() === right.toLowerCase();
+}
+
+// src/resources/capabilities.ts
+var meshCapabilitiesResource = {
+  uri: "mesh://capabilities",
+  name: "Capability Directory",
+  description: "Known mesh capabilities aggregated from the local agent cache",
+  mimeType: "application/json"
+};
+async function readCapabilitiesResource(context) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const agent of context.agentCache.getAllActive(1e3)) {
+    for (const capability of agent.capabilities) {
+      counts.set(capability.name, (counts.get(capability.name) ?? 0) + 1);
+    }
+  }
+  return [...counts.entries()].map(([capability, agent_count]) => ({ capability, agent_count })).sort((left, right) => left.capability.localeCompare(right.capability));
+}
+
+// src/resources/task.ts
+import { TaskStatus } from "@hivemind-os/collective-types";
+
+// src/encryption.ts
+function supportsEncryptedBlobs(blobStore) {
+  return typeof blobStore.storeEncrypted === "function" && typeof blobStore.fetchDecrypted === "function";
+}
+async function fetchMeshBlob(blobStore, blobId) {
+  return supportsEncryptedBlobs(blobStore) ? await blobStore.fetchDecrypted(blobId) : await blobStore.fetch(blobId);
+}
+function hexToBytes(value) {
+  if (!value || value.length !== 64 || !/^[a-f0-9]+$/i.test(value)) {
+    return null;
+  }
+  return new Uint8Array(Buffer.from(value, "hex"));
+}
+
+// src/resources/task.ts
+var decoder = new TextDecoder();
+var meshTaskResourceTemplate = {
+  uriTemplate: "mesh://task/{id}",
+  name: "Task Details",
+  description: "Resolve task details and result payload by task id",
+  mimeType: "application/json"
+};
+async function readTaskResource(taskId, context) {
+  const task = await context.taskClient.getTask(taskId);
+  if (!task) {
+    throw new Error(`Task ${taskId} was not found.`);
+  }
+  let result;
+  if ((task.status === TaskStatus.COMPLETED || task.status === TaskStatus.RELEASED) && task.resultBlobId) {
+    const bytes = await fetchMeshBlob(context.blobStore, task.resultBlobId);
+    result = bytes ? decoder.decode(bytes) : void 0;
+  }
+  return {
+    id: task.id,
+    requester: task.requester,
+    provider: task.provider,
+    capability: task.capability,
+    input_blob_id: task.inputBlobId,
+    result_blob_id: task.resultBlobId,
+    price_mist: task.price.toString(),
+    status: TaskStatus[task.status] ?? "UNKNOWN",
+    created_at: task.createdAt,
+    accepted_at: task.acceptedAt,
+    completed_at: task.completedAt,
+    expires_at: task.expiresAt,
+    agreement_hash: task.agreementHash,
+    result
+  };
+}
+
+// src/resources/wallet.ts
+import { PaymentRail } from "@hivemind-os/collective-types";
+
+// src/tools/balance.ts
+var meshBalanceTool = {
+  name: "collective_balance",
+  description: "Get the current wallet balance in MIST and SUI",
+  inputSchema: {
+    type: "object",
+    properties: {},
+    required: []
+  }
+};
+async function runMeshBalance(_params, context) {
+  const address = context.keypair.getPublicKey().toSuiAddress();
+  const balanceMist = await context.suiClient.getBalance(address);
+  return {
+    address,
+    balance_mist: balanceMist.toString(),
+    balance_sui: formatMistToSui(balanceMist)
+  };
+}
+function formatMistToSui(balanceMist) {
+  const whole = balanceMist / 1000000000n;
+  const fraction = balanceMist % 1000000000n;
+  if (fraction === 0n) {
+    return whole.toString();
+  }
+  const fractionText = fraction.toString().padStart(9, "0").replace(/0+$/, "");
+  return `${whole.toString()}.${fractionText}`;
+}
+
+// src/resources/wallet.ts
+var meshWalletResource = {
+  uri: "mesh://wallet",
+  name: "Wallet Overview",
+  description: "Current wallet balance and local spending totals",
+  mimeType: "application/json"
+};
+async function readWalletResource(context) {
+  const address = context.keypair.getPublicKey().toSuiAddress();
+  const balance = await context.suiClient.getBalance(address);
+  return {
+    address,
+    balance_mist: balance.toString(),
+    balance_sui: formatMistToSui(balance),
+    spent_today_mist: context.spendingPolicy.getSpent("day", PaymentRail.SUI_ESCROW).toString(),
+    spent_month_mist: context.spendingPolicy.getSpent("month", PaymentRail.SUI_ESCROW).toString(),
+    rail: PaymentRail.SUI_ESCROW
+  };
+}
+
+// src/resources/index.ts
+var staticResources = [meshCapabilitiesResource, meshWalletResource];
+var resourceTemplates = [meshAgentResourceTemplate, meshTaskResourceTemplate];
+function registerResourceHandlers(server, context) {
+  server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+    resources: staticResources
+  }));
+  server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => ({
+    resourceTemplates
+  }));
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const uri = request.params.uri;
+    const data = await routeResourceRead(uri, context);
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: "application/json",
+          text: serialize(data)
+        }
+      ]
+    };
+  });
+}
+async function routeResourceRead(uri, context) {
+  const parsed = new URL(uri);
+  switch (parsed.host) {
+    case "capabilities":
+      return readCapabilitiesResource(context);
+    case "wallet":
+      return readWalletResource(context);
+    case "agent":
+      return readAgentResource(decodeURIComponent(parsed.pathname.replace(/^\//, "")), context);
+    case "task":
+      return readTaskResource(decodeURIComponent(parsed.pathname.replace(/^\//, "")), context);
+    default:
+      throw new Error(`Unknown resource: ${uri}`);
+  }
+}
+function serialize(payload) {
+  return JSON.stringify(payload, bigintReplacer, 2);
+}
+function bigintReplacer(_key, value) {
+  return typeof value === "bigint" ? value.toString() : value;
+}
+
+// src/tools/index.ts
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { SessionExpiredError } from "@hivemind-os/collective-core";
+
+// src/tools/indexer-client.ts
+async function executeIndexerQuery(context, query, variables) {
+  const endpoint = resolveIndexerUrl(context);
+  if (!endpoint) {
+    throw new Error("Indexer is not configured.");
+  }
+  const fetchImpl = context.indexer?.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(endpoint, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({ query, variables })
+  });
+  if (!response.ok) {
+    throw new Error(`Indexer query failed with status ${response.status}.`);
+  }
+  const payload = await response.json();
+  if (payload.errors && payload.errors.length > 0) {
+    throw new Error(payload.errors.map((entry) => entry.message ?? "Unknown GraphQL error").join("; "));
+  }
+  if (!payload.data) {
+    throw new Error("Indexer query returned no data.");
+  }
+  return payload.data;
+}
+async function queryIndexerAgents(context, params) {
+  const data = await executeIndexerQuery(
+    context,
+    `query IndexedAgents($capability: String, $limit: Int, $minReputation: Float, $category: String) {
+      agents(capability: $capability, limit: $limit, minReputation: $minReputation, category: $category) {
+        nodes {
+          id
+          owner
+          did
+          name
+          description
+          endpoint
+          active
+          version
+          registeredAt
+          updatedAt
+          totalTasksCompleted
+          totalTasksFailed
+          totalTasksDisputed
+          totalEarningsMist
+          hasStake
+          stakeMist
+          stakeType
+          capabilities {
+            name
+            description
+            version
+            executionMode
+            paymentRails
+            pricing {
+              rail
+              amount
+              currency
+            }
+          }
+        }
+      }
+    }`,
+    {
+      capability: params.capability,
+      limit: params.limit,
+      minReputation: params.minReputation,
+      category: params.category
+    }
+  );
+  return data.agents.nodes.map(mapGraphqlAgent);
+}
+function resolveIndexerUrl(context) {
+  const value = context.indexer?.graphqlUrl ?? process.env.COLLECTIVE_INDEXER_URL;
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function mapGraphqlAgent(agent) {
+  return {
+    id: agent.id,
+    owner: agent.owner,
+    did: agent.did,
+    name: agent.name,
+    description: agent.description,
+    endpoint: agent.endpoint ?? void 0,
+    active: agent.active,
+    version: agent.version,
+    registeredAt: Number(agent.registeredAt),
+    updatedAt: Number(agent.updatedAt),
+    totalTasksCompleted: agent.totalTasksCompleted,
+    totalTasksFailed: agent.totalTasksFailed,
+    totalTasksDisputed: agent.totalTasksDisputed,
+    totalEarningsMist: BigInt(agent.totalEarningsMist),
+    hasStake: agent.hasStake,
+    stakeMist: agent.stakeMist ? BigInt(agent.stakeMist) : void 0,
+    stakeType: agent.stakeType ?? void 0,
+    capabilities: agent.capabilities.map((capability) => ({
+      name: capability.name,
+      description: capability.description,
+      version: capability.version,
+      executionMode: capability.executionMode ?? void 0,
+      paymentRails: capability.paymentRails ?? void 0,
+      pricing: {
+        rail: capability.pricing.rail,
+        amount: BigInt(capability.pricing.amount),
+        currency: capability.pricing.currency
+      }
+    }))
+  };
+}
+
+// src/tools/analytics.ts
+var meshAnalyticsTool = {
+  name: "collective_analytics",
+  description: "Query task volume, top providers, and marketplace analytics from the Agentic Mesh indexer",
+  inputSchema: {
+    type: "object",
+    properties: {
+      view: { type: "string", enum: ["summary", "task-volume", "top-providers", "marketplace"] },
+      period: { type: "string", enum: ["HOUR", "DAY", "WEEK"] },
+      buckets: { type: "number" },
+      limit: { type: "number" },
+      sort_by: { type: "string", enum: ["COMPLETED_TASKS", "EARNINGS", "REPUTATION"] }
+    }
+  }
+};
+async function runMeshAnalytics(params, context) {
+  const view = params.view ?? "summary";
+  switch (view) {
+    case "task-volume": {
+      const data = await executeIndexerQuery(
+        context,
+        `query TaskVolume($period: TimePeriod!, $buckets: Int) {
+          taskVolume(period: $period, buckets: $buckets) {
+            label
+            count
+            volumeMist
+          }
+        }`,
+        {
+          period: params.period ?? "DAY",
+          buckets: params.buckets ?? 14
+        }
+      );
+      return { view, period: params.period ?? "DAY", buckets: params.buckets ?? 14, data: data.taskVolume };
+    }
+    case "top-providers": {
+      const data = await executeIndexerQuery(
+        context,
+        `query TopProviders($limit: Int, $sortBy: ProviderSortField) {
+          topProviders(limit: $limit, sortBy: $sortBy) {
+            did
+            owner
+            name
+            completedTasks
+            earningsMist
+            disputeCount
+            successRate
+            reputation
+          }
+        }`,
+        {
+          limit: params.limit ?? 10,
+          sortBy: params.sort_by ?? "COMPLETED_TASKS"
+        }
+      );
+      return { view, limit: params.limit ?? 10, sort_by: params.sort_by ?? "COMPLETED_TASKS", data: data.topProviders };
+    }
+    case "marketplace": {
+      const data = await executeIndexerQuery(
+        context,
+        `query MarketplaceAnalytics {
+          analytics {
+            marketplace {
+              averageBidCount
+              acceptanceRate
+              categoryPopularity {
+                category
+                taskCount
+              }
+            }
+          }
+        }`
+      );
+      return { view, data: data.analytics.marketplace };
+    }
+    case "summary":
+    default: {
+      const data = await executeIndexerQuery(
+        context,
+        `query AnalyticsSummary {
+          analytics {
+            totalAgents
+            activeAgents
+            totalTasks
+            completedTasks
+            disputedTasks
+            totalVolumeMist
+            averageGasCosts {
+              capability
+              averageGasMist
+              taskCount
+            }
+            marketplace {
+              averageBidCount
+              acceptanceRate
+              categoryPopularity {
+                category
+                taskCount
+              }
+            }
+          }
+        }`
+      );
+      return { view: "summary", data: data.analytics };
+    }
+  }
+}
+
+// src/tools/deactivate.ts
+var meshDeactivateTool = {
+  name: "collective_deactivate",
+  description: "Deactivate an existing agent card",
+  inputSchema: {
+    type: "object",
+    properties: {
+      agent_card_id: { type: "string", description: "Agent card object id" }
+    },
+    required: ["agent_card_id"]
+  }
+};
+async function runMeshDeactivate(params, context) {
+  const result = await context.registryClient.deactivateAgent({
+    cardId: params.agent_card_id,
+    keypair: context.keypair
+  });
+  context.agentCache.removeAgent(params.agent_card_id);
+  return {
+    tx_digest: result.txDigest,
+    status: "deactivated"
+  };
+}
+
+// src/tools/discover.ts
+import { ReputationScoreCalculator } from "@hivemind-os/collective-core";
+var scoreCalculator = new ReputationScoreCalculator();
+var meshDiscoverTool = {
+  name: "collective_discover",
+  description: "Find agents by capability on the Agentic Mesh network",
+  inputSchema: {
+    type: "object",
+    properties: {
+      capability: { type: "string", description: "Capability name to search for" },
+      limit: { type: "number", description: "Max results (default 10)" },
+      sort_by: { type: "string", enum: ["price", "reputation"], description: "Sort results by price or reputation" },
+      useIndexer: { type: "boolean", description: "Prefer the indexer GraphQL API when available" }
+    },
+    required: ["capability"]
+  }
+};
+async function runMeshDiscover(params, context) {
+  const capability = params.capability.trim();
+  const limit = normalizeLimit(params.limit);
+  const sortBy = params.sort_by ?? "price";
+  const { agents, source } = await discoverAgentsByCapability(capability, context, limit, sortBy, params.useIndexer);
+  return {
+    capability,
+    source,
+    agents: agents.map((agent) => summarizeAgent(agent, capability))
+  };
+}
+async function discoverAgentsByCapability(capability, context, limit = 10, sortBy = "price", useIndexer) {
+  const normalizedCapability = capability.trim();
+  if (!normalizedCapability) {
+    return { agents: [], source: "cache" };
+  }
+  if (shouldUseIndexer(context, useIndexer)) {
+    try {
+      const indexed = await queryIndexerAgents(context, {
+        capability: normalizedCapability,
+        limit
+      });
+      if (indexed.length > 0) {
+        return {
+          agents: sortBy === "reputation" ? indexed.slice(0, limit) : sortByPrice(indexed, normalizedCapability).slice(0, limit),
+          source: "indexer"
+        };
+      }
+    } catch (error) {
+      context.logger?.warn?.({ err: error }, "Indexer discovery failed; falling back to local cache.");
+    }
+  }
+  const cached = (await queryLocalCache(context, normalizedCapability, Math.max(limit * 2, limit), sortBy)).filter((agent) => hasCapability(agent, normalizedCapability)).slice(0, limit);
+  if (cached.length > 0) {
+    return {
+      agents: sortBy === "reputation" ? cached : sortByPrice(cached, normalizedCapability).slice(0, limit),
+      source: "cache"
+    };
+  }
+  const discovered = await context.registryClient.discoverByCapability(normalizedCapability, limit, {
+    sortByReputation: sortBy === "reputation"
+  });
+  for (const agent of discovered) {
+    context.agentCache.upsertAgent(agent);
+  }
+  const ranked = sortBy === "reputation" ? discovered : sortByPrice(discovered, normalizedCapability);
+  return { agents: ranked.slice(0, limit), source: "registry" };
+}
+async function resolveProviderCapability(capability, context, providerDid) {
+  const normalizedCapability = capability.trim();
+  if (!normalizedCapability) {
+    throw new Error("Capability is required.");
+  }
+  if (providerDid) {
+    const cachedAgent = context.agentCache.getAgentByDID(providerDid);
+    const cachedCapability = cachedAgent ? findCapability(cachedAgent, normalizedCapability) : void 0;
+    if (cachedAgent?.active && cachedCapability) {
+      return { agent: cachedAgent, capability: cachedCapability };
+    }
+    const { agents: agents2 } = await discoverAgentsByCapability(normalizedCapability, context, 50);
+    const matched = agents2.find((entry) => entry.did === providerDid);
+    const matchedCapability = matched ? findCapability(matched, normalizedCapability) : void 0;
+    if (!matched || !matchedCapability) {
+      throw new Error(`Provider ${providerDid} was not found for capability ${normalizedCapability}.`);
+    }
+    return { agent: matched, capability: matchedCapability };
+  }
+  const { agents } = await discoverAgentsByCapability(normalizedCapability, context, 20);
+  const ranked = agents.map((agent) => ({ agent, capability: findCapability(agent, normalizedCapability) })).filter((entry) => Boolean(entry.capability)).sort((left, right) => compareBigInt(left.capability.pricing.amount, right.capability.pricing.amount));
+  if (ranked.length === 0) {
+    throw new Error(`No providers found for capability ${normalizedCapability}.`);
+  }
+  return ranked[0];
+}
+function summarizeAgent(agent, capability) {
+  const scopedCapabilities = capability ? agent.capabilities.filter((entry) => capabilityNameEquals(entry.name, capability)) : agent.capabilities;
+  const reputation = scoreCalculator.computeScore(agent, []);
+  return {
+    name: agent.name,
+    did: agent.did,
+    capabilities: scopedCapabilities.map((entry) => entry.name),
+    pricing: scopedCapabilities.map((entry) => ({
+      capability: entry.name,
+      price_mist: entry.pricing.amount.toString(),
+      rail: entry.pricing.rail,
+      currency: entry.pricing.currency
+    })),
+    reputation: {
+      success_rate: reputation.successRate,
+      total_tasks: reputation.totalTasks,
+      total_disputes: reputation.totalDisputes,
+      total_earnings_mist: reputation.totalEarningsMist.toString()
+    },
+    endpoint: agent.endpoint
+  };
+}
+async function queryLocalCache(context, capability, limit, sortBy) {
+  const cache = context.agentCache;
+  if (typeof cache.queryAgentsAdvanced === "function") {
+    return await cache.queryAgentsAdvanced({
+      capability,
+      limit,
+      sortBy: sortBy === "reputation" ? "reputation" : "stake"
+    });
+  }
+  return context.agentCache.searchByCapability(capability, limit, { sortByReputation: sortBy === "reputation" });
+}
+function shouldUseIndexer(context, useIndexer) {
+  if (useIndexer === false) {
+    return false;
+  }
+  return Boolean(resolveIndexerUrl(context));
+}
+function findCapability(agent, capability) {
+  return agent.capabilities.find((entry) => capabilityNameEquals(entry.name, capability));
+}
+function hasCapability(agent, capability) {
+  return findCapability(agent, capability) !== void 0;
+}
+function capabilityNameEquals(left, right) {
+  return left.toLowerCase() === right.toLowerCase();
+}
+function compareBigInt(left, right) {
+  if (left === right) {
+    return 0;
+  }
+  return left < right ? -1 : 1;
+}
+function normalizeLimit(limit) {
+  if (typeof limit !== "number" || Number.isNaN(limit)) {
+    return 10;
+  }
+  return Math.max(1, Math.floor(limit));
+}
+function sortByPrice(agents, capability) {
+  return [...agents].sort((left, right) => {
+    const leftCapability = findCapability(left, capability);
+    const rightCapability = findCapability(right, capability);
+    if (!leftCapability && !rightCapability) {
+      return 0;
+    }
+    if (!leftCapability) {
+      return 1;
+    }
+    if (!rightCapability) {
+      return -1;
+    }
+    return compareBigInt(leftCapability.pricing.amount, rightCapability.pricing.amount);
+  });
+}
+
+// src/tools/dispute.ts
+import { DisputeClient } from "@hivemind-os/collective-core";
+var meshDisputeTool = {
+  name: "collective_dispute",
+  description: "Open, respond to, accept, or inspect on-chain task disputes",
+  inputSchema: {
+    type: "object",
+    properties: {
+      action: { type: "string", enum: ["open", "respond", "accept", "status"] },
+      task_id: { type: "string", description: "Task object id" },
+      dispute_id: { type: "string", description: "Dispute object id" },
+      evidence: { type: "string", description: "Plain text or JSON-encoded evidence to store before opening/responding" },
+      evidence_blob_id: { type: "string", description: "Existing Walrus/blobstore blob id containing dispute evidence" },
+      proposed_split_mist: { type: "string", description: "Amount, in MIST, to allocate back to the requester" },
+      arbitrator_address: { type: "string", description: "Optional arbitrator address for open actions" }
+    },
+    required: ["action"]
+  }
+};
+async function runMeshDispute(params, context) {
+  const client = context.disputeClient ?? new DisputeClient(context.suiClient, context.networkConfig);
+  switch (params.action) {
+    case "open": {
+      if (!params.task_id) {
+        throw new Error("task_id is required when action=open");
+      }
+      const evidenceBlobId = await resolveEvidenceBlobId(params, context);
+      const result = await client.openDispute({
+        taskId: params.task_id,
+        evidenceBlobId,
+        proposedSplitMist: parseMist(params.proposed_split_mist, "proposed_split_mist"),
+        arbitratorAddress: params.arbitrator_address,
+        signer: context.keypair
+      });
+      return {
+        action: "open",
+        dispute_id: result.disputeId,
+        task_id: params.task_id,
+        evidence_blob_id: evidenceBlobId,
+        tx_digest: result.txDigest
+      };
+    }
+    case "respond": {
+      if (!params.dispute_id) {
+        throw new Error("dispute_id is required when action=respond");
+      }
+      const evidenceBlobId = await resolveEvidenceBlobId(params, context);
+      const result = await client.respondToDispute({
+        disputeId: params.dispute_id,
+        evidenceBlobId,
+        proposedSplitMist: parseMist(params.proposed_split_mist, "proposed_split_mist"),
+        signer: context.keypair
+      });
+      return {
+        action: "respond",
+        dispute_id: params.dispute_id,
+        evidence_blob_id: evidenceBlobId,
+        tx_digest: result.txDigest
+      };
+    }
+    case "accept": {
+      if (!params.dispute_id || !params.task_id) {
+        throw new Error("dispute_id and task_id are required when action=accept");
+      }
+      const result = await client.acceptResolution({
+        disputeId: params.dispute_id,
+        taskId: params.task_id,
+        signer: context.keypair
+      });
+      return {
+        action: "accept",
+        dispute_id: params.dispute_id,
+        task_id: params.task_id,
+        requester_amount_mist: result.requesterAmount.toString(),
+        provider_amount_mist: result.providerAmount.toString(),
+        tx_digest: result.txDigest
+      };
+    }
+    case "status": {
+      if ((params.dispute_id ? 1 : 0) + (params.task_id ? 1 : 0) !== 1) {
+        throw new Error("Provide exactly one of dispute_id or task_id when action=status");
+      }
+      const dispute = params.dispute_id ? await client.getDispute(params.dispute_id) : await client.getDisputeByTask(params.task_id);
+      if (!dispute) {
+        throw new Error(params.task_id ? `No dispute found for task ${params.task_id}.` : `Dispute ${params.dispute_id ?? ""} was not found.`);
+      }
+      return {
+        action: "status",
+        dispute
+      };
+    }
+    default:
+      throw new Error(`Unknown dispute action: ${String(params.action)}`);
+  }
+}
+async function resolveEvidenceBlobId(params, context) {
+  if ((params.evidence_blob_id ? 1 : 0) + (params.evidence ? 1 : 0) !== 1) {
+    throw new Error("Provide exactly one of evidence or evidence_blob_id for dispute open/respond actions");
+  }
+  if (params.evidence_blob_id) {
+    return params.evidence_blob_id;
+  }
+  if (!params.evidence) {
+    throw new Error("evidence or evidence_blob_id is required for dispute open/respond actions");
+  }
+  const stored = await context.blobStore.store(new TextEncoder().encode(params.evidence));
+  return stored.blobId;
+}
+function parseMist(value, field) {
+  if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) {
+    return BigInt(value);
+  }
+  if (typeof value === "string" && /^\d+$/.test(value.trim())) {
+    return BigInt(value.trim());
+  }
+  throw new Error(`${field} must be a non-negative integer string.`);
+}
+
+// src/tools/execute.ts
+import { PaymentRail as PaymentRail2, TaskStatus as TaskStatus2 } from "@hivemind-os/collective-types";
+import { PaymentRailSelector, RelayConsumerClient, ReputationEventPublisher } from "@hivemind-os/collective-core";
+var encoder = new TextEncoder();
+var decoder2 = new TextDecoder();
+var DEFAULT_TIMEOUT_SECONDS = 120;
+var DEFAULT_DISPUTE_WINDOW_MS = 5 * 6e4;
+var DEFAULT_EXPIRY_HOURS = 24;
+var meshExecuteTool = {
+  name: "collective_execute",
+  description: "Execute a mesh task. Returns a task handle (async) if the client supports MCP Tasks, otherwise blocks until completion.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      capability: { type: "string", description: "Capability name to execute" },
+      provider_did: { type: "string", description: "Specific provider DID to use" },
+      input: { type: "string", description: "Task input payload" },
+      max_price_mist: { type: "number", description: "Maximum spend in MIST" },
+      timeout_seconds: { type: "number", description: "Polling timeout in seconds (default 120)" },
+      mode: { type: "string", enum: ["auto", "sync", "async"], description: "Execution preference (default auto)" }
+    },
+    required: ["capability", "input"]
+  }
+};
+async function runMeshExecute(params, context) {
+  const resolved = await resolveProviderCapability(params.capability, context, params.provider_did);
+  const priceMist = resolved.capability.pricing.amount;
+  const maxPrice = toOptionalBigInt(params.max_price_mist);
+  if (maxPrice !== void 0 && priceMist > maxPrice) {
+    throw new Error(`Provider price ${priceMist.toString()} exceeds max_price_mist ${maxPrice.toString()}.`);
+  }
+  const mode = params.mode ?? "auto";
+  if (mode !== "async") {
+    const relayResult = await tryRelayExecution(params, context, resolved, priceMist);
+    if (relayResult) {
+      await publishSuccessfulReputationEvent(context, {
+        providerDid: relayResult.provider_did,
+        taskId: relayResult.task_id,
+        capability: resolved.capability.name,
+        priceMist,
+        latencyMs: relayResult.latency_ms
+      });
+      return relayResult;
+    }
+  }
+  const prepared = await prepareAsyncExecution(params, context, resolved, priceMist);
+  const task = await waitForTaskCompletion(prepared.taskId, context, params.timeout_seconds);
+  if (!task.resultBlobId) {
+    throw new Error(`Task ${prepared.taskId} completed without a result blob.`);
+  }
+  const resultBytes = await fetchMeshBlob(context.blobStore, task.resultBlobId);
+  if (!resultBytes) {
+    throw new Error(`Result blob ${task.resultBlobId} was not found.`);
+  }
+  await context.taskClient.releasePayment({
+    taskId: prepared.taskId,
+    keypair: context.keypair
+  });
+  context.spendingPolicy.record({
+    amountMist: prepared.priceMist,
+    rail: prepared.rail,
+    taskId: prepared.taskId,
+    appId: prepared.providerDid,
+    originAppName: context.originAppName
+  });
+  await publishSuccessfulReputationEvent(context, {
+    providerDid: prepared.providerDid,
+    taskId: prepared.taskId,
+    capability: resolved.capability.name,
+    priceMist: prepared.priceMist,
+    latencyMs: task.acceptedAt && task.completedAt ? task.completedAt - task.acceptedAt : void 0
+  });
+  return {
+    task_id: prepared.taskId,
+    result: decoder2.decode(resultBytes),
+    provider_did: prepared.providerDid,
+    price_mist: prepared.priceMist.toString(),
+    status: TaskStatus2[TaskStatus2.RELEASED],
+    execution_mode: "async",
+    payment_rail: prepared.rail
+  };
+}
+async function prepareMeshExecution(params, context) {
+  const resolved = await resolveProviderCapability(params.capability, context, params.provider_did);
+  return prepareAsyncExecution(params, context, resolved, resolved.capability.pricing.amount);
+}
+async function prepareAsyncExecution(params, context, resolved, priceMist) {
+  if (resolved.capability.pricing.rail !== PaymentRail2.SUI_ESCROW) {
+    throw new Error(`Capability ${resolved.capability.name} does not support SUI escrow execution.`);
+  }
+  approveSpend(context, priceMist, resolved.capability.pricing.rail, resolved.agent.did);
+  const { blobId } = await storeTaskInput(context, resolved.agent, encoder.encode(params.input));
+  const posted = await context.taskClient.postTask({
+    capability: resolved.capability.name,
+    category: "general",
+    inputBlobId: blobId,
+    priceMist,
+    disputeWindowMs: DEFAULT_DISPUTE_WINDOW_MS,
+    expiryHours: DEFAULT_EXPIRY_HOURS,
+    keypair: context.keypair
+  });
+  return {
+    taskId: posted.taskId,
+    providerDid: resolved.agent.did,
+    priceMist,
+    rail: resolved.capability.pricing.rail
+  };
+}
+async function tryRelayExecution(params, context, resolved, priceMist) {
+  const relayUrl = getRelayUrl(resolved.agent);
+  if (!relayUrl || !context.relayAuthProvider) {
+    return null;
+  }
+  try {
+    const selector = context.paymentRailSelector ?? new PaymentRailSelector();
+    const selectedRail = selector.selectRail({
+      executionMode: "sync",
+      consumerHasSuiWallet: Boolean(context.relayAuthProvider),
+      consumerHasEvmWallet: Boolean(context.x402Client),
+      providerAcceptsSui: providerAcceptsSui(resolved.capability),
+      providerAcceptsX402: providerAcceptsX402(resolved.agent, resolved.capability),
+      amount: priceMist,
+      currency: resolved.capability.pricing.currency
+    });
+    const rail = toPaymentRail(selectedRail);
+    approveSpend(context, priceMist, rail, resolved.agent.did);
+    const client = new RelayConsumerClient(context.x402Client ?? null, context.relayAuthProvider, { relayUrl });
+    const response = await client.executeSync({
+      providerDid: resolved.agent.did,
+      capability: resolved.capability.name,
+      input: params.input,
+      paymentRail: rail,
+      timeoutMs: normalizeTimeoutMs(params.timeout_seconds)
+    });
+    const taskId = response.taskId ?? `relay-${resolved.agent.did}-${Date.now()}`;
+    context.spendingPolicy.record({
+      amountMist: priceMist,
+      rail,
+      taskId,
+      appId: resolved.agent.did,
+      originAppName: context.originAppName
+    });
+    return {
+      task_id: taskId,
+      result: stringifyRelayResult(response.result),
+      provider_did: response.providerDid ?? resolved.agent.did,
+      price_mist: priceMist.toString(),
+      status: "COMPLETED",
+      execution_mode: "sync",
+      payment_rail: rail,
+      payment_receipt: response.paymentReceipt,
+      latency_ms: response.latencyMs
+    };
+  } catch (error) {
+    if (!shouldFallbackToAsync(error)) {
+      throw error;
+    }
+    context.logger?.warn?.(
+      { err: error, providerDid: resolved.agent.did, capability: resolved.capability.name },
+      "Relay execution unavailable; falling back to async Sui flow."
+    );
+    return null;
+  }
+}
+async function waitForTaskCompletion(taskId, context, timeoutSeconds = DEFAULT_TIMEOUT_SECONDS) {
+  const timeoutMs = normalizeTimeoutMs(timeoutSeconds);
+  const startedAt = Date.now();
+  while (true) {
+    const task = await context.taskClient.getTask(taskId);
+    if (!task) {
+      throw new Error(`Task ${taskId} was not found.`);
+    }
+    if (task.status === TaskStatus2.COMPLETED || task.status === TaskStatus2.RELEASED) {
+      return task;
+    }
+    if (task.status === TaskStatus2.CANCELLED || task.status === TaskStatus2.DISPUTED) {
+      throw new Error(`Task ${taskId} ended with status ${taskStatusLabel(task.status)}.`);
+    }
+    const elapsedMs = Date.now() - startedAt;
+    if (elapsedMs >= timeoutMs) {
+      throw new Error(`Timed out waiting for task ${taskId} to complete.`);
+    }
+    const remainingMs = timeoutMs - elapsedMs;
+    await delay(Math.min(remainingMs, 1e3));
+  }
+}
+function approveSpend(context, amountMist, rail, appId) {
+  const decision = context.spendingPolicy.evaluate({
+    amountMist,
+    rail,
+    appId,
+    originAppName: context.originAppName
+  });
+  if (!decision.approved) {
+    throw new Error(decision.reason ?? "Spending policy rejected the request.");
+  }
+}
+function getRelayUrl(agent) {
+  const relayEndpoint = agent.relayEndpoints?.find((endpoint) => !endpoint.modes || endpoint.modes.includes("sync"));
+  if (relayEndpoint?.endpoint) {
+    return relayEndpoint.endpoint;
+  }
+  if (agent.endpoint && /^(https?|wss?):\/\//i.test(agent.endpoint)) {
+    return agent.endpoint;
+  }
+  return void 0;
+}
+function providerAcceptsSui(capability) {
+  return capability.paymentRails?.includes(PaymentRail2.SUI_TRANSFER) ?? capability.pricing.rail !== PaymentRail2.X402_BASE;
+}
+function providerAcceptsX402(agent, capability) {
+  return capability.paymentRails?.includes(PaymentRail2.X402_BASE) ?? Boolean(getRelayUrl(agent));
+}
+function toPaymentRail(selectedRail) {
+  switch (selectedRail) {
+    case "sui-escrow":
+      return PaymentRail2.SUI_ESCROW;
+    case "sui-transfer":
+      return PaymentRail2.SUI_TRANSFER;
+    case "x402-base":
+      return PaymentRail2.X402_BASE;
+  }
+}
+function shouldFallbackToAsync(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return /relay request timed out|fetch failed|provider .* is not connected to the relay|provider not found|payment challenge required|relay execution unavailable/i.test(
+    error.message
+  );
+}
+function stringifyRelayResult(result) {
+  return typeof result === "string" ? result : JSON.stringify(result);
+}
+function normalizeTimeoutMs(timeoutSeconds) {
+  if (typeof timeoutSeconds !== "number" || Number.isNaN(timeoutSeconds)) {
+    return DEFAULT_TIMEOUT_SECONDS * 1e3;
+  }
+  return Math.max(0, Math.floor(timeoutSeconds * 1e3));
+}
+function toOptionalBigInt(value) {
+  if (typeof value !== "number" || Number.isNaN(value)) {
+    return void 0;
+  }
+  return BigInt(Math.max(0, Math.floor(value)));
+}
+async function storeTaskInput(context, provider, input) {
+  const providerEncryptionKey = hexToBytes(provider.encryptionPublicKey);
+  const encryptionEnabled = context.encryption?.enabled ?? supportsEncryptedBlobs(context.blobStore);
+  const requireEncryption = context.encryption?.requireEncryption ?? false;
+  if (encryptionEnabled && providerEncryptionKey) {
+    if (!supportsEncryptedBlobs(context.blobStore)) {
+      throw new Error("Encryption is enabled, but the configured blobstore does not support encrypted payloads.");
+    }
+    return await context.blobStore.storeEncrypted(input, providerEncryptionKey);
+  }
+  if (requireEncryption) {
+    throw new Error(`Provider ${provider.did} does not publish an encryption key.`);
+  }
+  return await context.blobStore.store(input);
+}
+function taskStatusLabel(status) {
+  return TaskStatus2[status] ?? "UNKNOWN";
+}
+async function publishSuccessfulReputationEvent(context, params) {
+  const publisher = context.reputationPublisher ?? (hasSigningIdentity(context.relayAuthProvider) ? new ReputationEventPublisher(context.blobStore, context.relayAuthProvider) : null);
+  if (!publisher) {
+    return;
+  }
+  try {
+    const event = await publisher.createEvent({
+      type: "task_completion",
+      subject: params.providerDid,
+      taskId: params.taskId,
+      outcome: "success",
+      capability: params.capability,
+      latencyMs: params.latencyMs,
+      paymentAmount: {
+        amount: params.priceMist.toString(),
+        currency: "MIST"
+      }
+    });
+    await context.reputationStore?.addEvent(event);
+    await publisher.publishEvent(event);
+  } catch (error) {
+    context.logger?.warn?.({ err: error, taskId: params.taskId }, "Failed to publish reputation event.");
+  }
+}
+function hasSigningIdentity(identity) {
+  return Boolean(identity && typeof identity.getDID === "function" && typeof identity.signPersonalMessage === "function");
+}
+function delay(ms) {
+  return new Promise((resolvePromise) => {
+    setTimeout(resolvePromise, ms);
+  });
+}
+
+// src/tools/execute-async.ts
+var meshExecuteAsyncTool = {
+  name: "collective_execute_async",
+  description: "Submit a mesh task and return immediately",
+  inputSchema: {
+    type: "object",
+    properties: {
+      capability: { type: "string", description: "Capability name to execute" },
+      provider_did: { type: "string", description: "Specific provider DID to use" },
+      input: { type: "string", description: "Task input payload" },
+      max_price_mist: { type: "number", description: "Maximum spend in MIST" }
+    },
+    required: ["capability", "input"]
+  }
+};
+async function runMeshExecuteAsync(params, context) {
+  const prepared = await prepareMeshExecution(params, context);
+  return {
+    task_id: prepared.taskId,
+    provider_did: prepared.providerDid,
+    price_mist: prepared.priceMist.toString(),
+    status: "OPEN"
+  };
+}
+
+// src/tools/metering.ts
+import { decodeMeteredResult, getMeteredResultUnits, parseMeteredResultEnvelope, ResultVerifier } from "@hivemind-os/collective-core";
+import { PaymentRail as PaymentRail3, PaymentScheme, TaskStatus as TaskStatus3 } from "@hivemind-os/collective-types";
+var encoder2 = new TextEncoder();
+var decoder3 = new TextDecoder();
+var DEFAULT_TIMEOUT_SECONDS2 = 120;
+var DEFAULT_DISPUTE_WINDOW_MS2 = 5 * 6e4;
+var DEFAULT_EXPIRY_HOURS2 = 24;
+var meshMeteredExecuteTool = {
+  name: "collective_metered_execute",
+  description: "Execute a metered mesh task with capped escrow and result verification",
+  inputSchema: {
+    type: "object",
+    properties: {
+      capability: { type: "string", description: "Capability name to execute" },
+      provider_did: { type: "string", description: "Specific provider DID to use" },
+      input: { type: "string", description: "Task input payload" },
+      max_price_mist: { type: "number", description: "Maximum escrow in MIST" },
+      unit_price_mist: { type: "number", description: "Price per metered unit in MIST" },
+      timeout_seconds: { type: "number", description: "Polling timeout in seconds (default 120)" }
+    },
+    required: ["capability", "input", "max_price_mist", "unit_price_mist"]
+  }
+};
+var meshVerifyResultTool = {
+  name: "collective_verify_result",
+  description: "Verify a metered task result blob against its on-chain hash chain root",
+  inputSchema: {
+    type: "object",
+    properties: {
+      task_id: { type: "string", description: "Task object id" }
+    },
+    required: ["task_id"]
+  }
+};
+async function runMeshMeteredExecute(params, context) {
+  const resolved = await resolveProviderCapability(params.capability, context, params.provider_did);
+  if (resolved.capability.pricing.rail !== PaymentRail3.SUI_ESCROW) {
+    throw new Error(`Capability ${resolved.capability.name} does not support SUI escrow execution.`);
+  }
+  const maxPriceMist = toRequiredBigInt(params.max_price_mist, "max_price_mist");
+  const unitPriceMist = toRequiredBigInt(params.unit_price_mist, "unit_price_mist");
+  const spendingDecision = context.spendingPolicy.evaluate({
+    amountMist: maxPriceMist,
+    rail: PaymentRail3.SUI_ESCROW,
+    appId: resolved.agent.did,
+    originAppName: context.originAppName
+  });
+  if (!spendingDecision.approved) {
+    throw new Error(spendingDecision.reason ?? "Spending policy rejected the request.");
+  }
+  const inputBlob = await storeTaskInput2(context, resolved.agent, encoder2.encode(params.input));
+  const posted = await context.taskClient.postMeteredTask({
+    capability: resolved.capability.name,
+    category: "general",
+    inputBlobId: inputBlob.blobId,
+    agreementHash: `metered:${resolved.capability.name}`,
+    maxPriceMist,
+    unitPriceMist,
+    disputeWindowMs: DEFAULT_DISPUTE_WINDOW_MS2,
+    expiryHours: DEFAULT_EXPIRY_HOURS2,
+    keypair: context.keypair
+  });
+  const task = await waitForTaskCompletion(posted.taskId, context, params.timeout_seconds ?? DEFAULT_TIMEOUT_SECONDS2);
+  const verification = await verifyMeteredTaskResult(task.id, context);
+  await context.taskClient.releaseMeteredPayment({
+    taskId: task.id,
+    keypair: context.keypair
+  });
+  context.spendingPolicy.record({
+    amountMist: task.price,
+    rail: PaymentRail3.SUI_ESCROW,
+    taskId: task.id,
+    appId: resolved.agent.did,
+    originAppName: context.originAppName
+  });
+  return {
+    task_id: task.id,
+    provider_did: resolved.agent.did,
+    result: verification.result,
+    status: TaskStatus3[TaskStatus3.RELEASED],
+    payment_rail: PaymentRail3.SUI_ESCROW,
+    payment_scheme: PaymentScheme.UPTO,
+    max_price_mist: (task.maxPrice ?? maxPriceMist).toString(),
+    actual_price_mist: task.price.toString(),
+    unit_price_mist: (task.unitPrice ?? unitPriceMist).toString(),
+    metered_units: task.meteredUnits ?? verification.metered_units,
+    verification_hash: verification.verification_hash,
+    verified: verification.verified
+  };
+}
+async function runMeshVerifyResult(params, context) {
+  return await verifyMeteredTaskResult(params.task_id, context);
+}
+async function verifyMeteredTaskResult(taskId, context) {
+  const task = await context.taskClient.getTask(taskId);
+  if (!task) {
+    throw new Error(`Task ${taskId} was not found.`);
+  }
+  if (!task.resultBlobId) {
+    throw new Error(`Task ${taskId} does not have a result blob.`);
+  }
+  const resultBytes = await fetchMeshBlob(context.blobStore, task.resultBlobId);
+  if (!resultBytes) {
+    throw new Error(`Result blob ${task.resultBlobId} was not found.`);
+  }
+  const envelope = parseMeteredResultEnvelope(resultBytes);
+  if (!envelope) {
+    throw new Error(`Result blob ${task.resultBlobId} is not a metered result envelope.`);
+  }
+  const verifier = new ResultVerifier();
+  const verified = verifier.verify(task, envelope.proof, getMeteredResultUnits(envelope));
+  return {
+    task_id: task.id,
+    verified,
+    verification_hash: task.verificationHash ?? envelope.proof.root,
+    metered_units: task.meteredUnits ?? envelope.proof.unitCount,
+    result: decoder3.decode(decodeMeteredResult(envelope))
+  };
+}
+function toRequiredBigInt(value, name) {
+  if (typeof value !== "number" || Number.isNaN(value) || value < 0) {
+    throw new Error(`Invalid ${name}.`);
+  }
+  return BigInt(Math.floor(value));
+}
+async function storeTaskInput2(context, provider, input) {
+  const providerEncryptionKey = hexToBytes(provider.encryptionPublicKey) ?? void 0;
+  const encryptionEnabled = context.encryption?.enabled ?? supportsEncryptedBlobs(context.blobStore);
+  const requireEncryption = context.encryption?.requireEncryption ?? false;
+  if (encryptionEnabled && providerEncryptionKey) {
+    if (!supportsEncryptedBlobs(context.blobStore)) {
+      throw new Error("Encryption is enabled, but the configured blobstore does not support encrypted payloads.");
+    }
+    return await context.blobStore.storeEncrypted(input, providerEncryptionKey);
+  }
+  if (requireEncryption) {
+    throw new Error(`Provider ${provider.did} does not publish an encryption key.`);
+  }
+  return await context.blobStore.store(input);
+}
+
+// src/tools/marketplace-accept-bid.ts
+import { MarketplaceClient } from "@hivemind-os/collective-core";
+var meshMarketplaceAcceptBidTool = {
+  name: "collective_marketplace_accept_bid",
+  description: "Accept a marketplace bid and optionally reject competing bids",
+  inputSchema: {
+    type: "object",
+    properties: {
+      task_id: { type: "string", description: "Marketplace task id" },
+      bid_id: { type: "string", description: "Bid id to accept" },
+      reject_competing: { type: "boolean", description: "Reject other active bids in the same transaction (default true)" }
+    },
+    required: ["task_id", "bid_id"]
+  }
+};
+async function runMeshMarketplaceAcceptBid(params, context) {
+  const client = context.marketplaceClient ?? new MarketplaceClient(context.suiClient, context.networkConfig);
+  const result = await client.acceptBid({
+    taskId: params.task_id,
+    bidId: params.bid_id,
+    rejectCompeting: params.reject_competing,
+    signer: context.keypair
+  });
+  return {
+    task_id: params.task_id,
+    bid_id: params.bid_id,
+    rejected_bid_ids: result.rejectedBidIds,
+    tx_digest: result.txDigest
+  };
+}
+
+// src/tools/marketplace-bid.ts
+import { MarketplaceClient as MarketplaceClient2 } from "@hivemind-os/collective-core";
+var meshMarketplaceBidTool = {
+  name: "collective_marketplace_bid",
+  description: "Place a marketplace bid on an open task",
+  inputSchema: {
+    type: "object",
+    properties: {
+      task_id: { type: "string", description: "Open task object id" },
+      bid_price_mist: { type: "string", description: "Bid price in MIST" },
+      reputation_score: { type: "string", description: "Optional reputation score override" },
+      evidence: { type: "string", description: "Optional proposal or qualifications blob content" }
+    },
+    required: ["task_id", "bid_price_mist"]
+  }
+};
+async function runMeshMarketplaceBid(params, context) {
+  const client = context.marketplaceClient ?? new MarketplaceClient2(context.suiClient, context.networkConfig);
+  const result = await client.placeBid({
+    taskId: params.task_id,
+    bidPriceMist: parseMist2(params.bid_price_mist, "bid_price_mist"),
+    reputationScore: params.reputation_score == null ? void 0 : parseMist2(params.reputation_score, "reputation_score"),
+    evidenceBlob: params.evidence,
+    signer: context.keypair
+  });
+  return {
+    bid_id: result.bidId,
+    task_id: params.task_id,
+    tx_digest: result.txDigest,
+    reputation_score: result.reputationScore.toString()
+  };
+}
+function parseMist2(value, field) {
+  if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) {
+    return BigInt(value);
+  }
+  if (typeof value === "string" && /^\d+$/.test(value.trim())) {
+    return BigInt(value.trim());
+  }
+  throw new Error(`${field} must be a non-negative integer string.`);
+}
+
+// src/tools/marketplace-browse.ts
+import { MarketplaceClient as MarketplaceClient3 } from "@hivemind-os/collective-core";
+var meshMarketplaceBrowseTool = {
+  name: "collective_marketplace_browse",
+  description: "Browse open marketplace tasks by category and price filters",
+  inputSchema: {
+    type: "object",
+    properties: {
+      category: { type: "string", description: "Optional marketplace category filter" },
+      min_price_mist: { type: "string", description: "Optional minimum escrow budget in MIST" },
+      max_price_mist: { type: "string", description: "Optional maximum escrow budget in MIST" },
+      limit: { type: "number", description: "Maximum number of open tasks to return (default 20)" }
+    },
+    required: []
+  }
+};
+async function runMeshMarketplaceBrowse(params, context) {
+  const client = context.marketplaceClient ?? new MarketplaceClient3(context.suiClient, context.networkConfig);
+  const tasks = await client.browseOpenTasks({
+    category: params.category,
+    minPriceMist: parseOptionalMist(params.min_price_mist),
+    maxPriceMist: parseOptionalMist(params.max_price_mist),
+    limit: normalizeLimit2(params.limit)
+  });
+  return {
+    tasks,
+    count: tasks.length
+  };
+}
+function parseOptionalMist(value) {
+  if (value == null) {
+    return void 0;
+  }
+  if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) {
+    return BigInt(value);
+  }
+  if (typeof value === "string" && /^\d+$/.test(value.trim())) {
+    return BigInt(value.trim());
+  }
+  throw new Error("Price filters must be non-negative integer strings.");
+}
+function normalizeLimit2(limit) {
+  if (limit == null) {
+    return 20;
+  }
+  if (!Number.isSafeInteger(limit) || limit <= 0) {
+    throw new Error("limit must be a positive integer.");
+  }
+  return limit;
+}
+
+// src/tools/marketplace-post.ts
+import { MarketplaceClient as MarketplaceClient4 } from "@hivemind-os/collective-core";
+var DEFAULT_DISPUTE_WINDOW_MS3 = 6e4;
+var DEFAULT_EXPIRY_HOURS3 = 24;
+var meshMarketplacePostTool = {
+  name: "collective_marketplace_post",
+  description: "Post an open marketplace task with category metadata",
+  inputSchema: {
+    type: "object",
+    properties: {
+      capability: { type: "string", description: "Capability requested for the task" },
+      category: { type: "string", description: "Marketplace category used for browsing" },
+      price_mist: { type: "string", description: "Escrowed task budget in MIST" },
+      input: { type: "string", description: "Inline task input to upload to blob storage" },
+      input_blob_id: { type: "string", description: "Existing blob id containing task input" },
+      agreement_hash: { type: "string", description: "Optional agreement hash or plaintext summary" },
+      dispute_window_ms: { type: "number", description: "Optional dispute window override in milliseconds" },
+      expiry_hours: { type: "number", description: "Optional task expiry in hours" }
+    },
+    required: ["capability", "category", "price_mist"]
+  }
+};
+async function runMeshMarketplacePost(params, context) {
+  const client = context.marketplaceClient ?? new MarketplaceClient4(context.suiClient, context.networkConfig);
+  const inputBlobId = await resolveInputBlobId(params, context);
+  const result = await client.postOpenTask({
+    capability: params.capability,
+    category: params.category,
+    inputBlobId,
+    agreementHash: params.agreement_hash,
+    priceMist: parseMist3(params.price_mist, "price_mist"),
+    disputeWindowMs: normalizeNonNegativeInteger(params.dispute_window_ms, DEFAULT_DISPUTE_WINDOW_MS3, "dispute_window_ms"),
+    expiryHours: normalizeNonNegativeInteger(params.expiry_hours, DEFAULT_EXPIRY_HOURS3, "expiry_hours"),
+    signer: context.keypair
+  });
+  return {
+    task_id: result.taskId,
+    tx_digest: result.txDigest,
+    capability: params.capability,
+    category: params.category,
+    input_blob_id: inputBlobId
+  };
+}
+async function resolveInputBlobId(params, context) {
+  if ((params.input_blob_id ? 1 : 0) + (params.input ? 1 : 0) !== 1) {
+    throw new Error("Provide exactly one of input or input_blob_id when posting a marketplace task");
+  }
+  if (params.input_blob_id) {
+    return params.input_blob_id;
+  }
+  if (!params.input) {
+    throw new Error("input or input_blob_id is required when posting a marketplace task");
+  }
+  const stored = await context.blobStore.store(new TextEncoder().encode(params.input));
+  return stored.blobId;
+}
+function parseMist3(value, field) {
+  if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) {
+    return BigInt(value);
+  }
+  if (typeof value === "string" && /^\d+$/.test(value.trim())) {
+    return BigInt(value.trim());
+  }
+  throw new Error(`${field} must be a non-negative integer string.`);
+}
+function normalizeNonNegativeInteger(value, fallback, field) {
+  if (value == null) {
+    return fallback;
+  }
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new Error(`${field} must be a non-negative integer.`);
+  }
+  return value;
+}
+
+// src/tools/multi-execute.ts
+import {
+  AggregationMode,
+  ProviderSelectionStrategy
+} from "@hivemind-os/collective-types";
+import {
+  CircuitBreaker,
+  FanOutExecutor,
+  PerformanceTracker,
+  ProviderSelector
+} from "@hivemind-os/collective-core";
+var routingCircuitBreaker = new CircuitBreaker();
+var routingPerformanceTracker = new PerformanceTracker();
+var providerSelector = new ProviderSelector({
+  circuitBreaker: routingCircuitBreaker,
+  performanceTracker: routingPerformanceTracker
+});
+var meshMultiExecuteTool = {
+  name: "collective_multi_execute",
+  description: "Execute a mesh task across multiple providers and aggregate the results",
+  inputSchema: {
+    type: "object",
+    properties: {
+      capability: { type: "string", description: "Capability name to execute" },
+      input: { description: "Task input payload" },
+      fanOutCount: { type: "number", description: "How many providers to fan out to (default 3)" },
+      strategy: {
+        type: "string",
+        enum: Object.values(ProviderSelectionStrategy),
+        description: "Provider selection strategy (default weighted)"
+      },
+      aggregation: {
+        type: "string",
+        enum: Object.values(AggregationMode),
+        description: "Aggregation mode (default first_success)"
+      },
+      timeout: { type: "number", description: "Per-provider timeout in milliseconds" },
+      maxPricePerProvider: { type: "number", description: "Maximum price per provider in MIST" }
+    },
+    required: ["capability", "input"]
+  }
+};
+async function runMeshMultiExecute(params, context) {
+  const capability = params.capability.trim();
+  if (!capability) {
+    throw new Error("Capability is required.");
+  }
+  const fanOutCount = normalizePositiveInteger(params.fanOutCount, 3);
+  const strategy = parseSelectionStrategy(params.strategy);
+  const aggregation = parseAggregation(params.aggregation);
+  const request = {
+    capability,
+    input: params.input,
+    fanOutCount,
+    strategy,
+    aggregation,
+    timeout: normalizeOptionalInteger(params.timeout),
+    maxPricePerProvider: toOptionalBigInt2(params.maxPricePerProvider)
+  };
+  const { agents: discoveredAgents } = await discoverAgentsByCapability(
+    capability,
+    context,
+    Math.max(fanOutCount * 3, fanOutCount),
+    "reputation"
+  );
+  const candidates = filterByMaxPrice(discoveredAgents, capability, request.maxPricePerProvider);
+  const selected = providerSelector.selectProviders(candidates, capability, strategy, fanOutCount);
+  if (selected.length === 0) {
+    throw new Error(`No eligible providers found for capability ${capability}.`);
+  }
+  const executor = new FanOutExecutor({
+    circuitBreaker: routingCircuitBreaker,
+    performanceTracker: routingPerformanceTracker,
+    executeProvider: async (provider, executionRequest, executionContext) => {
+      if (executionContext.signal.aborted) {
+        throw executionContext.signal.reason ?? new Error("Provider execution aborted.");
+      }
+      const value = await runMeshExecute({
+        capability: executionRequest.capability,
+        provider_did: provider.did,
+        input: serializeInput(executionRequest.input),
+        timeout_seconds: executionRequest.timeout ? Math.max(1, Math.ceil(executionRequest.timeout / 1e3)) : void 0
+      }, context);
+      return {
+        value,
+        aggregateValue: value.result,
+        cost: BigInt(value.price_mist)
+      };
+    }
+  });
+  const result = await executor.execute(request, selected);
+  return {
+    capability,
+    strategy,
+    aggregation,
+    providers: selected.map((provider) => ({
+      did: provider.did,
+      price_mist: provider.price.toString(),
+      reputation: provider.reputation,
+      estimated_latency_ms: provider.estimatedLatency,
+      composite_score: provider.compositeScore
+    })),
+    results: result.results.map((entry) => ({
+      provider: entry.provider,
+      status: entry.status,
+      result: entry.result,
+      duration_ms: entry.durationMs,
+      error: entry.error
+    })),
+    aggregated_result: result.aggregatedResult,
+    total_cost_mist: result.totalCost.toString()
+  };
+}
+function filterByMaxPrice(agents, capability, maxPricePerProvider) {
+  if (maxPricePerProvider === void 0) {
+    return agents;
+  }
+  return agents.filter((agent) => {
+    const matched = agent.capabilities.find((entry) => entry.name.toLowerCase() === capability.toLowerCase());
+    return matched ? matched.pricing.amount <= maxPricePerProvider : false;
+  });
+}
+function parseSelectionStrategy(strategy) {
+  if (!strategy) {
+    return ProviderSelectionStrategy.WEIGHTED;
+  }
+  if (Object.values(ProviderSelectionStrategy).includes(strategy)) {
+    return strategy;
+  }
+  throw new Error(`Unsupported provider selection strategy: ${String(strategy)}.`);
+}
+function parseAggregation(aggregation) {
+  if (!aggregation) {
+    return AggregationMode.FIRST_SUCCESS;
+  }
+  if (Object.values(AggregationMode).includes(aggregation)) {
+    return aggregation;
+  }
+  throw new Error(`Unsupported aggregation mode: ${String(aggregation)}.`);
+}
+function normalizePositiveInteger(value, fallback) {
+  if (typeof value !== "number" || Number.isNaN(value)) {
+    return fallback;
+  }
+  return Math.max(1, Math.floor(value));
+}
+function normalizeOptionalInteger(value) {
+  if (typeof value !== "number" || Number.isNaN(value)) {
+    return void 0;
+  }
+  return Math.max(1, Math.floor(value));
+}
+function toOptionalBigInt2(value) {
+  if (typeof value !== "number" || Number.isNaN(value)) {
+    return void 0;
+  }
+  return BigInt(Math.max(0, Math.floor(value)));
+}
+function serializeInput(input) {
+  return typeof input === "string" ? input : JSON.stringify(input);
+}
+
+// src/tools/policy-update.ts
+import { PaymentRail as PaymentRail4 } from "@hivemind-os/collective-types";
+var meshPolicyUpdateTool = {
+  name: "collective_policy_update",
+  description: "Update local spending policy limits",
+  inputSchema: {
+    type: "object",
+    properties: {
+      daily_limit_mist: { type: "number", description: "Daily MIST limit" },
+      monthly_limit_mist: { type: "number", description: "Monthly MIST limit" },
+      per_task_limit_mist: { type: "number", description: "Per-task MIST limit" }
+    },
+    required: []
+  }
+};
+async function runMeshPolicyUpdate(params, context) {
+  const currentPolicy = clonePolicy(readPolicySnapshot(context));
+  const nextLimits = [...currentPolicy.limits];
+  applyLimit(nextLimits, "transaction", params.per_task_limit_mist);
+  applyLimit(nextLimits, "day", params.daily_limit_mist);
+  applyLimit(nextLimits, "month", params.monthly_limit_mist);
+  const updatedPolicy = {
+    ...currentPolicy,
+    limits: nextLimits
+  };
+  context.spendingPolicy.updatePolicy(updatedPolicy);
+  return {
+    updated: true,
+    limits: updatedPolicy.limits.map((limit) => ({
+      interval: limit.interval,
+      amount_mist: limit.amount.toString(),
+      rail: limit.rail ?? PaymentRail4.SUI_ESCROW
+    }))
+  };
+}
+function readPolicySnapshot(context) {
+  const engineWithPolicy = context.spendingPolicy;
+  return engineWithPolicy.policy ?? { limits: [] };
+}
+function clonePolicy(policy) {
+  return {
+    ...policy,
+    limits: policy.limits.map((limit) => ({ ...limit })),
+    allowlist: policy.allowlist ? [...policy.allowlist] : void 0,
+    denylist: policy.denylist ? [...policy.denylist] : void 0
+  };
+}
+function applyLimit(limits, interval, amount) {
+  if (typeof amount !== "number" || Number.isNaN(amount)) {
+    return;
+  }
+  const nextLimit = {
+    amount: BigInt(Math.max(0, Math.floor(amount))),
+    interval,
+    rail: PaymentRail4.SUI_ESCROW
+  };
+  const index = limits.findIndex(
+    (entry) => entry.interval === interval && (entry.rail ?? PaymentRail4.SUI_ESCROW) === PaymentRail4.SUI_ESCROW
+  );
+  if (index >= 0) {
+    limits[index] = nextLimit;
+    return;
+  }
+  limits.push(nextLimit);
+}
+
+// src/tools/register.ts
+import { PaymentRail as PaymentRail5 } from "@hivemind-os/collective-types";
+var meshRegisterTool = {
+  name: "collective_register",
+  description: "Register the current daemon identity as a provider",
+  inputSchema: {
+    type: "object",
+    properties: {
+      name: { type: "string", description: "Display name for the agent" },
+      description: { type: "string", description: "Agent description" },
+      capabilities: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            description: { type: "string" },
+            version: { type: "string" },
+            price_mist: { type: "number" }
+          },
+          required: ["name", "description", "version", "price_mist"]
+        }
+      }
+    },
+    required: ["name", "description", "capabilities"]
+  }
+};
+async function runMeshRegister(params, context) {
+  const capabilities = params.capabilities.map((entry) => ({
+    name: entry.name,
+    description: entry.description,
+    version: entry.version,
+    pricing: {
+      rail: PaymentRail5.SUI_ESCROW,
+      amount: BigInt(Math.max(0, Math.floor(entry.price_mist))),
+      currency: "MIST"
+    }
+  }));
+  const result = await context.registryClient.registerAgent({
+    name: params.name,
+    did: context.did,
+    description: params.description,
+    capabilities,
+    endpoint: `mesh://agent/${context.did}`,
+    encryptionPublicKey: context.encryption?.enabled ? hexToBytes(context.encryption.publicKey) ?? void 0 : void 0,
+    keypair: context.keypair
+  });
+  const card = await context.registryClient.getAgentCard(result.agentCardId);
+  if (card) {
+    context.agentCache.upsertAgent(card);
+  }
+  return {
+    agent_card_id: result.agentCardId,
+    did: context.did,
+    tx_digest: result.txDigest
+  };
+}
+
+// src/tools/relay-registry.ts
+import { RelayRegistryClient } from "@hivemind-os/collective-core";
+var meshRelayRegistryTool = {
+  name: "collective_relay_registry",
+  description: "List registered community relays or register this node as a relay operator",
+  inputSchema: {
+    type: "object",
+    properties: {
+      action: { type: "string", enum: ["list", "register"] },
+      endpoint: { type: "string", description: "Relay websocket or HTTPS endpoint when action=register" },
+      stake_id: { type: "string", description: "Relay stake position object id when action=register" },
+      region: { type: "string", description: "Relay region label when action=register" },
+      routing_fee_bps: { type: "number", description: "Routing fee in basis points when action=register" },
+      capabilities: {
+        type: "array",
+        items: { type: "string" },
+        description: 'Optional relay capabilities when action=register (defaults to ["routing"])'
+      }
+    },
+    required: ["action"]
+  }
+};
+async function runMeshRelayRegistry(params, context) {
+  const client = context.relayRegistryClient ?? new RelayRegistryClient(context.suiClient, context.networkConfig);
+  switch (params.action) {
+    case "list": {
+      const relays = await client.listRelays();
+      return {
+        action: "list",
+        count: relays.length,
+        relays
+      };
+    }
+    case "register": {
+      const endpoint = requireNonEmpty(params.endpoint, "endpoint");
+      const stakeId = requireNonEmpty(params.stake_id, "stake_id");
+      const region = requireNonEmpty(params.region, "region");
+      if (params.routing_fee_bps === void 0) {
+        throw new Error("routing_fee_bps is required when action=register");
+      }
+      if (!Number.isInteger(params.routing_fee_bps) || params.routing_fee_bps < 0 || params.routing_fee_bps > 1e4) {
+        throw new Error("routing_fee_bps must be an integer between 0 and 10000");
+      }
+      const capabilities = normalizeCapabilities(params.capabilities);
+      const result = await client.registerRelay({
+        endpoint,
+        stakeId,
+        region,
+        routingFeeBps: params.routing_fee_bps,
+        capabilities,
+        signer: context.keypair
+      });
+      return {
+        action: "register",
+        relay_id: result.relayId,
+        tx_digest: result.txDigest,
+        endpoint,
+        region,
+        routing_fee_bps: params.routing_fee_bps,
+        capabilities
+      };
+    }
+    default:
+      throw new Error(`Unknown relay registry action: ${String(params.action)}`);
+  }
+}
+function requireNonEmpty(value, field) {
+  const normalized = value?.trim();
+  if (!normalized) {
+    throw new Error(`${field} is required when action=register`);
+  }
+  return normalized;
+}
+function normalizeCapabilities(capabilities) {
+  const normalized = capabilities?.map((capability) => capability.trim()).filter(Boolean) ?? [];
+  return normalized.length > 0 ? [...new Set(normalized)] : ["routing"];
+}
+
+// src/tools/stake.ts
+import { StakingClient, STAKING_COOLDOWN_MS } from "@hivemind-os/collective-core";
+var meshStakeTool = {
+  name: "collective_stake",
+  description: "Manage stake deposits, status, and withdrawals for the local Agentic Mesh identity",
+  inputSchema: {
+    type: "object",
+    properties: {
+      action: { type: "string", enum: ["deposit", "status", "withdraw"] },
+      amount_sui: { type: "string", description: "SUI amount to deposit when action=deposit" },
+      stake_type: { type: "string", enum: ["agent", "relay"], description: "Stake type for deposits (default agent)" }
+    },
+    required: ["action"]
+  }
+};
+async function runMeshStake(params, context) {
+  const client = context.stakingClient ?? new StakingClient(context.suiClient, context.networkConfig);
+  const owner = context.keypair.getPublicKey().toSuiAddress();
+  switch (params.action) {
+    case "deposit": {
+      if (!params.amount_sui) {
+        throw new Error("amount_sui is required when action=deposit");
+      }
+      const amountMist = parseSuiToMist(params.amount_sui);
+      const result = await client.depositStake({
+        amountMist,
+        stakeType: params.stake_type ?? "agent",
+        signer: context.keypair
+      });
+      return {
+        action: "deposit",
+        stake_id: result.stakeId,
+        tx_digest: result.txDigest,
+        amount_mist: amountMist.toString(),
+        amount_sui: params.amount_sui,
+        stake_type: params.stake_type ?? "agent"
+      };
+    }
+    case "status": {
+      const stake = await client.getStakeByOwner(owner);
+      return {
+        action: "status",
+        owner,
+        staked: Boolean(stake),
+        stake
+      };
+    }
+    case "withdraw": {
+      const stake = await client.getStakeByOwner(owner);
+      if (!stake) {
+        throw new Error("No stake position found for this wallet.");
+      }
+      if (stake.deactivatedAt === 0) {
+        const result2 = await client.startDeactivation({ stakeId: stake.id, signer: context.keypair });
+        return {
+          action: "deactivation_started",
+          stake_id: stake.id,
+          cooldown_ends_at: result2.cooldownEndsAt,
+          tx_digest: result2.txDigest
+        };
+      }
+      const cooldownEndsAt = stake.deactivatedAt + STAKING_COOLDOWN_MS;
+      if (Date.now() < cooldownEndsAt) {
+        return {
+          action: "cooling_down",
+          stake_id: stake.id,
+          cooldown_ends_at: cooldownEndsAt,
+          cooldown_remaining_ms: Math.max(cooldownEndsAt - Date.now(), 0)
+        };
+      }
+      const result = await client.withdrawStake({ stakeId: stake.id, signer: context.keypair });
+      return {
+        action: "withdrawn",
+        stake_id: stake.id,
+        amount_returned_mist: result.amountReturned.toString(),
+        tx_digest: result.txDigest
+      };
+    }
+    default:
+      throw new Error(`Unknown staking action: ${String(params.action)}`);
+  }
+}
+function parseSuiToMist(input) {
+  const trimmed = input.trim();
+  if (!/^\d+(?:\.\d{1,9})?$/.test(trimmed)) {
+    throw new Error(`Invalid SUI amount: ${input}`);
+  }
+  const [whole, fraction = ""] = trimmed.split(".");
+  return BigInt(whole) * 1000000000n + BigInt(fraction.padEnd(9, "0"));
+}
+
+// src/tools/task-history.ts
+var meshTaskHistoryTool = {
+  name: "collective_task_history",
+  description: "Query locally persisted task history",
+  inputSchema: {
+    type: "object",
+    properties: {
+      limit: { type: "number", description: "Max task rows to return (default 20)" },
+      status_filter: { type: "string", description: "Optional task status filter" }
+    },
+    required: []
+  }
+};
+async function runMeshTaskHistory(params, context) {
+  const db = context.taskHistoryDb;
+  if (!db?.prepare) {
+    return {
+      tasks: [],
+      note: "Local task history is not initialized yet."
+    };
+  }
+  const limit = normalizeLimit3(params.limit);
+  const statusFilter = params.status_filter?.trim();
+  try {
+    const statement = statusFilter ? db.prepare(
+      "SELECT * FROM task_history WHERE status = ? ORDER BY created_at DESC LIMIT ?"
+    ) : db.prepare("SELECT * FROM task_history ORDER BY created_at DESC LIMIT ?");
+    const rows = statusFilter ? statement.all(statusFilter, limit) : statement.all(limit);
+    return {
+      tasks: rows.map((row) => serializeBigInts(row))
+    };
+  } catch {
+    return {
+      tasks: [],
+      note: "Local task history database is not available yet."
+    };
+  }
+}
+function normalizeLimit3(limit) {
+  if (typeof limit !== "number" || Number.isNaN(limit)) {
+    return 20;
+  }
+  return Math.max(1, Math.floor(limit));
+}
+function serializeBigInts(value) {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => serializeBigInts(entry));
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [key, serializeBigInts(entry)])
+    );
+  }
+  return value;
+}
+
+// src/tools/task-status.ts
+import { decodeMeteredResult as decodeMeteredResult2, parseMeteredResultEnvelope as parseMeteredResultEnvelope2 } from "@hivemind-os/collective-core";
+import { TaskStatus as TaskStatus4 } from "@hivemind-os/collective-types";
+var decoder4 = new TextDecoder();
+var meshTaskStatusTool = {
+  name: "collective_task_status",
+  description: "Get task status and fetch the result if available",
+  inputSchema: {
+    type: "object",
+    properties: {
+      task_id: { type: "string", description: "Task object id" }
+    },
+    required: ["task_id"]
+  }
+};
+async function runMeshTaskStatus(params, context) {
+  const task = await context.taskClient.getTask(params.task_id);
+  if (!task) {
+    throw new Error(`Task ${params.task_id} was not found.`);
+  }
+  let result;
+  if ((task.status === TaskStatus4.COMPLETED || task.status === TaskStatus4.RELEASED) && task.resultBlobId) {
+    const resultBytes = await fetchMeshBlob(context.blobStore, task.resultBlobId);
+    if (resultBytes) {
+      const envelope = parseMeteredResultEnvelope2(resultBytes);
+      result = decoder4.decode(envelope ? decodeMeteredResult2(envelope) : resultBytes);
+    }
+  }
+  return {
+    task_id: task.id,
+    status: TaskStatus4[task.status] ?? "UNKNOWN",
+    provider_did: findProviderDid(context, task.provider),
+    result,
+    price_mist: task.price.toString(),
+    created_at: task.createdAt
+  };
+}
+function findProviderDid(context, owner) {
+  if (!owner) {
+    return void 0;
+  }
+  return context.agentCache.getAllActive(1e3).find((agent) => agent.owner === owner)?.did;
+}
+
+// src/tools/index.ts
+var toolDefinitions = [
+  meshAnalyticsTool,
+  meshDiscoverTool,
+  meshDisputeTool,
+  meshExecuteTool,
+  meshExecuteAsyncTool,
+  meshMeteredExecuteTool,
+  meshVerifyResultTool,
+  meshMarketplacePostTool,
+  meshMarketplaceBrowseTool,
+  meshMultiExecuteTool,
+  meshMarketplaceBidTool,
+  meshMarketplaceAcceptBidTool,
+  meshTaskStatusTool,
+  meshRegisterTool,
+  meshDeactivateTool,
+  meshBalanceTool,
+  meshPolicyUpdateTool,
+  meshStakeTool,
+  meshRelayRegistryTool,
+  meshTaskHistoryTool
+];
+var meshToolHandlers = {
+  [meshAnalyticsTool.name]: runMeshAnalytics,
+  [meshDiscoverTool.name]: runMeshDiscover,
+  [meshDisputeTool.name]: runMeshDispute,
+  [meshExecuteTool.name]: runMeshExecute,
+  [meshExecuteAsyncTool.name]: runMeshExecuteAsync,
+  [meshMeteredExecuteTool.name]: runMeshMeteredExecute,
+  [meshVerifyResultTool.name]: runMeshVerifyResult,
+  [meshMarketplacePostTool.name]: runMeshMarketplacePost,
+  [meshMarketplaceBrowseTool.name]: runMeshMarketplaceBrowse,
+  [meshMultiExecuteTool.name]: runMeshMultiExecute,
+  [meshMarketplaceBidTool.name]: runMeshMarketplaceBid,
+  [meshMarketplaceAcceptBidTool.name]: runMeshMarketplaceAcceptBid,
+  [meshTaskStatusTool.name]: runMeshTaskStatus,
+  [meshRegisterTool.name]: runMeshRegister,
+  [meshDeactivateTool.name]: runMeshDeactivate,
+  [meshBalanceTool.name]: runMeshBalance,
+  [meshPolicyUpdateTool.name]: runMeshPolicyUpdate,
+  [meshStakeTool.name]: runMeshStake,
+  [meshRelayRegistryTool.name]: runMeshRelayRegistry,
+  [meshTaskHistoryTool.name]: runMeshTaskHistory
+};
+function registerToolHandlers(server, context) {
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: toolDefinitions
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const handler = meshToolHandlers[request.params.name];
+    if (!handler) {
+      return createErrorResult(`Unknown tool: ${request.params.name}`);
+    }
+    try {
+      const response = await handler(request.params.arguments ?? {}, context);
+      return createSuccessResult(response);
+    } catch (error) {
+      const message = error instanceof SessionExpiredError ? "Authentication expired. Please re-authenticate via the daemon portal." : error instanceof Error ? error.message : String(error);
+      const sessionState = await getSessionState(context);
+      return createErrorResult(
+        sessionState ? `${message} (session state: ${sessionState})` : message,
+        sessionState ? { session_state: sessionState, reauth_required: error instanceof SessionExpiredError } : void 0
+      );
+    }
+  });
+}
+var meshToolDefinitions = toolDefinitions;
+function createSuccessResult(payload) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: serialize2(payload)
+      }
+    ]
+  };
+}
+function createErrorResult(message, details) {
+  return {
+    isError: true,
+    content: [
+      {
+        type: "text",
+        text: serialize2({ error: message, ...details })
+      }
+    ]
+  };
+}
+async function getSessionState(context) {
+  const provider = context.authProvider;
+  if (!provider?.getSessionState) {
+    return null;
+  }
+  const state = await provider.getSessionState();
+  return typeof state === "string" ? state : null;
+}
+function serialize2(payload) {
+  return JSON.stringify(payload, bigintReplacer2, 2);
+}
+function bigintReplacer2(_key, value) {
+  return typeof value === "bigint" ? value.toString() : value;
+}
+
+// src/index.ts
+function registerMeshTools(server, context) {
+  registerToolHandlers(server, context);
+  registerResourceHandlers(server, context);
+}
+function createMeshMcpServer(context) {
+  const server = new Server(
+    {
+      name: "@hivemind-os/collective-mcp-server",
+      version: "0.1.0"
+    },
+    {
+      capabilities: {
+        tools: {},
+        resources: {}
+      }
+    }
+  );
+  registerMeshTools(server, context);
+  return server;
+}
+export {
+  createMeshMcpServer,
+  meshMeteredExecuteTool,
+  meshMultiExecuteTool,
+  meshToolDefinitions,
+  meshToolHandlers,
+  meshVerifyResultTool,
+  registerMeshTools,
+  registerResourceHandlers,
+  runMeshMeteredExecute,
+  runMeshMultiExecute,
+  runMeshVerifyResult
+};
+//# sourceMappingURL=index.js.map