@hashgraphonline/conversational-agent 0.1.209 → 0.1.210

package/src/services/EntityResolver.ts

@@ -0,0 +1,135 @@
+import { ChatOpenAI } from '@langchain/openai';
+import type { EntityAssociation } from '../memory/SmartMemoryManager';
+
+export interface EntityResolverConfig {
+  apiKey: string;
+  modelName?: string;
+}
+
+/**
+ * LLM-based entity resolver that replaces brittle regex patterns
+ */
+export class EntityResolver {
+  private llm: ChatOpenAI;
+
+  constructor(config: EntityResolverConfig) {
+    this.llm = new ChatOpenAI({
+      apiKey: config.apiKey,
+      modelName: config.modelName || 'gpt-4o-mini',
+      temperature: 0,
+    });
+  }
+
+  /**
+   * Resolve entity references using LLM instead of regex
+   */
+  async resolveReferences(
+    message: string,
+    entities: EntityAssociation[]
+  ): Promise<string> {
+    if (!entities || entities.length === 0) {
+      return message;
+    }
+
+    // Group by type for context
+    const byType = entities.reduce((acc, e) => {
+      if (!acc[e.entityType]) acc[e.entityType] = [];
+      acc[e.entityType].push(e);
+      return acc;
+    }, {} as Record<string, EntityAssociation[]>);
+
+    let context = 'Available entities in memory:\n';
+    for (const [type, list] of Object.entries(byType)) {
+      const recent = list[0];
+      context += `Most recent ${type}: "${recent.entityName}" = ${recent.entityId}\n`;
+      if (list.length > 1) {
+        context += `  (${list.length - 1} other ${type}s in memory)\n`;
+      }
+    }
+
+    const prompt = `Task: Replace entity references with their IDs from memory.
+
+${context}
+
+User message: "${message}"
+
+Instructions:
+- If the user says "the topic" or "that topic" → replace with the most recent topic ID
+- If the user says "the token" or "that token" → replace with the most recent token ID  
+- If the user says "it" or "that" after an action verb → replace with the most recent entity ID
+- Examples:
+  * "submit on the topic" → "submit on 0.0.6543472"
+  * "airdrop the token" → "airdrop 0.0.123456"
+  * "send a message to it" → "send a message to 0.0.6543472"
+
+Return ONLY the message with replacements made. Do not add any explanations.
+Resolved message:`;
+
+    try {
+      const response = await this.llm.invoke(prompt);
+      const resolved = (response.content as string).trim();
+
+      if (resolved !== message && resolved.includes('0.0.')) {
+        console.log(`[EntityResolver] Resolved: "${message}" → "${resolved}"`);
+        return resolved;
+      }
+
+      return message;
+    } catch (error) {
+      console.error('[EntityResolver] Failed:', error);
+      return message;
+    }
+  }
+
+  /**
+   * Extract entities from agent response using LLM
+   */
+  async extractEntities(
+    response: unknown,
+    userMessage: string
+  ): Promise<
+    Array<{ id: string; name: string; type: string; transactionId?: string }>
+  > {
+    const text =
+      typeof response === 'string' ? response : JSON.stringify(response);
+
+    const prompt = `Analyze this agent response and extract ONLY newly created entities.
+
+User asked: "${userMessage.substring(0, 200)}"
+
+Agent response: ${text.substring(0, 3000)}
+
+Look for:
+1. Success messages with entity IDs (e.g., "Successfully created topic 0.0.6543472")
+2. Transaction confirmations that created new entities
+3. Entity IDs that appear after words like "created", "new", "successfully"
+
+DO NOT include:
+- Account IDs that already existed (like sender/receiver accounts)
+- Entity IDs that were parameters to the operation
+- Failed operations
+
+Return a JSON array of newly created entities:
+[{"id": "0.0.XXX", "name": "descriptive_name", "type": "topic|token|account"}]
+
+If no entities were created, return: []
+
+JSON:`;
+
+    try {
+      const response = await this.llm.invoke(prompt);
+      const content = response.content as string;
+      const match = content.match(/\[[\s\S]*?\]/);
+      if (match) {
+        const entities = JSON.parse(match[0]);
+        if (entities.length > 0) {
+          console.log('[EntityResolver] Extracted entities:', entities);
+        }
+        return entities;
+      }
+    } catch (error) {
+      console.error('[EntityResolver] Extract failed:', error);
+    }
+    return [];
+  }
+}

package/src/tools/EntityResolverTool.ts

