@hashgraphonline/standards-agent-kit 0.2.110 → 0.2.113

package/dist/cjs/tools/hcs6/CreateDynamicRegistryTool.d.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import { BaseHCS6TransactionTool } from './base-hcs6-tools';
+import { HCS6TransactionToolParams } from './hcs6-tool-params';
+import { TransactionResponse } from 'hedera-agent-kit';
+/**
+ * Schema for creating a dynamic hashinal registry
+ */
+declare const CreateDynamicRegistrySchema: z.ZodObject<{
+    ttl: z.ZodDefault<z.ZodNumber>;
+    adminKey: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodString]>>;
+    submitKey: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodString]>>;
+}, "strip", z.ZodTypeAny, {
+    ttl: number;
+    adminKey?: string | boolean | undefined;
+    submitKey?: string | boolean | undefined;
+}, {
+    ttl?: number | undefined;
+    adminKey?: string | boolean | undefined;
+    submitKey?: string | boolean | undefined;
+}>;
+export type CreateDynamicRegistryInput = z.infer<typeof CreateDynamicRegistrySchema>;
+/**
+ * Tool for creating HCS-6 dynamic registries
+ */
+export declare class CreateDynamicRegistryTool extends BaseHCS6TransactionTool<typeof CreateDynamicRegistrySchema> {
+    name: string;
+    description: string;
+    schema: z.ZodObject<{
+        ttl: z.ZodDefault<z.ZodNumber>;
+        adminKey: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodString]>>;
+        submitKey: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodString]>>;
+    }, "strip", z.ZodTypeAny, {
+        ttl: number;
+        adminKey?: string | boolean | undefined;
+        submitKey?: string | boolean | undefined;
+    }, {
+        ttl?: number | undefined;
+        adminKey?: string | boolean | undefined;
+        submitKey?: string | boolean | undefined;
+    }>;
+    constructor(params: HCS6TransactionToolParams);
+    protected _call(params: CreateDynamicRegistryInput): Promise<TransactionResponse>;
+}
+export {};

package/dist/cjs/tools/hcs6/QueryDynamicRegistryTool.d.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import { BaseHCS6QueryTool } from './base-hcs6-tools';
+import { HCS6QueryToolParams } from './hcs6-tool-params';
+import { TransactionResponse } from 'hedera-agent-kit';
+/**
+ * Schema for querying a dynamic registry
+ */
+declare const QueryDynamicRegistrySchema: z.ZodObject<{
+    topicId: z.ZodString;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    order: z.ZodDefault<z.ZodOptional<z.ZodEnum<["asc", "desc"]>>>;
+    skip: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    topicId: string;
+    limit: number;
+    order: "asc" | "desc";
+    skip?: number | undefined;
+}, {
+    topicId: string;
+    limit?: number | undefined;
+    order?: "asc" | "desc" | undefined;
+    skip?: number | undefined;
+}>;
+export type QueryDynamicRegistryInput = z.infer<typeof QueryDynamicRegistrySchema>;
+/**
+ * Tool for querying HCS-6 dynamic registries
+ */
+export declare class QueryDynamicRegistryTool extends BaseHCS6QueryTool<typeof QueryDynamicRegistrySchema> {
+    name: string;
+    description: string;
+    schema: z.ZodObject<{
+        topicId: z.ZodString;
+        limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        order: z.ZodDefault<z.ZodOptional<z.ZodEnum<["asc", "desc"]>>>;
+        skip: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        topicId: string;
+        limit: number;
+        order: "asc" | "desc";
+        skip?: number | undefined;
+    }, {
+        topicId: string;
+        limit?: number | undefined;
+        order?: "asc" | "desc" | undefined;
+        skip?: number | undefined;
+    }>;
+    constructor(params: HCS6QueryToolParams);
+    protected _call(params: QueryDynamicRegistryInput): Promise<TransactionResponse>;
+}
+export {};

package/dist/cjs/tools/hcs6/RegisterDynamicHashinalTool.d.ts

