@hol-org/hashnet-mcp 1.0.0

package/dist/index.js

@@ -0,0 +1,1946 @@
+// src/transports/index.ts
+import http from "http";
+import { randomUUID as randomUUID2 } from "crypto";
+import { PassThrough } from "stream";
+
+// src/mcp.ts
+import { randomUUID } from "crypto";
+import {
+  RegistryBrokerError as RegistryBrokerError2
+} from "@hashgraphonline/standards-sdk";
+import { FastMCP } from "fastmcp";
+import { z as z3 } from "zod";
+
+// src/broker.ts
+import { RegistryBrokerClient } from "@hashgraphonline/standards-sdk";
+import Bottleneck from "bottleneck";
+import IORedis from "ioredis";
+import { fetch as undiciFetch } from "undici";
+
+// src/config.ts
+import { config as loadEnv } from "dotenv";
+import { z } from "zod";
+if (process.env.NODE_ENV !== "test") {
+  loadEnv();
+}
+var LOG_LEVELS = ["fatal", "error", "warn", "info", "debug", "trace"];
+var envSchema = z.object({
+  REGISTRY_BROKER_API_URL: z.string().url().default("https://registry.hashgraphonline.com/api/v1"),
+  REGISTRY_BROKER_API_KEY: z.string().min(1).optional(),
+  HEDERA_ACCOUNT_ID: z.string().min(1).optional(),
+  HEDERA_PRIVATE_KEY: z.string().min(1).optional(),
+  PORT: z.coerce.number().int().positive().default(3333),
+  BROKER_MAX_CONCURRENT: z.coerce.number().int().positive().optional(),
+  BROKER_MIN_TIME_MS: z.coerce.number().int().nonnegative().optional(),
+  BROKER_RESERVOIR: z.coerce.number().int().positive().optional(),
+  BROKER_RESERVOIR_REFRESH_INTERVAL_MS: z.coerce.number().int().positive().optional(),
+  BROKER_RESERVOIR_REFRESH_AMOUNT: z.coerce.number().int().positive().optional(),
+  BROKER_RATE_LIMIT_REDIS_URL: z.string().url().optional(),
+  LOG_LEVEL: z.enum(LOG_LEVELS).default("info"),
+  WORKFLOW_DRY_RUN: z.enum(["0", "1"]).optional().transform((value) => value === "1"),
+  BROKER_AUTO_TOP_UP: z.enum(["0", "1"]).optional().transform((value) => value === "1")
+}).superRefine((val, ctx) => {
+  const hasAccount = Boolean(val.HEDERA_ACCOUNT_ID);
+  const hasKey = Boolean(val.HEDERA_PRIVATE_KEY);
+  if (hasAccount !== hasKey) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "HEDERA_ACCOUNT_ID and HEDERA_PRIVATE_KEY must both be set to enable registrationAutoTopUp."
+    });
+  }
+});
+var normalized = (value) => {
+  if (value === void 0) return void 0;
+  const trimmed = value.trim();
+  return trimmed.length === 0 ? void 0 : trimmed;
+};
+var parsed = envSchema.safeParse({
+  REGISTRY_BROKER_API_URL: normalized(process.env.REGISTRY_BROKER_API_URL),
+  REGISTRY_BROKER_API_KEY: normalized(process.env.REGISTRY_BROKER_API_KEY),
+  HEDERA_ACCOUNT_ID: normalized(process.env.HEDERA_ACCOUNT_ID),
+  HEDERA_PRIVATE_KEY: normalized(process.env.HEDERA_PRIVATE_KEY),
+  PORT: normalized(process.env.PORT),
+  BROKER_MAX_CONCURRENT: normalized(process.env.BROKER_MAX_CONCURRENT),
+  BROKER_MIN_TIME_MS: normalized(process.env.BROKER_MIN_TIME_MS),
+  BROKER_RESERVOIR: normalized(process.env.BROKER_RESERVOIR),
+  BROKER_RESERVOIR_REFRESH_INTERVAL_MS: normalized(process.env.BROKER_RESERVOIR_REFRESH_INTERVAL_MS),
+  BROKER_RESERVOIR_REFRESH_AMOUNT: normalized(process.env.BROKER_RESERVOIR_REFRESH_AMOUNT),
+  BROKER_RATE_LIMIT_REDIS_URL: normalized(process.env.BROKER_RATE_LIMIT_REDIS_URL),
+  LOG_LEVEL: normalized(process.env.LOG_LEVEL),
+  WORKFLOW_DRY_RUN: normalized(process.env.WORKFLOW_DRY_RUN),
+  BROKER_AUTO_TOP_UP: normalized(process.env.BROKER_AUTO_TOP_UP)
+});
+if (!parsed.success) {
+  throw new Error(`Invalid environment configuration:
+${parsed.error.toString()}`);
+}
+var config = {
+  registryBrokerUrl: parsed.data.REGISTRY_BROKER_API_URL,
+  registryBrokerApiKey: parsed.data.REGISTRY_BROKER_API_KEY,
+  hederaAccountId: parsed.data.HEDERA_ACCOUNT_ID,
+  hederaPrivateKey: parsed.data.HEDERA_PRIVATE_KEY,
+  port: parsed.data.PORT,
+  autoTopUpEnabled: Boolean(parsed.data.BROKER_AUTO_TOP_UP) && Boolean(parsed.data.HEDERA_ACCOUNT_ID && parsed.data.HEDERA_PRIVATE_KEY),
+  rateLimit: (() => {
+    const {
+      BROKER_MAX_CONCURRENT,
+      BROKER_MIN_TIME_MS,
+      BROKER_RESERVOIR,
+      BROKER_RESERVOIR_REFRESH_AMOUNT,
+      BROKER_RESERVOIR_REFRESH_INTERVAL_MS,
+      BROKER_RATE_LIMIT_REDIS_URL
+    } = parsed.data;
+    const hasLimiter = BROKER_MAX_CONCURRENT || BROKER_MIN_TIME_MS || BROKER_RESERVOIR || BROKER_RATE_LIMIT_REDIS_URL;
+    if (!hasLimiter) return void 0;
+    return {
+      maxConcurrent: BROKER_MAX_CONCURRENT,
+      minTimeMs: BROKER_MIN_TIME_MS,
+      reservoir: BROKER_RESERVOIR,
+      reservoirRefreshAmount: BROKER_RESERVOIR_REFRESH_AMOUNT,
+      reservoirRefreshIntervalMs: BROKER_RESERVOIR_REFRESH_INTERVAL_MS,
+      redis: BROKER_RATE_LIMIT_REDIS_URL ? {
+        url: BROKER_RATE_LIMIT_REDIS_URL
+      } : void 0
+    };
+  })(),
+  workflowDryRun: parsed.data.WORKFLOW_DRY_RUN ?? false,
+  httpStreamPort: parsed.data.HTTP_STREAM_PORT,
+  logLevel: parsed.data.LOG_LEVEL
+};
+
+// src/broker.ts
+var broker = new RegistryBrokerClient({
+  baseUrl: config.registryBrokerUrl,
+  apiKey: config.registryBrokerApiKey,
+  registrationAutoTopUp: config.autoTopUpEnabled ? {
+    accountId: config.hederaAccountId,
+    privateKey: config.hederaPrivateKey,
+    memo: "mcp-autotopup"
+  } : void 0
+});
+var brokerLimiter = createLimiter();
+function createLimiter() {
+  if (!config.rateLimit) return void 0;
+  const limiterOptions = {};
+  if (config.rateLimit.maxConcurrent !== void 0) {
+    limiterOptions.maxConcurrent = config.rateLimit.maxConcurrent;
+  }
+  if (config.rateLimit.minTimeMs !== void 0) {
+    limiterOptions.minTime = config.rateLimit.minTimeMs;
+  }
+  if (config.rateLimit.reservoir !== void 0) {
+    limiterOptions.reservoir = config.rateLimit.reservoir;
+  }
+  if (config.rateLimit.reservoirRefreshAmount !== void 0) {
+    limiterOptions.reservoirRefreshAmount = config.rateLimit.reservoirRefreshAmount;
+  }
+  if (config.rateLimit.reservoirRefreshIntervalMs !== void 0) {
+    limiterOptions.reservoirRefreshInterval = config.rateLimit.reservoirRefreshIntervalMs;
+  }
+  if (config.rateLimit.redis?.url) {
+    limiterOptions.datastore = "ioredis";
+    limiterOptions.connection = new IORedis(config.rateLimit.redis.url);
+  }
+  if (!limiterOptions.maxConcurrent && !limiterOptions.minTime && !limiterOptions.reservoir && !limiterOptions.datastore) {
+    return void 0;
+  }
+  return new Bottleneck(limiterOptions);
+}
+async function withBroker(task) {
+  if (brokerLimiter) {
+    return brokerLimiter.schedule(() => task(broker));
+  }
+  return task(broker);
+}
+async function getCreditBalance(accountId) {
+  if (!config.registryBrokerApiKey) {
+    throw new Error("REGISTRY_BROKER_API_KEY is required to fetch credit balances.");
+  }
+  const base = config.registryBrokerUrl.endsWith("/") ? config.registryBrokerUrl : `${config.registryBrokerUrl}/`;
+  const url = new URL("credits/balance", base);
+  if (accountId) {
+    url.searchParams.set("accountId", accountId);
+  }
+  const headers = {
+    accept: "application/json",
+    "x-api-key": config.registryBrokerApiKey
+  };
+  const request = async () => {
+    const response = await undiciFetch(url, { method: "GET", headers });
+    if (!response.ok) {
+      const hint = await safeReadBody(response);
+      throw new Error(`Failed to fetch credit balance (${response.status}): ${hint ?? response.statusText}`);
+    }
+    return await response.json();
+  };
+  if (brokerLimiter) {
+    return brokerLimiter.schedule(request);
+  }
+  return request();
+}
+async function safeReadBody(response) {
+  try {
+    const text = await response.text();
+    return text || void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/logger.ts
+import pino from "pino";
+var logger = pino({
+  level: config.logLevel,
+  base: void 0
+});
+
+// src/schemas/agent.ts
+import { z as z2 } from "zod";
+var socialLinkSchema = z2.object({
+  platform: z2.string(),
+  handle: z2.string()
+});
+var aiAgentSchema = z2.object({
+  type: z2.union([z2.literal(0), z2.literal(1)]),
+  capabilities: z2.array(z2.number().int().nonnegative()),
+  model: z2.string(),
+  creator: z2.string().optional()
+});
+var mcpServerSchema = z2.object({
+  version: z2.string(),
+  connectionInfo: z2.object({
+    url: z2.string().url(),
+    transport: z2.enum(["stdio", "sse"])
+  }),
+  services: z2.array(z2.number().int().nonnegative()),
+  description: z2.string(),
+  capabilities: z2.array(z2.string()).optional(),
+  resources: z2.array(
+    z2.object({
+      name: z2.string(),
+      description: z2.string()
+    })
+  ).optional(),
+  tools: z2.array(
+    z2.object({
+      name: z2.string(),
+      description: z2.string()
+    })
+  ).optional(),
+  maintainer: z2.string().optional(),
+  repository: z2.string().optional(),
+  docs: z2.string().optional()
+});
+var baseProfileSchema = z2.object({
+  version: z2.string(),
+  type: z2.number().int(),
+  display_name: z2.string(),
+  alias: z2.string().optional(),
+  bio: z2.string().optional(),
+  socials: z2.array(socialLinkSchema).optional(),
+  profileImage: z2.string().optional(),
+  uaid: z2.string().optional(),
+  properties: z2.record(z2.string(), z2.any()).optional(),
+  inboundTopicId: z2.string().optional(),
+  outboundTopicId: z2.string().optional(),
+  base_account: z2.string().optional()
+});
+var agentProfileSchema = baseProfileSchema.extend({
+  aiAgent: aiAgentSchema.optional(),
+  mcpServer: mcpServerSchema.optional()
+});
+var metadataSchema = z2.object({
+  trustScore: z2.number().min(0).max(100).optional(),
+  verified: z2.boolean().optional(),
+  avgLatency: z2.number().nonnegative().optional(),
+  uptime: z2.number().min(0).max(100).optional(),
+  provider: z2.string().optional(),
+  category: z2.string().optional(),
+  adapter: z2.string().optional(),
+  openConvAICompatible: z2.boolean().optional(),
+  customFields: z2.record(z2.string(), z2.union([z2.string(), z2.number(), z2.boolean()])).optional()
+});
+var agentRegistrationSchema = z2.object({
+  profile: agentProfileSchema,
+  endpoint: z2.string().url().optional(),
+  protocol: z2.string().optional(),
+  communicationProtocol: z2.string().optional(),
+  registry: z2.string().optional(),
+  additionalRegistries: z2.array(z2.string()).optional(),
+  metadata: metadataSchema.optional()
+});
+
+// src/workflows/env.ts
+function ensureRequiredEnv(requiredEnv, options) {
+  if (!requiredEnv?.length) return;
+  const missing = getMissingEnvVars(requiredEnv);
+  if (missing.length > 0) {
+    options?.logger?.error?.({ missingEnv: missing }, "workflow.env.missing");
+    const label = options?.context ?? "workflow";
+    throw new Error(`Missing required environment variables for ${label}: ${missing.join(", ")}`);
+  }
+}
+function getMissingEnvVars(requiredEnv) {
+  return requiredEnv.filter((variable) => {
+    const value = process.env[variable];
+    return value === void 0 || value.length === 0;
+  });
+}
+
+// src/workflows/pipeline.ts
+function createPipeline(definition) {
+  async function run(input, options) {
+    const pipelineLogger = logger.child({ pipeline: definition.name });
+    const dryRun = options?.dryRun ?? config.workflowDryRun;
+    ensureRequiredEnv(definition.requiredEnv, { logger: pipelineLogger, context: definition.name });
+    const context = await definition.createContext(input);
+    const stepsResults = [];
+    for (let index = 0; index < definition.steps.length; index += 1) {
+      const step = definition.steps[index];
+      const stepLogger = pipelineLogger.child({ step: step.name, index });
+      const stepArgs = {
+        input,
+        context,
+        dryRun,
+        logger: stepLogger
+      };
+      const shouldSkip = await shouldSkipStep(step, stepArgs, dryRun);
+      const startedAt = Date.now();
+      if (shouldSkip) {
+        stepLogger.info({ dryRun }, "pipeline.step.skipped");
+        stepsResults.push({ name: step.name, durationMs: 0, skipped: true });
+        await options?.hooks?.onStepStart?.({ pipeline: definition.name, step: step.name, index, context });
+        await options?.hooks?.onStepSuccess?.({ pipeline: definition.name, step: step.name, index, context, output: void 0 });
+        continue;
+      }
+      pipelineLogger.info({ step: step.name }, "pipeline.step.start");
+      await options?.hooks?.onStepStart?.({ pipeline: definition.name, step: step.name, index, context });
+      try {
+        const output = await step.run(stepArgs);
+        const durationMs = Date.now() - startedAt;
+        stepLogger.info({ durationMs }, "pipeline.step.success");
+        stepsResults.push({ name: step.name, durationMs, skipped: false, output });
+        await options?.hooks?.onStepSuccess?.({ pipeline: definition.name, step: step.name, index, context, output });
+      } catch (error) {
+        const durationMs = Date.now() - startedAt;
+        const message = error instanceof Error ? error.message : String(error);
+        stepLogger.error({ durationMs, error: message }, "pipeline.step.error");
+        stepsResults.push({ name: step.name, durationMs, skipped: false, error: message });
+        await options?.hooks?.onStepError?.({ pipeline: definition.name, step: step.name, index, context, error });
+        throw error;
+      }
+    }
+    return {
+      pipeline: definition.name,
+      context,
+      steps: stepsResults,
+      dryRun
+    };
+  }
+  return { definition, run };
+}
+async function shouldSkipStep(step, args, dryRun) {
+  if (dryRun && step.allowDuringDryRun !== true) {
+    return true;
+  }
+  if (step.skip) {
+    return Boolean(await step.skip(args));
+  }
+  return false;
+}
+
+// src/workflows/registry.ts
+var pipelines = /* @__PURE__ */ new Map();
+function registerPipeline(definition) {
+  const pipeline = createPipeline(definition);
+  pipelines.set(definition.name, pipeline);
+  return pipeline;
+}
+
+// src/workflows/discovery.ts
+var discoveryDefinition = {
+  name: "workflow.discovery",
+  description: "Run hol.search and hol.vectorSearch to explore agents.",
+  version: "1.0.0",
+  requiredEnv: ["REGISTRY_BROKER_API_KEY"],
+  createContext: () => ({ results: {} }),
+  steps: [
+    {
+      name: "hol.search",
+      description: "Keyword search",
+      allowDuringDryRun: true,
+      run: async ({ input, context }) => {
+        const payload = { q: input.query, limit: input.limit ?? 5 };
+        const response = await withBroker((client) => client.search(payload));
+        context.results.search = response;
+        return response;
+      }
+    },
+    {
+      name: "hol.vectorSearch",
+      description: "Vector similarity search",
+      allowDuringDryRun: true,
+      run: async ({ input, context }) => {
+        if (!input.query) {
+          return void 0;
+        }
+        const response = await withBroker((client) => client.vectorSearch({ query: input.query, limit: input.limit ?? 5 }));
+        context.results.vector = response;
+        return response;
+      }
+    }
+  ]
+};
+var discoveryPipeline = registerPipeline(discoveryDefinition);
+
+// src/workflows/utils/credits.ts
+import { RegistryBrokerError } from "@hashgraphonline/standards-sdk";
+
+// src/workflows/errors.ts
+var InsufficientCreditsError = class extends Error {
+  code = "INSUFFICIENT_CREDITS";
+  summary;
+  constructor(quote, hint) {
+    const shortfall = Math.max(0, quote.shortfallCredits ?? 0);
+    const message = hint ?? `Insufficient registry credits (shortfall: ${shortfall})`;
+    super(message);
+    this.name = "InsufficientCreditsError";
+    this.summary = {
+      requiredCredits: quote.requiredCredits,
+      availableCredits: quote.availableCredits ?? 0,
+      shortfallCredits: shortfall,
+      estimatedHbar: quote.estimatedHbar,
+      creditsPerHbar: quote.creditsPerHbar,
+      registry: quote.registry,
+      protocol: quote.protocol,
+      accountId: quote.accountId
+    };
+  }
+};
+
+// src/workflows/utils/credits.ts
+async function runCreditAwareRegistration({ payload, onShortfall }) {
+  while (true) {
+    try {
+      const response = await withBroker((client) => client.registerAgent(payload));
+      return response;
+    } catch (error) {
+      const converted = await translateCreditError(error, payload);
+      if (converted) {
+        const action = await onShortfall?.(converted) ?? "abort";
+        if (action === "retry") {
+          continue;
+        }
+        throw converted;
+      }
+      throw error;
+    }
+  }
+}
+async function translateCreditError(error, payload) {
+  if (!(error instanceof RegistryBrokerError) || error.status !== 402) {
+    return null;
+  }
+  const quote = await withBroker((client) => client.getRegistrationQuote(payload));
+  return new InsufficientCreditsError(quote);
+}
+async function waitForRegistrationCompletion(attemptId) {
+  return withBroker(
+    (client) => client.waitForRegistrationCompletion(attemptId, {
+      intervalMs: 2e3,
+      timeoutMs: 5 * 6e4
+    })
+  );
+}
+
+// src/workflows/registration.ts
+var registrationDefinition = {
+  name: "workflow.registerMcp",
+  description: "Quote, register, and wait for completion.",
+  version: "1.0.0",
+  requiredEnv: ["REGISTRY_BROKER_API_KEY"],
+  createContext: ({ payload }) => ({ payload }),
+  steps: [
+    {
+      name: "hol.getRegistrationQuote",
+      allowDuringDryRun: true,
+      run: async ({ context }) => {
+        const quote = await withBroker((client) => client.getRegistrationQuote(context.payload));
+        context.quote = quote;
+        return quote;
+      }
+    },
+    {
+      name: "hol.registerAgent",
+      run: async ({ context }) => {
+        const response = await runCreditAwareRegistration({
+          payload: context.payload,
+          onShortfall: async (err) => {
+            context.quote = err.summary;
+            return "abort";
+          }
+        });
+        if ("attemptId" in response && typeof response.attemptId === "string") {
+          context.attemptId = response.attemptId;
+        }
+        context.result = response;
+        return response;
+      }
+    },
+    {
+      name: "hol.waitForRegistrationCompletion",
+      run: async ({ context }) => {
+        if (!context.attemptId) {
+          throw new Error("Registration attemptId missing.");
+        }
+        const result = await withBroker(
+          (client) => client.waitForRegistrationCompletion(context.attemptId, {
+            intervalMs: 2e3,
+            timeoutMs: 5 * 6e4
+          })
+        );
+        if (result?.result?.uaid) {
+          context.uaid = result.result.uaid;
+        }
+        return result;
+      }
+    }
+  ]
+};
+var registrationPipeline = registerPipeline(registrationDefinition);
+
+// src/workflows/chat.ts
+var chatDefinition = {
+  name: "workflow.chatSmoke",
+  description: "Create a chat session, send a message, read history, compact, and close.",
+  version: "1.0.0",
+  requiredEnv: ["REGISTRY_BROKER_API_KEY"],
+  createContext: ({ uaid, auth }) => ({ uaid, auth, transcript: void 0 }),
+  steps: [
+    {
+      name: "hol.chat.createSession",
+      run: async ({ context }) => {
+        const response = await withBroker(
+          (client) => client.chat.createSession({ uaid: context.uaid, historyTtlSeconds: 60, auth: context.auth })
+        );
+        if (response?.sessionId) {
+          context.sessionId = response.sessionId;
+        }
+        return response;
+      }
+    },
+    {
+      name: "hol.chat.sendMessage",
+      run: async ({ input, context }) => {
+        if (!context.sessionId) throw new Error("Missing chat session");
+        return withBroker(
+          (client) => client.chat.sendMessage({
+            sessionId: context.sessionId,
+            message: input.message ?? "Hello from workflow.chatSmoke",
+            auth: input.auth ?? context.auth
+          })
+        );
+      }
+    },
+    {
+      name: "hol.chat.history",
+      run: async ({ context }) => {
+        if (!context.sessionId) throw new Error("Missing chat session");
+        const history = await withBroker((client) => client.chat.getHistory(context.sessionId));
+        context.transcript = history;
+        return history;
+      }
+    },
+    {
+      name: "hol.chat.compact",
+      allowDuringDryRun: true,
+      run: async ({ context }) => {
+        if (!context.sessionId) throw new Error("Missing chat session");
+        return withBroker((client) => client.chat.compactHistory({ sessionId: context.sessionId, preserveEntries: 2 }));
+      }
+    },
+    {
+      name: "hol.chat.end",
+      allowDuringDryRun: true,
+      run: async ({ context }) => {
+        if (!context.sessionId) throw new Error("Missing chat session");
+        return withBroker((client) => client.chat.endSession(context.sessionId));
+      }
+    }
+  ]
+};
+var chatPipeline = registerPipeline(chatDefinition);
+
+// src/workflows/ops.ts
+var opsDefinition = {
+  name: "workflow.opsCheck",
+  description: "Run stats, metrics, dashboard, listProtocols, detectProtocol.",
+  version: "1.0.0",
+  requiredEnv: ["REGISTRY_BROKER_API_KEY"],
+  createContext: () => ({}),
+  steps: [
+    {
+      name: "hol.stats",
+      allowDuringDryRun: true,
+      run: async ({ context }) => {
+        const response = await withBroker((client) => client.stats());
+        context.stats = response;
+        return response;
+      }
+    },
+    {
+      name: "hol.metricsSummary",
+      allowDuringDryRun: true,
+      run: async ({ context }) => {
+        const response = await withBroker((client) => client.metricsSummary());
+        context.metrics = response;
+        return response;
+      }
+    },
+    {
+      name: "hol.dashboardStats",
+      allowDuringDryRun: true,
+      run: async ({ context }) => {
+        const response = await withBroker((client) => client.dashboardStats());
+        context.dashboard = response;
+        return response;
+      }
+    },
+    {
+      name: "hol.listProtocols",
+      allowDuringDryRun: true,
+      run: async () => withBroker((client) => client.listProtocols())
+    },
+    {
+      name: "hol.detectProtocol",
+      allowDuringDryRun: true,
+      run: async () => withBroker(
+        (client) => client.detectProtocol({
+          headers: { "content-type": "application/json" },
+          body: "{}"
+        })
+      )
+    }
+  ]
+};
+var opsPipeline = registerPipeline(opsDefinition);
+
+// src/workflows/combined.ts
+var fullDefinition = {
+  name: "workflow.fullRegistration",
+  description: "Discovery \u2192 Registration \u2192 Chat \u2192 Ops health check",
+  version: "1.0.0",
+  requiredEnv: ["REGISTRY_BROKER_API_KEY", "HEDERA_ACCOUNT_ID", "HEDERA_PRIVATE_KEY"],
+  createContext: () => ({}),
+  steps: [
+    {
+      name: "workflow.discovery",
+      allowDuringDryRun: true,
+      run: async ({ input, context }) => {
+        const result = await discoveryPipeline.run({ query: input.discoveryQuery, limit: 5 });
+        context.discovery = result;
+        return result;
+      }
+    },
+    {
+      name: "workflow.registerMcp",
+      run: async ({ input, context, dryRun }) => {
+        const payload = { payload: input.registrationPayload };
+        const result = await registrationPipeline.run(payload, { dryRun });
+        context.registration = result;
+        context.uaid = result.context.uaid;
+        return result;
+      }
+    },
+    {
+      name: "workflow.chatSmoke",
+      run: async ({ input, context, dryRun }) => {
+        if (!context.uaid) throw new Error("UAID missing from registration context");
+        const result = await chatPipeline.run({ uaid: context.uaid, message: input.chatMessage }, { dryRun });
+        context.chat = result;
+        return result;
+      }
+    },
+    {
+      name: "workflow.opsCheck",
+      allowDuringDryRun: true,
+      run: async ({ context, dryRun }) => {
+        const result = await opsPipeline.run({}, { dryRun });
+        context.ops = result;
+        return result;
+      }
+    }
+  ]
+};
+var fullWorkflowPipeline = registerPipeline(fullDefinition);
+
+// src/workflows/scaffold.ts
+function scaffoldWorkflow(definition) {
+  if (!definition.version) {
+    definition.version = "1.0.0";
+  }
+  if (!definition.requiredEnv) {
+    definition.requiredEnv = ["REGISTRY_BROKER_API_KEY"];
+  }
+  return registerPipeline(definition);
+}
+
+// src/workflows/openrouter-chat.ts
+var openRouterChatDefinition = {
+  name: "workflow.openrouterChat",
+  description: "Discover an OpenRouter model and run a chat message against it.",
+  version: "1.0.0",
+  requiredEnv: ["REGISTRY_BROKER_API_KEY"],
+  createContext: () => ({}),
+  steps: [
+    {
+      name: "hol.search",
+      run: async ({ input, context }) => {
+        const result = await withBroker(
+          (client) => client.search({ q: input.modelId, registries: input.registry ? [input.registry] : ["openrouter"], limit: 1 })
+        );
+        if (!result.hits?.length) {
+          throw new Error(`Model ${input.modelId} not found in registry ${input.registry ?? "openrouter"}`);
+        }
+        context.uaid = result.hits[0].uaid;
+        return result.hits[0];
+      }
+    },
+    {
+      name: "hol.chat.createSession",
+      run: async ({ input, context }) => {
+        if (!context.uaid) throw new Error("UAID missing from discovery step");
+        const auth = input.authToken ? { type: "bearer", token: input.authToken } : void 0;
+        const response = await withBroker(
+          (client) => client.chat.createSession({ uaid: context.uaid, historyTtlSeconds: input.historyTtlSeconds ?? 900, auth })
+        );
+        context.sessionId = response.sessionId;
+        return response;
+      }
+    },
+    {
+      name: "hol.chat.sendMessage",
+      run: async ({ input, context }) => {
+        if (!context.sessionId) throw new Error("Missing chat session");
+        const auth = input.authToken ? { type: "bearer", token: input.authToken } : void 0;
+        return withBroker(
+          (client) => client.chat.sendMessage({ sessionId: context.sessionId, auth, message: input.message })
+        );
+      }
+    },
+    {
+      name: "hol.chat.history",
+      allowDuringDryRun: true,
+      run: async ({ context }) => {
+        if (!context.sessionId) throw new Error("Missing chat session");
+        const history = await withBroker((client) => client.chat.getHistory(context.sessionId));
+        context.transcript = history;
+        return history;
+      }
+    },
+    {
+      name: "hol.chat.end",
+      allowDuringDryRun: true,
+      run: async ({ context }) => {
+        if (!context.sessionId) throw new Error("Missing chat session");
+        return withBroker((client) => client.chat.endSession(context.sessionId));
+      }
+    }
+  ]
+};
+var openRouterChatWorkflow = scaffoldWorkflow(openRouterChatDefinition);
+
+// src/workflows/registry-showcase.ts
+var registryShowcaseDefinition = {
+  name: "workflow.registryBrokerShowcase",
+  description: "Discovery + analytics + chat showcase workflow inspired by registry-broker-demo.ts.",
+  version: "1.0.0",
+  requiredEnv: ["REGISTRY_BROKER_API_KEY"],
+  createContext: () => ({}),
+  steps: [
+    {
+      name: "workflow.discovery",
+      allowDuringDryRun: true,
+      run: async ({ input, context, dryRun }) => {
+        const result = await discoveryPipeline.run({ query: input.query }, { dryRun });
+        context.discovery = result;
+        context.uaid = input.uaid ?? result.steps[0]?.output?.hits?.[0]?.uaid;
+        return result;
+      }
+    },
+    {
+      name: "hol.listProtocols",
+      allowDuringDryRun: true,
+      run: async ({ context }) => {
+        const response = await withBroker((client) => client.listProtocols());
+        context.listProtocols = response;
+        return response;
+      }
+    },
+    {
+      name: "hol.detectProtocol",
+      allowDuringDryRun: true,
+      run: async ({ context }) => {
+        const response = await withBroker((client) => client.detectProtocol({ headers: { "content-type": "application/json" }, body: "{}" }));
+        context.detectProtocol = response;
+        return response;
+      }
+    },
+    {
+      name: "hol.stats",
+      allowDuringDryRun: true,
+      run: async ({ context }) => {
+        const response = await withBroker((client) => client.stats());
+        context.stats = response;
+        return response;
+      }
+    },
+    {
+      name: "hol.metricsSummary",
+      allowDuringDryRun: true,
+      run: async ({ context }) => {
+        const response = await withBroker((client) => client.metricsSummary());
+        context.metrics = response;
+        return response;
+      }
+    },
+    {
+      name: "hol.dashboardStats",
+      allowDuringDryRun: true,
+      run: async ({ context }) => {
+        const response = await withBroker((client) => client.dashboardStats());
+        context.dashboard = response;
+        return response;
+      }
+    },
+    {
+      name: "hol.websocketStats",
+      allowDuringDryRun: true,
+      run: async ({ context }) => {
+        const response = await withBroker((client) => client.websocketStats());
+        context.websocket = response;
+        return response;
+      }
+    },
+    {
+      name: "workflow.registryBrokerShowcase.chat",
+      skip: ({ input, context }) => !(input.message && context.uaid),
+      run: async ({ input, context, dryRun }) => {
+        if (!context.uaid) throw new Error("No UAID discovered for chat");
+        const result = await chatPipeline.run({ uaid: context.uaid, message: input.message }, { dryRun });
+        context.chat = result;
+        return result;
+      }
+    },
+    {
+      name: "hol.getRegistrationQuote",
+      skip: ({ input }) => !input.performCreditCheck,
+      run: async ({ context }) => {
+        const response = await withBroker((client) => client.getRegistrationQuote(context.discovery?.context?.registrationPayload || context.discovery));
+        context.creditQuote = response;
+        return response;
+      }
+    }
+  ]
+};
+var registryBrokerShowcaseWorkflow = scaffoldWorkflow(registryShowcaseDefinition);
+
+// src/workflows/agentverse-bridge.ts
+var agentverseBridgeDefinition = {
+  name: "workflow.agentverseBridge",
+  description: "Relay messages between a local UAID session and an Agentverse UAID.",
+  version: "1.0.0",
+  requiredEnv: ["REGISTRY_BROKER_API_KEY"],
+  createContext: () => ({ transcripts: [] }),
+  steps: [
+    {
+      name: "workflow.agentverseBridge.createSessions",
+      run: async ({ input, context }) => {
+        const local = await withBroker(
+          (client) => client.chat.createSession({ uaid: input.uaid, auth: input.localAuth, historyTtlSeconds: 300 })
+        );
+        const agentverse = await withBroker(
+          (client) => client.chat.createSession({ uaid: input.agentverseUaid, auth: input.agentverseAuth, historyTtlSeconds: 300 })
+        );
+        context.localSession = local.sessionId;
+        context.agentverseSession = agentverse.sessionId;
+        return { local, agentverse };
+      }
+    },
+    {
+      name: "workflow.agentverseBridge.relay",
+      run: async ({ input, context }) => {
+        if (!context.localSession || !context.agentverseSession) {
+          throw new Error("Sessions missing");
+        }
+        const iterations = input.iterations ?? 1;
+        for (let i = 0; i < iterations; i += 1) {
+          const localResponse = await withBroker(
+            (client) => client.chat.sendMessage({ sessionId: context.localSession, auth: input.localAuth, message: input.localMessage })
+          );
+          context.transcripts.push({ target: "local", response: localResponse });
+          const agentverseResponse = await withBroker(
+            (client) => client.chat.sendMessage({ sessionId: context.agentverseSession, auth: input.agentverseAuth, message: input.agentverseMessage })
+          );
+          context.transcripts.push({ target: "agentverse", response: agentverseResponse });
+        }
+        return context.transcripts;
+      }
+    },
+    {
+      name: "workflow.agentverseBridge.history",
+      allowDuringDryRun: true,
+      run: async ({ context }) => {
+        const localHistory = await withBroker((client) => client.chat.getHistory(context.localSession));
+        const agentverseHistory = await withBroker((client) => client.chat.getHistory(context.agentverseSession));
+        return { localHistory, agentverseHistory };
+      }
+    },
+    {
+      name: "workflow.agentverseBridge.cleanup",
+      allowDuringDryRun: true,
+      run: async ({ context }) => {
+        await Promise.all([
+          withBroker((client) => client.chat.endSession(context.localSession)),
+          withBroker((client) => client.chat.endSession(context.agentverseSession))
+        ]);
+        return { ended: true };
+      }
+    }
+  ]
+};
+var agentverseBridgeWorkflow = scaffoldWorkflow(agentverseBridgeDefinition);
+
+// src/workflows/erc8004-discovery.ts
+var erc8004DiscoveryDefinition = {
+  name: "workflow.erc8004Discovery",
+  description: "Filter search/vector/namespace lookups for ERC-8004 registries.",
+  version: "1.0.0",
+  requiredEnv: ["REGISTRY_BROKER_API_KEY"],
+  createContext: () => ({}),
+  steps: [
+    {
+      name: "hol.search",
+      allowDuringDryRun: true,
+      run: async ({ input, context }) => {
+        const response = await withBroker(
+          (client) => client.search({ q: input.query, registries: ["erc-8004"], limit: input.limit ?? 10 })
+        );
+        context.hits = response.hits;
+        return response;
+      }
+    },
+    {
+      name: "hol.registrySearchByNamespace",
+      allowDuringDryRun: true,
+      run: async ({ input }) => withBroker((client) => client.registrySearchByNamespace("erc-8004", input.query))
+    }
+  ]
+};
+var erc8004DiscoveryWorkflow = scaffoldWorkflow(erc8004DiscoveryDefinition);
+
+// src/workflows/register-advanced.ts
+var registerAgentAdvancedDefinition = {
+  name: "workflow.registerAgentAdvanced",
+  description: "Extended registration workflow with additional registries and optional updates.",
+  version: "1.0.0",
+  requiredEnv: ["REGISTRY_BROKER_API_KEY"],
+  createContext: ({ payload }) => ({ payload, resolvedRegistries: [], missingRegistries: [] }),
+  steps: [
+    {
+      name: "hol.getAdditionalRegistries",
+      allowDuringDryRun: true,
+      skip: ({ input }) => !input.additionalRegistrySelections?.length && !input.updateAdditionalRegistries?.length,
+      run: async () => withBroker((client) => client.getAdditionalRegistries())
+    },
+    {
+      name: "workflow.resolveAdditionalRegistries",
+      allowDuringDryRun: true,
+      run: async ({ input, context }, resultFromCatalog) => {
+        if (!resultFromCatalog) return null;
+        const catalog = resultFromCatalog;
+        const selections = input.additionalRegistrySelections ?? [];
+        const { resolved, missing } = resolveAdditionalSelections(selections, catalog);
+        context.resolvedRegistries = resolved;
+        context.missingRegistries = missing;
+        if (resolved.length > 0) {
+          context.payload = {
+            ...context.payload,
+            additionalRegistries: resolved
+          };
+        }
+        return { resolved, missing };
+      }
+    },
+    {
+      name: "hol.getRegistrationQuote",
+      allowDuringDryRun: true,
+      run: async ({ context }) => withBroker((client) => client.getRegistrationQuote(context.payload))
+    },
+    {
+      name: "workflow.registerAgentAdvanced.register",
+      run: async ({ input, context }) => {
+        const response = await runCreditAwareRegistration({
+          payload: context.payload,
+          onShortfall: async (summary) => {
+            context.lastQuote = summary;
+            if (!input.creditTopUp) {
+              return "abort";
+            }
+            await purchaseCreditsWithHbar(input.creditTopUp, summary);
+            return "retry";
+          }
+        });
+        context.registrationResult = response;
+        if ("attemptId" in response && typeof response.attemptId === "string") {
+          context.attemptId = response.attemptId;
+        }
+        if ("uaid" in response && typeof response.uaid === "string") {
+          context.uaid = response.uaid;
+        }
+        return response;
+      }
+    },
+    {
+      name: "hol.waitForRegistrationCompletion",
+      run: async ({ context }) => {
+        if (!context.attemptId) throw new Error("Registration attemptId missing.");
+        const result = await waitForRegistrationCompletion(context.attemptId);
+        context.progress = result;
+        if (result?.result?.uaid) {
+          context.uaid = result.result.uaid;
+        }
+        return result;
+      }
+    },
+    {
+      name: "workflow.registerAgentAdvanced.update",
+      skip: ({ input }) => input.skipUpdate || !input.updateAdditionalRegistries?.length,
+      run: async ({ input, context }) => {
+        if (!context.uaid) throw new Error("UAID missing for update.");
+        const resolved = input.updateAdditionalRegistries ?? [];
+        const updatePayload = {
+          ...context.payload,
+          additionalRegistries: resolved
+        };
+        const response = await withBroker((client) => client.updateAgent(context.uaid, updatePayload));
+        context.updateResult = response;
+        return response;
+      }
+    }
+  ]
+};
+var registerAgentAdvancedPipeline = scaffoldWorkflow(registerAgentAdvancedDefinition);
+function resolveAdditionalSelections(selections, catalog) {
+  const resolved = /* @__PURE__ */ new Set();
+  const missing = [];
+  for (const selection of selections) {
+    const matches = collectMatches(selection, catalog);
+    if (matches.length === 0) {
+      missing.push(selection);
+    } else {
+      matches.forEach((key) => resolved.add(key));
+    }
+  }
+  return { resolved: Array.from(resolved), missing };
+}
+function collectMatches(selection, catalog) {
+  const target = selection.trim().toLowerCase();
+  if (!target) return [];
+  const matches = [];
+  for (const registry of catalog.registries) {
+    const registryId = registry.id.toLowerCase();
+    if (registryId === target) {
+      registry.networks.forEach((network) => matches.push(network.key));
+      continue;
+    }
+    for (const network of registry.networks) {
+      const keyLower = network.key.toLowerCase();
+      const networkIdLower = network.networkId?.toLowerCase();
+      const labelLower = network.label?.toLowerCase();
+      const nameLower = network.name?.toLowerCase();
+      if (target === keyLower || networkIdLower && target === networkIdLower || labelLower && target === labelLower || nameLower && target === nameLower || target === `${registryId}:${networkIdLower}`) {
+        matches.push(network.key);
+      }
+    }
+  }
+  return matches;
+}
+async function purchaseCreditsWithHbar(config2, summary) {
+  const hbarAmount = config2.hbarAmount ?? Math.max(0.25, (summary.shortfallCredits ?? 1) / 100);
+  await withBroker(
+    (client) => client.purchaseCreditsWithHbar({
+      accountId: config2.accountId,
+      privateKey: config2.privateKey,
+      hbarAmount,
+      memo: config2.memo ?? "workflow.registerAgentAdvanced:topup",
+      metadata: {
+        shortfall: summary.shortfallCredits,
+        requiredCredits: summary.requiredCredits
+      }
+    })
+  );
+}
+
+// src/workflows/register-erc8004.ts
+var registerAgentErc8004Definition = {
+  name: "workflow.registerAgentErc8004",
+  description: "ERC-8004-specific registration workflow with optional ledger verification.",
+  version: "1.0.0",
+  requiredEnv: ["REGISTRY_BROKER_API_KEY"],
+  createContext: () => ({ resolvedNetworks: [], missingNetworks: [] }),
+  steps: [
+    {
+      name: "hol.getAdditionalRegistries",
+      allowDuringDryRun: true,
+      run: async () => withBroker((client) => client.getAdditionalRegistries())
+    },
+    {
+      name: "workflow.erc8004.resolveNetworks",
+      allowDuringDryRun: true,
+      run: async ({ input, context }, catalog) => {
+        const response = catalog;
+        const selections = input.erc8004Networks?.length ? input.erc8004Networks : defaultErc8004Selections(response);
+        const { resolved, missing } = resolveErc8004Selections(selections, response);
+        context.resolvedNetworks = resolved;
+        context.missingNetworks = missing;
+        return { resolved, missing };
+      }
+    },
+    {
+      name: "hol.ledger.authenticate",
+      skip: ({ input }) => !input.ledgerVerification,
+      run: async ({ input }) => withBroker((client) => client.verifyLedgerChallenge(input.ledgerVerification))
+    },
+    {
+      name: "workflow.registerAgentAdvanced",
+      run: async ({ input, context, dryRun }) => {
+        const advancedInput = {
+          payload: withAdditionalRegistries(input.payload, context.resolvedNetworks),
+          additionalRegistrySelections: context.resolvedNetworks,
+          updateAdditionalRegistries: input.updateAdditionalRegistries,
+          skipUpdate: input.skipUpdate,
+          creditTopUp: input.creditTopUp
+        };
+        const result = await registerAgentAdvancedPipeline.run(advancedInput, { dryRun });
+        context.advancedResult = result;
+        return result;
+      }
+    }
+  ]
+};
+var registerAgentErc8004Pipeline = scaffoldWorkflow(registerAgentErc8004Definition);
+function resolveErc8004Selections(selections, catalog) {
+  const resolved = /* @__PURE__ */ new Set();
+  const missing = [];
+  selections.forEach((entry) => {
+    const normalized2 = entry.trim().toLowerCase();
+    if (!normalized2) return;
+    let matched = false;
+    for (const descriptor of catalog.registries) {
+      if (!descriptor.id.toLowerCase().startsWith("erc-8004")) continue;
+      for (const network of descriptor.networks) {
+        const candidates = [network.key, network.networkId, network.label, network.name].map((value) => value?.toLowerCase().trim()).filter(Boolean);
+        if (candidates.includes(normalized2) || `${descriptor.id.toLowerCase()}:${network.networkId?.toLowerCase()}` === normalized2) {
+          resolved.add(network.key);
+          matched = true;
+        }
+      }
+    }
+    if (!matched) {
+      missing.push(entry);
+    }
+  });
+  return { resolved: Array.from(resolved), missing };
+}
+function defaultErc8004Selections(catalog) {
+  const defaults = catalog.registries.find((entry) => entry.id.toLowerCase() === "erc-8004");
+  if (!defaults) return [];
+  return defaults.networks.map((network) => network.key);
+}
+function withAdditionalRegistries(payload, networks) {
+  if (networks.length === 0) return payload;
+  return { ...payload, additionalRegistries: networks };
+}
+
+// src/workflows/x402-topup.ts
+var x402TopUpDefinition = {
+  name: "workflow.x402TopUp",
+  description: "Buy registry credits via X402 using an EVM wallet.",
+  version: "1.0.0",
+  requiredEnv: ["REGISTRY_BROKER_API_KEY"],
+  createContext: () => ({}),
+  steps: [
+    {
+      name: "hol.ledger.authenticate",
+      skip: ({ input }) => !input.ledgerVerification,
+      run: async ({ input, context }) => {
+        const verification = await withBroker((client) => client.verifyLedgerChallenge(input.ledgerVerification));
+        context.ledgerVerification = verification;
+        return verification;
+      }
+    },
+    {
+      name: "hol.x402.minimums",
+      allowDuringDryRun: true,
+      run: async ({ context }) => {
+        const minimums = await withBroker((client) => client.getX402Minimums());
+        context.minimums = minimums;
+        return minimums;
+      }
+    },
+    {
+      name: "hol.x402.buyCredits",
+      run: async ({ input, context }) => {
+        const payload = {
+          accountId: input.accountId,
+          credits: input.credits,
+          usdAmount: input.usdAmount,
+          description: input.description,
+          metadata: input.metadata,
+          evmPrivateKey: input.evmPrivateKey,
+          network: input.network,
+          rpcUrl: input.rpcUrl
+        };
+        const purchase = await withBroker((client) => client.buyCreditsWithX402(payload));
+        context.purchase = purchase;
+        return purchase;
+      }
+    }
+  ]
+};
+var x402TopUpWorkflow = scaffoldWorkflow(x402TopUpDefinition);
+
+// src/workflows/erc8004-x402.ts
+var erc8004X402Definition = {
+  name: "workflow.erc8004X402",
+  description: "Register on ERC-8004 networks with X402 credit purchases and chat smoke.",
+  version: "1.0.0",
+  requiredEnv: ["REGISTRY_BROKER_API_KEY"],
+  createContext: () => ({}),
+  steps: [
+    {
+      name: "workflow.x402TopUp",
+      skip: ({ input }) => !input.creditPurchase,
+      run: async ({ input, dryRun }) => x402TopUpWorkflow.run(
+        {
+          accountId: input.creditPurchase.accountId,
+          credits: input.creditPurchase.credits,
+          evmPrivateKey: input.creditPurchase.evmPrivateKey,
+          network: input.creditPurchase.network,
+          ledgerVerification: input.creditPurchase.ledgerVerification
+        },
+        { dryRun }
+      )
+    },
+    {
+      name: "workflow.registerAgentErc8004",
+      run: async ({ input, dryRun }) => registerAgentErc8004Pipeline.run(
+        {
+          payload: input.payload,
+          erc8004Networks: input.erc8004Networks,
+          creditTopUp: void 0
+        },
+        { dryRun }
+      )
+    },
+    {
+      name: "workflow.erc8004X402.chat",
+      skip: ({ input }) => !input.chatMessage,
+      run: async ({ input, context, dryRun }) => {
+        const uaid = context?.context?.registrationResult?.context?.uaid;
+        if (!uaid) throw new Error("UAID missing after registration");
+        return chatPipeline.run({ uaid, message: input.chatMessage }, { dryRun });
+      }
+    }
+  ]
+};
+var erc8004X402Workflow = scaffoldWorkflow(erc8004X402Definition);
+
+// src/workflows/x402-registration.ts
+var x402RegistrationDefinition = {
+  name: "workflow.x402Registration",
+  description: "Full agent registration funded via X402 credits with chat validation.",
+  version: "1.0.0",
+  requiredEnv: ["REGISTRY_BROKER_API_KEY"],
+  createContext: () => ({}),
+  steps: [
+    {
+      name: "workflow.x402TopUp",
+      run: async ({ input, dryRun }) => x402TopUpWorkflow.run(
+        {
+          accountId: input.x402.accountId,
+          credits: input.x402.credits,
+          evmPrivateKey: input.x402.evmPrivateKey,
+          ledgerVerification: input.x402.ledgerVerification
+        },
+        { dryRun }
+      )
+    },
+    {
+      name: "workflow.registerAgentAdvanced",
+      run: async ({ input, dryRun }) => registerAgentAdvancedPipeline.run({ payload: input.payload }, { dryRun })
+    },
+    {
+      name: "workflow.x402Registration.chat",
+      skip: ({ input }) => !input.chatMessage,
+      run: async ({ input, context, dryRun }) => {
+        const uaid = context.context?.registrationResult?.context?.uaid;
+        if (!uaid) throw new Error("UAID missing after registration");
+        return chatPipeline.run({ uaid, message: input.chatMessage }, { dryRun });
+      }
+    }
+  ]
+};
+var x402RegistrationWorkflow = scaffoldWorkflow(x402RegistrationDefinition);
+
+// src/mcp.ts
+var agentAuthSchema = z3.object({
+  type: z3.enum(["bearer", "basic", "header", "apiKey"]).optional(),
+  token: z3.string().optional(),
+  username: z3.string().optional(),
+  password: z3.string().optional(),
+  headerName: z3.string().optional(),
+  headerValue: z3.string().optional(),
+  headers: z3.record(z3.string(), z3.string()).optional()
+}).partial();
+var chatSessionSchema = z3.object({
+  uaid: z3.string().min(1),
+  historyTtlSeconds: z3.number().int().positive().optional(),
+  auth: agentAuthSchema.optional()
+});
+var chatMessageSchema = z3.object({
+  sessionId: z3.string().min(1),
+  message: z3.string().min(1),
+  auth: agentAuthSchema.optional()
+});
+var chatCompactSchema = z3.object({
+  sessionId: z3.string().min(1),
+  preserveEntries: z3.number().int().min(0).default(4),
+  auth: agentAuthSchema.optional()
+});
+var searchInput = z3.object({
+  q: z3.string().optional(),
+  limit: z3.number().int().min(1).max(50).default(10),
+  capabilities: z3.array(z3.string()).optional(),
+  registries: z3.array(z3.string()).optional(),
+  minTrust: z3.number().int().min(0).max(100).optional(),
+  verified: z3.boolean().optional(),
+  online: z3.boolean().optional(),
+  sortBy: z3.enum(["trust", "latency", "most-recent"]).optional(),
+  sortOrder: z3.enum(["asc", "desc"]).optional(),
+  metadata: z3.record(z3.string(), z3.array(z3.string())).optional(),
+  type: z3.enum(["ai-agents", "mcp-servers"]).optional()
+});
+var vectorSearchInput = z3.object({
+  query: z3.string().min(1),
+  limit: z3.number().int().min(1).max(20).default(5)
+});
+var uaidInput = z3.object({ uaid: z3.string().min(1) });
+var registrationPayload = z3.object({
+  payload: agentRegistrationSchema
+});
+var workflowDiscoveryInput = z3.object({
+  query: z3.string().optional(),
+  limit: z3.number().int().min(1).max(50).optional()
+});
+var workflowRegistrationInput = z3.object({
+  payload: agentRegistrationSchema
+});
+var workflowChatInput = z3.object({
+  uaid: z3.string().min(1),
+  message: z3.string().optional()
+});
+var workflowOpsInput = z3.object({});
+var workflowFullInput = z3.object({
+  registrationPayload: agentRegistrationSchema,
+  discoveryQuery: z3.string().optional(),
+  chatMessage: z3.string().optional()
+});
+var waitForRegistrationInput = z3.object({
+  attemptId: z3.string(),
+  intervalMs: z3.number().int().positive().default(2e3),
+  timeoutMs: z3.number().int().positive().default(5 * 60 * 1e3)
+});
+var detectProtocolInput = z3.object({
+  headers: z3.record(z3.string(), z3.string()),
+  body: z3.string().optional()
+});
+var sessionIdInput = z3.object({ sessionId: z3.string().min(1) });
+var emptyObject = z3.object({});
+var updateAgentInput = z3.object({
+  uaid: z3.string().min(1),
+  payload: agentRegistrationSchema
+});
+var registryNamespaceInput = z3.object({
+  registry: z3.string().min(1),
+  query: z3.string().optional()
+});
+var creditBalanceInput = z3.object({
+  hederaAccountId: z3.string().min(1).optional(),
+  x402AccountId: z3.string().min(1).optional()
+});
+var ledgerNetworkEnum = z3.enum(["mainnet", "testnet"]);
+var ledgerChallengeInput = z3.object({
+  accountId: z3.string().min(1),
+  network: ledgerNetworkEnum
+});
+var ledgerVerifyInput = z3.object({
+  challengeId: z3.string().min(1),
+  accountId: z3.string().min(1),
+  network: ledgerNetworkEnum,
+  signature: z3.string().min(1),
+  signatureKind: z3.enum(["raw", "map"]).optional(),
+  publicKey: z3.string().optional(),
+  expiresInMinutes: z3.number().int().positive().optional()
+});
+var purchaseHbarInput = z3.object({
+  accountId: z3.string().min(1),
+  privateKey: z3.string().min(1),
+  hbarAmount: z3.number().positive(),
+  memo: z3.string().optional(),
+  metadata: z3.record(z3.string(), z3.any()).optional()
+});
+var buyX402Input = z3.object({
+  accountId: z3.string().min(1),
+  credits: z3.number().positive(),
+  usdAmount: z3.number().positive().optional(),
+  description: z3.string().optional(),
+  metadata: z3.record(z3.string(), z3.any()).optional(),
+  evmPrivateKey: z3.string().min(1),
+  network: z3.enum(["base", "base-sepolia"]).optional(),
+  rpcUrl: z3.string().url().optional()
+});
+var mcp = new FastMCP({
+  name: "hashgraph-standards",
+  version: "1.0.0",
+  description: "MCP tools exposing Hashgraph Online Registry Broker via standards-sdk"
+});
+var toolDefinitions = [
+  {
+    name: "hol.search",
+    description: "Keyword search for agents or MCP servers with filtering controls.",
+    schema: searchInput,
+    handler: (input) => withBroker((client) => client.search(input))
+  },
+  {
+    name: "hol.vectorSearch",
+    description: "Vector similarity search across registered agents.",
+    schema: vectorSearchInput,
+    handler: (input) => withBroker((client) => client.vectorSearch(input))
+  },
+  {
+    name: "hol.resolveUaid",
+    description: "Resolve, validate, and check the status of a UAID in one call.",
+    schema: uaidInput,
+    handler: ({ uaid }) => withBroker(async (client) => {
+      const [resolved, validation, status] = await Promise.all([
+        client.resolveUaid(uaid),
+        client.validateUaid(uaid),
+        client.getUaidConnectionStatus(uaid)
+      ]);
+      return { resolved, validation, status };
+    })
+  },
+  {
+    name: "hol.closeUaidConnection",
+    description: "Force-close any open UAID connection.",
+    schema: uaidInput,
+    handler: ({ uaid }) => withBroker((client) => client.closeUaidConnection(uaid))
+  },
+  {
+    name: "hol.getRegistrationQuote",
+    description: "Estimate fees for a given agent registration payload.",
+    schema: registrationPayload,
+    handler: ({ payload }) => withBroker((client) => client.getRegistrationQuote(payload))
+  },
+  {
+    name: "hol.registerAgent",
+    description: "Submit an HCS-11-compatible agent registration.",
+    schema: registrationPayload,
+    handler: ({ payload }) => withBroker((client) => client.registerAgent(payload))
+  },
+  {
+    name: "hol.waitForRegistrationCompletion",
+    description: "Poll the registry broker until a registration attempt resolves.",
+    schema: waitForRegistrationInput,
+    handler: ({ attemptId, intervalMs, timeoutMs }) => withBroker(
+      (client) => client.waitForRegistrationCompletion(attemptId, {
+        intervalMs,
+        timeoutMs
+      })
+    )
+  },
+  {
+    name: "hol.updateAgent",
+    description: "Update an existing agent registration payload.",
+    schema: updateAgentInput,
+    handler: ({ uaid, payload }) => withBroker((client) => client.updateAgent(uaid, payload))
+  },
+  {
+    name: "hol.additionalRegistries",
+    description: "Retrieve the catalog of additional registries and networks.",
+    schema: emptyObject,
+    handler: () => withBroker((client) => client.getAdditionalRegistries())
+  },
+  {
+    name: "hol.registrySearchByNamespace",
+    description: "Search within a specific registry namespace.",
+    schema: registryNamespaceInput,
+    handler: ({ registry, query }) => withBroker((client) => client.registrySearchByNamespace(registry, query))
+  },
+  {
+    name: "hol.chat.createSession",
+    description: "Open a chat session linked to a UAID.",
+    schema: chatSessionSchema,
+    handler: (input) => withBroker((client) => client.chat.createSession(input))
+  },
+  {
+    name: "hol.chat.sendMessage",
+    description: "Send a message to an active chat session.",
+    schema: chatMessageSchema,
+    handler: (input) => withBroker((client) => client.chat.sendMessage(input))
+  },
+  {
+    name: "hol.chat.history",
+    description: "Retrieve the message history for a chat session.",
+    schema: sessionIdInput,
+    handler: ({ sessionId }) => withBroker((client) => client.chat.getHistory(sessionId))
+  },
+  {
+    name: "hol.chat.compact",
+    description: "Compact chat history while preserving the latest entries.",
+    schema: chatCompactSchema,
+    handler: (input) => withBroker((client) => client.chat.compactHistory(input))
+  },
+  {
+    name: "hol.chat.end",
+    description: "End a chat session and release broker resources.",
+    schema: sessionIdInput,
+    handler: ({ sessionId }) => withBroker((client) => client.chat.endSession(sessionId))
+  },
+  {
+    name: "hol.listProtocols",
+    description: "List all registered protocols/adapters known to the broker.",
+    schema: emptyObject,
+    handler: () => runBrokerCall("hol.listProtocols", () => withBroker((client) => client.listProtocols()))
+  },
+  {
+    name: "hol.detectProtocol",
+    description: "Detect the expected protocol for an inbound request payload.",
+    schema: detectProtocolInput,
+    handler: (input) => runBrokerCall("hol.detectProtocol", () => withBroker((client) => client.detectProtocol(input)))
+  },
+  {
+    name: "hol.stats",
+    description: "High-level registry statistics and usage metrics.",
+    schema: emptyObject,
+    handler: () => withBroker((client) => client.stats())
+  },
+  {
+    name: "hol.metricsSummary",
+    description: "Aggregated broker metrics suitable for dashboards.",
+    schema: emptyObject,
+    handler: () => withBroker((client) => client.metricsSummary())
+  },
+  {
+    name: "hol.dashboardStats",
+    description: "Detailed dashboard statistics from the broker.",
+    schema: emptyObject,
+    handler: () => withBroker((client) => client.dashboardStats())
+  },
+  {
+    name: "hol.websocketStats",
+    description: "Retrieve websocket connection counts and throughput.",
+    schema: emptyObject,
+    handler: () => withBroker((client) => client.websocketStats())
+  },
+  {
+    name: "hol.ledger.challenge",
+    description: "Create a ledger challenge message for account verification.",
+    schema: ledgerChallengeInput,
+    handler: (input) => withBroker((client) => client.createLedgerChallenge(input))
+  },
+  {
+    name: "hol.ledger.authenticate",
+    description: "Verify a signed ledger challenge (sets ledger API key).",
+    schema: ledgerVerifyInput,
+    handler: (input) => withBroker((client) => client.verifyLedgerChallenge(input))
+  },
+  {
+    name: "hol.purchaseCredits.hbar",
+    description: "Purchase registry credits using HBAR funds.",
+    schema: purchaseHbarInput,
+    handler: (input) => withBroker((client) => client.purchaseCreditsWithHbar(input))
+  },
+  {
+    name: "hol.credits.balance",
+    description: "Fetch credit balances for the current API key and optional Hedera/X402 accounts.",
+    schema: creditBalanceInput,
+    handler: async (input) => {
+      const hederaAccountId = input.hederaAccountId;
+      const [apiKeyBalance, hederaBalance, x402Balance] = await Promise.all([
+        getCreditBalance(),
+        hederaAccountId ? safeBalanceLookup("hedera", hederaAccountId) : Promise.resolve(null),
+        input.x402AccountId ? safeBalanceLookup("x402", input.x402AccountId) : Promise.resolve(null)
+      ]);
+      return {
+        apiKey: apiKeyBalance,
+        hedera: hederaBalance,
+        x402: x402Balance
+      };
+    }
+  },
+  {
+    name: "hol.x402.minimums",
+    description: "Fetch the minimum credit purchase requirements for X402.",
+    schema: emptyObject,
+    handler: () => withBroker((client) => client.getX402Minimums())
+  },
+  {
+    name: "hol.x402.buyCredits",
+    description: "Buy registry credits via X402 using an EVM private key.",
+    schema: buyX402Input,
+    handler: (input) => withBroker((client) => client.buyCreditsWithX402(input))
+  },
+  {
+    name: "workflow.discovery",
+    description: "Pipeline: hol.search + hol.vectorSearch",
+    schema: workflowDiscoveryInput,
+    handler: async (input) => formatPipelineResult(await discoveryPipeline.run(input))
+  },
+  {
+    name: "workflow.registerMcp",
+    description: "Pipeline: get quote, register agent, wait for completion",
+    schema: workflowRegistrationInput,
+    handler: async ({ payload }) => formatPipelineResult(await registrationPipeline.run({ payload }))
+  },
+  {
+    name: "workflow.chatSmoke",
+    description: "Pipeline: chat session smoke test for UAID",
+    schema: workflowChatInput,
+    handler: async (input) => formatPipelineResult(await chatPipeline.run(input))
+  },
+  {
+    name: "workflow.opsCheck",
+    description: "Pipeline: stats, metrics, dashboard, protocols",
+    schema: workflowOpsInput,
+    handler: async () => formatPipelineResult(await opsPipeline.run({}))
+  },
+  {
+    name: "workflow.openrouterChat",
+    description: "Pipeline: discover OpenRouter model and run a chat message",
+    schema: z3.object({ modelId: z3.string().min(1), registry: z3.string().optional(), message: z3.string(), authToken: z3.string().optional() }),
+    handler: async (input) => formatPipelineResult(await openRouterChatWorkflow.run(input))
+  },
+  {
+    name: "workflow.registryBrokerShowcase",
+    description: "Pipeline: discovery, analytics, UAID validation, chat",
+    schema: z3.object({ query: z3.string().optional(), uaid: z3.string().optional(), message: z3.string().optional(), performCreditCheck: z3.boolean().optional() }),
+    handler: async (input) => formatPipelineResult(await registryBrokerShowcaseWorkflow.run(input))
+  },
+  {
+    name: "workflow.agentverseBridge",
+    description: "Pipeline: relay chat between local UAID and Agentverse UAID",
+    schema: z3.object({
+      uaid: z3.string().min(1),
+      agentverseUaid: z3.string().min(1),
+      localMessage: z3.string().min(1),
+      agentverseMessage: z3.string().min(1),
+      iterations: z3.number().int().positive().optional()
+    }),
+    handler: async (input) => formatPipelineResult(await agentverseBridgeWorkflow.run(input))
+  },
+  {
+    name: "workflow.erc8004Discovery",
+    description: "Pipeline: search ERC-8004 registries",
+    schema: z3.object({ query: z3.string().optional(), limit: z3.number().int().positive().optional() }),
+    handler: async (input) => formatPipelineResult(await erc8004DiscoveryWorkflow.run(input))
+  },
+  {
+    name: "workflow.erc8004X402",
+    description: "Pipeline: ERC-8004 registration funded via X402 credits",
+    schema: z3.object({
+      payload: agentRegistrationSchema,
+      erc8004Networks: z3.array(z3.string()).optional(),
+      chatMessage: z3.string().optional()
+    }),
+    handler: async (input) => formatPipelineResult(await erc8004X402Workflow.run(input))
+  },
+  {
+    name: "workflow.x402Registration",
+    description: "Pipeline: register agent using X402 payments + chat smoke test",
+    schema: z3.object({
+      payload: agentRegistrationSchema,
+      chatMessage: z3.string().optional()
+    }),
+    handler: async (input) => formatPipelineResult(await x402RegistrationWorkflow.run(input))
+  },
+  {
+    name: "workflow.fullRegistration",
+    description: "Pipeline: discovery \u2192 register \u2192 chat \u2192 ops",
+    schema: workflowFullInput,
+    handler: async (input) => formatPipelineResult(await fullWorkflowPipeline.run(input))
+  }
+];
+function formatPipelineResult(result) {
+  const summaryLines = [
+    `Workflow: ${result.pipeline}`,
+    result.dryRun ? "(dry-run)" : void 0,
+    result.context?.uaid ? `UAID: ${result.context.uaid}` : void 0,
+    `Steps executed: ${result.steps.length}`
+  ].filter(Boolean);
+  return {
+    content: [
+      { type: "text", text: summaryLines.join("\n") },
+      buildObjectContent("pipeline.result", result)
+    ],
+    structuredContent: result
+  };
+}
+function buildLoggedTool(definition) {
+  return {
+    name: definition.name,
+    description: definition.description,
+    parameters: definition.schema,
+    execute: async (args, context) => {
+      const requestId = context?.requestId ?? randomUUID();
+      const started = Date.now();
+      try {
+        const parsedInput = definition.schema.parse(args);
+        logger.debug({ requestId, tool: definition.name }, "tool.invoke");
+        const result = await definition.handler(parsedInput);
+        logger.info(
+          {
+            requestId,
+            tool: definition.name,
+            durationMs: Date.now() - started
+          },
+          "tool.success"
+        );
+        return normalizeResult(result);
+      } catch (error) {
+        logger.error(
+          {
+            requestId,
+            tool: definition.name,
+            durationMs: Date.now() - started,
+            error: error instanceof Error ? error.message : String(error)
+          },
+          "tool.failure"
+        );
+        throw error;
+      }
+    }
+  };
+}
+for (const definition of toolDefinitions) {
+  mcp.addTool(buildLoggedTool(definition));
+}
+var registeredTools = toolDefinitions;
+function isContentValue(value) {
+  return Boolean(
+    value && typeof value === "object" && "type" in value && typeof value.type === "string"
+  );
+}
+function normalizeResult(value) {
+  if (isResultShape(value)) {
+    const record = value;
+    return {
+      content: normalizeContent(record.content),
+      structuredContent: isPlainObject(record.structuredContent) ? record.structuredContent : void 0,
+      isError: typeof record.isError === "boolean" ? record.isError : void 0
+    };
+  }
+  if (isPlainObject(value)) {
+    return {
+      content: [buildObjectContent("tool.result", value)],
+      structuredContent: value
+    };
+  }
+  return { content: normalizeContent(value) };
+}
+function normalizeContent(result) {
+  if (Array.isArray(result) && result.every(isContentValue)) {
+    return result;
+  }
+  if (isContentValue(result)) {
+    return [result];
+  }
+  if (result === void 0 || result === null) {
+    return [{ type: "text", text: "ok" }];
+  }
+  if (typeof result === "string" || typeof result === "number" || typeof result === "boolean") {
+    return [{ type: "text", text: String(result) }];
+  }
+  if (isPlainObject(result)) {
+    return [buildObjectContent("tool.result", result)];
+  }
+  return [{ type: "text", text: JSON.stringify(result) }];
+}
+function buildObjectContent(name, value) {
+  return {
+    type: "text",
+    text: `${name}:
+${JSON.stringify(value, null, 2)}`
+  };
+}
+function isResultShape(value) {
+  return Boolean(value && typeof value === "object" && ("content" in value || "structuredContent" in value));
+}
+function isPlainObject(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+async function runBrokerCall(label, fn) {
+  try {
+    return await fn();
+  } catch (error) {
+    if (error instanceof RegistryBrokerError2) {
+      const body = typeof error.body === "object" ? JSON.stringify(error.body) : String(error.body);
+      throw new Error(`${label} failed (${error.status} ${error.statusText ?? ""}): ${body}`);
+    }
+    throw error;
+  }
+}
+async function safeBalanceLookup(label, accountId) {
+  try {
+    return await getCreditBalance(accountId);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { error: `${label} balance unavailable: ${message}`, accountId };
+  }
+}
+mcp.addResource({
+  name: "hol.search.help",
+  uri: "help://rb/search",
+  mimeType: "text/markdown",
+  load: async () => [
+    {
+      text: [
+        "# hol.search",
+        "",
+        "Discover registered agents or MCP servers.",
+        "",
+        "- `q`: keyword search",
+        "- `capabilities`: filter by declared skills",
+        '- `metadata`: pass `{ "region": ["na"] }` style filters',
+        "- `type`: limit results to `ai-agents` or `mcp-servers`"
+      ].join("\n")
+    }
+  ]
+});
+
+// src/transports/index.ts
+var LOOPBACK = "127.0.0.1";
+async function runStdio() {
+  logger.info("Starting stdio transport");
+  await mcp.stdio();
+  logger.info("Stdio transport exited");
+}
+async function runSSE() {
+  const upstreamPort = config.httpStreamPort ?? config.port + 1;
+  await startHttpStreamBackend(upstreamPort);
+  const gateway = createGatewayServer(upstreamPort);
+  await new Promise((resolve, reject) => {
+    gateway.once("error", reject);
+    gateway.listen(config.port, () => {
+      logger.info({ port: config.port, upstreamPort }, "Gateway listening");
+      resolve();
+    });
+  });
+}
+async function startHttpStreamBackend(port) {
+  await mcp.start({
+    transportType: "httpStream",
+    httpStream: {
+      port,
+      host: LOOPBACK,
+      endpoint: "/mcp/stream",
+      enableJsonResponse: false
+    }
+  });
+  logger.info({ port }, "HTTP stream backend ready");
+}
+function createGatewayServer(upstreamPort) {
+  return http.createServer(createGatewayHandler(upstreamPort));
+}
+function createGatewayHandler(upstreamPort) {
+  return (req, res) => {
+    if (!req.url) {
+      res.writeHead(400).end("Missing URL");
+      return;
+    }
+    if (req.url.startsWith("/healthz")) {
+      const body = JSON.stringify({
+        status: "ok",
+        uptime: process.uptime(),
+        tools: registeredTools.length,
+        requestId: randomUUID2()
+      });
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end(body);
+      return;
+    }
+    proxyRequest(req, res, upstreamPort);
+  };
+}
+function proxyRequest(req, res, upstreamPort) {
+  logger.debug({ method: req.method, url: req.url }, "gateway.forward");
+  const proxyReq = http.request(
+    {
+      hostname: LOOPBACK,
+      port: upstreamPort,
+      method: req.method,
+      path: req.url,
+      headers: {
+        ...req.headers,
+        host: `${LOOPBACK}:${upstreamPort}`
+      }
+    },
+    (proxyRes) => {
+      res.writeHead(proxyRes.statusCode ?? 502, proxyRes.headers);
+      proxyRes.pipe(res);
+    }
+  );
+  proxyReq.on("error", (error) => {
+    logger.error({ error }, "proxy.error");
+    if (!res.headersSent) {
+      res.writeHead(502);
+    }
+    res.end("Upstream error");
+  });
+  if (req.method && ["POST", "PUT", "PATCH"].includes(req.method)) {
+    const tee = new PassThrough();
+    let preview = "";
+    tee.on("data", (chunk) => {
+      if (preview.length < 512) {
+        preview += chunk.toString();
+      }
+    });
+    tee.on("end", () => {
+      if (preview.length) {
+        logger.debug({ preview: preview.slice(0, 512) }, "proxy.preview");
+      }
+    });
+    req.pipe(tee).pipe(proxyReq);
+  } else {
+    req.pipe(proxyReq);
+  }
+}
+
+// src/index.ts
+var transport = (process.env.MCP_TRANSPORT ?? "sse").toLowerCase();
+if (transport === "stdio") {
+  logger.info({ transport }, "starting MCP server");
+  runStdio().catch((err) => {
+    logger.error({ err }, "Failed to start stdio transport");
+    process.exitCode = 1;
+  });
+} else {
+  logger.info({ transport }, "starting MCP server");
+  runSSE().catch((err) => {
+    logger.error({ err }, "Failed to start SSE transport");
+    process.exitCode = 1;
+  });
+}
+//# sourceMappingURL=index.js.map