@@ -0,0 +1,170 @@
+import { StructuredTool } from '@langchain/core/tools';
+import { z } from 'zod';
+import { ChatOpenAI } from '@langchain/openai';
+import type { EntityAssociation } from '../memory/SmartMemoryManager';
+
+const ResolveEntitiesSchema = z.object({
+  message: z.string().describe('The message containing entity references to resolve'),
+  entities: z.array(z.object({
+    entityId: z.string(),
+    entityName: z.string(),
+    entityType: z.string(),
+  })).describe('Available entities in memory'),
+});
+
+const ExtractEntitiesSchema = z.object({
+  response: z.string().describe('Agent response text to extract entities from'),
+  userMessage: z.string().describe('Original user message for context'),
+});
+
+export class ResolveEntitiesTool extends StructuredTool {
+  name = 'resolve_entities';
+  description = 'Resolves entity references like "the topic", "it", "that" to actual entity IDs';
+  schema = ResolveEntitiesSchema;
+  
+  private llm: ChatOpenAI;
+  
+  constructor(apiKey: string, modelName = 'gpt-4o-mini') {
+    super();
+    this.llm = new ChatOpenAI({
+      apiKey,
+      modelName,
+      temperature: 0,
+    });
+  }
+  
+  async _call(input: z.infer<typeof ResolveEntitiesSchema>): Promise<string> {
+    const { message, entities } = input;
+    
+    if (!entities || entities.length === 0) {
+      return message;
+    }
+    
+    const byType = this.groupEntitiesByType(entities);
+    const context = this.buildEntityContext(byType);
+    
+    const prompt = `Task: Replace entity references with IDs.
+
+${context}
+
+Message: "${message}"
+
+Rules:
+- "the topic" or "that topic" → replace with most recent topic ID
+- "the token" or "that token" → replace with most recent token ID
+- "it" or "that" after action verb → replace with most recent entity ID
+- "airdrop X" without token ID → add most recent token ID as first parameter
+- Token operations without explicit token → use most recent token ID
+
+Examples:
+- "submit on the topic" → "submit on 0.0.6543472"
+- "airdrop the token" → "airdrop 0.0.123456"
+- "airdrop 10 to 0.0.5842697" → "airdrop 0.0.123456 10 to 0.0.5842697"
+- "mint 100" → "mint 0.0.123456 100"
+
+Return ONLY the resolved message:`;
+    
+    try {
+      const response = await this.llm.invoke(prompt);
+      return (response.content as string).trim();
+    } catch (error) {
+      console.error('[ResolveEntitiesTool] Failed:', error);
+      return message;
+    }
+  }
+  
+  private groupEntitiesByType(entities: EntityGroup): GroupedEntities {
+    return entities.reduce((acc, entity) => {
+      if (!acc[entity.entityType]) {
+        acc[entity.entityType] = [];
+      }
+      acc[entity.entityType].push(entity);
+      return acc;
+    }, {} as GroupedEntities);
+  }
+  
+  private buildEntityContext(groupedEntities: GroupedEntities): string {
+    let context = 'Available entities:\n';
+    for (const [type, list] of Object.entries(groupedEntities)) {
+      const recent = list[0];
+      context += `- Most recent ${type}: "${recent.entityName}" = ${recent.entityId}\n`;
+    }
+    return context;
+  }
+}
+
+export class ExtractEntitiesTool extends StructuredTool {
+  name = 'extract_entities';
+  description = 'Extracts newly created entities from agent responses';
+  schema = ExtractEntitiesSchema;
+  
+  private llm: ChatOpenAI;
+  
+  constructor(apiKey: string, modelName = 'gpt-4o-mini') {
+    super();
+    this.llm = new ChatOpenAI({
+      apiKey,
+      modelName,
+      temperature: 0,
+    });
+  }
+  
+  async _call(input: z.infer<typeof ExtractEntitiesSchema>): Promise<string> {
+    const { response, userMessage } = input;
+    
+    const prompt = `Extract ONLY newly created entities from this response.
+
+User asked: "${userMessage.substring(0, 200)}"
+Response: ${response.substring(0, 3000)}
+
+Look for:
+- Success messages with new entity IDs
+- Words like "created", "new", "successfully" followed by entity IDs
+
+Return JSON array of created entities:
+[{"id": "0.0.XXX", "name": "name", "type": "topic|token|account"}]
+
+If none created, return: []
+
+JSON:`;
+    
+    try {
+      const llmResponse = await this.llm.invoke(prompt);
+      const content = llmResponse.content as string;
+      const match = content.match(/\[[\s\S]*?\]/);
+      if (match) {
+        return match[0];
+      }
+      return '[]';
+    } catch (error) {
+      console.error('[ExtractEntitiesTool] Failed:', error);
+      return '[]';
+    }
+  }
+}
+
+export function createEntityTools(apiKey: string, modelName = 'gpt-4o-mini'): {
+  resolveEntities: ResolveEntitiesTool;
+  extractEntities: ExtractEntitiesTool;
+} {
+  return {
+    resolveEntities: new ResolveEntitiesTool(apiKey, modelName),
+    extractEntities: new ExtractEntitiesTool(apiKey, modelName),
+  };
+}
+
+interface EntityReference {
+  entityId: string;
+  entityName: string;
+  entityType: string;
+}
+
+type EntityGroup = EntityReference[];
+
+type GroupedEntities = Record<string, EntityGroup>;
+
+interface ExtractedEntity {
+  id: string;
+  name: string;
+  type: string;
+}

