@hashgraphonline/standards-agent-kit 0.2.130 → 0.2.132

package/src/tools/inscriber/RetrieveInscriptionTool.ts

@@ -15,6 +15,26 @@ const retrieveInscriptionSchema = z.object({
     .describe('API key for inscription service'),
 });
 
+/**
+ * Type definition for inscription retrieval result
+ */
+interface InscriptionRetrievalResult {
+  inscriptionId?: string;
+  transactionId: string;
+  topicId?: string;
+  status?: string;
+  holderId?: string;
+  metadata?: unknown;
+  tags?: unknown;
+  mode?: string;
+  chunks?: unknown;
+  createdAt?: string;
+  completedAt?: string;
+  fileUrl?: string;
+  mimeType?: string;
+  fileSize?: number;
+}
+
 
 /**
  * Tool for retrieving inscriptions
@@ -30,7 +50,7 @@ export class RetrieveInscriptionTool extends BaseInscriberQueryTool<typeof retri
   protected async executeQuery(
     params: z.infer<typeof retrieveInscriptionSchema>,
     _runManager?: CallbackManagerForToolRun
-  ): Promise<unknown> {
+  ): Promise<InscriptionRetrievalResult> {
     const result = await this.inscriberBuilder.retrieveInscription(
       params.transactionId,
       {
@@ -39,21 +59,23 @@ export class RetrieveInscriptionTool extends BaseInscriberQueryTool<typeof retri
       }
     );
 
+    const typedResult = result as unknown as Record<string, unknown>;
+
     return {
-      inscriptionId: (result as any).inscriptionId,
-      transactionId: result.transactionId,
-      topicId: (result as any).topic_id,
-      status: result.status,
-      holderId: (result as any).holderId,
+      inscriptionId: typedResult.inscriptionId as string | undefined,
+      transactionId: result.transactionId || 'unknown',
+      topicId: typedResult.topic_id as string | undefined,
+      status: result.status || 'unknown',
+      holderId: typedResult.holderId as string | undefined,
       metadata: result.metadata,
-      tags: (result as any).tags,
+      tags: typedResult.tags,
       mode: result.mode,
-      chunks: (result as any).chunks,
-      createdAt: (result as any).createdAt,
-      completedAt: (result as any).completed || (result as any).completedAt,
+      chunks: typedResult.chunks,
+      createdAt: typedResult.createdAt as string | undefined,
+      completedAt: (typedResult.completed || typedResult.completedAt) as string | undefined,
       fileUrl: result.fileUrl,
-      mimeType: (result as any).mimeType,
-      fileSize: (result as any).fileSize,
+      mimeType: typedResult.mimeType as string | undefined,
+      fileSize: typedResult.fileSize as number | undefined,
     };
   }
 }

package/src/tools/inscriber/base-inscriber-tools.ts

@@ -60,22 +60,11 @@ export abstract class BaseInscriberTransactionTool<
     input: InscriptionInput,
     options: InscriptionOptions
   ): Promise<QuoteResult> {
-    const operatorId = this.inscriberBuilder['hederaKit'].signer.getAccountId().toString();
-    const operatorPrivateKey = this.inscriberBuilder['hederaKit'].signer?.getOperatorPrivateKey()
-      ? this.inscriberBuilder['hederaKit'].signer.getOperatorPrivateKey().toStringRaw()
-      : '';
-
     const network = this.inscriberBuilder['hederaKit'].client.network;
     const networkType = network.toString().includes('mainnet')
       ? 'mainnet'
       : 'testnet';
 
-    const clientConfig = {
-      accountId: operatorId,
-      privateKey: operatorPrivateKey,
-      network: networkType as 'mainnet' | 'testnet',
-    };
-
     const quoteOptions = {
       ...options,
       quoteOnly: true,
@@ -83,7 +72,7 @@ export abstract class BaseInscriberTransactionTool<
     };
 
     const result = await this.inscriberBuilder.inscribe(input, quoteOptions);
-    
+
     if (!result.quote || result.confirmed) {
       throw new Error('Failed to generate quote - unexpected response type');
     }
@@ -136,22 +125,11 @@ export abstract class BaseInscriberQueryTool<
     input: InscriptionInput,
     options: InscriptionOptions
   ): Promise<QuoteResult> {
-    const operatorId = this.inscriberBuilder['hederaKit'].signer.getAccountId().toString();
-    const operatorPrivateKey = this.inscriberBuilder['hederaKit'].signer?.getOperatorPrivateKey()
-      ? this.inscriberBuilder['hederaKit'].signer.getOperatorPrivateKey().toStringRaw()
-      : '';
-
     const network = this.inscriberBuilder['hederaKit'].client.network;
     const networkType = network.toString().includes('mainnet')
       ? 'mainnet'
       : 'testnet';
 
-    const clientConfig = {
-      accountId: operatorId,
-      privateKey: operatorPrivateKey,
-      network: networkType as 'mainnet' | 'testnet',
-    };
-
     const quoteOptions = {
       ...options,
       quoteOnly: true,
@@ -159,7 +137,7 @@ export abstract class BaseInscriberQueryTool<
     };
 
     const result = await this.inscriberBuilder.inscribe(input, quoteOptions);
-    
+
     if (!result.quote || result.confirmed) {
       throw new Error('Failed to generate quote - unexpected response type');
     }

package/src/types/content-resolver.ts

@@ -1,11 +1,11 @@
 /**
  * Content Resolver Types
- * 
+ *
  * Re-export types from standards-sdk for content resolution.
  */
 
