@axiom-lattice/examples-deep_research 1.0.16 → 1.0.18

package/src/agents/inventory_doctor/tools.ts

@@ -0,0 +1,244 @@
+/**
+ * Inventory Doctor Agent Tools
+ * 
+ * Tools for diagnosing and fixing WMS pick-shortage incidents
+ */
+
+import z from "zod";
+import { registerToolLattice } from "@axiom-lattice/core";
+
+/**
+ * Get WMS movement tasks for a SKU and location
+ * Returns pending tasks that might affect inventory visibility
+ */
+registerToolLattice(
+  "get_wms_movement_tasks",
+  {
+    name: "get_wms_movement_tasks",
+    description:
+      "Retrieve in-flight movement tasks (putaway/move/wave) for a specific SKU and location. Use this to check for tasks in middle states that might cause inventory discrepancies.",
+    needUserApprove: false,
+    schema: z.object({
+      skuId: z.string().describe("SKU identifier"),
+      locationId: z.string().describe("Location identifier"),
+    }),
+  },
+  async (input: { skuId: string; locationId: string }) => {
+    // Mock data with random values
+    const taskTypes = ["putaway", "move", "wave", "replenishment"];
+    const statuses = ["in_progress", "pending", "queued", "processing"];
+    const hasPendingTasks = Math.random() > 0.3; // 70% chance of having pending tasks
+    const taskCount = hasPendingTasks ? Math.floor(Math.random() * 3) + 1 : 0;
+
+    const tasks = Array.from({ length: taskCount }, (_, i) => ({
+      id: `move-${Math.floor(Math.random() * 9000) + 1000}`,
+      type: taskTypes[Math.floor(Math.random() * taskTypes.length)],
+      status: statuses[Math.floor(Math.random() * statuses.length)],
+      etaMin: Math.floor(Math.random() * 60) + 5, // 5-65 minutes
+    }));
+
+    return {
+      pending: hasPendingTasks,
+      tasks,
+    };
+  }
+);
+
+/**
+ * Get location activity logs
+ * Returns recent activity logs for a location to identify unconfirmed moves or cancellations
+ */
+registerToolLattice(
+  "get_location_logs",
+  {
+    name: "get_location_logs",
+    description:
+      "Retrieve activity logs for a location within a specified lookback period. Use this to identify unconfirmed moves, cancellations, or other activities that might explain inventory discrepancies.",
+    needUserApprove: false,
+    schema: z.object({
+      locationId: z.string().describe("Location identifier"),
+      lookbackHours: z.number().describe("Number of hours to look back"),
+    }),
+  },
+  async (input: { locationId: string; lookbackHours: number }) => {
+    // Mock data with random values
+    const actions = ["move", "putaway", "pick", "adjustment", "cycle_count"];
+    const statuses = [
+      "pending_confirm",
+      "completed",
+      "cancelled",
+      "in_progress",
+      "failed",
+    ];
+    const operators = [
+      "op_x",
+      "op_y",
+      "op_z",
+      "worker_01",
+      "worker_05",
+      "worker_12",
+    ];
+    const locations = ["A-01", "A-02", "B-01", "B-02", "C-03", "D-05"];
+
+    const logCount = Math.floor(Math.random() * 5) + 1; // 1-5 logs
+    const now = new Date();
+    const logs = Array.from({ length: logCount }, (_, i) => {
+      const hoursAgo = Math.floor(Math.random() * input.lookbackHours);
+      const timestamp = new Date(now.getTime() - hoursAgo * 60 * 60 * 1000);
+      const fromLoc = locations[Math.floor(Math.random() * locations.length)];
+      const toLoc = locations[Math.floor(Math.random() * locations.length)];
+
+      return {
+        ts: timestamp.toISOString(),
+        action: actions[Math.floor(Math.random() * actions.length)],
+        from: fromLoc,
+        to: toLoc !== fromLoc ? toLoc : locations[Math.floor(Math.random() * locations.length)],
+        status: statuses[Math.floor(Math.random() * statuses.length)],
+        operator: operators[Math.floor(Math.random() * operators.length)],
+      };
+    });
+
+    // Sort by timestamp descending
+    logs.sort((a, b) => new Date(b.ts).getTime() - new Date(a.ts).getTime());
+
+    return logs;
+  }
+);
+
+/**
+ * Retry synchronization for a stuck task
+ * Attempts to refresh the status of a task that might be in a middle state
+ */
+registerToolLattice(
+  "retry_sync",
+  {
+    name: "retry_sync",
+    description:
+      "Retry synchronization for a task that appears to be stuck in a middle state. This will attempt to refresh the task status and resolve data delays.",
+    needUserApprove: false,
+    schema: z.object({
+      taskId: z.string().describe("Task identifier to retry"),
+    }),
+  },
+  async (input: { taskId: string }) => {
+    // Mock data with random outcomes
+    const fixed = Math.random() > 0.2; // 80% success rate
+    const messages = [
+      "status refreshed to completed",
+      "task synchronized successfully",
+      "sync completed, inventory updated",
+      "task status updated to completed",
+      "synchronization failed, task still in progress",
+      "unable to sync, task may require manual intervention",
+    ];
+
+    return {
+      fixed,
+      message: fixed
+        ? messages[Math.floor(Math.random() * 4)]
+        : messages[Math.floor(Math.random() * 2) + 4],
+    };
+  }
+);
+
+/**
+ * Dispatch a cycle count task for physical verification
+ * Creates a cycle count task and assigns it to an operator
+ */
+registerToolLattice(
+  "dispatch_cycle_count",
+  {
+    name: "dispatch_cycle_count",
+    description:
+      "Dispatch a cycle count task to physically verify inventory at specified locations. Use this when physical verification is needed to resolve inventory discrepancies.",
+    needUserApprove: false,
+    schema: z.object({
+      skuId: z.string().describe("SKU identifier to verify"),
+      locations: z.array(z.string()).describe("List of location identifiers to check"),
+      priority: z.string().describe("Priority level (e.g., 'high', 'medium', 'low')"),
+    }),
+  },
+  async (input: {
+    skuId: string;
+    locations: string[];
+    priority: string;
+  }) => {
+    // Mock data with random values
+    const workers = [
+      "worker_01",
+      "worker_05",
+      "worker_07",
+      "worker_12",
+      "worker_15",
+      "worker_20",
+    ];
+    const taskId = `cc-${Math.floor(Math.random() * 9000) + 1000}`;
+    const assignee = workers[Math.floor(Math.random() * workers.length)];
+    const etaMinutes = Math.floor(Math.random() * 30) + 5; // 5-35 minutes
+    const eta = `${etaMinutes}m`;
+
+    return {
+      taskId,
+      assignee,
+      eta,
+    };
+  }
+);
+
+/**
+ * Notify picker about inventory status
+ * Sends a notification to the picker about the current status
+ */
+registerToolLattice(
+  "notify_picker",
+  {
+    name: "notify_picker",
+    description:
+      "Send a notification message to the picker about inventory status, retry instructions, or other relevant information.",
+    needUserApprove: false,
+    schema: z.object({
+      message: z.string().describe("Message to send to the picker"),
+    }),
+  },
+  async (input: { message: string }) => {
+    // Mock data with random delivery status
+    const delivered = Math.random() > 0.1; // 90% success rate
+
+    return {
+      delivered,
+    };
+  }
+);
+
+/**
+ * Write case report to file system
+ * Saves the diagnostic case report as a markdown file
+ */
+registerToolLattice(
+  "write_case_report",
+  {
+    name: "write_case_report",
+    description:
+      "Save the diagnostic case report as a markdown file. Use this to record the diagnosis, actions taken, and recommendations for audit purposes.",
+    needUserApprove: false,
+    schema: z.object({
+      markdown: z.string().describe("Markdown content of the case report"),
+    }),
+  },
+  async (input: { markdown: string }) => {
+    // Mock data with random path and timestamp
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, -5);
+    const reportId = Math.floor(Math.random() * 10000);
+    const paths = [
+      `/reports/inventory-case-latest.md`,
+      `/reports/inventory-case-${reportId}.md`,
+      `/reports/case-${timestamp}.md`,
+      `/reports/inventory-diagnosis-${reportId}.md`,
+    ];
+
+    return {
+      saved: true,
+      path: paths[Math.floor(Math.random() * paths.length)],
+    };
+  }
+);

