@hashgraphonline/standards-agent-kit 0.2.132 → 0.2.135

package/dist/es/standards-agent-kit.es40.js

@@ -0,0 +1,141 @@
+import { ServerSigner, HederaAgentKit } from "hedera-agent-kit";
+import { HCS10Builder } from "./standards-agent-kit.es3.js";
+import { RegisterAgentTool } from "./standards-agent-kit.es9.js";
+import { FindRegistrationsTool } from "./standards-agent-kit.es14.js";
+import { InitiateConnectionTool } from "./standards-agent-kit.es11.js";
+import { ListConnectionsTool } from "./standards-agent-kit.es12.js";
+import { SendMessageToConnectionTool } from "./standards-agent-kit.es10.js";
+import { CheckMessagesTool } from "./standards-agent-kit.es13.js";
+import { ConnectionMonitorTool } from "./standards-agent-kit.es15.js";
+import { ManageConnectionRequestsTool } from "./standards-agent-kit.es16.js";
+import { AcceptConnectionRequestTool } from "./standards-agent-kit.es17.js";
+import { RetrieveProfileTool } from "./standards-agent-kit.es18.js";
+import { ListUnapprovedConnectionRequestsTool } from "./standards-agent-kit.es19.js";
+import { OpenConvaiState } from "./standards-agent-kit.es39.js";
+import { Logger } from "@hashgraphonline/standards-sdk";
+import { ENV_FILE_PATH } from "./standards-agent-kit.es45.js";
+const initializeStandardsAgentKit = async (options) => {
+  const config = options?.clientConfig || {};
+  const operatorId = config.operatorId || process.env.HEDERA_OPERATOR_ID;
+  const operatorPrivateKey = config.operatorKey || process.env.HEDERA_OPERATOR_KEY;
+  const networkEnv = config.network || process.env.HEDERA_NETWORK || "testnet";
+  const shouldSilence = process.env.DISABLE_LOGGING === "true";
+  const logger = Logger.getInstance({
+    level: config.logLevel || "info",
+    silent: shouldSilence
+  });
+  let network;
+  if (networkEnv === "mainnet") {
+    network = "mainnet";
+  } else if (networkEnv === "testnet") {
+    network = "testnet";
+  } else {
+    logger.warn(
+      `Unsupported network specified: '${networkEnv}'. Defaulting to 'testnet'.`
+    );
+    network = "testnet";
+  }
+  if (!operatorId || !operatorPrivateKey) {
+    throw new Error(
+      "Operator ID and private key must be provided either through options or environment variables."
+    );
+  }
+  const stateManager = options?.stateManager || new OpenConvaiState({
+    defaultEnvFilePath: ENV_FILE_PATH,
+    defaultPrefix: "TODD"
+  });
+  logger.info("State manager initialized");
+  const signer = new ServerSigner(operatorId, operatorPrivateKey, network);
+  const hederaKit = new HederaAgentKit(signer);
+  await hederaKit.initialize();
+  logger.info(`HederaAgentKit initialized for ${operatorId} on ${network}`);
+  const hcs10Builder = new HCS10Builder(hederaKit, stateManager, {
+    useEncryption: config.useEncryption,
+    registryUrl: config.registryUrl,
+    logLevel: config.logLevel
+  });
+  let monitoringHederaKit;
+  let monitoringHcs10Builder;
+  if (options?.monitoringClient) {
+    const monitoringSigner = new ServerSigner(operatorId, operatorPrivateKey, network);
+    monitoringHederaKit = new HederaAgentKit(monitoringSigner);
+    await monitoringHederaKit.initialize();
+    monitoringHcs10Builder = new HCS10Builder(monitoringHederaKit, stateManager, {
+      useEncryption: config.useEncryption,
+      registryUrl: config.registryUrl,
+      logLevel: "error"
+    });
+    logger.info("Monitoring client initialized");
+  }
+  const tools = {};
+  tools.registerAgentTool = new RegisterAgentTool({
+    hederaKit,
+    hcs10Builder,
+    logger: void 0
+  });
+  if (options?.createAllTools) {
+    tools.findRegistrationsTool = new FindRegistrationsTool({
+      hederaKit,
+      hcs10Builder,
+      logger: void 0
+    });
+    tools.retrieveProfileTool = new RetrieveProfileTool({
+      hederaKit,
+      hcs10Builder,
+      logger: void 0
+    });
+    tools.initiateConnectionTool = new InitiateConnectionTool({
+      hederaKit,
+      hcs10Builder,
+      logger: void 0
+    });
+    tools.listConnectionsTool = new ListConnectionsTool({
+      hederaKit,
+      hcs10Builder,
+      logger: void 0
+    });
+    tools.sendMessageToConnectionTool = new SendMessageToConnectionTool({
+      hederaKit,
+      hcs10Builder,
+      logger: void 0
+    });
+    tools.checkMessagesTool = new CheckMessagesTool({
+      hederaKit,
+      hcs10Builder,
+      logger: void 0
+    });
+    tools.connectionMonitorTool = new ConnectionMonitorTool({
+      hederaKit: monitoringHederaKit || hederaKit,
+      hcs10Builder: monitoringHcs10Builder || hcs10Builder,
+      logger: void 0
+    });
+    tools.manageConnectionRequestsTool = new ManageConnectionRequestsTool({
+      hederaKit,
+      hcs10Builder,
+      logger: void 0
+    });
+    tools.acceptConnectionRequestTool = new AcceptConnectionRequestTool({
+      hederaKit,
+      hcs10Builder,
+      logger: void 0
+    });
+    tools.listUnapprovedConnectionRequestsTool = new ListUnapprovedConnectionRequestsTool({
+      hederaKit,
+      hcs10Builder,
+      logger: void 0
+    });
+    logger.info("All tools initialized");
+  }
+  return {
+    hederaKit,
+    hcs10Builder,
+    monitoringHederaKit,
+    monitoringHcs10Builder,
+    tools,
+    stateManager
+  };
+};
+export {
+  initializeStandardsAgentKit
+};
+//# sourceMappingURL=standards-agent-kit.es40.js.map