@@ -0,0 +1,102 @@
+import { z } from 'zod';
+import { BaseHCS6TransactionTool } from './base-hcs6-tools';
+import { HCS6TransactionToolParams } from './hcs6-tool-params';
+import { TransactionResponse } from 'hedera-agent-kit';
+/**
+ * Schema for registering a dynamic hashinal
+ */
+declare const RegisterDynamicHashinalSchema: z.ZodObject<{
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    data: z.ZodOptional<z.ZodObject<{
+        base64: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        mimeType: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        base64?: string | undefined;
+        url?: string | undefined;
+        mimeType?: string | undefined;
+    }, {
+        base64?: string | undefined;
+        url?: string | undefined;
+        mimeType?: string | undefined;
+    }>>;
+    memo: z.ZodOptional<z.ZodString>;
+    ttl: z.ZodDefault<z.ZodNumber>;
+    registryTopicId: z.ZodOptional<z.ZodString>;
+    submitKey: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    metadata: Record<string, unknown>;
+    ttl: number;
+    data?: {
+        base64?: string | undefined;
+        url?: string | undefined;
+        mimeType?: string | undefined;
+    } | undefined;
+    memo?: string | undefined;
+    submitKey?: string | undefined;
+    registryTopicId?: string | undefined;
+}, {
+    metadata: Record<string, unknown>;
+    data?: {
+        base64?: string | undefined;
+        url?: string | undefined;
+        mimeType?: string | undefined;
+    } | undefined;
+    memo?: string | undefined;
+    ttl?: number | undefined;
+    submitKey?: string | undefined;
+    registryTopicId?: string | undefined;
+}>;
+export type RegisterDynamicHashinalInput = z.infer<typeof RegisterDynamicHashinalSchema>;
+/**
+ * Tool for registering (creating) dynamic hashinals
+ */
+export declare class RegisterDynamicHashinalTool extends BaseHCS6TransactionTool<typeof RegisterDynamicHashinalSchema> {
+    name: string;
+    description: string;
+    schema: z.ZodObject<{
+        metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        data: z.ZodOptional<z.ZodObject<{
+            base64: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            base64?: string | undefined;
+            url?: string | undefined;
+            mimeType?: string | undefined;
+        }, {
+            base64?: string | undefined;
+            url?: string | undefined;
+            mimeType?: string | undefined;
+        }>>;
+        memo: z.ZodOptional<z.ZodString>;
+        ttl: z.ZodDefault<z.ZodNumber>;
+        registryTopicId: z.ZodOptional<z.ZodString>;
+        submitKey: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        metadata: Record<string, unknown>;
+        ttl: number;
+        data?: {
+            base64?: string | undefined;
+            url?: string | undefined;
+            mimeType?: string | undefined;
+        } | undefined;
+        memo?: string | undefined;
+        submitKey?: string | undefined;
+        registryTopicId?: string | undefined;
+    }, {
+        metadata: Record<string, unknown>;
+        data?: {
+            base64?: string | undefined;
+            url?: string | undefined;
+            mimeType?: string | undefined;
+        } | undefined;
+        memo?: string | undefined;
+        ttl?: number | undefined;
+        submitKey?: string | undefined;
+        registryTopicId?: string | undefined;
+    }>;
+    constructor(params: HCS6TransactionToolParams);
+    protected _call(params: RegisterDynamicHashinalInput): Promise<TransactionResponse>;
+}
+export {};