package/src/index.ts

@@ -6,6 +6,11 @@ import {
   registerCheckpointSaver,
   registerModelLattice,
   registerScheduleLattice,
+  FileSystemSkillStore,
+  registerStoreLattice,
+
+  storeLatticeManager,
+  skillLatticeManager,
 } from "@axiom-lattice/core";
 import "./agents";
 
@@ -17,6 +22,7 @@ import {
 } from "@axiom-lattice/protocols";
 import { PostgreSQLScheduleStorage } from "@axiom-lattice/pg-stores";
 // 在文件开头添加
+const fs = require("fs");
 const PACKAGE_VERSION = require("../package.json").version;
 const BUILD_TIME = new Date().toISOString();
 const IS_DEV = process.env.NODE_ENV !== "production";
@@ -105,6 +111,81 @@ registerModelLattice(
 );
 LatticeGateway.registerLatticeRoutes(LatticeGateway.app);
 
+// Configure Skill Store with FileSystem storage
+// Point to the skills directory in data_agent
+// Always use source directory (src/) since .md files are not copied to dist/ during build
+// Try multiple path resolution strategies to work in both dev and production
+const possiblePaths = [
+  // Production: from dist/ go up to src/
+  path.resolve(__dirname, "../src/agents/data_agent/skills"),
+  // Development: relative to __dirname (src/)
+  path.resolve(__dirname, "./agents/data_agent/skills"),
+  // Fallback: from project root
+  path.resolve(process.cwd(), "examples/deep_research/src/agents/data_agent/skills"),
+];
+
+// Check which path exists, default to first path
+let skillsRootDir: string = possiblePaths[0];
+for (const possiblePath of possiblePaths) {
+  if (fs.existsSync(possiblePath)) {
+    skillsRootDir = possiblePath;
+    break;
+  }
+}
+
+if (!fs.existsSync(skillsRootDir)) {
+  console.warn(
+    `Warning: Skills directory not found at any of the expected paths. Using: ${skillsRootDir}`
+  );
+}
+
+console.log(`Skill store root directory: ${skillsRootDir}`);
+
+const skillStore = new FileSystemSkillStore({
+  rootDir: skillsRootDir,
+});
+
+// Remove the default skill store and register our custom one
+// This ensures tools like load_skills and load_skill_content can access our skills
+storeLatticeManager.removeLattice("default", "skill");
+registerStoreLattice("default", "skill", skillStore);
+
+// Configure SkillLatticeManager to use the store
+skillLatticeManager.configureStore("default");
+
+// Test loading skills on startup to verify configuration
+(async () => {
+  try {
+    const skills = await skillStore.getAllSkills();
+    console.log(`Loaded ${skills.length} skills from file system:`);
+    if (skills.length === 0) {
+      console.warn(
+        `Warning: No skills found. Please check if the directory exists: ${skillsRootDir}`
+      );
+    } else {
+      skills.forEach((skill) => {
+        console.log(`  - ${skill.name}: ${skill.description.substring(0, 50)}...`);
+      });
+    }
+  } catch (error) {
+    console.error("Failed to load skills on startup:", error);
+    if (error instanceof Error) {
+      console.error("Error details:", error.message);
+      console.error("Stack:", error.stack);
+    }
+  }
+})();
+
+// // Load skills from the file system asynchronously
+// (async () => {
+//   try {
+//     await loadSkillsFromStore();
+//     console.log("Skills loaded successfully from file system");
+//   } catch (error) {
+//     console.error("Failed to load skills:", error);
+//   }
+// })();
+
 // // 注册 Schedule Lattice（使用 PostgreSQL 持久化）
 // registerScheduleLattice("default", {
 //   name: "Default Scheduler",

