@xache/langchain 0.3.0 → 0.5.0

package/dist/index.mjs

@@ -22,6 +22,9 @@ var XacheChatMessageHistory = class extends BaseListChatMessageHistory {
       apiUrl: config.apiUrl || "https://api.xache.xyz",
       did,
       privateKey: config.privateKey,
+      signer: config.signer,
+      walletProvider: config.walletProvider,
+      encryptionKey: config.encryptionKey,
       timeout: config.timeout,
       debug: config.debug
     });
@@ -216,7 +219,10 @@ var XacheRetriever = class extends BaseRetriever {
     this.client = new XacheClient2({
       apiUrl: config.apiUrl || "https://api.xache.xyz",
       did,
-      privateKey: config.privateKey
+      privateKey: config.privateKey,
+      signer: config.signer,
+      walletProvider: config.walletProvider,
+      encryptionKey: config.encryptionKey
     });
     this.k = config.k ?? 5;
     this.filterContext = config.context;
@@ -262,6 +268,9 @@ var XacheExtractor = class {
       apiUrl: config.apiUrl || "https://api.xache.xyz",
       did,
       privateKey: config.privateKey,
+      signer: config.signer,
+      walletProvider: config.walletProvider,
+      encryptionKey: config.encryptionKey,
       timeout: config.timeout,
       debug: config.debug
     });