package/dist/cjs/tools/hcs6/UpdateDynamicHashinalTool.d.ts

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+import { BaseHCS6TransactionTool } from './base-hcs6-tools';
+import { HCS6TransactionToolParams } from './hcs6-tool-params';
+import { TransactionResponse } from 'hedera-agent-kit';
+/**
+ * Schema for updating a dynamic hashinal
+ */
+declare const UpdateDynamicHashinalSchema: z.ZodObject<{
+    registryTopicId: z.ZodString;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    data: z.ZodOptional<z.ZodObject<{
+        base64: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        mimeType: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        base64?: string | undefined;
+        url?: string | undefined;
+        mimeType?: string | undefined;
+    }, {
+        base64?: string | undefined;
+        url?: string | undefined;
+        mimeType?: string | undefined;
+    }>>;
+    memo: z.ZodOptional<z.ZodString>;
+    submitKey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    metadata: Record<string, unknown>;
+    submitKey: string;
+    registryTopicId: string;
+    data?: {
+        base64?: string | undefined;
+        url?: string | undefined;
+        mimeType?: string | undefined;
+    } | undefined;
+    memo?: string | undefined;
+}, {
+    metadata: Record<string, unknown>;
+    submitKey: string;
+    registryTopicId: string;
+    data?: {
+        base64?: string | undefined;
+        url?: string | undefined;
+        mimeType?: string | undefined;
+    } | undefined;
+    memo?: string | undefined;
+}>;
+export type UpdateDynamicHashinalInput = z.infer<typeof UpdateDynamicHashinalSchema>;
+/**
+ * Tool for updating dynamic hashinals
+ */
+export declare class UpdateDynamicHashinalTool extends BaseHCS6TransactionTool<typeof UpdateDynamicHashinalSchema> {
+    name: string;
+    description: string;
+    schema: z.ZodObject<{
+        registryTopicId: z.ZodString;
+        metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        data: z.ZodOptional<z.ZodObject<{
+            base64: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            base64?: string | undefined;
+            url?: string | undefined;
+            mimeType?: string | undefined;
+        }, {
+            base64?: string | undefined;
+            url?: string | undefined;
+            mimeType?: string | undefined;
+        }>>;
+        memo: z.ZodOptional<z.ZodString>;
+        submitKey: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        metadata: Record<string, unknown>;
+        submitKey: string;
+        registryTopicId: string;
+        data?: {
+            base64?: string | undefined;
+            url?: string | undefined;
+            mimeType?: string | undefined;
+        } | undefined;
+        memo?: string | undefined;
+    }, {
+        metadata: Record<string, unknown>;
+        submitKey: string;
+        registryTopicId: string;
+        data?: {
+            base64?: string | undefined;
+            url?: string | undefined;
+            mimeType?: string | undefined;
+        } | undefined;
+        memo?: string | undefined;
+    }>;
+    constructor(params: HCS6TransactionToolParams);
+    protected _call(params: UpdateDynamicHashinalInput): Promise<TransactionResponse>;
+}
+export {};

package/dist/cjs/tools/hcs6/base-hcs6-tools.d.ts

@@ -0,0 +1,28 @@
+import { BaseHederaTransactionTool, BaseHederaQueryTool, BaseServiceBuilder } from 'hedera-agent-kit';
+import { HCS6Builder } from '../../builders/hcs6/hcs6-builder';
+import { HCS6TransactionToolParams, HCS6QueryToolParams } from './hcs6-tool-params';
+import { z } from 'zod';
+/**
+ * Base class for HCS6 transaction tools
+ */
+export declare abstract class BaseHCS6TransactionTool<T extends z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny> = z.ZodObject<z.ZodRawShape>> extends BaseHederaTransactionTool<T> {
+    protected hcs6Builder: HCS6Builder;
+    namespace: "hcs6";
+    constructor(params: HCS6TransactionToolParams);
+    /**
+     * Override to return the HCS6Builder
+     */
+    protected getServiceBuilder(): BaseServiceBuilder;
+}
+/**
+ * Base class for HCS6 query tools
+ */
+export declare abstract class BaseHCS6QueryTool<T extends z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny> = z.ZodObject<z.ZodRawShape>> extends BaseHederaQueryTool<T> {
+    protected hcs6Builder: HCS6Builder;
+    namespace: "hcs6";
+    constructor(params: HCS6QueryToolParams);
+    /**
+     * Override to return the HCS6Builder
+     */
+    protected getServiceBuilder(): BaseServiceBuilder;
+}