package/src/agents/data_agent/tools/load_skills.ts

@@ -1,88 +0,0 @@
-/**
- * Load Skills Tools
- * Tools for loading skill metadata and content
- */
-
-import z from "zod";
-import { registerToolLattice } from "@axiom-lattice/core";
-import * as analystSkill from "../skills/analyst";
-import * as dataVisualizationSkill from "../skills/data-visualization";
-import * as sqlQuerySkill from "../skills/sql-query";
-import * as analysisMethodologySkill from "../skills/analysis-methodology";
-import * as notebookReportSkill from "../skills/notebook-report";
-import * as infographicCreatorSkill from "../skills/infographic-creator";
-
-// Type definition for skill structure
-interface Skill {
-  name: string;
-  description: string;
-  prompt: string;
-}
-
-// Registry of all available skills
-const skillsRegistry: Record<string, Skill> = {
-  analyst: analystSkill.analyst,
-  "data-visualization": dataVisualizationSkill.dataVisualization,
-  "sql-query": sqlQuerySkill.sqlQuery,
-  "analysis-methodology": analysisMethodologySkill.analysisMethodology,
-  "notebook-report": notebookReportSkill.notebookReport,
-  "infographic-creator": infographicCreatorSkill.infographicCreator,
-};
-
-/**
- * Load all skills and return their metadata (name and description, without prompt)
- */
-registerToolLattice(
-  "load_skills",
-  {
-    name: "load_skills",
-    description:
-      "Load all available skills and return their metadata (name and description). This tool returns skill information without the prompt content. Use this to discover what skills are available.",
-    needUserApprove: false,
-    schema: z.object({}),
-  },
-  async (_input: Record<string, never>, _config: any) => {
-    try {
-      const skillsMeta = Object.values(skillsRegistry).map((skill) => ({
-        name: skill.name,
-        description: skill.description,
-      }));
-
-      return JSON.stringify(skillsMeta, null, 2);
-    } catch (error) {
-      return `Error loading skills: ${error instanceof Error ? error.message : String(error)
-        }`;
-    }
-  }
-);
-
-/**
- * Load a specific skill's content and return its prompt
- */
-registerToolLattice(
-  "load_skill_content",
-  {
-    name: "load_skill_content",
-    description:
-      "Load a specific skill's content by name and return its prompt. Use this tool to get the full prompt content for a skill that you want to use.",
-    needUserApprove: false,
-    schema: z.object({
-      skill_name: z.string().describe("The name of the skill to load"),
-    }),
-  },
-  async (input: { skill_name: string }, _config: any) => {
-    try {
-      const skill = skillsRegistry[input.skill_name];
-
-      if (!skill) {
-        const availableSkills = Object.keys(skillsRegistry).join(", ");
-        return `Skill "${input.skill_name}" not found. Available skills: ${availableSkills}`;
-      }
-
-      return skill.prompt;
-    } catch (error) {
-      return `Error loading skill content: ${error instanceof Error ? error.message : String(error)
-        }`;
-    }
-  }
-);