package/dist/es/standards-agent-kit.es40.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"standards-agent-kit.es40.js","sources":["../../src/init/init.ts"],"sourcesContent":["import { HederaAgentKit, ServerSigner } from 'hedera-agent-kit';\nimport { HCS10Builder } from '../builders/hcs10/hcs10-builder';\nimport { RegisterAgentTool } from '../tools/hcs10/RegisterAgentTool';\nimport { FindRegistrationsTool } from '../tools/hcs10/FindRegistrationsTool';\nimport { InitiateConnectionTool } from '../tools/hcs10/InitiateConnectionTool';\nimport { ListConnectionsTool } from '../tools/hcs10/ListConnectionsTool';\nimport { SendMessageToConnectionTool } from '../tools/hcs10/SendMessageToConnectionTool';\nimport { CheckMessagesTool } from '../tools/hcs10/CheckMessagesTool';\nimport { ConnectionMonitorTool } from '../tools/hcs10/ConnectionMonitorTool';\nimport { ManageConnectionRequestsTool } from '../tools/hcs10/ManageConnectionRequestsTool';\nimport { AcceptConnectionRequestTool } from '../tools/hcs10/AcceptConnectionRequestTool';\nimport { RetrieveProfileTool } from '../tools/hcs10/RetrieveProfileTool';\nimport { ListUnapprovedConnectionRequestsTool } from '../tools/hcs10/ListUnapprovedConnectionRequestsTool';\nimport { IStateManager } from '../state/state-types';\nimport { OpenConvaiState } from '../state/open-convai-state';\nimport { Logger } from '@hashgraphonline/standards-sdk';\nimport { ENV_FILE_PATH } from '../utils/state-tools';\n\nexport interface HCS10ClientConfig {\n  operatorId?: string;\n  operatorKey?: string;\n  network?: 'mainnet' | 'testnet';\n  useEncryption?: boolean;\n  registryUrl?: string;\n  logLevel?: 'debug' | 'info' | 'warn' | 'error';\n}\n\nexport interface HCS10InitializationOptions {\n  clientConfig?: HCS10ClientConfig;\n  stateManager?: IStateManager;\n  createAllTools?: boolean;\n  monitoringClient?: boolean;\n}\n\n/**\n * Tool collection containing all available tools from the standards-agent-kit\n */\nexport interface HCS10Tools {\n  registerAgentTool: RegisterAgentTool;\n  findRegistrationsTool: FindRegistrationsTool;\n  retrieveProfileTool: RetrieveProfileTool;\n  initiateConnectionTool: InitiateConnectionTool;\n  listConnectionsTool: ListConnectionsTool;\n  sendMessageToConnectionTool: SendMessageToConnectionTool;\n  checkMessagesTool: CheckMessagesTool;\n  connectionMonitorTool: ConnectionMonitorTool;\n  manageConnectionRequestsTool: ManageConnectionRequestsTool;\n  acceptConnectionRequestTool: AcceptConnectionRequestTool;\n  listUnapprovedConnectionRequestsTool: ListUnapprovedConnectionRequestsTool;\n}\n\n/**\n * Initializes the HCS10 client and returns pre-registered LangChain tools.\n *\n * @param options - Initialization options\n * @returns Object containing hederaKit, hcs10Builder and requested tools\n */\nexport const initializeStandardsAgentKit = async (\n  options?: HCS10InitializationOptions\n): Promise<{\n  hederaKit: HederaAgentKit;\n  hcs10Builder: HCS10Builder;\n  monitoringHederaKit?: HederaAgentKit;\n  monitoringHcs10Builder?: HCS10Builder;\n  tools: Partial<HCS10Tools>;\n  stateManager: IStateManager;\n}> => {\n  const config = options?.clientConfig || {};\n\n  const operatorId = config.operatorId || process.env.HEDERA_OPERATOR_ID;\n  const operatorPrivateKey =\n    config.operatorKey || process.env.HEDERA_OPERATOR_KEY;\n\n  const networkEnv = config.network || process.env.HEDERA_NETWORK || 'testnet';\n\n  const shouldSilence = process.env.DISABLE_LOGGING === 'true';\n  const logger = Logger.getInstance({\n    level: config.logLevel || 'info',\n    silent: shouldSilence,\n  });\n\n  let network: 'mainnet' | 'testnet';\n  if (networkEnv === 'mainnet') {\n    network = 'mainnet';\n  } else if (networkEnv === 'testnet') {\n    network = 'testnet';\n  } else {\n    logger.warn(\n      `Unsupported network specified: '${networkEnv}'. Defaulting to 'testnet'.`\n    );\n    network = 'testnet';\n  }\n\n  if (!operatorId || !operatorPrivateKey) {\n    throw new Error(\n      'Operator ID and private key must be provided either through options or environment variables.'\n    );\n  }\n\n  const stateManager =\n    options?.stateManager ||\n    new OpenConvaiState({\n      defaultEnvFilePath: ENV_FILE_PATH,\n      defaultPrefix: 'TODD',\n    });\n  logger.info('State manager initialized');\n\n  const signer = new ServerSigner(operatorId, operatorPrivateKey, network);\n  const hederaKit = new HederaAgentKit(signer);\n  await hederaKit.initialize();\n  logger.info(`HederaAgentKit initialized for ${operatorId} on ${network}`);\n\n  const hcs10Builder = new HCS10Builder(hederaKit, stateManager, {\n    useEncryption: config.useEncryption,\n    registryUrl: config.registryUrl,\n    logLevel: config.logLevel,\n  });\n\n  let monitoringHederaKit: HederaAgentKit | undefined;\n  let monitoringHcs10Builder: HCS10Builder | undefined;\n\n  if (options?.monitoringClient) {\n    const monitoringSigner = new ServerSigner(operatorId, operatorPrivateKey, network);\n    monitoringHederaKit = new HederaAgentKit(monitoringSigner);\n    await monitoringHederaKit.initialize();\n    monitoringHcs10Builder = new HCS10Builder(monitoringHederaKit, stateManager, {\n      useEncryption: config.useEncryption,\n      registryUrl: config.registryUrl,\n      logLevel: 'error',\n    });\n    logger.info('Monitoring client initialized');\n  }\n\n  const tools: Partial<HCS10Tools> = {};\n\n  tools.registerAgentTool = new RegisterAgentTool({\n    hederaKit,\n    hcs10Builder,\n    logger: undefined,\n  });\n\n  if (options?.createAllTools) {\n    tools.findRegistrationsTool = new FindRegistrationsTool({\n      hederaKit,\n      hcs10Builder,\n      logger: undefined,\n    });\n    tools.retrieveProfileTool = new RetrieveProfileTool({\n      hederaKit,\n      hcs10Builder,\n      logger: undefined,\n    });\n    tools.initiateConnectionTool = new InitiateConnectionTool({\n      hederaKit,\n      hcs10Builder,\n      logger: undefined,\n    });\n    tools.listConnectionsTool = new ListConnectionsTool({\n      hederaKit,\n      hcs10Builder,\n      logger: undefined,\n    });\n    tools.sendMessageToConnectionTool = new SendMessageToConnectionTool({\n      hederaKit,\n      hcs10Builder,\n      logger: undefined,\n    });\n    tools.checkMessagesTool = new CheckMessagesTool({\n      hederaKit,\n      hcs10Builder,\n      logger: undefined,\n    });\n    tools.connectionMonitorTool = new ConnectionMonitorTool({\n      hederaKit: monitoringHederaKit || hederaKit,\n      hcs10Builder: monitoringHcs10Builder || hcs10Builder,\n      logger: undefined,\n    });\n    tools.manageConnectionRequestsTool = new ManageConnectionRequestsTool({\n      hederaKit,\n      hcs10Builder,\n      logger: undefined,\n    });\n    tools.acceptConnectionRequestTool = new AcceptConnectionRequestTool({\n      hederaKit,\n      hcs10Builder,\n      logger: undefined,\n    });\n    tools.listUnapprovedConnectionRequestsTool =\n      new ListUnapprovedConnectionRequestsTool({\n        hederaKit,\n        hcs10Builder,\n        logger: undefined,\n      });\n\n    logger.info('All tools initialized');\n  }\n\n  return {\n    hederaKit,\n    hcs10Builder,\n    monitoringHederaKit,\n    monitoringHcs10Builder,\n    tools,\n    stateManager,\n  };\n};"],"names":[],"mappings":"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"}