package/dist/cjs/tools/hcs6/hcs6-tool-params.d.ts

@@ -0,0 +1,18 @@
+import { HederaAgentKit, BasePluginContext } from 'hedera-agent-kit';
+import { HCS6Builder } from '../../builders/hcs6/hcs6-builder';
+/**
+ * Parameters for HCS6 transaction tools
+ */
+export interface HCS6TransactionToolParams {
+    hederaKit: HederaAgentKit;
+    hcs6Builder: HCS6Builder;
+    logger?: BasePluginContext['logger'];
+}
+/**
+ * Parameters for HCS6 query tools
+ */
+export interface HCS6QueryToolParams {
+    hederaKit: HederaAgentKit;
+    hcs6Builder: HCS6Builder;
+    logger?: BasePluginContext['logger'];
+}

package/dist/cjs/tools/hcs6/index.d.ts

@@ -0,0 +1,6 @@
+export * from './base-hcs6-tools';
+export * from './hcs6-tool-params';
+export * from './CreateDynamicRegistryTool';
+export * from './RegisterDynamicHashinalTool';
+export * from './UpdateDynamicHashinalTool';
+export * from './QueryDynamicRegistryTool';

package/dist/cjs/tools/index.d.ts

@@ -1,3 +1,4 @@
 export * from './hcs10';
 export * from './hcs2';
+export * from './hcs6';
 export * from './inscriber';

package/dist/cjs/tools/inscriber/InscribeFromBufferTool.d.ts

@@ -20,23 +20,23 @@ declare const inscribeFromBufferSchema: z.ZodObject<{
     base64Data: string;
     tags?: string[] | undefined;
     metadata?: Record<string, unknown> | undefined;
+    mimeType?: string | undefined;
     mode?: "file" | "hashinal" | undefined;
     chunkSize?: number | undefined;
     waitForConfirmation?: boolean | undefined;
     apiKey?: string | undefined;
     timeoutMs?: number | undefined;
-    mimeType?: string | undefined;
 }, {
     fileName: string;
     base64Data: string;
     tags?: string[] | undefined;
     metadata?: Record<string, unknown> | undefined;
+    mimeType?: string | undefined;
     mode?: "file" | "hashinal" | undefined;
     chunkSize?: number | undefined;
     waitForConfirmation?: boolean | undefined;
     apiKey?: string | undefined;
     timeoutMs?: number | undefined;
-    mimeType?: string | undefined;
 }>;
 /**
  * Tool for inscribing content from buffer
@@ -60,23 +60,23 @@ export declare class InscribeFromBufferTool extends BaseInscriberQueryTool<typeo
         base64Data: string;
         tags?: string[] | undefined;
         metadata?: Record<string, unknown> | undefined;
+        mimeType?: string | undefined;
         mode?: "file" | "hashinal" | undefined;
         chunkSize?: number | undefined;
         waitForConfirmation?: boolean | undefined;
         apiKey?: string | undefined;
         timeoutMs?: number | undefined;
-        mimeType?: string | undefined;
     }, {
         fileName: string;
         base64Data: string;
         tags?: string[] | undefined;
         metadata?: Record<string, unknown> | undefined;
+        mimeType?: string | undefined;
         mode?: "file" | "hashinal" | undefined;
         chunkSize?: number | undefined;
         waitForConfirmation?: boolean | undefined;
         apiKey?: string | undefined;
         timeoutMs?: number | undefined;
-        mimeType?: string | undefined;
     }>;
     protected executeQuery(params: z.infer<typeof inscribeFromBufferSchema>, _runManager?: CallbackManagerForToolRun): Promise<unknown>;
 }

package/dist/es/builders/hcs6/hcs6-builder.d.ts

@@ -0,0 +1,47 @@
+import { BaseServiceBuilder, HederaAgentKit } from 'hedera-agent-kit';
+import { HCS6Client, HCS6CreateRegistryOptions, HCS6RegisterEntryOptions, HCS6QueryRegistryOptions, HCS6RegisterOptions, HCS6CreateHashinalOptions, HCS6TopicRegistrationResponse, HCS6RegistryOperationResponse, HCS6TopicRegistry, HCS6CreateHashinalResponse } from '@hashgraphonline/standards-sdk';
+/**
+ * Builder for HCS-6 operations that delegates to HCS6Client
+ */
+export declare class HCS6Builder extends BaseServiceBuilder {
+    protected hcs6Client?: HCS6Client;
+    constructor(hederaKit: HederaAgentKit);
+    /**
+     * Get or create HCS-6 client
+     */
+    protected getHCS6Client(): Promise<HCS6Client>;
+    /**
+     * Create a new HCS-6 dynamic registry
+     * Note: This executes the transaction directly via HCS6Client
+     */
+    createRegistry(options?: HCS6CreateRegistryOptions): Promise<HCS6TopicRegistrationResponse>;
+    /**
+     * Register a new dynamic hashinal entry in an HCS-6 registry
+     */
+    registerEntry(registryTopicId: string, options: HCS6RegisterEntryOptions): Promise<HCS6RegistryOperationResponse>;
+    /**
+     * Query entries from an HCS-6 registry
+     */
+    getRegistry(topicId: string, options?: HCS6QueryRegistryOptions): Promise<HCS6TopicRegistry>;
+    /**
+     * Create a complete dynamic hashinal with inscription and registry
+     */
+    createHashinal(options: HCS6CreateHashinalOptions): Promise<HCS6CreateHashinalResponse>;
+    /**
+     * Register a dynamic hashinal with combined inscription and registry creation
+     * This is the main method for creating and updating dynamic hashinals
+     */
+    register(options: HCS6RegisterOptions): Promise<HCS6CreateHashinalResponse>;
+    /**
+     * Submit a raw message to an HCS-6 topic
+     */
+    submitMessage(topicId: string, payload: any): Promise<any>;
+    /**
+     * Get topic info from mirror node
+     */
+    getTopicInfo(topicId: string): Promise<any>;
+    /**
+     * Close the HCS-6 client
+     */
+    close(): Promise<void>;
+}

