@xache/langchain 0.5.0 → 0.7.0

package/dist/index.js

@@ -24,6 +24,11 @@ __export(index_exports, {
   XacheCollectiveContributeTool: () => XacheCollectiveContributeTool,
   XacheCollectiveQueryTool: () => XacheCollectiveQueryTool,
   XacheConversationBufferMemory: () => XacheConversationBufferMemory,
+  XacheEphemeralCreateSessionTool: () => XacheEphemeralCreateSessionTool,
+  XacheEphemeralPromoteTool: () => XacheEphemeralPromoteTool,
+  XacheEphemeralReadSlotTool: () => XacheEphemeralReadSlotTool,
+  XacheEphemeralStatusTool: () => XacheEphemeralStatusTool,
+  XacheEphemeralWriteSlotTool: () => XacheEphemeralWriteSlotTool,
   XacheExtractor: () => XacheExtractor,
   XacheGraphAskTool: () => XacheGraphAskTool,
   XacheGraphEntityHistoryTool: () => XacheGraphEntityHistoryTool,
@@ -33,11 +38,17 @@ __export(index_exports, {
   XacheGraphQueryTool: () => XacheGraphQueryTool,
   XacheGraphRetriever: () => XacheGraphRetriever,
   XacheMemory: () => XacheMemory,
+  XacheMemoryProbeTool: () => XacheMemoryProbeTool,
   XacheReputationChecker: () => XacheReputationChecker,
   XacheReputationTool: () => XacheReputationTool,
   XacheRetriever: () => XacheRetriever,
   createCollectiveContributeTool: () => createCollectiveContributeTool,
   createCollectiveQueryTool: () => createCollectiveQueryTool,
+  createEphemeralCreateSessionTool: () => createEphemeralCreateSessionTool,
+  createEphemeralPromoteTool: () => createEphemeralPromoteTool,
+  createEphemeralReadSlotTool: () => createEphemeralReadSlotTool,
+  createEphemeralStatusTool: () => createEphemeralStatusTool,
+  createEphemeralWriteSlotTool: () => createEphemeralWriteSlotTool,
   createGraphAddEntityTool: () => createGraphAddEntityTool,
   createGraphAddRelationshipTool: () => createGraphAddRelationshipTool,
   createGraphAskTool: () => createGraphAskTool,
@@ -46,6 +57,7 @@ __export(index_exports, {
   createGraphLoadTool: () => createGraphLoadTool,
   createGraphMergeEntitiesTool: () => createGraphMergeEntitiesTool,
   createGraphQueryTool: () => createGraphQueryTool,
+  createMemoryProbeTool: () => createMemoryProbeTool,
   createReputationTool: () => createReputationTool
 });
 module.exports = __toCommonJS(index_exports);
@@ -990,12 +1002,254 @@ var XacheGraphRetriever = class extends import_retrievers2.BaseRetriever {
     });
   }
 };
+
+// src/probe.ts
+var import_tools4 = require("@langchain/core/tools");
+var import_zod4 = require("zod");
+var import_sdk7 = require("@xache/sdk");
+function createClient4(config) {
+  const chainPrefix = config.chain === "solana" ? "sol" : "evm";
+  const did = `did:agent:${chainPrefix}:${config.walletAddress.toLowerCase()}`;
+  return new import_sdk7.XacheClient({
+    apiUrl: config.apiUrl || "https://api.xache.xyz",
+    did,
+    privateKey: config.privateKey,
+    signer: config.signer,
+    walletProvider: config.walletProvider,
+    encryptionKey: config.encryptionKey
+  });
+}
+var COGNITIVE_CATEGORIES = [
+  "preference",
+  "fact",
+  "event",
+  "procedure",
+  "relationship",
+  "observation",
+  "decision",
+  "goal",
+  "constraint",
+  "reference",
+  "summary",
+  "handoff",
+  "pattern",
+  "feedback",
+  "unknown"
+];
+function createMemoryProbeTool(config) {
+  const client = createClient4(config);
+  return new import_tools4.DynamicStructuredTool({
+    name: "xache_memory_probe",
+    description: "Search your memories by topic using zero-knowledge semantic matching. Use this when you want to check what you already know about a topic without knowing exact storage keys. Returns matching memories with decrypted data.",
+    schema: import_zod4.z.object({
+      query: import_zod4.z.string().describe("What to search for in your memories"),
+      category: import_zod4.z.enum(COGNITIVE_CATEGORIES).optional().describe("Filter by cognitive category"),
+      limit: import_zod4.z.number().optional().default(10).describe("Maximum number of results (1-50)")
+    }),
+    func: async ({ query, category, limit }) => {
+      const result = await client.memory.probe({
+        query,
+        category,
+        limit: limit || 10
+      });
+      const matches = result.matches || [];
+      if (matches.length === 0) {
+        return "No matching memories found for this query.";
+      }
+      let output = `Found ${matches.length} matching memories (total: ${result.total}):
+`;
+      matches.forEach((match, i) => {
+        const data = typeof match.data === "string" ? match.data.slice(0, 300) : JSON.stringify(match.data).slice(0, 300);
+        output += `
+${i + 1}. [${match.category}] ${data}`;
+        output += ` (key: ${match.storageKey})`;
+      });
+      return output;
+    }
+  });
+}
+var XacheMemoryProbeTool = class {
+  constructor(config) {
+    this.tool = createMemoryProbeTool(config);
+  }
+  asTool() {
+    return this.tool;
+  }
+};
+
+// src/ephemeral.ts
+var import_tools5 = require("@langchain/core/tools");
+var import_zod5 = require("zod");
+var import_sdk8 = require("@xache/sdk");
+function createClient5(config) {
+  const chainPrefix = config.chain === "solana" ? "sol" : "evm";
+  const did = `did:agent:${chainPrefix}:${config.walletAddress.toLowerCase()}`;
+  return new import_sdk8.XacheClient({
+    apiUrl: config.apiUrl || "https://api.xache.xyz",
+    did,
+    privateKey: config.privateKey,
+    signer: config.signer,
+    walletProvider: config.walletProvider,
+    encryptionKey: config.encryptionKey
+  });
+}
+function createEphemeralCreateSessionTool(config) {
+  const client = createClient5(config);
+  return new import_tools5.DynamicStructuredTool({
+    name: "xache_ephemeral_create_session",
+    description: "Create a new ephemeral working memory session. Returns a session key for storing temporary data in slots.",
+    schema: import_zod5.z.object({
+      ttlSeconds: import_zod5.z.number().optional().describe("Session time-to-live in seconds (default: 3600)"),
+      maxWindows: import_zod5.z.number().optional().describe("Maximum renewal windows (default: 5)")
+    }),
+    func: async ({ ttlSeconds, maxWindows }) => {
+      const session = await client.ephemeral.createSession({
+        ttlSeconds,
+        maxWindows
+      });
+      return [
+        `Created ephemeral session.`,
+        `Session Key: ${session.sessionKey}`,
+        `Status: ${session.status}`,
+        `TTL: ${session.ttlSeconds}s`,
+        `Expires: ${session.expiresAt}`
+      ].join("\n");
+    }
+  });
+}
+function createEphemeralWriteSlotTool(config) {
+  const client = createClient5(config);
+  return new import_tools5.DynamicStructuredTool({
+    name: "xache_ephemeral_write_slot",
+    description: "Write data to an ephemeral session slot. Slots: conversation, facts, tasks, cache, scratch, handoff.",
+    schema: import_zod5.z.object({
+      sessionKey: import_zod5.z.string().describe("The ephemeral session key"),
+      slot: import_zod5.z.enum(["conversation", "facts", "tasks", "cache", "scratch", "handoff"]).describe("Slot name"),
+      data: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.unknown()).describe("Data to write to the slot")
+    }),
+    func: async ({ sessionKey, slot, data }) => {
+      await client.ephemeral.writeSlot(sessionKey, slot, data);
+      return `Wrote data to slot "${slot}" in session ${sessionKey.substring(0, 12)}...`;
+    }
+  });
+}
+function createEphemeralReadSlotTool(config) {
+  const client = createClient5(config);
+  return new import_tools5.DynamicStructuredTool({
+    name: "xache_ephemeral_read_slot",
+    description: "Read data from an ephemeral session slot. Slots: conversation, facts, tasks, cache, scratch, handoff.",
+    schema: import_zod5.z.object({
+      sessionKey: import_zod5.z.string().describe("The ephemeral session key"),
+      slot: import_zod5.z.enum(["conversation", "facts", "tasks", "cache", "scratch", "handoff"]).describe("Slot name")
+    }),
+    func: async ({ sessionKey, slot }) => {
+      const data = await client.ephemeral.readSlot(sessionKey, slot);
+      return JSON.stringify(data, null, 2);
+    }
+  });
+}
+function createEphemeralPromoteTool(config) {
+  const client = createClient5(config);
+  return new import_tools5.DynamicStructuredTool({
+    name: "xache_ephemeral_promote",
+    description: "Promote an ephemeral session to persistent memory. Extracts valuable data from slots and stores as permanent memories.",
+    schema: import_zod5.z.object({
+      sessionKey: import_zod5.z.string().describe("The ephemeral session key to promote")
+    }),
+    func: async ({ sessionKey }) => {
+      const result = await client.ephemeral.promoteSession(sessionKey);
+      let output = `Promoted session ${sessionKey.substring(0, 12)}...
+`;
+      output += `Memories created: ${result.memoriesCreated}
+`;
+      if (result.memoryIds.length > 0) {
+        output += `Memory IDs: ${result.memoryIds.join(", ")}
+`;
+      }
+      if (result.receiptId) {
+        output += `Receipt: ${result.receiptId}`;
+      }
+      return output;
+    }
+  });
+}
+function createEphemeralStatusTool(config) {
+  const client = createClient5(config);
+  return new import_tools5.DynamicStructuredTool({
+    name: "xache_ephemeral_status",
+    description: "Get the status and details of an ephemeral session. Shows active slots, size, TTL, and window information.",
+    schema: import_zod5.z.object({
+      sessionKey: import_zod5.z.string().describe("The ephemeral session key")
+    }),
+    func: async ({ sessionKey }) => {
+      const session = await client.ephemeral.getSession(sessionKey);
+      if (!session) {
+        return `Session ${sessionKey.substring(0, 12)}... not found.`;
+      }
+      return [
+        `Session: ${session.sessionKey.substring(0, 12)}...`,
+        `Status: ${session.status}`,
+        `Window: ${session.window}/${session.maxWindows}`,
+        `TTL: ${session.ttlSeconds}s`,
+        `Expires: ${session.expiresAt}`,
+        `Active Slots: ${session.activeSlots.length > 0 ? session.activeSlots.join(", ") : "none"}`,
+        `Total Size: ${session.totalSize} bytes`,
+        `Cumulative Cost: $${session.cumulativeCost.toFixed(4)}`
+      ].join("\n");
+    }
+  });
+}
+var XacheEphemeralCreateSessionTool = class {
+  constructor(config) {
+    this.tool = createEphemeralCreateSessionTool(config);
+  }
+  asTool() {
+    return this.tool;
+  }
+};
+var XacheEphemeralWriteSlotTool = class {
+  constructor(config) {
+    this.tool = createEphemeralWriteSlotTool(config);
+  }
+  asTool() {
+    return this.tool;
+  }
+};
+var XacheEphemeralReadSlotTool = class {
+  constructor(config) {
+    this.tool = createEphemeralReadSlotTool(config);
+  }
+  asTool() {
+    return this.tool;
+  }
+};
+var XacheEphemeralPromoteTool = class {
+  constructor(config) {
+    this.tool = createEphemeralPromoteTool(config);
+  }
+  asTool() {
+    return this.tool;
+  }
+};
+var XacheEphemeralStatusTool = class {
+  constructor(config) {
+    this.tool = createEphemeralStatusTool(config);
+  }
+  asTool() {
+    return this.tool;
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   XacheChatMessageHistory,
   XacheCollectiveContributeTool,
   XacheCollectiveQueryTool,
   XacheConversationBufferMemory,
+  XacheEphemeralCreateSessionTool,
+  XacheEphemeralPromoteTool,
+  XacheEphemeralReadSlotTool,
+  XacheEphemeralStatusTool,
+  XacheEphemeralWriteSlotTool,
   XacheExtractor,
   XacheGraphAskTool,
   XacheGraphEntityHistoryTool,
@@ -1005,11 +1259,17 @@ var XacheGraphRetriever = class extends import_retrievers2.BaseRetriever {
   XacheGraphQueryTool,
   XacheGraphRetriever,
   XacheMemory,
+  XacheMemoryProbeTool,
   XacheReputationChecker,
   XacheReputationTool,
   XacheRetriever,
   createCollectiveContributeTool,
   createCollectiveQueryTool,
+  createEphemeralCreateSessionTool,
+  createEphemeralPromoteTool,
+  createEphemeralReadSlotTool,
+  createEphemeralStatusTool,
+  createEphemeralWriteSlotTool,
   createGraphAddEntityTool,
   createGraphAddRelationshipTool,
   createGraphAskTool,
@@ -1018,6 +1278,7 @@ var XacheGraphRetriever = class extends import_retrievers2.BaseRetriever {
   createGraphLoadTool,
   createGraphMergeEntitiesTool,
   createGraphQueryTool,
+  createMemoryProbeTool,
   createReputationTool
 });
 //# sourceMappingURL=index.js.map