-export type { 
+export type {
   ContentResolverInterface,
   ReferenceResolutionResult,
-  ContentStoreInterface 
+  ContentStoreInterface
 } from '@hashgraphonline/standards-sdk';

package/src/types/inscription-response.ts

@@ -0,0 +1,234 @@
+/**
+ * Structured response interface for inscription tools
+ * Provides a consistent, user-friendly format for inscription results
+ */
+
+export interface InscriptionSuccessResponse {
+  success: true;
+  type: 'inscription';
+  title: string;
+  message: string;
+  inscription: {
+    /** The HRL (Hashinal Reference Link) for minting - e.g., "hcs://1/0.0.123456" */
+    hrl: string;
+    /** Topic ID where the inscription was stored */
+    topicId: string;
+    /** Type of Hashinal - Static (HCS-5) or Dynamic (HCS-6) */
+    standard: 'Static' | 'Dynamic';
+    /** CDN URL for direct access to the inscribed content */
+    cdnUrl?: string;
+    /** Transaction ID of the inscription */
+    transactionId?: string;
+  };
+  metadata: {
+    /** Name/title of the inscribed content */
+    name?: string;
+    /** Creator of the content */
+    creator?: string;
+    /** Description of the content */
+    description?: string;
+    /** Content type (image, text, etc.) */
+    type?: string;
+    /** Additional attributes */
+    attributes?: Array<{ trait_type: string; value: string | number }>;
+  };
+  nextSteps: {
+    /** Primary action the user should take next */
+    primary: string;
+    /** Additional context or options */
+    context?: string;
+    /** Specific metadata value to use for minting */
+    mintingMetadata: string;
+  };
+  /** HashLink block data (only present when withHashLinkBlocks=true) */
+  hashLinkBlock?: {
+    /** Block topic ID on HCS */
+    blockId: string;
+    /** HashLink reference to the block */
+    hashLink: string;
+    /** Template topic ID */
+    template: string;
+    /** Block attributes for rendering */
+    attributes: BlockAttributes;
+  };
+}
+
+export interface InscriptionQuoteResponse {
+  success: true;
+  type: 'quote';
+  title: string;
+  message: string;
+  quote: {
+    /** Total cost in HBAR */
+    totalCostHbar: string;
+    /** When the quote expires */
+    validUntil: string;
+    /** Cost breakdown details */
+    breakdown?: CostBreakdown;
+  };
+  content: {
+    /** Name of the content to be inscribed */
+    name?: string;
+    /** Creator of the content */
+    creator?: string;
+    /** Type of content */
+    type?: string;
+  };
+}
+
+export interface InscriptionErrorResponse {
+  success: false;
+  type: 'error';
+  title: string;
+  message: string;
+  error: {
+    /** Error code for programmatic handling */
+    code: string;
+    /** Detailed error message */
+    details: string;
+    /** Suggestions for fixing the error */
+    suggestions?: string[];
+  };
+}
+
+export type InscriptionResponse =
+  | InscriptionSuccessResponse
+  | InscriptionQuoteResponse
+  | InscriptionErrorResponse;
+
+/**
+ * Helper function to create a successful inscription response
+ */
+export function createInscriptionSuccess(params: {
+  hrl: string;
+  topicId: string;
+  standard: 'Static' | 'Dynamic';
+  cdnUrl?: string;
+  transactionId?: string;
+  metadata: {
+    name?: string;
+    creator?: string;
+    description?: string;
+    type?: string;
+    attributes?: Array<{ trait_type: string; value: string | number }>;
+  };
+}): InscriptionSuccessResponse {
+  const { hrl, topicId, standard, cdnUrl, transactionId, metadata } = params;
+
+  return {
+    success: true,
+    type: 'inscription',
+    title: `${standard} Hashinal Inscription Complete`,
+    message: `Successfully inscribed "${
+      metadata.name || 'your content'
+    }" as a ${standard} Hashinal. The content is now ready for NFT minting.`,
+    inscription: {
+      hrl,
+      topicId,
+      standard,
+      cdnUrl,
+      transactionId,
+    },
+    metadata,
+    nextSteps: {
+      primary: 'Use the HRL below as metadata when minting your NFT',
+      context:
+        'The HRL (Hedera Resource Locator) is the standardized way to reference your inscribed content in NFT metadata.',
+      mintingMetadata: hrl,
+    },
+  };
+}
+
+/**
+ * Block attributes for HashLink rendering
+ */
+interface BlockAttributes {
+  /** Display name */
+  name?: string;
+  /** Description text */
+  description?: string;
+  /** Image URL */
+  image?: string;
+  /** Content type */
+  contentType?: string;
+  /** Size in bytes */
+  size?: number;
+  /** Custom metadata */
+  metadata?: Record<string, string | number | boolean>;
+}
+
+/**
+ * Transfer details in cost breakdown
+ */
+interface TransferDetails {
+  to: string;
+  amount: string;
+  description: string;
+}
+
+/**
+ * Cost breakdown details for inscription quote
+ */
+interface CostBreakdown {
+  transfers: TransferDetails[];
+  baseFee?: number;
+  sizeFee?: number;
+  networkFee?: number;
+  serviceFee?: number;
+  totalFee?: number;
+  currency?: string;
+}
+
+/**
+ * Helper function to create a quote response
+ */
+export function createInscriptionQuote(params: {
+  totalCostHbar: string;
+  validUntil: string;
+  breakdown?: CostBreakdown;
+  content: {
+    name?: string;
+    creator?: string;
+    type?: string;
+  };
+}): InscriptionQuoteResponse {
+  const { totalCostHbar, validUntil, breakdown, content } = params;
+
+  return {
+    success: true,
+    type: 'quote',
+    title: 'Inscription Cost Quote',
+    message: `Estimated cost to inscribe "${
+      content.name || 'your content'
+    }" is ${totalCostHbar} HBAR.`,
+    quote: {
+      totalCostHbar,
+      validUntil,
+      breakdown,
+    },
+    content,
+  };
+}
+
+/**
+ * Helper function to create an error response
+ */
+export function createInscriptionError(params: {
+  code: string;
+  details: string;
+  suggestions?: string[];
+}): InscriptionErrorResponse {
+  const { code, details, suggestions } = params;
+
+  return {
+    success: false,
+    type: 'error',
+    title: 'Inscription Failed',
+    message: `Unable to complete inscription: ${details}`,
+    error: {
+      code,
+      details,
+      suggestions,
+    },
+  };
+}

package/src/utils/Encryption.ts

@@ -1,4 +1,4 @@
-// src/utils/Encryption.ts
+
 /**
  * Placeholder for encryption functionality.
  * Currently, encryption is disabled. The useEncryption flag is false by default.

package/src/utils/HederaClient.ts

@@ -1,9 +1,8 @@
-// src/utils/HederaClient.ts
+
 import { Client, AccountId, PrivateKey, TopicMessage, TopicMessageQuery } from '@hashgraph/sdk';
 import * as dotenv from 'dotenv';
 import { HCS10Message } from '../hcs10/types';
 
-// Load environment variables from .env file
 dotenv.config();
 
 /**

package/src/utils/metadata-defaults.ts

@@ -9,11 +9,22 @@ export function generateDefaultMetadata(params: {
   fileName?: string;
   mimeType?: string;
   operatorAccount: string;
-}) {
+}): {
+  name: string;
+  creator: string;
+  description: string;
+  type: string;
+  image: string;
+} {
   const defaultName = params.fileName?.replace(/\.[^/.]+$/, '') || 'Hashinal NFT';
-  const defaultType = params.mimeType?.startsWith('image/') ? 'image' : 
-                      params.mimeType?.startsWith('video/') ? 'video' :
-                      params.mimeType?.startsWith('audio/') ? 'audio' : 'media';
+  let defaultType = 'media';
+  if (params.mimeType?.startsWith('image/')) {
+    defaultType = 'image';
+  } else if (params.mimeType?.startsWith('video/')) {
+    defaultType = 'video';
+  } else if (params.mimeType?.startsWith('audio/')) {
+    defaultType = 'audio';
+  }
 
   return {
     name: params.name || defaultName,

package/src/utils/state-tools.ts

@@ -125,8 +125,7 @@ export async function createAgent(
       client,
     };
   } catch (error) {
-    console.log('error', error, baseClient);
-    logger.error(`Error creating ${agentName} agent:`, error);
+    logger.error(`Error creating ${agentName} agent:`, error, { baseClient });
     return null;
   }
 }

package/src/validation/content-ref-schemas.ts

@@ -5,7 +5,7 @@ import { z } from 'zod';
  */
 export const contentRefSchema = z
   .string()
-  .regex(/^content-ref:[a-fA-F0-9]{64}$/, 'Content reference must be in format "content-ref:[64-char hex]"')
+  .regex(/^content-ref:[a-zA-Z0-9_-]+$/, 'Content reference must be in format "content-ref:[alphanumeric-id]"')
   .describe('Content reference in format "content-ref:[id]"');
 
 /**
@@ -15,6 +15,6 @@ export function validateContentRef(input: string): string {
   try {
     return contentRefSchema.parse(input);
   } catch (error) {
-    throw new Error(`Invalid content reference format. Expected "content-ref:[64-character-hash]" but got "${input}"`);
+    throw new Error(`Invalid content reference format. Expected "content-ref:[alphanumeric-id]" but got "${input}"`);
   }
 }

package/src/validation/hip412-schemas.ts

@@ -39,7 +39,7 @@ export const hip412MetadataSchema = z.object({
 /**
  * Validates metadata against HIP-412 standard
  */
-export function validateHIP412Metadata(metadata: any): z.infer<typeof hip412MetadataSchema> {
+export function validateHIP412Metadata(metadata: unknown): z.infer<typeof hip412MetadataSchema> {
   try {
     return hip412MetadataSchema.parse(metadata);
   } catch (error) {

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

@@ -1,89 +0,0 @@
-import { z } from "zod";
-import { BaseHCS10TransactionTool } from "./standards-agent-kit.es8.js";
-const SendMessageToConnectionZodSchema = z.object({
-  targetIdentifier: z.string().optional().describe(
-    "The request key (e.g., 'req-1:0.0.6155171@0.0.6154875'), account ID (e.g., 0.0.12345) of the target agent, OR the connection number (e.g., '1', '2') from the 'list_connections' tool. Request key is most deterministic."
-  ),
-  connectionId: z.string().optional().describe(
-    "The connection number (e.g., '1', '2') from the 'list_connections' tool."
-  ),
-  agentId: z.string().optional().describe("The account ID (e.g., 0.0.12345) of the target agent."),
-  message: z.string().describe("The text message content to send."),
-  disableMonitoring: z.boolean().optional().default(false)
-});
-class SendMessageToConnectionTool extends BaseHCS10TransactionTool {
-  constructor(params) {
-    super(params);
-    this.name = "send_message_to_connection";
-    this.description = "Use this to send a message to an agent you already have an active connection with. Provide the target agent's account ID (e.g., 0.0.12345) and your message. If no active connection exists, this will fail - use initiate_connection instead to create a new connection first.";
-    this.specificInputSchema = SendMessageToConnectionZodSchema;
-    this.requiresMultipleTransactions = true;
-    this.neverScheduleThisTool = true;
-  }
-  async callBuilderMethod(builder, specificArgs) {
-    const hcs10Builder = builder;
-    const targetIdentifier = specificArgs.targetIdentifier || specificArgs.agentId || specificArgs.connectionId;
-    if (!targetIdentifier) {
-      throw new Error(
-        "Either targetIdentifier, connectionId, or agentId must be provided"
-      );
-    }
-    const stateManager = hcs10Builder.getStateManager();
-    if (stateManager) {
-      const connectionsManager = stateManager.getConnectionsManager();
-      if (connectionsManager) {
-        try {
-          const currentAgent = stateManager.getCurrentAgent();
-          if (currentAgent && currentAgent.accountId) {
-            await connectionsManager.fetchConnectionData(
-              currentAgent.accountId
-            );
-          }
-        } catch (error) {
-          console.debug("Could not refresh connections:", error);
-        }
-      }
-      if (targetIdentifier.match(/^\d+$/)) {
-        const connections = stateManager.listConnections();
-        const connectionIndex = parseInt(targetIdentifier) - 1;
-        const establishedConnections = connections.filter(
-          (conn) => conn.status === "established" && !conn.isPending && !conn.needsConfirmation
-        );
-        if (connectionIndex >= 0 && connectionIndex < establishedConnections.length) {
-          const selectedConnection = establishedConnections[connectionIndex];
-          if (selectedConnection && selectedConnection.connectionTopicId) {
-            await hcs10Builder.sendMessageToConnection({
-              targetIdentifier: selectedConnection.connectionTopicId,
-              message: specificArgs.message,
-              disableMonitoring: specificArgs.disableMonitoring
-            });
-            return;
-          }
-        }
-      }
-      if (targetIdentifier.match(/^\d+\.\d+\.\d+$/)) {
-        const connections = stateManager.listConnections();
-        const establishedConnection = connections.find(
-          (conn) => (conn.targetAccountId === targetIdentifier || conn.targetAccountId === `0.0.${targetIdentifier}`) && conn.status === "established" && !conn.isPending && !conn.needsConfirmation
-        );
-        if (establishedConnection && establishedConnection.connectionTopicId) {
-          await hcs10Builder.sendMessageToConnection({
-            targetIdentifier: establishedConnection.connectionTopicId,
-            message: specificArgs.message,
-            disableMonitoring: specificArgs.disableMonitoring
-          });
-          return;
-        }
-      }
-    }
-    await hcs10Builder.sendMessageToConnection({
-      targetIdentifier,
-      message: specificArgs.message,
-      disableMonitoring: specificArgs.disableMonitoring
-    });
-  }
-}
-export {
-  SendMessageToConnectionTool
-};
-//# sourceMappingURL=standards-agent-kit.es10.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"standards-agent-kit.es10.js","sources":["../../src/tools/hcs10/SendMessageToConnectionTool.ts"],"sourcesContent":["import { z } from 'zod';\nimport { BaseHCS10TransactionTool } from './base-hcs10-tools';\nimport { HCS10Builder } from '../../builders/hcs10/hcs10-builder';\nimport { HCS10TransactionToolParams } from './hcs10-tool-params';\nimport { BaseServiceBuilder } from 'hedera-agent-kit';\n\nconst SendMessageToConnectionZodSchema = z.object({\n  targetIdentifier: z\n    .string()\n    .optional()\n    .describe(\n      \"The request key (e.g., 'req-1:0.0.6155171@0.0.6154875'), account ID (e.g., 0.0.12345) of the target agent, OR the connection number (e.g., '1', '2') from the 'list_connections' tool. Request key is most deterministic.\"\n    ),\n  connectionId: z\n    .string()\n    .optional()\n    .describe(\n      \"The connection number (e.g., '1', '2') from the 'list_connections' tool.\"\n    ),\n  agentId: z\n    .string()\n    .optional()\n    .describe('The account ID (e.g., 0.0.12345) of the target agent.'),\n  message: z.string().describe('The text message content to send.'),\n  disableMonitoring: z.boolean().optional().default(false),\n});\n\n/**\n * A tool to send a message to an agent over an established HCS-10 connection.\n */\nexport class SendMessageToConnectionTool extends BaseHCS10TransactionTool<\n  typeof SendMessageToConnectionZodSchema\n> {\n  name = 'send_message_to_connection';\n  description =\n    \"Use this to send a message to an agent you already have an active connection with. Provide the target agent's account ID (e.g., 0.0.12345) and your message. If no active connection exists, this will fail - use initiate_connection instead to create a new connection first.\";\n  specificInputSchema = SendMessageToConnectionZodSchema;\n  constructor(params: HCS10TransactionToolParams) {\n    super(params);\n    this.requiresMultipleTransactions = true;\n    this.neverScheduleThisTool = true;\n  }\n\n  protected async callBuilderMethod(\n    builder: BaseServiceBuilder,\n    specificArgs: z.infer<typeof SendMessageToConnectionZodSchema>\n  ): Promise<void> {\n    const hcs10Builder = builder as HCS10Builder;\n\n    const targetIdentifier =\n      specificArgs.targetIdentifier ||\n      specificArgs.agentId ||\n      specificArgs.connectionId;\n\n    if (!targetIdentifier) {\n      throw new Error(\n        'Either targetIdentifier, connectionId, or agentId must be provided'\n      );\n    }\n\n    const stateManager = hcs10Builder.getStateManager();\n    if (stateManager) {\n      const connectionsManager = stateManager.getConnectionsManager();\n      if (connectionsManager) {\n        try {\n          const currentAgent = stateManager.getCurrentAgent();\n          if (currentAgent && currentAgent.accountId) {\n            await connectionsManager.fetchConnectionData(\n              currentAgent.accountId\n            );\n          }\n        } catch (error) {\n          console.debug('Could not refresh connections:', error);\n        }\n      }\n\n      if (targetIdentifier.match(/^\\d+$/)) {\n        const connections = stateManager.listConnections();\n        const connectionIndex = parseInt(targetIdentifier) - 1; // Connection numbers are 1-based\n\n        const establishedConnections = connections.filter(\n          (conn) =>\n            conn.status === 'established' &&\n            !conn.isPending &&\n            !conn.needsConfirmation\n        );\n\n        if (\n          connectionIndex >= 0 &&\n          connectionIndex < establishedConnections.length\n        ) {\n          const selectedConnection = establishedConnections[connectionIndex];\n          if (selectedConnection && selectedConnection.connectionTopicId) {\n            await hcs10Builder.sendMessageToConnection({\n              targetIdentifier: selectedConnection.connectionTopicId,\n              message: specificArgs.message,\n              disableMonitoring: specificArgs.disableMonitoring,\n            });\n            return;\n          }\n        }\n      }\n\n      if (targetIdentifier.match(/^\\d+\\.\\d+\\.\\d+$/)) {\n        const connections = stateManager.listConnections();\n        const establishedConnection = connections.find(\n          (conn) =>\n            (conn.targetAccountId === targetIdentifier ||\n              conn.targetAccountId === `0.0.${targetIdentifier}`) &&\n            conn.status === 'established' &&\n            !conn.isPending &&\n            !conn.needsConfirmation\n        );\n\n        if (establishedConnection && establishedConnection.connectionTopicId) {\n          await hcs10Builder.sendMessageToConnection({\n            targetIdentifier: establishedConnection.connectionTopicId,\n            message: specificArgs.message,\n            disableMonitoring: specificArgs.disableMonitoring,\n          });\n          return;\n        }\n      }\n    }\n\n    await hcs10Builder.sendMessageToConnection({\n      targetIdentifier: targetIdentifier,\n      message: specificArgs.message,\n      disableMonitoring: specificArgs.disableMonitoring,\n    });\n  }\n}\n"],"names":[],"mappings":";;AAMA,MAAM,mCAAmC,EAAE,OAAO;AAAA,EAChD,kBAAkB,EACf,SACA,WACA;AAAA,IACC;AAAA,EAAA;AAAA,EAEJ,cAAc,EACX,SACA,WACA;AAAA,IACC;AAAA,EAAA;AAAA,EAEJ,SAAS,EACN,OAAA,EACA,SAAA,EACA,SAAS,uDAAuD;AAAA,EACnE,SAAS,EAAE,SAAS,SAAS,mCAAmC;AAAA,EAChE,mBAAmB,EAAE,QAAA,EAAU,SAAA,EAAW,QAAQ,KAAK;AACzD,CAAC;AAKM,MAAM,oCAAoC,yBAE/C;AAAA,EAKA,YAAY,QAAoC;AAC9C,UAAM,MAAM;AALd,SAAA,OAAO;AACP,SAAA,cACE;AACF,SAAA,sBAAsB;AAGpB,SAAK,+BAA+B;AACpC,SAAK,wBAAwB;AAAA,EAC/B;AAAA,EAEA,MAAgB,kBACd,SACA,cACe;AACf,UAAM,eAAe;AAErB,UAAM,mBACJ,aAAa,oBACb,aAAa,WACb,aAAa;AAEf,QAAI,CAAC,kBAAkB;AACrB,YAAM,IAAI;AAAA,QACR;AAAA,MAAA;AAAA,IAEJ;AAEA,UAAM,eAAe,aAAa,gBAAA;AAClC,QAAI,cAAc;AAChB,YAAM,qBAAqB,aAAa,sBAAA;AACxC,UAAI,oBAAoB;AACtB,YAAI;AACF,gBAAM,eAAe,aAAa,gBAAA;AAClC,cAAI,gBAAgB,aAAa,WAAW;AAC1C,kBAAM,mBAAmB;AAAA,cACvB,aAAa;AAAA,YAAA;AAAA,UAEjB;AAAA,QACF,SAAS,OAAO;AACd,kBAAQ,MAAM,kCAAkC,KAAK;AAAA,QACvD;AAAA,MACF;AAEA,UAAI,iBAAiB,MAAM,OAAO,GAAG;AACnC,cAAM,cAAc,aAAa,gBAAA;AACjC,cAAM,kBAAkB,SAAS,gBAAgB,IAAI;AAErD,cAAM,yBAAyB,YAAY;AAAA,UACzC,CAAC,SACC,KAAK,WAAW,iBAChB,CAAC,KAAK,aACN,CAAC,KAAK;AAAA,QAAA;AAGV,YACE,mBAAmB,KACnB,kBAAkB,uBAAuB,QACzC;AACA,gBAAM,qBAAqB,uBAAuB,eAAe;AACjE,cAAI,sBAAsB,mBAAmB,mBAAmB;AAC9D,kBAAM,aAAa,wBAAwB;AAAA,cACzC,kBAAkB,mBAAmB;AAAA,cACrC,SAAS,aAAa;AAAA,cACtB,mBAAmB,aAAa;AAAA,YAAA,CACjC;AACD;AAAA,UACF;AAAA,QACF;AAAA,MACF;AAEA,UAAI,iBAAiB,MAAM,iBAAiB,GAAG;AAC7C,cAAM,cAAc,aAAa,gBAAA;AACjC,cAAM,wBAAwB,YAAY;AAAA,UACxC,CAAC,UACE,KAAK,oBAAoB,oBACxB,KAAK,oBAAoB,OAAO,gBAAgB,OAClD,KAAK,WAAW,iBAChB,CAAC,KAAK,aACN,CAAC,KAAK;AAAA,QAAA;AAGV,YAAI,yBAAyB,sBAAsB,mBAAmB;AACpE,gBAAM,aAAa,wBAAwB;AAAA,YACzC,kBAAkB,sBAAsB;AAAA,YACxC,SAAS,aAAa;AAAA,YACtB,mBAAmB,aAAa;AAAA,UAAA,CACjC;AACD;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAEA,UAAM,aAAa,wBAAwB;AAAA,MACzC;AAAA,MACA,SAAS,aAAa;AAAA,MACtB,mBAAmB,aAAa;AAAA,IAAA,CACjC;AAAA,EACH;AACF;"}

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

@@ -1,40 +0,0 @@
-import { z } from "zod";
-import { BaseHCS10TransactionTool } from "./standards-agent-kit.es8.js";
-const InitiateConnectionZodSchema = z.object({
-  targetAccountId: z.string().describe(
-    "The Hedera account ID (e.g., 0.0.12345) of the agent you want to connect with."
-  ),
-  disableMonitor: z.boolean().optional().describe(
-    "If true, does not wait for connection confirmation. Returns immediately after sending the request."
-  ),
-  memo: z.string().optional().describe(
-    'Optional memo to include with the connection request (e.g., "Hello from Alice"). If not provided, defaults to "true" or "false" based on monitoring preference.'
-  )
-});
-class InitiateConnectionTool extends BaseHCS10TransactionTool {
-  constructor(params) {
-    super(params);
-    this.name = "initiate_connection";
-    this.description = "ONLY use this to START a BRAND NEW connection to an agent you have NEVER connected to before. If you already have an active connection to this agent, use send_message_to_connection instead. This creates a new connection request and waits for acceptance.";
-    this.specificInputSchema = InitiateConnectionZodSchema;
-    this.neverScheduleThisTool = true;
-    this.requiresMultipleTransactions = true;
-  }
-  async callBuilderMethod(builder, specificArgs) {
-    const hcs10Builder = builder;
-    const params = {
-      targetAccountId: specificArgs.targetAccountId
-    };
-    if (specificArgs.disableMonitor !== void 0) {
-      params.disableMonitor = specificArgs.disableMonitor;
-    }
-    if (specificArgs.memo !== void 0) {
-      params.memo = specificArgs.memo;
-    }
-    await hcs10Builder.initiateConnection(params);
-  }
-}
-export {
-  InitiateConnectionTool
-};
-//# sourceMappingURL=standards-agent-kit.es11.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"standards-agent-kit.es11.js","sources":["../../src/tools/hcs10/InitiateConnectionTool.ts"],"sourcesContent":["import { z } from 'zod';\nimport { BaseHCS10TransactionTool } from './base-hcs10-tools';\nimport { HCS10Builder } from '../../builders/hcs10/hcs10-builder';\nimport { HCS10TransactionToolParams } from './hcs10-tool-params';\nimport { BaseServiceBuilder } from 'hedera-agent-kit';\n\nconst InitiateConnectionZodSchema = z.object({\n  targetAccountId: z\n    .string()\n    .describe(\n      'The Hedera account ID (e.g., 0.0.12345) of the agent you want to connect with.'\n    ),\n  disableMonitor: z\n    .boolean()\n    .optional()\n    .describe(\n      'If true, does not wait for connection confirmation. Returns immediately after sending the request.'\n    ),\n  memo: z\n    .string()\n    .optional()\n    .describe(\n      'Optional memo to include with the connection request (e.g., \"Hello from Alice\"). If not provided, defaults to \"true\" or \"false\" based on monitoring preference.'\n    ),\n});\n\n/**\n * A tool to actively START a NEW HCS-10 connection TO a target agent.\n * Requires the target agent's account ID.\n * It retrieves their profile, sends a connection request, and optionally waits for confirmation.\n * Use this tool ONLY to actively INITIATE an OUTGOING connection.\n */\nexport class InitiateConnectionTool extends BaseHCS10TransactionTool<\n  typeof InitiateConnectionZodSchema\n> {\n  name = 'initiate_connection';\n  description =\n    'ONLY use this to START a BRAND NEW connection to an agent you have NEVER connected to before. If you already have an active connection to this agent, use send_message_to_connection instead. This creates a new connection request and waits for acceptance.';\n  specificInputSchema = InitiateConnectionZodSchema;\n  constructor(params: HCS10TransactionToolParams) {\n    super(params);\n    this.neverScheduleThisTool = true;\n    this.requiresMultipleTransactions = true;\n  }\n\n  protected async callBuilderMethod(\n    builder: BaseServiceBuilder,\n    specificArgs: z.infer<typeof InitiateConnectionZodSchema>\n  ): Promise<void> {\n    const hcs10Builder = builder as HCS10Builder;\n    const params: {\n      targetAccountId: string;\n      disableMonitor?: boolean;\n      memo?: string;\n    } = {\n      targetAccountId: specificArgs.targetAccountId,\n    };\n    if (specificArgs.disableMonitor !== undefined) {\n      params.disableMonitor = specificArgs.disableMonitor;\n    }\n    if (specificArgs.memo !== undefined) {\n      params.memo = specificArgs.memo;\n    }\n    await hcs10Builder.initiateConnection(params);\n  }\n}"],"names":[],"mappings":";;AAMA,MAAM,8BAA8B,EAAE,OAAO;AAAA,EAC3C,iBAAiB,EACd,OAAA,EACA;AAAA,IACC;AAAA,EAAA;AAAA,EAEJ,gBAAgB,EACb,UACA,WACA;AAAA,IACC;AAAA,EAAA;AAAA,EAEJ,MAAM,EACH,SACA,WACA;AAAA,IACC;AAAA,EAAA;AAEN,CAAC;AAQM,MAAM,+BAA+B,yBAE1C;AAAA,EAKA,YAAY,QAAoC;AAC9C,UAAM,MAAM;AALd,SAAA,OAAO;AACP,SAAA,cACE;AACF,SAAA,sBAAsB;AAGpB,SAAK,wBAAwB;AAC7B,SAAK,+BAA+B;AAAA,EACtC;AAAA,EAEA,MAAgB,kBACd,SACA,cACe;AACf,UAAM,eAAe;AACrB,UAAM,SAIF;AAAA,MACF,iBAAiB,aAAa;AAAA,IAAA;AAEhC,QAAI,aAAa,mBAAmB,QAAW;AAC7C,aAAO,iBAAiB,aAAa;AAAA,IACvC;AACA,QAAI,aAAa,SAAS,QAAW;AACnC,aAAO,OAAO,aAAa;AAAA,IAC7B;AACA,UAAM,aAAa,mBAAmB,MAAM;AAAA,EAC9C;AACF;"}

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

@@ -1,40 +0,0 @@
-import { z } from "zod";
-import { BaseHCS10QueryTool } from "./standards-agent-kit.es8.js";
-const ListConnectionsZodSchema = z.object({
-  includeDetails: z.boolean().optional().describe(
-    "Whether to include detailed information about each connection"
-  ),
-  showPending: z.boolean().optional().describe("Whether to include pending connection requests")
-});
-class ListConnectionsTool extends BaseHCS10QueryTool {
-  constructor(params) {
-    super(params);
-    this.name = "list_connections";
-    this.description = "Lists all active HCS-10 connections. Use this FIRST before sending messages to check if you already have an active connection to a target agent. Shows connection details and agent information for each active connection.";
-    this.specificInputSchema = ListConnectionsZodSchema;
-  }
-  async executeQuery(args) {
-    const hcs10Builder = this.hcs10Builder;
-    const params = {};
-    if (args.includeDetails !== void 0) {
-      params.includeDetails = args.includeDetails;
-    }
-    if (args.showPending !== void 0) {
-      params.showPending = args.showPending;
-    }
-    await hcs10Builder.listConnections(params);
-    const result = await hcs10Builder.execute();
-    if (result.success && "rawResult" in result && result.rawResult) {
-      const raw = result.rawResult;
-      return {
-        success: true,
-        data: raw.formattedOutput || raw.message || "Connections listed"
-      };
-    }
-    return result;
-  }
-}
-export {
-  ListConnectionsTool
-};
-//# sourceMappingURL=standards-agent-kit.es12.js.map