package/dist/es/builders/hcs6/index.d.ts

@@ -0,0 +1 @@
+export * from './hcs6-builder';

package/dist/es/builders/index.d.ts

@@ -1,4 +1,5 @@
 export * from './types';
 export * from './hcs10/hcs10-builder';
 export * from './hcs2/hcs2-builder';
+export * from './hcs6/hcs6-builder';
 export * from './inscriber/inscriber-builder';

package/dist/es/index.d.ts

@@ -2,6 +2,6 @@ export * from './tools';
 export * from './state';
 export * from './init';
 export * from './plugins';
-export { HCS10Builder, HCS2Builder, InscriberBuilder } from './builders';
+export { HCS10Builder, HCS2Builder, HCS6Builder, InscriberBuilder } from './builders';
 export type { ExecuteResult } from './builders';
 export { HCS10Client } from './hcs10';

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

@@ -1,48 +1,57 @@
 import { HCS10Builder } from "./standards-agent-kit.es2.js";
 import { HCS2Builder } from "./standards-agent-kit.es3.js";
-import { InscriberBuilder } from "./standards-agent-kit.es4.js";
-import { HCS10Client } from "./standards-agent-kit.es5.js";
-import { BaseHCS10QueryTool, BaseHCS10TransactionTool } from "./standards-agent-kit.es6.js";
-import { RegisterAgentTool } from "./standards-agent-kit.es7.js";
-import { SendMessageToConnectionTool } from "./standards-agent-kit.es8.js";
-import { InitiateConnectionTool } from "./standards-agent-kit.es9.js";
-import { ListConnectionsTool } from "./standards-agent-kit.es10.js";
-import { CheckMessagesTool } from "./standards-agent-kit.es11.js";
-import { FindRegistrationsTool } from "./standards-agent-kit.es12.js";
-import { ConnectionMonitorTool } from "./standards-agent-kit.es13.js";
-import { ManageConnectionRequestsTool } from "./standards-agent-kit.es14.js";
-import { AcceptConnectionRequestTool } from "./standards-agent-kit.es15.js";
-import { RetrieveProfileTool } from "./standards-agent-kit.es16.js";
-import { ListUnapprovedConnectionRequestsTool } from "./standards-agent-kit.es17.js";
-import { NaturalLanguageMapper } from "./standards-agent-kit.es18.js";
-import { BaseHCS2QueryTool, BaseHCS2TransactionTool } from "./standards-agent-kit.es19.js";
-import { CreateRegistryTool } from "./standards-agent-kit.es20.js";
-import { RegisterEntryTool } from "./standards-agent-kit.es21.js";
-import { UpdateEntryTool } from "./standards-agent-kit.es22.js";
-import { DeleteEntryTool } from "./standards-agent-kit.es23.js";
-import { MigrateRegistryTool } from "./standards-agent-kit.es24.js";
-import { QueryRegistryTool } from "./standards-agent-kit.es25.js";
-import { BaseInscriberQueryTool, BaseInscriberTransactionTool } from "./standards-agent-kit.es26.js";
-import { InscribeFromUrlTool } from "./standards-agent-kit.es27.js";
-import { InscribeFromFileTool } from "./standards-agent-kit.es28.js";
-import { InscribeFromBufferTool } from "./standards-agent-kit.es29.js";
-import { InscribeHashinalTool } from "./standards-agent-kit.es30.js";
-import { RetrieveInscriptionTool } from "./standards-agent-kit.es31.js";
-import { OpenConvaiState } from "./standards-agent-kit.es32.js";
-import { initializeStandardsAgentKit } from "./standards-agent-kit.es33.js";
+import { HCS6Builder } from "./standards-agent-kit.es4.js";
+import { InscriberBuilder } from "./standards-agent-kit.es5.js";
+import { HCS10Client } from "./standards-agent-kit.es6.js";
+import { BaseHCS10QueryTool, BaseHCS10TransactionTool } from "./standards-agent-kit.es7.js";
+import { RegisterAgentTool } from "./standards-agent-kit.es8.js";
+import { SendMessageToConnectionTool } from "./standards-agent-kit.es9.js";
+import { InitiateConnectionTool } from "./standards-agent-kit.es10.js";
+import { ListConnectionsTool } from "./standards-agent-kit.es11.js";
+import { CheckMessagesTool } from "./standards-agent-kit.es12.js";
+import { FindRegistrationsTool } from "./standards-agent-kit.es13.js";
+import { ConnectionMonitorTool } from "./standards-agent-kit.es14.js";
+import { ManageConnectionRequestsTool } from "./standards-agent-kit.es15.js";
+import { AcceptConnectionRequestTool } from "./standards-agent-kit.es16.js";
+import { RetrieveProfileTool } from "./standards-agent-kit.es17.js";
+import { ListUnapprovedConnectionRequestsTool } from "./standards-agent-kit.es18.js";
+import { NaturalLanguageMapper } from "./standards-agent-kit.es19.js";
+import { BaseHCS2QueryTool, BaseHCS2TransactionTool } from "./standards-agent-kit.es20.js";
+import { CreateRegistryTool } from "./standards-agent-kit.es21.js";
+import { RegisterEntryTool } from "./standards-agent-kit.es22.js";
+import { UpdateEntryTool } from "./standards-agent-kit.es23.js";
+import { DeleteEntryTool } from "./standards-agent-kit.es24.js";
+import { MigrateRegistryTool } from "./standards-agent-kit.es25.js";
+import { QueryRegistryTool } from "./standards-agent-kit.es26.js";
+import { BaseHCS6QueryTool, BaseHCS6TransactionTool } from "./standards-agent-kit.es27.js";
+import { CreateDynamicRegistryTool } from "./standards-agent-kit.es28.js";
+import { RegisterDynamicHashinalTool } from "./standards-agent-kit.es29.js";
+import { UpdateDynamicHashinalTool } from "./standards-agent-kit.es30.js";
+import { QueryDynamicRegistryTool } from "./standards-agent-kit.es31.js";
+import { BaseInscriberQueryTool, BaseInscriberTransactionTool } from "./standards-agent-kit.es32.js";
+import { InscribeFromUrlTool } from "./standards-agent-kit.es33.js";
+import { InscribeFromFileTool } from "./standards-agent-kit.es34.js";
+import { InscribeFromBufferTool } from "./standards-agent-kit.es35.js";
+import { InscribeHashinalTool } from "./standards-agent-kit.es36.js";
+import { RetrieveInscriptionTool } from "./standards-agent-kit.es37.js";
+import { OpenConvaiState } from "./standards-agent-kit.es38.js";
+import { initializeStandardsAgentKit } from "./standards-agent-kit.es39.js";
 import { BasePlugin, HederaGetHbarPriceTool, PluginRegistry } from "hedera-agent-kit";
