@hashgraphonline/conversational-agent 0.2.106 → 0.2.107

package/src/conversational-agent.ts

@@ -16,7 +16,7 @@ import { HCS10Plugin } from './plugins/hcs-10/HCS10Plugin';
 import { HCS2Plugin } from './plugins/hcs-2/HCS2Plugin';
 import { InscribePlugin } from './plugins/inscribe/InscribePlugin';
 import { getWalletBridgeProvider } from './runtime/wallet-bridge';
-import { InscriberBuilder } from '@hashgraphonline/standards-agent-kit';
+import { InscriberBuilder, SignerProviderRegistry } from '@hashgraphonline/standards-agent-kit';
 import { HbarPlugin } from './plugins/hbar/HbarPlugin';
 import { OpenConvaiState } from '@hashgraphonline/standards-agent-kit';
 import type { IStateManager } from '@hashgraphonline/standards-agent-kit';
@@ -225,7 +225,6 @@ export class ConversationalAgent {
       const bytesMode = opMode !== 'autonomous';
       let signer: AbstractSigner;
 
-      // Enforce wallet-only execution in Provide Bytes mode (no server fallback)
       try {
         type InscriberBuilderAug = typeof InscriberBuilder & {
           setPreferWalletOnly?: (prefer: boolean) => void;
@@ -233,9 +232,27 @@ export class ConversationalAgent {
           setWalletExecutor?: (fn: (base64: string, network: 'mainnet' | 'testnet') => Promise<{ transactionId: string }>) => void;
           setStartInscriptionDelegate?: (fn: (request: Record<string, unknown>, network: 'mainnet' | 'testnet') => Promise<unknown>) => void;
         };
-        const IB = InscriberBuilder as InscriberBuilderAug;
+        type InscriberBuilderAug3 = typeof InscriberBuilder & {
+          setPreferWalletOnly?: (prefer: boolean) => void;
+          setWalletInfoResolver?: (
+            fn: () => Promise<{ accountId: string; network: string } | null>
+          ) => void;
+          setWalletExecutor?: (
+            fn: (
+              base64: string,
+              network: 'mainnet' | 'testnet'
+            ) => Promise<{ transactionId: string }>
+          ) => void;
+          setStartInscriptionDelegate?: (
+            fn: (
+              request: Record<string, unknown>,
+              network: 'mainnet' | 'testnet'
+            ) => Promise<unknown>
+          ) => void;
+        };
+        const IB = InscriberBuilder as InscriberBuilderAug3;
         if (typeof IB.setPreferWalletOnly === 'function') {
-          IB.setPreferWalletOnly(bytesMode);
+          IB.setPreferWalletOnly(false);
         }
       } catch (e) {
         this.logger.warn('Failed to set wallet-only preference', e as Error);
@@ -254,11 +271,9 @@ export class ConversationalAgent {
         signerClass: Object.getPrototypeOf(signer)?.constructor?.name || 'unknown',
       });
 
-      // Register wallet bridge providers for standards-agent-kit builders (wallet-first, DRY)
       try {
         const bridge = getWalletBridgeProvider();
         if (bridge) {
-          // Provide wallet status and execution for builders that support delegates
           type InscriberBuilderAug2 = typeof InscriberBuilder & {
             setWalletInfoResolver?: (fn: () => Promise<{ accountId: string; network: string } | null>) => void;
             setWalletExecutor?: (fn: (base64: string, network: 'mainnet' | 'testnet') => Promise<{ transactionId: string }>) => void;
@@ -285,28 +300,66 @@ export class ConversationalAgent {
             });
           }
 
-          // Also wire wallet info/executor into the SAK SignerProviderRegistry for HCS builders (if available)
           try {
-            const sak = await import('@hashgraphonline/standards-agent-kit');
-            const reg: any = (sak as any)?.SignerProviderRegistry;
-            if (reg) {
-              reg.setWalletInfoResolver(async () => {
-                const status = await bridge.status();
-                if (status.connected && status.accountId && status.network) {
-                  return { accountId: status.accountId, network: status.network as 'mainnet' | 'testnet' };
-                }
-                return null;
-              });
-              reg.setWalletExecutor(async (base64: string, network: 'mainnet' | 'testnet') => {
-                return await bridge.executeBytes(base64, network);
-              });
-              if (typeof (bridge as any).startHCS === 'function') {
-                reg.setStartHCSDelegate(async (op: any, request: Record<string, unknown>, network: 'mainnet' | 'testnet') => {
-                  return await (bridge as any).startHCS(op, request, network);
-                });
+            type HCSOp =
+              | 'submitConnectionRequest'
+              | 'handleConnectionRequest'
+              | 'sendMessage'
+              | 'hcs2.createRegistry'
+              | 'hcs2.migrateRegistry'
+              | 'hcs2.registerEntry'
+              | 'hcs2.updateEntry'
+              | 'hcs2.deleteEntry'
+              | 'hcs2.submitMessage'
+              | 'hcs6.createRegistry'
+              | 'hcs6.registerEntry'
+              | 'hcs6.submitMessage';
+            type WalletBridgeProviderExt = ReturnType<typeof getWalletBridgeProvider> & {
+              startHCS?: (
+                op: HCSOp,
+                request: Record<string, unknown>,
+                network: 'mainnet' | 'testnet'
+              ) => Promise<{ transactionBytes: string }>
+            };
+
+            const status = await bridge.status();
+            const enforceWallet = !!(bytesMode && status.connected);
+
+            SignerProviderRegistry.setWalletInfoResolver(async () => {
+              const s = await bridge.status();
+              if (s.connected && s.accountId && s.network) {
+                return {
+                  accountId: s.accountId,
+                  network: s.network as 'mainnet' | 'testnet',
+                };
               }
-              // In bytes modes, always require wallet execution (no server fallback)
-              reg.setPreferWalletOnly(!!bytesMode);
+              return null;
+            });
+
+            SignerProviderRegistry.setWalletExecutor(async (
+              base64: string,
+              network: 'mainnet' | 'testnet'
+            ) => {
+              return await bridge.executeBytes(base64, network);
+            });
+
+            const extended = bridge as WalletBridgeProviderExt;
+            if (typeof extended?.startHCS === 'function') {
+              SignerProviderRegistry.setStartHCSDelegate(async (op, request, network) => {
+                return await extended.startHCS!(op as HCSOp, request, network);
+              });
+            } else {
+              SignerProviderRegistry.setStartHCSDelegate(null);
+            }
+
+            SignerProviderRegistry.setPreferWalletOnly(enforceWallet);
+
+            type InscriberBuilderAug3 = typeof InscriberBuilder & {
+              setPreferWalletOnly?: (prefer: boolean) => void;
+            };
+            const IB2 = InscriberBuilder as InscriberBuilderAug3;
+            if (typeof IB2.setPreferWalletOnly === 'function') {
+              IB2.setPreferWalletOnly(enforceWallet);
             }
           } catch (sakWireErr) {
             this.logger.warn('Failed to wire SAK SignerProviderRegistry wallet delegates', sakWireErr as Error);

package/src/core/tool-registry.ts

@@ -201,7 +201,6 @@ export class ToolRegistry {
 
     this.tools.set(tool.name, entry);
 
-    // Forward optional field guidance metadata/provider to registry
     try {
       const metaFG = metadata.fieldGuidance as FG_ToolFieldConfiguration | undefined;
       if (metaFG) {

package/src/forms/field-guidance-registry.ts

@@ -185,7 +185,6 @@ class FieldGuidanceRegistry {
         return merged;
       }
     }
-    // No static guidance matched; try provider-only (apply from highest to lowest)
     const providers = this.pickMatchingProviders(toolName);
     if (providers.length > 0) {
       let merged: FieldGuidance = {};
@@ -234,7 +233,6 @@ class FieldGuidanceRegistry {
         return result;
       }
     }
-    // No static matched → provider-only
     const providers = this.pickMatchingProviders(toolName);
     if (providers.length > 0) {
       let mergedWarnings: string[] | undefined;

package/src/memory/smart-memory-manager.ts

@@ -702,7 +702,6 @@ export class SmartMemoryManager {
         }
       }
 
-      // Merge duplicates by entityId, preferring the newest and one that carries transactionId
       const mergedById = new Map<string, EntityAssociation>();
       const getTime = (d: Date | string): number =>
         d instanceof Date ? d.getTime() : new Date(d).getTime();

package/src/plugins/hcs-10/HCS10Plugin.ts

@@ -157,8 +157,6 @@ export class HCS10Plugin extends BasePlugin {
         }
       }
 
-      // Always initialize HCS-10 tools, even in bytes mode. Some operations may execute directly
-      // when returnBytes/provideBytes is active; that is acceptable and preferred over disabling.
       this.initializeTools();
       this.context.logger.info('HCS-10 Plugin initialized successfully');
     } catch (error) {

package/src/plugins/hcs-2/HCS2Plugin.ts

@@ -40,8 +40,6 @@ export class HCS2Plugin extends BasePlugin {
     }
 
     try {
-      // Always initialize HCS-2 tools, even in bytes mode. Some tools may execute directly when
-      // returnBytes/provideBytes is active, which is acceptable.
       this.initializeTools();
 
       this.context.logger.info(

package/src/plugins/inscribe/InscribePlugin.ts

@@ -43,7 +43,6 @@ export class InscribePlugin extends BasePlugin {
     try {
       this.initializeTools();
 
-      // Register field guidance provider for inscribe hashinal tools
       try {
         const provider = {
           getFieldGuidance: (fieldName: string): FieldGuidance | null => {

package/src/runtime/wallet-bridge.ts

@@ -28,6 +28,11 @@ export interface WalletBridgeProvider {
     request: Record<string, unknown>,
     network: WalletNetwork
   ) => Promise<StartInscriptionResult>;
+  startHCS?: (
+    op: string,
+    request: Record<string, unknown>,
+    network: WalletNetwork
+  ) => Promise<{ transactionBytes: string }>;
 }
 
 let providerRef: WalletBridgeProvider | null = null;

package/src/signers/browser-signer.ts

@@ -102,7 +102,6 @@ export class BrowserSigner extends AbstractSigner {
       network,
       new Logger({ module: 'BrowserSigner' })
     );
-    // Avoid cross-package PublicKey type incompatibility by reconstructing from string
     const anyKey: any = await mirror.getPublicKey(this.account.toString());
     const keyStr = typeof anyKey?.toString === 'function' ? anyKey.toString() : String(anyKey);
     return PublicKey.fromString(keyStr);