package/src/types/inscription.ts

@@ -0,0 +1,40 @@
+/**
+ * Inscription quote response from standards-agent-kit
+ */
+export interface InscriptionQuote {
+  totalCostHbar: string;
+  validUntil: string;
+  breakdown: {
+    transfers: Array<{
+      type: string;
+      amount: string;
+      description: string;
+    }>;
+  };
+}
+
+/**
+ * Parameters for inscription tool calls with quote support
+ */
+export interface InscriptionToolParams {
+  [key: string]: unknown;
+  quoteOnly?: boolean;
+}
+
+/**
+ * Result from inscription tool execution
+ */
+export interface InscriptionResult {
+  success: boolean;
+  transactionId?: string;
+  message: string;
+  quote?: InscriptionQuote;
+}
+
+/**
+ * User confirmation status for inscription
+ */
+export interface InscriptionConfirmation {
+  confirmed: boolean;
+  reason?: string;
+}

package/dist/cjs/plugins/hbar-transfer/index.d.ts

@@ -1 +0,0 @@
-export { HbarTransferPlugin } from './HbarTransferPlugin';

package/dist/types/plugins/hbar-transfer/index.d.ts

@@ -1 +0,0 @@
-export { HbarTransferPlugin } from './HbarTransferPlugin';

package/src/plugins/hbar-transfer/HbarTransferPlugin.ts

@@ -1,66 +0,0 @@
-import {
-  GenericPluginContext,
-  HederaTool,
-  BasePlugin,
-  HederaAgentKit,
-} from 'hedera-agent-kit';
-import { TransferHbarTool } from './TransferHbarTool';
-
-export class HbarTransferPlugin extends BasePlugin {
-  id = 'hbar-transfer';
-  name = 'HBAR Transfer Plugin';
-  description =
-    'HBAR transfer tool with proper decimal handling for multi-signature transactions';
-  version = '1.0.0';
-  author = 'Hashgraph Online';
-  namespace = 'account';
-
-  private tools: HederaTool[] = [];
-
-  override async initialize(context: GenericPluginContext): Promise<void> {
-    await super.initialize(context);
-
-    const hederaKit = context.config.hederaKit as HederaAgentKit;
-    if (!hederaKit) {
-      this.context.logger.warn(
-        'HederaKit not found in context. HBAR transfer tools will not be available.'
-      );
-      return;
-    }
-
-    try {
-      this.initializeTools();
-
-      this.context.logger.info(
-        'HBAR Transfer Plugin initialized successfully'
-      );
-    } catch (error) {
-      this.context.logger.error(
-        'Failed to initialize HBAR Transfer plugin:',
-        error
-      );
-    }
-  }
-
-  private initializeTools(): void {
-    const hederaKit = this.context.config.hederaKit as HederaAgentKit;
-    if (!hederaKit) {
-      throw new Error('HederaKit not found in context config');
-    }
-
-    this.tools = [
-      new TransferHbarTool({
-        hederaKit: hederaKit,
-        logger: this.context.logger,
-      }),
-    ];
-  }
-
-  override getTools(): HederaTool[] {
-    return this.tools;
-  }
-
-  async shutdown(): Promise<void> {
-    this.tools = [];
-  }
-}

package/src/plugins/hbar-transfer/index.ts

@@ -1 +0,0 @@
-export { HbarTransferPlugin } from './HbarTransferPlugin';