-import { HbarPricePlugin } from "./standards-agent-kit.es34.js";
+import { HbarPricePlugin } from "./standards-agent-kit.es40.js";
 export {
   AcceptConnectionRequestTool,
   BaseHCS10QueryTool,
   BaseHCS10TransactionTool,
   BaseHCS2QueryTool,
   BaseHCS2TransactionTool,
+  BaseHCS6QueryTool,
+  BaseHCS6TransactionTool,
   BaseInscriberQueryTool,
   BaseInscriberTransactionTool,
   BasePlugin,
   CheckMessagesTool,
   ConnectionMonitorTool,
+  CreateDynamicRegistryTool,
   CreateRegistryTool,
   DeleteEntryTool,
   FindRegistrationsTool,
@@ -50,6 +59,7 @@ export {
   HCS10Builder,
   HCS10Client,
   HCS2Builder,
+  HCS6Builder,
   HbarPricePlugin,
   InitiateConnectionTool,
   InscribeFromBufferTool,
@@ -64,12 +74,15 @@ export {
   NaturalLanguageMapper,
   OpenConvaiState,
   PluginRegistry,
+  QueryDynamicRegistryTool,
   QueryRegistryTool,
   RegisterAgentTool,
+  RegisterDynamicHashinalTool,
   RegisterEntryTool,
   RetrieveInscriptionTool,
   RetrieveProfileTool,
   SendMessageToConnectionTool,
+  UpdateDynamicHashinalTool,
   UpdateEntryTool,
   initializeStandardsAgentKit
 };

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

@@ -1 +1 @@
-{"version":3,"file":"standards-agent-kit.es.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"standards-agent-kit.es.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

@@ -1,40 +1,40 @@
 import { z } from "zod";
-import { BaseHCS10QueryTool } from "./standards-agent-kit.es6.js";
-const ListConnectionsZodSchema = z.object({
-  includeDetails: z.boolean().optional().describe(
-    "Whether to include detailed information about each connection"
+import { BaseHCS10TransactionTool } from "./standards-agent-kit.es7.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."
   ),
-  showPending: z.boolean().optional().describe("Whether to include pending connection requests")
+  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 ListConnectionsTool extends BaseHCS10QueryTool {
+class InitiateConnectionTool extends BaseHCS10TransactionTool {
   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;
+    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 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;
+  async callBuilderMethod(builder, specificArgs) {
+    const hcs10Builder = builder;
+    const params = {
+      targetAccountId: specificArgs.targetAccountId
+    };
+    if (specificArgs.disableMonitor !== void 0) {
+      params.disableMonitor = specificArgs.disableMonitor;
     }
-    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"
-      };
+    if (specificArgs.memo !== void 0) {
+      params.memo = specificArgs.memo;
     }
-    return result;
+    await hcs10Builder.initiateConnection(params);
   }
 }
 export {
-  ListConnectionsTool
+  InitiateConnectionTool
 };
 //# sourceMappingURL=standards-agent-kit.es10.js.map