package/dist/es/standards-agent-kit.es41.js

@@ -0,0 +1,33 @@
+import { BasePlugin, HederaGetHbarPriceTool } from "hedera-agent-kit";
+import { HederaGetHbarPriceTool as HederaGetHbarPriceTool2 } from "hedera-agent-kit";
+class HbarPricePlugin extends BasePlugin {
+  constructor() {
+    super(...arguments);
+    this.id = "hedera-hbar-price";
+    this.name = "Hedera HBAR Price Plugin";
+    this.description = "Provides tools to interact with Hedera network data, specifically HBAR price.";
+    this.version = "1.0.0";
+    this.author = "Hashgraph Online";
+    this.tools = [];
+  }
+  async initialize(context) {
+    await super.initialize(context);
+    this.initializeTools();
+  }
+  initializeTools() {
+    this.tools = [
+      new HederaGetHbarPriceTool({
+        hederaKit: this.context.config.hederaKit,
+        logger: this.context.logger
+      })
+    ];
+  }
+  getTools() {
+    return this.tools;
+  }
+}
+export {
+  HederaGetHbarPriceTool2 as GetHbarPriceTool,
+  HbarPricePlugin
+};
+//# sourceMappingURL=standards-agent-kit.es41.js.map

package/dist/es/standards-agent-kit.es41.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"standards-agent-kit.es41.js","sources":["../../src/plugins/hedera/HbarPricePlugin.ts"],"sourcesContent":["\nexport { HederaGetHbarPriceTool as GetHbarPriceTool } from 'hedera-agent-kit';\n\nimport { BasePlugin, GenericPluginContext, HederaTool, HederaAgentKit } from 'hedera-agent-kit';\nimport { HederaGetHbarPriceTool } from 'hedera-agent-kit';\n\n/**\n * Plugin to provide tools related to Hedera network information, like HBAR price.\n * Uses the built-in HederaGetHbarPriceTool from hedera-agent-kit.\n */\nexport class HbarPricePlugin extends BasePlugin<GenericPluginContext> {\n  id = 'hedera-hbar-price';\n  name = 'Hedera HBAR Price Plugin';\n  description = 'Provides tools to interact with Hedera network data, specifically HBAR price.';\n  version = '1.0.0';\n  author = 'Hashgraph Online';\n\n  private tools: HederaTool[] = [];\n\n  override async initialize(context: GenericPluginContext): Promise<void> {\n    await super.initialize(context);\n    this.initializeTools();\n  }\n\n  private initializeTools(): void {\n    this.tools = [\n      new HederaGetHbarPriceTool({\n        hederaKit: this.context.config.hederaKit as HederaAgentKit,\n        logger: this.context.logger\n      })\n    ];\n  }\n\n  getTools(): HederaTool[] {\n    return this.tools;\n  }\n}"],"names":["HederaGetHbarPriceTool"],"mappings":";;AAUO,MAAM,wBAAwB,WAAiC;AAAA,EAA/D,cAAA;AAAA,UAAA,GAAA,SAAA;AACL,SAAA,KAAK;AACL,SAAA,OAAO;AACP,SAAA,cAAc;AACd,SAAA,UAAU;AACV,SAAA,SAAS;AAET,SAAQ,QAAsB,CAAA;AAAA,EAAC;AAAA,EAE/B,MAAe,WAAW,SAA8C;AACtE,UAAM,MAAM,WAAW,OAAO;AAC9B,SAAK,gBAAA;AAAA,EACP;AAAA,EAEQ,kBAAwB;AAC9B,SAAK,QAAQ;AAAA,MACX,IAAIA,uBAAuB;AAAA,QACzB,WAAW,KAAK,QAAQ,OAAO;AAAA,QAC/B,QAAQ,KAAK,QAAQ;AAAA,MAAA,CACtB;AAAA,IAAA;AAAA,EAEL;AAAA,EAEA,WAAyB;AACvB,WAAO,KAAK;AAAA,EACd;AACF;"}