@@ -350,7 +359,10 @@ function createClient(config) {
   return new XacheClient4({
     apiUrl: config.apiUrl || "https://api.xache.xyz",
     did,
-    privateKey: config.privateKey
+    privateKey: config.privateKey,
+    signer: config.signer,
+    walletProvider: config.walletProvider,
+    encryptionKey: config.encryptionKey
   });
 }
 function createCollectiveContributeTool(config) {
@@ -459,7 +471,10 @@ function createClient2(config) {
   return new XacheClient5({
     apiUrl: config.apiUrl || "https://api.xache.xyz",
     did,
-    privateKey: config.privateKey
+    privateKey: config.privateKey,
+    signer: config.signer,
+    walletProvider: config.walletProvider,
+    encryptionKey: config.encryptionKey
   });
 }
 function createReputationTool(config) {
@@ -541,18 +556,421 @@ var XacheReputationChecker = class {
     return result.score >= minScore;
   }
 };
+
+// src/graph.ts
+import { DynamicStructuredTool as DynamicStructuredTool3 } from "@langchain/core/tools";
+import { BaseRetriever as BaseRetriever2 } from "@langchain/core/retrievers";
+import { Document as Document2 } from "@langchain/core/documents";
+import { z as z3 } from "zod";
+import {
+  XacheClient as XacheClient6
+} from "@xache/sdk";
+function createClient3(config) {
+  const chainPrefix = config.chain === "solana" ? "sol" : "evm";
+  const did = `did:agent:${chainPrefix}:${config.walletAddress.toLowerCase()}`;
+  return new XacheClient6({
+    apiUrl: config.apiUrl || "https://api.xache.xyz",
+    did,
+    privateKey: config.privateKey,
+    signer: config.signer,
+    walletProvider: config.walletProvider,
+    encryptionKey: config.encryptionKey
+  });
+}
+function getSubject(config) {
+  return config.subject || { scope: "GLOBAL" };
+}
+function buildLLMConfig(config) {
+  if (config.llmEndpoint) {
+    return {
+      type: "endpoint",
+      url: config.llmEndpoint,
+      authToken: config.llmAuthToken,
+      format: config.llmFormat || "openai",
+      model: config.llmModel
+    };
+  } else if (config.llmApiKey && config.llmProvider) {
+    return {
+      type: "api-key",
+      provider: config.llmProvider,
+      apiKey: config.llmApiKey,
+      model: config.llmModel
+    };
+  } else {
+    return {
+      type: "xache-managed",
+      provider: "anthropic",
+      model: config.llmModel
+    };
+  }
+}
+function createGraphExtractTool(config) {
+  const client = createClient3(config);
+  const subject = getSubject(config);
+  return new DynamicStructuredTool3({
+    name: "xache_graph_extract",
+    description: "Extract entities and relationships from text into the knowledge graph. Identifies people, organizations, tools, concepts and their connections.",
+    schema: z3.object({
+      trace: z3.string().describe("The text/trace to extract entities from"),
+      contextHint: z3.string().optional().describe('Domain hint (e.g., "engineering", "customer-support")')
+    }),
+    func: async ({ trace, contextHint }) => {
+      const result = await client.graph.extract({
+        trace,
+        llmConfig: buildLLMConfig(config),
+        subject,
+        options: {
+          contextHint,
+          confidenceThreshold: 0.7
+        }
+      });
+      const entities = result.entities || [];
+      const relationships = result.relationships || [];
+      if (entities.length === 0 && relationships.length === 0) {
+        return "No entities or relationships extracted.";
+      }
+      let output = `Extracted ${entities.length} entities, ${relationships.length} relationships.
+`;
+      for (const e of entities) {
+        output += `  Entity: ${e.name} [${e.type}]${e.isNew ? " (new)" : ""}
+`;
+      }
+      for (const r of relationships) {
+        output += `  Rel: ${r.from} \u2192 ${r.type} \u2192 ${r.to}
+`;
+      }
+      return output;
+    }
+  });
+}
+function createGraphQueryTool(config) {
+  const client = createClient3(config);
+  const subject = getSubject(config);
+  return new DynamicStructuredTool3({
+    name: "xache_graph_query",
+    description: "Query the knowledge graph around a specific entity. Returns connected entities and relationships within the specified depth.",
+    schema: z3.object({
+      startEntity: z3.string().describe("Name of the entity to start from"),
+      depth: z3.number().optional().default(2).describe("Number of hops (default: 2)")
+    }),
+    func: async ({ startEntity, depth }) => {
+      const graph = await client.graph.query({
+        subject,
+        startEntity,
+        depth: depth || 2
+      });
+      const data = graph.toJSON();
+      if (data.entities.length === 0) {
+        return `No entities found connected to "${startEntity}".`;
+      }
+      let output = `Subgraph: ${data.entities.length} entities, ${data.relationships.length} relationships
+`;
+      for (const e of data.entities) {
+        output += `  ${e.name} [${e.type}]`;
+        if (e.summary) output += ` \u2014 ${e.summary.substring(0, 80)}`;
+        output += "\n";
+      }
+      return output;
+    }
+  });
+}
+function createGraphAskTool(config) {
+  const client = createClient3(config);
+  const subject = getSubject(config);
+  return new DynamicStructuredTool3({
+    name: "xache_graph_ask",
+    description: "Ask a natural language question about the knowledge graph. Uses LLM to analyze entities and relationships and provide an answer.",
+    schema: z3.object({
+      question: z3.string().describe("The question to ask about the knowledge graph")
+    }),
+    func: async ({ question }) => {
+      const answer = await client.graph.ask({
+        subject,
+        question,
+        llmConfig: buildLLMConfig(config)
+      });
+      let output = `Answer: ${answer.answer}
+Confidence: ${(answer.confidence * 100).toFixed(0)}%`;
+      if (answer.sources?.length > 0) {
+        output += "\nSources: " + answer.sources.map((s) => `${s.name} [${s.type}]`).join(", ");
+      }
+      return output;
+    }
+  });
+}
+function createGraphAddEntityTool(config) {
+  const client = createClient3(config);
+  const subject = getSubject(config);
+  return new DynamicStructuredTool3({
+    name: "xache_graph_add_entity",
+    description: "Add an entity to the knowledge graph. Creates a person, organization, tool, concept, or other entity type.",
+    schema: z3.object({
+      name: z3.string().describe("Entity name"),
+      type: z3.string().describe("Entity type (person, organization, tool, concept, etc.)"),
+      summary: z3.string().optional().describe("Brief description"),
+      attributes: z3.record(z3.string(), z3.unknown()).optional().describe("Key-value attributes")
+    }),
+    func: async ({ name, type, summary, attributes }) => {
+      const entity = await client.graph.addEntity({
+        subject,
+        name,
+        type,
+        summary,
+        attributes
+      });
+      return `Created entity "${entity.name}" [${entity.type}], key: ${entity.key}`;
+    }
+  });
+}
+function createGraphAddRelationshipTool(config) {
+  const client = createClient3(config);
+  const subject = getSubject(config);
+  return new DynamicStructuredTool3({
+    name: "xache_graph_add_relationship",
+    description: "Create a relationship between two entities in the knowledge graph.",
+    schema: z3.object({
+      from: z3.string().describe("Source entity name"),
+      to: z3.string().describe("Target entity name"),
+      type: z3.string().describe("Relationship type (works_at, knows, uses, manages, etc.)"),
+      description: z3.string().optional().describe("Relationship description")
+    }),
+    func: async ({ from, to, type, description }) => {
+      const rel = await client.graph.addRelationship({
+        subject,
+        from,
+        to,
+        type,
+        description
+      });
+      return `Created relationship: ${from} \u2192 ${rel.type} \u2192 ${to}`;
+    }
+  });
+}
+function createGraphLoadTool(config) {
+  const client = createClient3(config);
+  const subject = getSubject(config);
+  return new DynamicStructuredTool3({
+    name: "xache_graph_load",
+    description: "Load the full knowledge graph. Returns all entities and relationships. Optionally filter by entity type or load a historical snapshot.",
+    schema: z3.object({
+      entityTypes: z3.array(z3.string()).optional().describe("Filter to specific entity types"),
+      validAt: z3.string().optional().describe("Load graph as it existed at this time (ISO8601)")
+    }),
+    func: async ({ entityTypes, validAt }) => {
+      const graph = await client.graph.load({
+        subject,
+        entityTypes,
+        validAt
+      });
+      const data = graph.toJSON();
+      if (data.entities.length === 0) {
+        return "Knowledge graph is empty.";
+      }
+      let output = `Knowledge graph: ${data.entities.length} entities, ${data.relationships.length} relationships
+`;
+      for (const e of data.entities) {
+        output += `  ${e.name} [${e.type}]`;
+        if (e.summary) output += ` \u2014 ${e.summary.substring(0, 80)}`;
+        output += "\n";
+      }
+      return output;
+    }
+  });
+}
+function createGraphMergeEntitiesTool(config) {
+  const client = createClient3(config);
+  const subject = getSubject(config);
+  return new DynamicStructuredTool3({
+    name: "xache_graph_merge_entities",
+    description: "Merge two entities into one. The source entity is superseded and the target entity is updated with merged attributes. Relationships are transferred.",
+    schema: z3.object({
+      sourceName: z3.string().describe("Entity to merge FROM (will be superseded)"),
+      targetName: z3.string().describe("Entity to merge INTO (will be updated)")
+    }),
+    func: async ({ sourceName, targetName }) => {
+      const merged = await client.graph.mergeEntities({
+        subject,
+        sourceName,
+        targetName
+      });
+      return `Merged "${sourceName}" into "${targetName}". Result: ${merged.name} [${merged.type}] (v${merged.version})`;
+    }
+  });
+}
+function createGraphEntityHistoryTool(config) {
+  const client = createClient3(config);
+  const subject = getSubject(config);
+  return new DynamicStructuredTool3({
+    name: "xache_graph_entity_history",
+    description: "Get the full version history of an entity. Shows how the entity has changed over time.",
+    schema: z3.object({
+      name: z3.string().describe("Entity name to look up history for")
+    }),
+    func: async ({ name }) => {
+      const versions = await client.graph.getEntityHistory({
+        subject,
+        name
+      });
+      if (versions.length === 0) {
+        return `No history found for entity "${name}".`;
+      }
+      let output = `History for "${name}": ${versions.length} version(s)
+`;
+      for (const v of versions) {
+        output += `  v${v.version} \u2014 ${v.name} [${v.type}]`;
+        if (v.summary) output += ` | ${v.summary.substring(0, 80)}`;
+        output += `
+    Valid: ${v.validFrom}${v.validTo ? ` \u2192 ${v.validTo}` : " \u2192 current"}
+`;
+      }
+      return output;
+    }
+  });
+}
+var XacheGraphExtractTool = class {
+  constructor(config) {
+    this.tool = createGraphExtractTool(config);
+  }
+  asTool() {
+    return this.tool;
+  }
+};
+var XacheGraphQueryTool = class {
+  constructor(config) {
+    this.tool = createGraphQueryTool(config);
+  }
+  asTool() {
+    return this.tool;
+  }
+};
+var XacheGraphAskTool = class {
+  constructor(config) {
+    this.tool = createGraphAskTool(config);
+  }
+  asTool() {
+    return this.tool;
+  }
+};
+var XacheGraphLoadTool = class {
+  constructor(config) {
+    this.tool = createGraphLoadTool(config);
+  }
+  asTool() {
+    return this.tool;
+  }
+};
+var XacheGraphMergeEntitiesTool = class {
+  constructor(config) {
+    this.tool = createGraphMergeEntitiesTool(config);
+  }
+  asTool() {
+    return this.tool;
+  }
+};
+var XacheGraphEntityHistoryTool = class {
+  constructor(config) {
+    this.tool = createGraphEntityHistoryTool(config);
+  }
+  asTool() {
+    return this.tool;
+  }
+};
+var XacheGraphRetriever = class extends BaseRetriever2 {
+  constructor(config) {
+    super(config);
+    this.lc_namespace = ["xache", "graph_retriever"];
+    const chainPrefix = config.chain === "solana" ? "sol" : "evm";
+    const did = `did:agent:${chainPrefix}:${config.walletAddress.toLowerCase()}`;
+    this.client = new XacheClient6({
+      apiUrl: config.apiUrl || "https://api.xache.xyz",
+      did,
+      privateKey: config.privateKey,
+      signer: config.signer,
+      walletProvider: config.walletProvider,
+      encryptionKey: config.encryptionKey
+    });
+    this.subject = config.subject || { scope: "GLOBAL" };
+    this.startEntity = config.startEntity;
+    this.depth = config.depth ?? 2;
+    this.k = config.k ?? 10;
+  }
+  static lc_name() {
+    return "XacheGraphRetriever";
+  }
+  async _getRelevantDocuments(query, _runManager) {
+    let graph;
+    if (this.startEntity) {
+      graph = await this.client.graph.query({
+        subject: this.subject,
+        startEntity: this.startEntity,
+        depth: this.depth
+      });
+    } else {
+      graph = await this.client.graph.load({ subject: this.subject });
+    }
+    const data = graph.toJSON();
+    const queryLower = query.toLowerCase();
+    const scored = data.entities.map((entity) => {
+      let score = 0;
+      const nameLower = entity.name.toLowerCase();
+      const summaryLower = (entity.summary || "").toLowerCase();
+      if (nameLower.includes(queryLower)) score += 3;
+      if (summaryLower.includes(queryLower)) score += 2;
+      const terms = queryLower.split(/\s+/);
+      for (const term of terms) {
+        if (nameLower.includes(term)) score += 1;
+        if (summaryLower.includes(term)) score += 0.5;
+      }
+      return { entity, score };
+    });
+    scored.sort((a, b) => b.score - a.score);
+    const topEntities = scored.slice(0, this.k);
+    return topEntities.map(({ entity }) => {
+      const content = [
+        `Name: ${entity.name}`,
+        `Type: ${entity.type}`,
+        entity.summary ? `Summary: ${entity.summary}` : null
+      ].filter(Boolean).join("\n");
+      return new Document2({
+        pageContent: content,
+        metadata: {
+          source: "xache-graph",
+          entityKey: entity.key,
+          entityName: entity.name,
+          entityType: entity.type,
+          storageKey: entity.storageKey
+        }
+      });
+    });
+  }
+};
 export {
   XacheChatMessageHistory,
   XacheCollectiveContributeTool,
   XacheCollectiveQueryTool,
   XacheConversationBufferMemory,
   XacheExtractor,
+  XacheGraphAskTool,
+  XacheGraphEntityHistoryTool,
+  XacheGraphExtractTool,
+  XacheGraphLoadTool,
+  XacheGraphMergeEntitiesTool,
+  XacheGraphQueryTool,
+  XacheGraphRetriever,
   XacheMemory,
   XacheReputationChecker,
   XacheReputationTool,
   XacheRetriever,
   createCollectiveContributeTool,
   createCollectiveQueryTool,
+  createGraphAddEntityTool,
+  createGraphAddRelationshipTool,
+  createGraphAskTool,
+  createGraphEntityHistoryTool,
+  createGraphExtractTool,
+  createGraphLoadTool,
+  createGraphMergeEntitiesTool,
+  createGraphQueryTool,
   createReputationTool
 };
 //# sourceMappingURL=index.mjs.map