@hol-org/hashnet-mcp 1.0.20 → 1.0.21

package/dist/index.js

@@ -1,2767 +0,0 @@
-// src/transports/index.ts
-import http from "http";
-import { randomUUID as randomUUID4 } from "crypto";
-import { PassThrough } from "stream";
-
-// src/mcp.ts
-import { randomUUID as randomUUID3 } from "crypto";
-import { RegistryBrokerError as RegistryBrokerError3 } from "@hashgraphonline/standards-sdk";
-import { FastMCP } from "fastmcp";
-import { z as z3 } from "zod";
-
-// src/broker.ts
-import { RegistryBrokerClient, RegistryBrokerError } 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({ quiet: true });
-}
-var LOG_LEVELS = ["fatal", "error", "warn", "info", "debug", "trace"];
-var envSchema = z.object({
-  REGISTRY_BROKER_API_URL: z.string().url().default("https://hol.org/registry/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"),
-  HTTP_STREAM_PORT: z.coerce.number().int().positive().optional(),
-  MEMORY_ENABLED: z.enum(["0", "1"]).optional().transform((value) => value === "1"),
-  MEMORY_STORE: z.enum(["file", "sqlite", "rocksdb", "memory", "redis"]).optional(),
-  MEMORY_STORAGE_PATH: z.string().default("tmp/memory.json"),
-  MEMORY_MAX_ENTRIES_PER_SCOPE: z.coerce.number().int().positive().optional(),
-  MEMORY_DEFAULT_TTL_SECONDS: z.coerce.number().int().positive().optional(),
-  MEMORY_SUMMARY_TRIGGER: z.coerce.number().int().positive().optional(),
-  MEMORY_MAX_RETURN_ENTRIES: z.coerce.number().int().positive().optional(),
-  MEMORY_CAPTURE_TOOLS: 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),
-  HTTP_STREAM_PORT: normalized(process.env.HTTP_STREAM_PORT),
-  MEMORY_ENABLED: normalized(process.env.MEMORY_ENABLED),
-  MEMORY_STORE: normalized(process.env.MEMORY_STORE),
-  MEMORY_STORAGE_PATH: normalized(process.env.MEMORY_STORAGE_PATH),
-  MEMORY_MAX_ENTRIES_PER_SCOPE: normalized(process.env.MEMORY_MAX_ENTRIES_PER_SCOPE),
-  MEMORY_DEFAULT_TTL_SECONDS: normalized(process.env.MEMORY_DEFAULT_TTL_SECONDS),
-  MEMORY_SUMMARY_TRIGGER: normalized(process.env.MEMORY_SUMMARY_TRIGGER),
-  MEMORY_MAX_RETURN_ENTRIES: normalized(process.env.MEMORY_MAX_RETURN_ENTRIES),
-  MEMORY_CAPTURE_TOOLS: normalized(process.env.MEMORY_CAPTURE_TOOLS)
-});
-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,
-  memory: {
-    enabled: parsed.data.MEMORY_ENABLED ?? false,
-    store: parsed.data.MEMORY_STORE ?? "file",
-    path: parsed.data.MEMORY_STORAGE_PATH ?? "tmp/memory.json",
-    maxEntriesPerScope: parsed.data.MEMORY_MAX_ENTRIES_PER_SCOPE ?? 200,
-    defaultTtlSeconds: parsed.data.MEMORY_DEFAULT_TTL_SECONDS ?? 24 * 60 * 60,
-    summaryTrigger: parsed.data.MEMORY_SUMMARY_TRIGGER ?? 100,
-    maxReturnEntries: parsed.data.MEMORY_MAX_RETURN_ENTRIES ?? 50,
-    captureTools: parsed.data.MEMORY_CAPTURE_TOOLS ?? true
-  }
-};
-
-// src/broker.ts
-var autoTopUpConfig = config.autoTopUpEnabled ? {
-  accountId: config.hederaAccountId,
-  privateKey: config.hederaPrivateKey,
-  memo: "mcp-autotopup"
-} : void 0;
-var broker = new RegistryBrokerClient({
-  baseUrl: normalizeRegistryUrl(config.registryBrokerUrl),
-  apiKey: config.registryBrokerApiKey,
-  fetchImplementation: undiciFetch,
-  registrationAutoTopUp: autoTopUpConfig,
-  historyAutoTopUp: autoTopUpConfig
-});
-var brokerLimiter = createLimiter();
-function createLimiter() {
-  if (!config.rateLimit) return void 0;
-  const redisClient = config.rateLimit.redis?.url ? new IORedis(config.rateLimit.redis.url) : void 0;
-  const limiterOptions = {
-    ...config.rateLimit.maxConcurrent !== void 0 ? { maxConcurrent: config.rateLimit.maxConcurrent } : {},
-    ...config.rateLimit.minTimeMs !== void 0 ? { minTime: config.rateLimit.minTimeMs } : {},
-    ...config.rateLimit.reservoir !== void 0 ? { reservoir: config.rateLimit.reservoir } : {},
-    ...config.rateLimit.reservoirRefreshAmount !== void 0 ? { reservoirRefreshAmount: config.rateLimit.reservoirRefreshAmount } : {},
-    ...config.rateLimit.reservoirRefreshIntervalMs !== void 0 ? { reservoirRefreshInterval: config.rateLimit.reservoirRefreshIntervalMs } : {},
-    ...redisClient ? { datastore: "ioredis", connection: redisClient } : {}
-  };
-  if (!limiterOptions.maxConcurrent && !limiterOptions.minTime && !limiterOptions.reservoir && !limiterOptions.datastore) {
-    return void 0;
-  }
-  return new Bottleneck(limiterOptions);
-}
-async function withBroker(task, label) {
-  const run = async () => {
-    if (!config.registryBrokerApiKey) {
-      throw new Error("REGISTRY_BROKER_API_KEY is required to call the registry broker. Set it in your environment or .env file.");
-    }
-    try {
-      return await task(broker);
-    } catch (error) {
-      throw formatBrokerError(error, label);
-    }
-  };
-  if (brokerLimiter) {
-    return brokerLimiter.schedule(run);
-  }
-  return run();
-}
-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;
-  }
-}
-function formatBrokerError(error, label) {
-  if (error instanceof RegistryBrokerError) {
-    const body = typeof error.body === "object" ? JSON.stringify(error.body) : error.body ? String(error.body) : "no response body";
-    const statusText = error.statusText ? ` ${error.statusText}` : "";
-    const prefix = label ? `${label} failed` : "Registry broker request failed";
-    return new Error(`${prefix} (${error.status}${statusText}): ${body}`);
-  }
-  return error instanceof Error ? error : new Error(String(error));
-}
-function normalizeRegistryUrl(rawUrl) {
-  try {
-    const parsed2 = new URL(rawUrl);
-    if (parsed2.hostname === "registry.hashgraphonline.com") {
-      parsed2.hostname = "hol.org";
-      parsed2.pathname = "/registry/api/v1";
-      parsed2.search = "";
-      parsed2.hash = "";
-      return stripTrailingSlash(parsed2.toString());
-    }
-    const cleanPath = parsed2.pathname.replace(/\/+$/, "");
-    parsed2.pathname = cleanPath.endsWith("/api/v1") ? cleanPath : `${cleanPath || ""}/api/v1`;
-    return stripTrailingSlash(parsed2.toString());
-  } catch {
-    return rawUrl;
-  }
-}
-function stripTrailingSlash(value) {
-  return value.endsWith("/") ? value.slice(0, -1) : value;
-}
-
-// src/logger.ts
-import pino from "pino";
-var logger = pino(
-  {
-    level: config.logLevel,
-    base: void 0
-  },
-  pino.destination(2)
-);
-
-// 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 as RegistryBrokerError2 } 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 ?? 0,
-      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 RegistryBrokerError2) || 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: (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 && typeof result === "object" && "result" in result) {
-          const progress = result;
-          const maybeUaid = progress.result?.uaid;
-          if (typeof maybeUaid === "string") {
-            context.uaid = maybeUaid;
-          }
-        }
-        return result;
-      }
-    }
-  ]
-};
-var registrationPipeline = registerPipeline(registrationDefinition);
-
-// src/memory/factory.ts
-import { createRequire } from "module";
-
-// src/memory/in-memory-store.ts
-import { randomUUID } from "crypto";
-
-// src/memory/types.ts
-function scopeKey(scope) {
-  return [scope.uaid ?? "", scope.sessionId ?? "", scope.namespace ?? "", scope.userId ?? ""].join("::");
-}
-
-// src/memory/in-memory-store.ts
-var InMemoryMemoryStore = class {
-  entries = /* @__PURE__ */ new Map();
-  summaries = /* @__PURE__ */ new Map();
-  async append(entry) {
-    const now = Date.now();
-    const key = scopeKey(entry.scope);
-    const record = {
-      ...entry,
-      id: randomUUID(),
-      createdAt: now
-    };
-    const existing = this.entries.get(key) ?? [];
-    existing.push(record);
-    this.entries.set(key, existing);
-    return record;
-  }
-  async listRecent(scope, limit) {
-    const key = scopeKey(scope);
-    const items = this.entries.get(key) ?? [];
-    return this.filterLive(items).sort((a, b) => b.createdAt - a.createdAt).slice(0, limit);
-  }
-  async trim(scope, maxEntries) {
-    const key = scopeKey(scope);
-    const items = this.filterLive(this.entries.get(key) ?? []).sort((a, b) => b.createdAt - a.createdAt);
-    const toKeep = items.slice(0, maxEntries);
-    const trimmed = items.length - toKeep.length;
-    this.entries.set(key, toKeep);
-    return trimmed;
-  }
-  async clear(scope) {
-    const key = scopeKey(scope);
-    const count = (this.entries.get(key) ?? []).length;
-    this.entries.delete(key);
-    this.summaries.delete(key);
-    return count;
-  }
-  async search(scope, query, limit) {
-    const key = scopeKey(scope);
-    const items = this.filterLive(this.entries.get(key) ?? []);
-    const normalized2 = query.toLowerCase();
-    return items.filter((item) => item.content.toLowerCase().includes(normalized2)).sort((a, b) => b.createdAt - a.createdAt).slice(0, limit);
-  }
-  async getSummary(scope) {
-    const key = scopeKey(scope);
-    return this.summaries.get(key) ?? null;
-  }
-  async upsertSummary(summary) {
-    const key = scopeKey(summary.scope);
-    this.summaries.set(key, summary);
-  }
-  async purgeExpired(nowMs) {
-    let removed = 0;
-    for (const [key, values] of this.entries.entries()) {
-      const live = values.filter((entry) => !entry.expiresAt || entry.expiresAt > nowMs);
-      removed += values.length - live.length;
-      this.entries.set(key, live);
-    }
-    return removed;
-  }
-  filterLive(entries) {
-    const now = Date.now();
-    return entries.filter((entry) => !entry.expiresAt || entry.expiresAt > now);
-  }
-};
-
-// src/memory/file-store.ts
-import fs from "fs";
-import path from "path";
-import { randomUUID as randomUUID2 } from "crypto";
-var FileMemoryStore = class {
-  filePath;
-  data;
-  constructor(filePath) {
-    this.filePath = filePath;
-    this.data = { entries: [], summaries: [] };
-    this.ensureLoaded();
-  }
-  async append(entry) {
-    const record = {
-      ...entry,
-      id: randomUUID2(),
-      createdAt: Date.now()
-    };
-    this.data.entries.push(record);
-    await this.save();
-    return record;
-  }
-  async listRecent(scope, limit) {
-    const key = scopeKey(scope);
-    const now = Date.now();
-    return this.data.entries.filter((entry) => scopeKey(entry.scope) === key).filter((entry) => !entry.expiresAt || entry.expiresAt > now).sort((a, b) => b.createdAt - a.createdAt).slice(0, limit);
-  }
-  async trim(scope, maxEntries) {
-    const key = scopeKey(scope);
-    const scoped = this.data.entries.filter((entry) => scopeKey(entry.scope) === key).sort((a, b) => b.createdAt - a.createdAt);
-    const keep = scoped.slice(0, maxEntries).map((entry) => entry.id);
-    const before = this.data.entries.length;
-    this.data.entries = this.data.entries.filter((entry) => scopeKey(entry.scope) !== key || keep.includes(entry.id));
-    const removed = before - this.data.entries.length;
-    if (removed > 0) {
-      await this.save();
-    }
-    return removed;
-  }
-  async clear(scope) {
-    const key = scopeKey(scope);
-    const beforeEntries = this.data.entries.length;
-    const beforeSummaries = this.data.summaries.length;
-    this.data.entries = this.data.entries.filter((entry) => scopeKey(entry.scope) !== key);
-    this.data.summaries = this.data.summaries.filter((summary) => scopeKey(summary.scope) !== key);
-    const removed = beforeEntries - this.data.entries.length + (beforeSummaries - this.data.summaries.length);
-    if (removed > 0) {
-      await this.save();
-    }
-    return removed;
-  }
-  async search(scope, query, limit) {
-    const key = scopeKey(scope);
-    const normalized2 = query.toLowerCase();
-    const now = Date.now();
-    return this.data.entries.filter((entry) => scopeKey(entry.scope) === key).filter((entry) => !entry.expiresAt || entry.expiresAt > now).filter((entry) => entry.content.toLowerCase().includes(normalized2)).sort((a, b) => b.createdAt - a.createdAt).slice(0, limit);
-  }
-  async getSummary(scope) {
-    const key = scopeKey(scope);
-    return this.data.summaries.find((summary) => scopeKey(summary.scope) === key) ?? null;
-  }
-  async upsertSummary(summary) {
-    const key = scopeKey(summary.scope);
-    const existingIndex = this.data.summaries.findIndex((entry) => scopeKey(entry.scope) === key);
-    if (existingIndex >= 0) {
-      this.data.summaries[existingIndex] = summary;
-    } else {
-      this.data.summaries.push(summary);
-    }
-    await this.save();
-  }
-  async purgeExpired(nowMs) {
-    const before = this.data.entries.length;
-    this.data.entries = this.data.entries.filter((entry) => !entry.expiresAt || entry.expiresAt > nowMs);
-    const removed = before - this.data.entries.length;
-    if (removed > 0) {
-      await this.save();
-    }
-    return removed;
-  }
-  ensureLoaded() {
-    const dir = path.dirname(this.filePath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    if (!fs.existsSync(this.filePath)) {
-      this.saveSync();
-      return;
-    }
-    try {
-      const content = fs.readFileSync(this.filePath, "utf8");
-      const parsed2 = JSON.parse(content);
-      this.data = {
-        entries: parsed2.entries ?? [],
-        summaries: parsed2.summaries ?? []
-      };
-    } catch {
-      this.data = { entries: [], summaries: [] };
-      this.saveSync();
-    }
-  }
-  async save() {
-    await fs.promises.writeFile(this.filePath, JSON.stringify(this.data, null, 2), "utf8");
-  }
-  saveSync() {
-    fs.writeFileSync(this.filePath, JSON.stringify(this.data, null, 2), "utf8");
-  }
-};
-
-// src/memory/factory.ts
-function createMemoryStore(config2) {
-  switch (config2.store) {
-    case "file":
-      return new FileMemoryStore(config2.path ?? "tmp/memory.json");
-    case "sqlite":
-      return loadSqliteStore(config2.path ?? "tmp/memory.db");
-    case "memory":
-      return new InMemoryMemoryStore();
-    case "rocksdb":
-      throw new Error("RocksDB backend not yet implemented. Use MEMORY_STORE=sqlite or memory for now.");
-    case "redis":
-      throw new Error("Redis backend not yet implemented. Use MEMORY_STORE=sqlite or memory for now.");
-    default:
-      throw new Error(`Unsupported memory store "${config2.store}".`);
-  }
-}
-function loadSqliteStore(filePath) {
-  const require2 = createRequire(import.meta.url);
-  const module = require2("./sqlite-store");
-  return new module.SqliteMemoryStore(filePath);
-}
-
-// src/memory/service.ts
-var DEFAULT_MAX_CHARS = 4e3;
-var REDACT_KEYS = ["privateKey", "apiKey", "token", "authorization", "auth", "evmPrivateKey", "password"];
-var MemoryService = class {
-  store;
-  config;
-  logger;
-  constructor(store, memoryConfig, logger2) {
-    this.store = store;
-    this.config = memoryConfig;
-    this.logger = logger2.child({ module: "memory" });
-  }
-  isEnabled() {
-    return this.config.enabled;
-  }
-  async recordEntry(params) {
-    if (!this.config.enabled) return null;
-    const content = truncate(params.content, DEFAULT_MAX_CHARS);
-    const ttlSeconds = params.ttlSeconds ?? this.config.defaultTtlSeconds;
-    const expiresAt = ttlSeconds ? Date.now() + ttlSeconds * 1e3 : void 0;
-    const entry = await this.store.append({
-      scope: params.scope,
-      role: params.role,
-      content,
-      toolName: params.toolName,
-      metadata: params.metadata ? redact(params.metadata) : void 0,
-      expiresAt
-    });
-    await this.store.trim(params.scope, this.config.maxEntriesPerScope);
-    await this.store.purgeExpired(Date.now());
-    if (this.config.summaryTrigger && this.config.summaryTrigger > 0) {
-      void this.maybeSummarize(params.scope).catch((error) => {
-        this.logger.warn({ error }, "memory.summarize.failed");
-      });
-    }
-    return entry;
-  }
-  async recordToolEvent(toolName, scope, payload) {
-    if (!this.config.enabled || !this.config.captureTools) return;
-    const excerpt = truncate(serialize(payload), DEFAULT_MAX_CHARS);
-    await this.recordEntry({
-      scope,
-      role: "tool",
-      content: `[${toolName}] ${excerpt}`,
-      toolName
-    });
-  }
-  async note(scope, content) {
-    return this.recordEntry({ scope, role: "note", content });
-  }
-  async getContext(params) {
-    const limit = clamp(params.limit ?? this.config.maxReturnEntries, 1, this.config.maxReturnEntries);
-    const entries = await this.store.listRecent(params.scope, limit);
-    const summary = params.includeSummary ? await this.store.getSummary(params.scope) : void 0;
-    return { entries, summary };
-  }
-  async search(params) {
-    const limit = clamp(params.limit ?? this.config.maxReturnEntries, 1, this.config.maxReturnEntries);
-    return this.store.search(params.scope, params.query, limit);
-  }
-  async clear(scope) {
-    return this.store.clear(scope);
-  }
-  async summarize(scope) {
-    if (!this.config.enabled) return null;
-    const entries = await this.store.listRecent(scope, this.config.summaryTrigger ?? this.config.maxReturnEntries);
-    if (!entries.length) return null;
-    const summary = buildHeuristicSummary(entries);
-    const record = { scope, content: summary, updatedAt: Date.now() };
-    await this.store.upsertSummary(record);
-    return record;
-  }
-  async maybeSummarize(scope) {
-    if (!this.config.summaryTrigger) return;
-    const entries = await this.store.listRecent(scope, this.config.summaryTrigger + 5);
-    if (entries.length < this.config.summaryTrigger) return;
-    await this.summarize(scope);
-  }
-};
-function createMemoryService() {
-  if (!config.memory.enabled) return null;
-  try {
-    const store = createMemoryStore(config.memory);
-    return new MemoryService(store, config.memory, logger);
-  } catch (error) {
-    logger.error({ error }, "memory.init.failed");
-    return null;
-  }
-}
-function truncate(value, max) {
-  if (value.length <= max) return value;
-  return `${value.slice(0, max)}\u2026`;
-}
-function clamp(value, min, max) {
-  return Math.min(Math.max(value, min), max);
-}
-function serialize(payload) {
-  if (typeof payload === "string") return payload;
-  if (payload === void 0 || payload === null) return "";
-  try {
-    return JSON.stringify(redact(payload), null, 2);
-  } catch (error) {
-    return `unserializable payload: ${error instanceof Error ? error.message : String(error)}`;
-  }
-}
-function redact(payload) {
-  if (Array.isArray(payload)) {
-    return payload.map((item) => redact(item));
-  }
-  if (payload && typeof payload === "object") {
-    const clone = {};
-    for (const [key, value] of Object.entries(payload)) {
-      if (REDACT_KEYS.includes(key.toLowerCase())) {
-        clone[key] = "[redacted]";
-      } else {
-        clone[key] = redact(value);
-      }
-    }
-    return clone;
-  }
-  return payload;
-}
-function buildHeuristicSummary(entries) {
-  const recent = entries.slice(0, 10).map((entry) => `${entry.role}${entry.toolName ? `(${entry.toolName})` : ""}: ${truncate(entry.content, 512)}`);
-  return ["Summary (heuristic, no LLM):", ...recent].join("\n");
-}
-
-// src/memory/index.ts
-var memoryService = createMemoryService();
-
-// src/workflows/utils/memory.ts
-async function loadMemoryContext(options) {
-  if (options.optOut) return null;
-  if (!memoryService || !memoryService.isEnabled()) return null;
-  return memoryService.getContext({
-    scope: options.scope,
-    limit: options.limit,
-    includeSummary: options.includeSummary ?? true
-  });
-}
-async function recordMemory(options) {
-  if (options.optOut) return;
-  if (!memoryService || !memoryService.isEnabled()) return;
-  await memoryService.recordEntry({
-    scope: options.scope,
-    role: options.role,
-    content: options.content,
-    toolName: options.toolName
-  });
-}
-
-// 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, disableMemory }) => ({ uaid, auth, transcript: void 0, memoryOptOut: disableMemory }),
-  steps: [
-    {
-      name: "workflow.chatSmoke.memory.load",
-      skip: ({ input }) => Boolean(input.disableMemory),
-      run: async ({ context }) => {
-        const scope = { uaid: context.uaid };
-        const loaded = await loadMemoryContext({ scope, optOut: context.memoryOptOut });
-        context.memoryContext = loaded ?? void 0;
-        return loaded ?? { skipped: true };
-      }
-    },
-    {
-      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");
-        const message = input.message ?? "Hello from workflow.chatSmoke";
-        await recordMemory({
-          scope: { uaid: context.uaid, sessionId: context.sessionId },
-          role: "user",
-          content: message,
-          toolName: "workflow.chatSmoke",
-          optOut: context.memoryOptOut
-        });
-        const response = await withBroker(
-          (client) => client.chat.sendMessage({
-            sessionId: context.sessionId,
-            message,
-            uaid: context.uaid,
-            auth: input.auth ?? context.auth
-          })
-        );
-        await recordMemory({
-          scope: { uaid: context.uaid, sessionId: context.sessionId },
-          role: "assistant",
-          content: JSON.stringify(response),
-          toolName: "workflow.chatSmoke",
-          optOut: context.memoryOptOut
-        });
-        return response;
-      }
-    },
-    {
-      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;
-        await recordMemory({
-          scope: { uaid: context.uaid, sessionId: context.sessionId },
-          role: "event",
-          content: JSON.stringify({ history }),
-          toolName: "workflow.chatSmoke",
-          optOut: context.memoryOptOut
-        });
-        return history;
-      }
-    },
-    {
-      name: "hol.chat.compact",
-      allowDuringDryRun: true,
-      run: async ({ context }) => {
-        if (!context.sessionId) throw new Error("Missing chat session");
-        try {
-          return await withBroker((client) => client.chat.compactHistory({ sessionId: context.sessionId, preserveEntries: 2 }));
-        } catch (error) {
-          const message = error instanceof Error ? error.message.toLowerCase() : "";
-          if (message.includes("authenticated account required") || message.includes("insufficient credits")) {
-            return { skipped: true, reason: "history compaction requires authenticated account" };
-          }
-          throw error;
-        }
-      }
-    },
-    {
-      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: (input) => ({ memoryOptOut: input.disableMemory }),
-  steps: [
-    {
-      name: "workflow.discovery",
-      allowDuringDryRun: true,
-      run: async ({ input, context }) => {
-        const result = await discoveryPipeline.run({ query: input.discoveryQuery, limit: 5 });
-        context.discovery = result;
-        await recordMemory({
-          scope: { namespace: "workflow.fullRegistration" },
-          role: "event",
-          content: JSON.stringify({ discovery: result }),
-          toolName: "workflow.fullRegistration",
-          optOut: context.memoryOptOut
-        });
-        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;
-        if (context.uaid) {
-          await recordMemory({
-            scope: { uaid: context.uaid },
-            role: "event",
-            content: JSON.stringify({ registration: result }),
-            toolName: "workflow.fullRegistration",
-            optOut: context.memoryOptOut
-          });
-        }
-        return result;
-      }
-    },
-    {
-      name: "workflow.fullRegistration.memory.load",
-      skip: ({ input, context }) => Boolean(input.disableMemory || !context.uaid),
-      run: async ({ context }) => {
-        if (!context.uaid) return { skipped: true };
-        const loaded = await loadMemoryContext({ scope: { uaid: context.uaid }, optOut: context.memoryOptOut });
-        context.memoryContext = loaded ?? void 0;
-        return loaded ?? { skipped: true };
-      }
-    },
-    {
-      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, disableMemory: input.disableMemory }, { 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: (input) => ({ memoryOptOut: input.disableMemory }),
-  steps: [
-    {
-      name: "workflow.openrouterChat.memory.load",
-      skip: ({ input }) => Boolean(input.disableMemory),
-      run: async ({ input, context }) => {
-        const scope = { namespace: "openrouter", userId: input.modelId };
-        const loaded = await loadMemoryContext({ scope, optOut: context.memoryOptOut });
-        return loaded ?? { skipped: true };
-      }
-    },
-    {
-      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;
-        await recordMemory({
-          scope: { uaid: context.uaid, sessionId: context.sessionId },
-          role: "user",
-          content: input.message,
-          toolName: "workflow.openrouterChat",
-          optOut: context.memoryOptOut
-        });
-        const response = await withBroker(
-          (client) => client.chat.sendMessage({ sessionId: context.sessionId, auth, message: input.message, uaid: context.uaid })
-        );
-        await recordMemory({
-          scope: { uaid: context.uaid, sessionId: context.sessionId },
-          role: "assistant",
-          content: JSON.stringify(response),
-          toolName: "workflow.openrouterChat",
-          optOut: context.memoryOptOut
-        });
-        return response;
-      }
-    },
-    {
-      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;
-        await recordMemory({
-          scope: { uaid: context.uaid, sessionId: context.sessionId },
-          role: "event",
-          content: JSON.stringify({ history }),
-          toolName: "workflow.openrouterChat",
-          optOut: context.memoryOptOut
-        });
-        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: (input) => ({ memoryOptOut: input.disableMemory }),
-  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;
-        if (context.uaid) {
-          await recordMemory({
-            scope: { uaid: context.uaid },
-            role: "event",
-            content: JSON.stringify({ discovery: result }),
-            toolName: "workflow.registryBrokerShowcase",
-            optOut: context.memoryOptOut
-          });
-        }
-        return result;
-      }
-    },
-    {
-      name: "workflow.registryBrokerShowcase.memory.load",
-      skip: ({ input }) => Boolean(input.disableMemory),
-      run: async ({ context }) => {
-        if (!context.uaid) return { skipped: true };
-        const loaded = await loadMemoryContext({ scope: { uaid: context.uaid }, optOut: context.memoryOptOut });
-        context.memoryContext = loaded ?? void 0;
-        return loaded ?? { skipped: true };
-      }
-    },
-    {
-      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;
-        await recordMemory({
-          scope: { uaid: context.uaid },
-          role: "event",
-          content: JSON.stringify({ detectProtocol: response }),
-          toolName: "workflow.registryBrokerShowcase",
-          optOut: context.memoryOptOut
-        });
-        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, disableMemory: input.disableMemory }, { dryRun });
-        context.chat = result;
-        return result;
-      }
-    },
-    {
-      name: "hol.getRegistrationQuote",
-      skip: ({ input }) => !input.performCreditCheck,
-      run: async ({ context }) => {
-        const discoveryRecord = context.discovery && typeof context.discovery === "object" ? context.discovery : null;
-        const payload = discoveryRecord?.context?.registrationPayload ?? context.discovery;
-        const response = await withBroker((client) => client.getRegistrationQuote(payload));
-        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;
-        context.localUaid = input.uaid;
-        context.agentverseUaid = input.agentverseUaid;
-        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,
-              uaid: context.localUaid
-            })
-          );
-          context.transcripts.push({ target: "local", response: localResponse });
-          const agentverseResponse = await withBroker(
-            (client) => client.chat.sendMessage({
-              sessionId: context.agentverseSession,
-              auth: input.agentverseAuth,
-              message: input.agentverseMessage,
-              uaid: context.agentverseUaid
-            })
-          );
-          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 ({ context }) => {
-        const catalog = await withBroker((client) => client.getAdditionalRegistries());
-        context.catalog = catalog;
-        return catalog;
-      }
-    },
-    {
-      name: "workflow.resolveAdditionalRegistries",
-      allowDuringDryRun: true,
-      run: async ({ input, context }) => {
-        const catalog = context.catalog;
-        if (!catalog) return null;
-        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 (err) => {
-            context.lastQuote = err.summary;
-            if (!input.creditTopUp) {
-              return "abort";
-            }
-            await purchaseCreditsWithHbar(input.creditTopUp, err.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 && typeof result === "object" && "result" in result) {
-          const progress = result;
-          const maybeUaid = progress.result?.uaid;
-          if (typeof maybeUaid === "string") {
-            context.uaid = maybeUaid;
-          }
-        }
-        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) {
-  if (!catalog.registries || catalog.registries.length === 0) {
-    return { resolved: [], missing: selections };
-  }
-  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();
-    const networks = registry.networks ?? [];
-    if (!registryId || networks.length === 0) continue;
-    if (registryId === target) {
-      networks.forEach((network) => {
-        if (network?.key) {
-          matches.push(network.key);
-        }
-      });
-      continue;
-    }
-    for (const network of networks) {
-      if (!network?.key) continue;
-      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 ({ context }) => {
-        const catalog = await withBroker((client) => client.getAdditionalRegistries());
-        context.catalog = catalog;
-        return catalog;
-      }
-    },
-    {
-      name: "workflow.erc8004.resolveNetworks",
-      allowDuringDryRun: true,
-      run: async ({ input, context }) => {
-        const response = context.catalog;
-        if (!response) {
-          context.resolvedNetworks = [];
-          context.missingNetworks = [];
-          return { resolved: [], missing: [] };
-        }
-        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) {
-  if (!catalog.registries || catalog.registries.length === 0) {
-    return { resolved: [], missing: selections };
-  }
-  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 ?? []) {
-      const descriptorId = descriptor.id?.toLowerCase();
-      const networks = descriptor.networks ?? [];
-      if (!descriptorId || !descriptorId.startsWith("erc-8004")) continue;
-      for (const network of networks) {
-        if (!network) continue;
-        const candidates = [network.key, network.networkId, network.label, network.name].map((value) => value?.toLowerCase().trim()).filter(Boolean);
-        if (candidates.includes(normalized2) || `${descriptorId}:${network.networkId?.toLowerCase()}` === normalized2) {
-          if (network.key) {
-            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 || !defaults.networks) return [];
-  return defaults.networks.map((network) => network?.key).filter((key) => Boolean(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 connectionInstructions = [
-  "You expose the Hashgraph Online Registry Broker via hol.* primitives and workflow.* pipelines. Prefer workflow.* when possible\u2014they bundle common steps and return a pipeline summary plus full results.",
-  "Discovery: use workflow.discovery (or hol.search / hol.vectorSearch) to find UAIDs/agents/MCP servers; pass q/query and optional filters like capabilities, metadata, or type=ai-agents|mcp-servers.",
-  "Registration: workflow.registerMcp (quote \u2192 register \u2192 wait) is the default; workflow.fullRegistration adds discovery/chat/ops. hol.registerAgent + hol.waitForRegistrationCompletion are the lower-level primitives.",
-  "Chat: call hol.resolveUaid if the UAID is unverified, then hol.chat.createSession (uaid + optional auth) followed by hol.chat.sendMessage (sessionId or uaid). Use hol.chat.history/compact/end to manage the session.",
-  "Operations: workflow.opsCheck or hol.stats/hol.metricsSummary/hol.dashboardStats show registry health; hol.listProtocols + hol.detectProtocol help route third-party requests.",
-  "Credits: check hol.credits.balance before purchases. Use hol.purchaseCredits.hbar or hol.x402.buyCredits only with explicit user approval (X402 requires an EVM key); hol.x402.minimums provides thresholds.",
-  "Always include UAIDs/sessionIds exactly as given and echo any auth headers/tokens the user supplies. If required fields are missing (UAID, payload, accountId), ask for them before calling tools.",
-  "Additional help resources: help://rb/search documents hol.search filters; help://hol/usage lists common recipes."
-].join("\n");
-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(),
-  senderUaid: z3.string().min(1).optional(),
-  encryptionRequested: z3.boolean().optional()
-});
-var chatMessageSchema = z3.object({
-  sessionId: z3.string().min(1).optional(),
-  uaid: z3.string().min(1).optional(),
-  message: z3.string().min(1),
-  streaming: z3.boolean().optional(),
-  auth: agentAuthSchema.optional()
-}).superRefine((value, ctx) => {
-  if (!value.sessionId && !value.uaid) {
-    ctx.addIssue({ code: z3.ZodIssueCode.custom, message: "Provide sessionId for existing chats or uaid to start a new one." });
-  }
-});
-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(),
-  disableMemory: z3.boolean().optional()
-});
-var workflowOpsInput = z3.object({});
-var workflowFullInput = z3.object({
-  registrationPayload: agentRegistrationSchema,
-  discoveryQuery: z3.string().optional(),
-  chatMessage: z3.string().optional(),
-  disableMemory: z3.boolean().optional()
-});
-var openRouterChatToolSchema = z3.object({
-  modelId: z3.string().min(1),
-  registry: z3.string().optional(),
-  message: z3.string(),
-  authToken: z3.string().optional(),
-  disableMemory: z3.boolean().optional()
-});
-var registryShowcaseToolSchema = z3.object({
-  query: z3.string().optional(),
-  uaid: z3.string().optional(),
-  message: z3.string().optional(),
-  performCreditCheck: z3.boolean().optional(),
-  disableMemory: z3.boolean().optional()
-});
-var erc8004DiscoveryToolSchema = z3.object({ query: z3.string().optional(), limit: z3.number().int().positive().optional() });
-var bridgePayloadSchema = 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()
-});
-var erc8004X402ToolSchema = z3.object({
-  payload: agentRegistrationSchema,
-  erc8004Networks: z3.array(z3.string()).optional(),
-  chatMessage: z3.string().optional()
-});
-var x402RegistrationToolSchema = z3.object({
-  payload: agentRegistrationSchema,
-  x402: z3.object({
-    accountId: z3.string().min(1),
-    credits: z3.number().positive(),
-    evmPrivateKey: z3.string().min(1),
-    ledgerVerification: z3.object({
-      challengeId: z3.string().min(1),
-      accountId: z3.string().min(1),
-      network: z3.enum(["mainnet", "testnet"]),
-      signature: z3.string().min(1),
-      signatureKind: z3.enum(["raw", "map"]).optional(),
-      publicKey: z3.string().optional(),
-      expiresInMinutes: z3.number().int().positive().optional()
-    }).optional()
-  }),
-  chatMessage: z3.string().optional()
-});
-var memoryScopeSchema = z3.object({
-  uaid: z3.string().min(1).optional(),
-  sessionId: z3.string().min(1).optional(),
-  namespace: z3.string().min(1).optional(),
-  userId: z3.string().min(1).optional()
-}).refine((value) => Boolean(value.uaid || value.sessionId || value.namespace || value.userId), {
-  message: "Provide at least one scope identifier (uaid, sessionId, namespace, or userId)."
-});
-var memoryContextSchema = z3.object({
-  scope: memoryScopeSchema,
-  limit: z3.number().int().positive().max(200).optional(),
-  includeSummary: z3.boolean().optional()
-});
-var memoryNoteSchema = z3.object({
-  scope: memoryScopeSchema,
-  content: z3.string().min(1)
-});
-var memoryClearSchema = z3.object({
-  scope: memoryScopeSchema
-});
-var memorySearchSchema = z3.object({
-  scope: memoryScopeSchema,
-  query: z3.string().min(1),
-  limit: z3.number().int().positive().max(200).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",
-  instructions: connectionInstructions,
-  // Route FastMCP logging to our pino logger (stderr) to keep stdio transport clean.
-  logger: {
-    debug: (...args) => logger.debug(args),
-    info: (...args) => logger.info(args),
-    warn: (...args) => logger.warn(args),
-    error: (...args) => logger.error(args),
-    log: (...args) => logger.info(args)
-  }
-});
-var rawToolDefinitions = [
-  {
-    name: "hol.search",
-    description: "Keyword search for agents or MCP servers with filtering controls.",
-    schema: searchInput,
-    handler: (input) => withBroker((client) => client.search(input), "hol.search")
-  },
-  {
-    name: "hol.vectorSearch",
-    description: "Vector similarity search across registered agents.",
-    schema: vectorSearchInput,
-    handler: (input) => withBroker((client) => client.vectorSearch(input), "hol.vectorSearch")
-  },
-  {
-    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 };
-    }, "hol.resolveUaid")
-  },
-  {
-    name: "hol.closeUaidConnection",
-    description: "Force-close any open UAID connection.",
-    schema: uaidInput,
-    handler: ({ uaid }) => withBroker((client) => client.closeUaidConnection(uaid), "hol.closeUaidConnection")
-  },
-  {
-    name: "hol.getRegistrationQuote",
-    description: "Estimate fees for a given agent registration payload.",
-    schema: registrationPayload,
-    handler: ({ payload }) => withBroker((client) => client.getRegistrationQuote(payload), "hol.getRegistrationQuote")
-  },
-  {
-    name: "hol.registerAgent",
-    description: "Submit an HCS-11-compatible agent registration.",
-    schema: registrationPayload,
-    handler: ({ payload }) => withBroker((client) => client.registerAgent(payload), "hol.registerAgent")
-  },
-  {
-    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
-      }),
-      "hol.waitForRegistrationCompletion"
-    )
-  },
-  {
-    name: "hol.updateAgent",
-    description: "Update an existing agent registration payload.",
-    schema: updateAgentInput,
-    handler: ({ uaid, payload }) => withBroker((client) => client.updateAgent(uaid, payload), "hol.updateAgent")
-  },
-  {
-    name: "hol.additionalRegistries",
-    description: "Retrieve the catalog of additional registries and networks.",
-    schema: emptyObject,
-    handler: () => withBroker((client) => client.getAdditionalRegistries(), "hol.additionalRegistries")
-  },
-  {
-    name: "hol.registrySearchByNamespace",
-    description: "Search within a specific registry namespace.",
-    schema: registryNamespaceInput,
-    handler: ({ registry, query }) => withBroker((client) => client.registrySearchByNamespace(registry, query), "hol.registrySearchByNamespace")
-  },
-  {
-    name: "hol.chat.createSession",
-    description: "Open a chat session linked to a UAID.",
-    schema: chatSessionSchema,
-    handler: (input) => withBroker((client) => client.chat.createSession(input), "hol.chat.createSession")
-  },
-  {
-    name: "hol.chat.sendMessage",
-    description: "Send a message to an active chat session.",
-    schema: chatMessageSchema,
-    handler: (input) => withBroker(async (client) => {
-      const { sessionId, uaid, message, auth, streaming } = input;
-      const scopeForMemory = { sessionId: sessionId ?? void 0, uaid: uaid ?? void 0 };
-      if (sessionId) {
-        const payload2 = { sessionId, message, auth, streaming };
-        await recordMemory2(scopeForMemory, "user", message, "hol.chat.sendMessage");
-        const response2 = await client.chat.sendMessage(payload2);
-        await recordMemory2(scopeForMemory, "assistant", stringifyForMemory(response2), "hol.chat.sendMessage");
-        return response2;
-      }
-      if (!uaid) {
-        throw new Error("sessionId missing; provide uaid so a session can be created before sending.");
-      }
-      const session = await client.chat.createSession({ uaid, auth });
-      const derivedSessionId = session.sessionId;
-      if (!derivedSessionId) {
-        throw new Error("Unable to determine sessionId from broker response when auto-creating chat session.");
-      }
-      const payload = {
-        sessionId: derivedSessionId,
-        message,
-        auth,
-        streaming
-      };
-      scopeForMemory.sessionId = derivedSessionId;
-      await recordMemory2(scopeForMemory, "user", message, "hol.chat.sendMessage");
-      const response = await client.chat.sendMessage(payload);
-      await recordMemory2(scopeForMemory, "assistant", stringifyForMemory(response), "hol.chat.sendMessage");
-      return response;
-    }, "hol.chat.sendMessage")
-  },
-  {
-    name: "hol.chat.history",
-    description: "Retrieve the message history for a chat session.",
-    schema: sessionIdInput,
-    handler: ({ sessionId }) => withBroker((client) => client.chat.getHistory(sessionId), "hol.chat.history")
-  },
-  {
-    name: "hol.chat.compact",
-    description: "Compact chat history while preserving the latest entries.",
-    schema: chatCompactSchema,
-    handler: (input) => withBroker((client) => client.chat.compactHistory(input), "hol.chat.compact")
-  },
-  {
-    name: "hol.chat.end",
-    description: "End a chat session and release broker resources.",
-    schema: sessionIdInput,
-    handler: ({ sessionId }) => withBroker((client) => client.chat.endSession(sessionId), "hol.chat.end")
-  },
-  {
-    name: "hol.stats",
-    description: "High-level registry statistics and usage metrics.",
-    schema: emptyObject,
-    handler: () => withBroker((client) => client.stats(), "hol.stats")
-  },
-  {
-    name: "hol.metricsSummary",
-    description: "Aggregated broker metrics suitable for dashboards.",
-    schema: emptyObject,
-    handler: () => withBroker((client) => client.metricsSummary(), "hol.metricsSummary")
-  },
-  {
-    name: "hol.dashboardStats",
-    description: "Detailed dashboard statistics from the broker.",
-    schema: emptyObject,
-    handler: () => withBroker((client) => client.dashboardStats(), "hol.dashboardStats")
-  },
-  {
-    name: "hol.websocketStats",
-    description: "Retrieve websocket connection counts and throughput.",
-    schema: emptyObject,
-    handler: () => withBroker((client) => client.websocketStats(), "hol.websocketStats")
-  },
-  {
-    name: "hol.ledger.challenge",
-    description: "Create a ledger challenge message for account verification.",
-    schema: ledgerChallengeInput,
-    handler: (input) => withBroker((client) => client.createLedgerChallenge(input), "hol.ledger.challenge")
-  },
-  {
-    name: "hol.ledger.authenticate",
-    description: "Verify a signed ledger challenge (sets ledger API key).",
-    schema: ledgerVerifyInput,
-    handler: (input) => withBroker((client) => client.verifyLedgerChallenge(input), "hol.ledger.authenticate")
-  },
-  {
-    name: "hol.purchaseCredits.hbar",
-    description: "Purchase registry credits using HBAR funds.",
-    schema: purchaseHbarInput,
-    handler: (input) => withBroker((client) => client.purchaseCreditsWithHbar(input), "hol.purchaseCredits.hbar")
-  },
-  {
-    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(), "hol.x402.minimums")
-  },
-  {
-    name: "hol.x402.buyCredits",
-    description: "Buy registry credits via X402 using an EVM private key.",
-    schema: buyX402Input,
-    handler: (input) => withBroker((client) => client.buyCreditsWithX402(input), "hol.x402.buyCredits")
-  },
-  {
-    name: "hol.memory.context",
-    description: "Fetch recent memory entries and optional summary for a scope.",
-    schema: memoryContextSchema,
-    handler: async (input) => {
-      const service = ensureMemoryEnabled();
-      return service.getContext({
-        scope: input.scope,
-        limit: input.limit,
-        includeSummary: input.includeSummary ?? true
-      });
-    }
-  },
-  {
-    name: "hol.memory.note",
-    description: "Save a free-form note into memory for the given scope.",
-    schema: memoryNoteSchema,
-    handler: async (input) => {
-      const service = ensureMemoryEnabled();
-      return service.note(input.scope, input.content);
-    }
-  },
-  {
-    name: "hol.memory.clear",
-    description: "Clear memory entries and summaries for the given scope.",
-    schema: memoryClearSchema,
-    handler: async (input) => {
-      const service = ensureMemoryEnabled();
-      const removed = await service.clear(input.scope);
-      return { removed };
-    }
-  },
-  {
-    name: "hol.memory.search",
-    description: "Keyword search across stored memory for a scope.",
-    schema: memorySearchSchema,
-    handler: async (input) => {
-      const service = ensureMemoryEnabled();
-      return service.search({ scope: input.scope, query: input.query, limit: input.limit });
-    }
-  },
-  {
-    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: openRouterChatToolSchema,
-    handler: async (input) => formatPipelineResult(await openRouterChatWorkflow.run(input))
-  },
-  {
-    name: "workflow.registryBrokerShowcase",
-    description: "Pipeline: discovery, analytics, UAID validation, chat",
-    schema: registryShowcaseToolSchema,
-    handler: async (input) => formatPipelineResult(await registryBrokerShowcaseWorkflow.run(input))
-  },
-  {
-    name: "workflow.agentverseBridge",
-    description: "Pipeline: relay chat between local UAID and Agentverse UAID",
-    schema: bridgePayloadSchema,
-    handler: async (input) => formatPipelineResult(await agentverseBridgeWorkflow.run(input))
-  },
-  {
-    name: "workflow.erc8004Discovery",
-    description: "Pipeline: search ERC-8004 registries",
-    schema: erc8004DiscoveryToolSchema,
-    handler: async (input) => formatPipelineResult(await erc8004DiscoveryWorkflow.run(input))
-  },
-  {
-    name: "workflow.erc8004X402",
-    description: "Pipeline: ERC-8004 registration funded via X402 credits",
-    schema: erc8004X402ToolSchema,
-    handler: async (input) => formatPipelineResult(await erc8004X402Workflow.run(input))
-  },
-  {
-    name: "workflow.x402Registration",
-    description: "Pipeline: register agent using X402 payments + chat smoke test",
-    schema: x402RegistrationToolSchema,
-    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))
-  }
-];
-var toolDefinitions = rawToolDefinitions;
-function ensureMemoryEnabled() {
-  if (!memoryService || !memoryService.isEnabled()) {
-    throw new Error("Memory is disabled or unavailable. Set MEMORY_ENABLED=1 and ensure the configured backend is installed.");
-  }
-  return memoryService;
-}
-function formatPipelineResult(result) {
-  const contextRecord = result.context && typeof result.context === "object" ? result.context : {};
-  const contextUaid = typeof contextRecord.uaid === "string" ? contextRecord.uaid : void 0;
-  const summaryLines = [
-    `Workflow: ${result.pipeline}`,
-    result.dryRun ? "(dry-run)" : void 0,
-    contextUaid ? `UAID: ${contextUaid}` : void 0,
-    `Steps executed: ${result.steps.length}`
-  ].filter(Boolean);
-  return {
-    content: [
-      { type: "text", text: summaryLines.join("\n") },
-      buildObjectContent("pipeline.result", result)
-    ]
-  };
-}
-function buildLoggedTool(definition) {
-  return {
-    name: definition.name,
-    description: definition.description,
-    parameters: definition.schema,
-    execute: async (args, context) => {
-      const requestId = context?.requestId ?? randomUUID3();
-      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);
-        if (memoryService && memoryService.isEnabled()) {
-          const scopeForMemory = deriveScopeFromArgs(parsedInput);
-          if (hasScope(scopeForMemory)) {
-            void memoryService.recordToolEvent(definition.name, scopeForMemory, { input: parsedInput, result }).catch((error) => logger.warn({ requestId, tool: definition.name, error }, "memory.capture.failed"));
-          }
-        }
-        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),
-      isError: typeof record.isError === "boolean" ? record.isError : void 0
-    };
-  }
-  if (isPlainObject(value)) {
-    return {
-      content: [buildObjectContent("tool.result", 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 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 };
-  }
-}
-function deriveScopeFromArgs(args) {
-  if (!args || typeof args !== "object") return {};
-  const record = args;
-  const scope = {};
-  if (typeof record.sessionId === "string") scope.sessionId = record.sessionId;
-  if (typeof record.uaid === "string") scope.uaid = record.uaid;
-  if (typeof record.namespace === "string") scope.namespace = record.namespace;
-  if (typeof record.userId === "string") scope.userId = record.userId;
-  return scope;
-}
-function hasScope(scope) {
-  return Boolean(scope.sessionId || scope.uaid || scope.namespace || scope.userId);
-}
-function stringifyForMemory(value) {
-  if (typeof value === "string") return value;
-  if (value === void 0 || value === null) return "";
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
-  }
-}
-async function recordMemory2(scope, role, content, toolName) {
-  if (!memoryService || !memoryService.isEnabled()) return;
-  try {
-    await memoryService.recordEntry({ scope, role, content, toolName });
-  } catch (error) {
-    logger.warn({ scope, toolName, error }, "memory.record.failed");
-  }
-}
-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")
-    }
-  ]
-});
-mcp.addResource({
-  name: "hol.tools.guide",
-  uri: "help://hol/usage",
-  mimeType: "text/markdown",
-  load: async () => [
-    {
-      text: [
-        "# Hashnet MCP quick usage",
-        "",
-        "Prefer workflow.* pipelines when available\u2014they run multiple broker calls and return both a text summary and structured results:",
-        "- Discovery: workflow.discovery { query?, limit? } (or hol.search / hol.vectorSearch).",
-        "- Registration: workflow.registerMcp { payload } (quote \u2192 register \u2192 wait) or workflow.fullRegistration to add discovery/chat/ops.",
-        "- Chat: hol.chat.createSession { uaid, auth?, historyTtlSeconds? } \u2192 hol.chat.sendMessage { sessionId OR uaid, message, auth?, streaming? } \u2192 hol.chat.history/compact/end.",
-        "- UAID validation/resets: hol.resolveUaid { uaid }, hol.closeUaidConnection { uaid }.",
-        "- Ops/metrics: workflow.opsCheck or hol.stats / hol.metricsSummary / hol.dashboardStats.",
-        "- Credits: hol.credits.balance first, then hol.purchaseCredits.hbar or hol.x402.buyCredits (X402 requires evmPrivateKey; call hol.x402.minimums to inspect limits).",
-        "- Protocols: hol.listProtocols and hol.detectProtocol when inspecting inbound requests.",
-        "",
-        "Ask the user for any missing UAID, registration payload fields, accountId, or auth tokens before calling tools. Keep sessionId/uaid strings verbatim."
-      ].join("\n")
-    }
-  ]
-});
-mcp.addResource({
-  name: "hol.memory.guide",
-  uri: "help://hol/memory",
-  mimeType: "text/markdown",
-  load: async () => [
-    {
-      text: [
-        "# Memory tools",
-        "",
-        "Memory is optional and disabled by default. Enable with `MEMORY_ENABLED=1` (defaults to SQLite at `MEMORY_STORAGE_PATH`).",
-        "",
-        "- `hol.memory.context { scope, limit?, includeSummary? }`: recent entries plus optional summary for a UAID/session/namespace.",
-        "- `hol.memory.note { scope, content }`: store a note in the scope.",
-        "- `hol.memory.search { scope, query, limit? }`: keyword search within scoped memory.",
-        "- `hol.memory.clear { scope }`: drop entries + summary for the scope.",
-        "",
-        "Scopes: supply at least one of `uaid`, `sessionId`, `namespace`, or `userId`. The service bounds responses to avoid overwhelming clients."
-      ].join("\n")
-    }
-  ]
-});
-
-// src/transports/index.ts
-var LOOPBACK = "127.0.0.1";
-async function runStdio() {
-  logger.info("Starting stdio transport");
-  await mcp.start({ transportType: "stdio" });
-  logger.info("Stdio transport started");
-}
-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: randomUUID4()
-      });
-      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