@ai-setting/roy-agent-core 1.4.10 → 1.4.12

package/dist/env/skill/tool/index.js

@@ -0,0 +1,114 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// packages/core/src/env/skill/types.ts
+import { z } from "zod";
+var SkillToolSchema = z.object({
+  skill: z.string().describe("Skill name to load")
+});
+
+// packages/core/src/env/skill/tool/skill-tool.ts
+function buildSkillDescription(items) {
+  const lines = [
+    "Load a skill by name. Available skills:",
+    "",
+    "## Available Skills",
+    ""
+  ];
+  if (items.length === 0) {
+    lines.push("No skills available.");
+  } else {
+    for (const item of items) {
+      lines.push(`- **${item.name}**: "${item.description}"`);
+    }
+  }
+  lines.push("");
+  lines.push("Use the 'skill' parameter to specify which skill to load.");
+  return lines.join(`
+`);
+}
+function createSkillTool(getSkillList, getSkill) {
+  return {
+    name: "skill",
+    description: buildSkillDescription(getSkillList()),
+    parameters: SkillToolSchema,
+    execute: async (args, ctx) => {
+      const params = SkillToolSchema.parse(args);
+      try {
+        const entry = getSkill(params.skill);
+        if (!entry) {
+          return {
+            success: false,
+            output: "",
+            error: `Skill not found: ${params.skill}`,
+            metadata: { execution_time_ms: 0 }
+          };
+        }
+        return {
+          success: true,
+          output: entry.content,
+          metadata: { execution_time_ms: 0 }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 }
+        };
+      }
+    }
+  };
+}
+export {
+  createSkillTool,
+  buildSkillDescription
+};