package/dist/es/standards-agent-kit.es42.js

@@ -0,0 +1,427 @@
+import { ZodType } from "zod";
+function extendZodSchema(schema) {
+  const extendedSchema = schema;
+  extendedSchema.withRender = function(config) {
+    const newSchema = Object.create(this);
+    const currentConfig = this._renderConfig || {};
+    const mergedConfig = {
+      ...currentConfig,
+      ...config,
+      ui: {
+        ...currentConfig.ui || {},
+        ...config.ui || {}
+      }
+    };
+    if (currentConfig.progressive || config.progressive) {
+      mergedConfig.progressive = {
+        ...currentConfig.progressive || {},
+        ...config.progressive || {}
+      };
+    }
+    if (currentConfig.block || config.block) {
+      mergedConfig.block = {
+        ...currentConfig.block || {},
+        ...config.block || {}
+      };
+    }
+    newSchema._renderConfig = mergedConfig;
+    newSchema.withRender = extendedSchema.withRender;
+    newSchema.withProgressive = extendedSchema.withProgressive;
+    newSchema.withBlock = extendedSchema.withBlock;
+    return newSchema;
+  };
+  extendedSchema.withProgressive = function(priority, group) {
+    const currentConfig = this._renderConfig || { fieldType: inferFieldTypeFromSchema(schema) };
+    return this.withRender({
+      ...currentConfig,
+      progressive: {
+        priority,
+        group
+      }
+    });
+  };
+  extendedSchema.withBlock = function(blockId) {
+    const currentConfig = this._renderConfig || { fieldType: inferFieldTypeFromSchema(schema) };
+    return this.withRender({
+      ...currentConfig,
+      block: {
+        id: blockId,
+        type: "field",
+        reusable: true
+      }
+    });
+  };
+  return extendedSchema;
+}
+function hasRenderConfig(schema) {
+  return Boolean(schema && typeof schema.withRender === "function");
+}
+function getRenderConfig(schema) {
+  if (hasRenderConfig(schema)) {
+    return schema._renderConfig;
+  }
+  return void 0;
+}
+function inferFieldTypeFromSchema(schema) {
+  const typeName = schema._def?.typeName;
+  switch (typeName) {
+    case "ZodString": {
+      const stringChecks = schema._def?.checks || [];
+      for (const check of stringChecks) {
+        if (check.kind === "email") {
+          return "text";
+        }
+        if (check.kind === "url") {
+          return "text";
+        }
+      }
+      return "text";
+    }
+    case "ZodNumber":
+    case "ZodBigInt":
+      return "number";
+    case "ZodBoolean":
+      return "checkbox";
+    case "ZodEnum":
+    case "ZodNativeEnum":
+      return "select";
+    case "ZodArray":
+      return "array";
+    case "ZodUnion":
+    case "ZodDiscriminatedUnion":
+      return "select";
+    case "ZodDate":
+      return "text";
+    case "ZodObject":
+      return "object";
+    case "ZodOptional":
+    case "ZodDefault": {
+      const innerType = schema._def?.innerType;
+      if (innerType) {
+        return inferFieldTypeFromSchema(innerType);
+      }
+      return "text";
+    }
+    default:
+      return "text";
+  }
+}
+function extractOptionsFromSchema(schema) {
+  const typeName = schema._def?.typeName;
+  if (typeName === "ZodEnum") {
+    const values = schema._def?.values;
+    if (Array.isArray(values)) {
+      return values.map((value) => ({
+        value,
+        label: value.charAt(0).toUpperCase() + value.slice(1).replace(/[_-]/g, " ")
+      }));
+    }
+  }
+  if (typeName === "ZodNativeEnum") {
+    const enumObject = schema._def?.values;
+    if (enumObject) {
+      return Object.entries(enumObject).map(([key, value]) => ({
+        value,
+        label: key.replace(/[_-]/g, " ")
+      }));
+    }
+  }
+  if (typeName === "ZodUnion") {
+    const options = [];
+    const unionOptions = schema._def?.options;
+    if (Array.isArray(unionOptions)) {
+      for (const option of unionOptions) {
+        if (option._def?.typeName === "ZodLiteral") {
+          const value = option._def?.value;
+          if (value !== void 0) {
+            options.push({
+              value,
+              label: typeof value === "string" ? value.charAt(0).toUpperCase() + value.slice(1) : String(value)
+            });
+          }
+        }
+      }
+    }
+    return options.length > 0 ? options : void 0;
+  }
+  return void 0;
+}
+function isOptionalSchema(schema) {
+  const typeName = schema._def?.typeName;
+  return typeName === "ZodOptional" || typeName === "ZodDefault";
+}
+function getInnerSchema(schema) {
+  const typeName = schema._def?.typeName;
+  if (typeName === "ZodOptional" || typeName === "ZodDefault") {
+    const innerType = schema._def?.innerType;
+    return innerType || schema;
+  }
+  return schema;
+}
+function extractValidationConstraints(schema) {
+  const innerSchema = getInnerSchema(schema);
+  const typeName = innerSchema._def?.typeName;
+  const constraints = {};
+  if (typeName === "ZodString") {
+    const def = innerSchema._def;
+    const checks = def.checks;
+    if (checks && Array.isArray(checks)) {
+      for (const check of checks) {
+        switch (check.kind) {
+          case "min":
+            constraints.minLength = check.value;
+            break;
+          case "max":
+            constraints.maxLength = check.value;
+            break;
+          case "email":
+            constraints.type = "email";
+            break;
+          case "url":
+            constraints.type = "url";
+            break;
+          case "regex":
+            constraints.pattern = check.regex;
+            break;
+        }
+      }
+    }
+  }
+  if (typeName === "ZodNumber") {
+    const def = innerSchema._def;
+    const checks = def.checks;
+    if (checks && Array.isArray(checks)) {
+      for (const check of checks) {
+        switch (check.kind) {
+          case "min":
+            constraints.min = check.value;
+            break;
+          case "max":
+            constraints.max = check.value;
+            break;
+          case "int":
+            constraints.step = 1;
+            break;
+          case "multipleOf":
+            constraints.step = check.value;
+            break;
+        }
+      }
+    }
+  }
+  if (typeName === "ZodArray") {
+    const def = innerSchema._def;
+    const minLength = def.minLength;
+    const maxLength = def.maxLength;
+    if (minLength !== void 0) {
+      constraints.minItems = minLength.value;
+    }
+    if (maxLength !== void 0) {
+      constraints.maxItems = maxLength.value;
+    }
+  }
+  return constraints;
+}
+function getDefaultValue(schema) {
+  const typeName = schema._def?.typeName;
+  if (typeName === "ZodDefault") {
+    const defaultValue = schema._def?.defaultValue;
+    if (typeof defaultValue === "function") {
+      return defaultValue();
+    }
+    return defaultValue;
+  }
+  const innerSchema = getInnerSchema(schema);
+  const innerTypeName = innerSchema._def?.typeName;
+  switch (innerTypeName) {
+    case "ZodString":
+      return "";
+    case "ZodNumber":
+    case "ZodBigInt":
+      return 0;
+    case "ZodBoolean":
+      return false;
+    case "ZodArray":
+      return [];
+    case "ZodObject": {
+      const shape = innerSchema._def?.shape;
+      if (shape) {
+        const defaultObj = {};
+        for (const [key, value] of Object.entries(shape)) {
+          defaultObj[key] = getDefaultValue(value);
+        }
+        return defaultObj;
+      }
+      return {};
+    }
+    case "ZodDate":
+      return /* @__PURE__ */ new Date();
+    case "ZodEnum": {
+      const values = innerSchema._def?.values;
+      return Array.isArray(values) && values.length > 0 ? values[0] : void 0;
+    }
+    default:
+      return void 0;
+  }
+}
+function extractFieldMetadata(schema) {
+  const innerSchema = getInnerSchema(schema);
+  const fieldType = inferFieldTypeFromSchema(schema);
+  const required = !isOptionalSchema(schema);
+  const optional = isOptionalSchema(schema);
+  const defaultValue = getDefaultValue(schema);
+  const options = extractOptionsFromSchema(innerSchema);
+  const constraints = extractValidationConstraints(schema);
+  const description = schema?.description;
+  return {
+    type: fieldType,
+    required,
+    optional,
+    default: defaultValue,
+    options,
+    constraints,
+    description,
+    validation: {
+      minLength: constraints.minLength,
+      maxLength: constraints.maxLength,
+      min: constraints.min,
+      max: constraints.max,
+      pattern: constraints.pattern ? new RegExp(constraints.pattern) : void 0
+    }
+  };
+}
+const renderConfigs = {
+  text: (label, placeholder, priority = "common") => ({
+    fieldType: "text",
+    ui: { label, placeholder, priority },
+    progressive: { priority }
+  }),
+  number: (label, min, max, priority = "common") => ({
+    fieldType: "number",
+    ui: { label, priority },
+    constraints: { min, max },
+    progressive: { priority }
+  }),
+  select: (label, options, priority = "common") => ({
+    fieldType: "select",
+    ui: { label, priority },
+    options,
+    progressive: { priority }
+  }),
+  textarea: (label, rows = 3, priority = "common") => ({
+    fieldType: "textarea",
+    ui: { label, priority },
+    props: { rows },
+    progressive: { priority }
+  }),
+  currency: (label, symbol = "HBAR", priority = "common") => ({
+    fieldType: "currency",
+    ui: { label, priority },
+    props: { symbol },
+    progressive: { priority }
+  }),
+  array: (label, itemLabel, priority = "advanced") => ({
+    fieldType: "array",
+    ui: { label, priority },
+    props: { itemLabel },
+    progressive: { priority }
+  }),
+  essential: {
+    text: (label, placeholder) => renderConfigs.text(label, placeholder, "essential"),
+    number: (label, min, max) => renderConfigs.number(label, min, max, "essential"),
+    select: (label, options) => renderConfigs.select(label, options, "essential"),
+    textarea: (label, rows) => renderConfigs.textarea(label, rows, "essential")
+  },
+  advanced: {
+    text: (label, placeholder) => renderConfigs.text(label, placeholder, "advanced"),
+    number: (label, min, max) => renderConfigs.number(label, min, max, "advanced"),
+    select: (label, options) => renderConfigs.select(label, options, "advanced"),
+    textarea: (label, rows) => renderConfigs.textarea(label, rows, "advanced"),
+    array: (label, itemLabel) => renderConfigs.array(label, itemLabel, "advanced")
+  },
+  expert: {
+    text: (label, placeholder) => renderConfigs.text(label, placeholder, "expert"),
+    number: (label, min, max) => renderConfigs.number(label, min, max, "expert"),
+    select: (label, options) => renderConfigs.select(label, options, "expert"),
+    textarea: (label, rows) => renderConfigs.textarea(label, rows, "expert")
+  }
+};
+function installZodRenderExtensions() {
+  if (!ZodType.prototype.withRender) {
+    ZodType.prototype.withRender = function(config) {
+      return extendZodSchema(this).withRender(config);
+    };
+    ZodType.prototype.withProgressive = function(priority, group) {
+      return extendZodSchema(this).withProgressive(priority, group);
+    };
+    ZodType.prototype.withBlock = function(blockId) {
+      return extendZodSchema(this).withBlock(blockId);
+    };
+  }
+}
+function createProgressiveSchema(baseSchema, groups) {
+  const extendedSchema = extendZodSchema(baseSchema);
+  const typeName = baseSchema._def?.typeName;
+  if (typeName === "ZodObject") {
+    const shape = baseSchema._def?.shape;
+    if (shape) {
+      for (const [fieldName, fieldSchema] of Object.entries(shape)) {
+        let fieldGroup;
+        let fieldPriority = "common";
+        for (const [groupName, groupConfig] of Object.entries(groups)) {
+          if (groupConfig.fields.includes(fieldName)) {
+            fieldGroup = groupName;
+            fieldPriority = groupConfig.priority;
+            break;
+          }
+        }
+        extendZodSchema(fieldSchema).withProgressive(fieldPriority, fieldGroup);
+      }
+      return extendedSchema;
+    }
+  }
+  return extendedSchema;
+}
+function enhanceRenderConfig(config) {
+  return {
+    ...config,
+    progressive: {
+      priority: config.ui?.priority || "common",
+      group: config.ui?.group
+    }
+  };
+}
+function extractProgressiveInfo(schema) {
+  const renderConfig = getRenderConfig(schema);
+  if (renderConfig?.progressive) {
+    return {
+      priority: renderConfig.progressive.priority,
+      group: renderConfig.progressive.group
+    };
+  }
+  if (renderConfig?.ui?.priority) {
+    return {
+      priority: renderConfig.ui.priority,
+      group: renderConfig.ui.group
+    };
+  }
+  return { priority: "common" };
+}
+export {
+  createProgressiveSchema,
+  enhanceRenderConfig,
+  extendZodSchema,
+  extractFieldMetadata,
+  extractOptionsFromSchema,
+  extractProgressiveInfo,
+  extractValidationConstraints,
+  getDefaultValue,
+  getInnerSchema,
+  getRenderConfig,
+  hasRenderConfig,
+  inferFieldTypeFromSchema,
+  installZodRenderExtensions,
+  isOptionalSchema,
+  renderConfigs
+};
+//# sourceMappingURL=standards-agent-kit.es42.js.map