@ai-setting/roy-agent-core 1.4.13 → 1.4.14

package/dist/shared/@ai-setting/roy-agent-core-m6y668cc.js

@@ -0,0 +1,377 @@
+import {
+  createSkillTool
+} from "./roy-agent-core-kydc9nwb.js";
+import {
+  envKeyToConfigKey
+} from "./roy-agent-core-jv3b7v9w.js";
+import {
+  BaseComponent
+} from "./roy-agent-core-m2x48hw6.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-yn761yve.js";
+
+// packages/core/src/env/skill/skill-component.ts
+init_logger();
+
+// packages/core/src/env/skill/scanner.ts
+init_logger();
+import fs2 from "fs/promises";
+import path2 from "path";
+import { glob } from "glob";
+
+// packages/core/src/env/skill/parser.ts
+init_logger();
+import fs from "fs/promises";
+var logger = createLogger("skill-parser");
+function parseFrontmatter(text) {
+  const result = {};
+  const lines = text.split(`
+`);
+  for (const line of lines) {
+    const match = line.match(/^(\w+):\s*"?(.+?)"?\s*$/);
+    if (match) {
+      const key = match[1];
+      let value = match[2];
+      if (value.startsWith('"') && value.endsWith('"')) {
+        value = value.slice(1, -1);
+      }
+      result[key] = value;
+    }
+  }
+  return result;
+}
+async function parseSkillFile(filePath, source) {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n?/);
+    if (!frontmatterMatch) {
+      logger.warn(`[SkillParser] Missing frontmatter in: ${filePath}`);
+      return null;
+    }
+    const frontmatter = parseFrontmatter(frontmatterMatch[1]);
+    const name = frontmatter.name;
+    const description = frontmatter.description;
+    if (!name) {
+      logger.warn(`[SkillParser] Missing name in frontmatter: ${filePath}`);
+      return null;
+    }
+    if (!description) {
+      logger.warn(`[SkillParser] Missing description in frontmatter: ${filePath}`);
+      return null;
+    }
+    const actualContent = content.replace(/^---\n[\s\S]*?\n---\n?/, "");
+    return {
+      name,
+      description,
+      filePath,
+      content: actualContent,
+      source,
+      loadedAt: Date.now()
+    };
+  } catch (error) {
+    logger.error(`[SkillParser] Failed to parse file: ${filePath}`, error);
+    return null;
+  }
+}
+
+// packages/core/src/env/skill/config.ts
+import path from "path";
+import os from "os";
+var DEFAULT_SKILL_CONFIG = {
+  skillPaths: [
+    {
+      type: "user",
+      path: path.join(os.homedir(), ".config", "roy-agent", "skills")
+    },
+    {
+      type: "project",
+      path: ".roy/skills"
+    }
+  ],
+  recursive: true,
+  cacheEnabled: true
+};
+var SOURCE_PRIORITY = {
+  "built-in": 0,
+  user: 1,
+  project: 2
+};
+function getSourcePriority(source) {
+  return SOURCE_PRIORITY[source] ?? 0;
+}
+
+// packages/core/src/env/skill/scanner.ts
+var logger2 = createLogger("skill-scanner");
+function expandPath(inputPath) {
+  if (inputPath.startsWith("~/")) {
+    const home = process.env.HOME || process.env.USERPROFILE || "";
+    return path2.join(home, inputPath.slice(2));
+  }
+  return path2.resolve(inputPath);
+}
+async function pathExists(p) {
+  try {
+    await fs2.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+class SkillScanner {
+  config;
+  skillsMap;
+  constructor(config) {
+    this.config = config;
+    this.skillsMap = new Map;
+  }
+  async scan() {
+    this.skillsMap.clear();
+    for (const skillPath of this.config.skillPaths) {
+      await this.scanPath(skillPath);
+    }
+    return this.skillsMap;
+  }
+  async scanPath(skillPath) {
+    const expandedPath = expandPath(skillPath.path);
+    if (!await pathExists(expandedPath)) {
+      logger2.info(`[SkillScanner] Path not found, skipping: ${expandedPath}`);
+      return;
+    }
+    logger2.info(`[SkillScanner] Scanning: ${expandedPath}`);
+    const sep = "/";
+    const basePattern = expandedPath.replace(/\\/g, "/");
+    const pattern = this.config.recursive ? `${basePattern}${sep}**${sep}SKILL.md` : `${basePattern}${sep}SKILL.md`;
+    const files = await glob(pattern, {
+      absolute: true,
+      ignore: ["**/node_modules/**"]
+    });
+    logger2.info(`[SkillScanner] Found ${files.length} SKILL.md files`);
+    for (const filePath of files) {
+      await this.processFile(filePath, skillPath.type);
+    }
+  }
+  async processFile(filePath, source) {
+    const entry = await parseSkillFile(filePath, source);
+    if (!entry) {
+      return;
+    }
+    const existing = this.skillsMap.get(entry.name);
+    if (!existing || getSourcePriority(source) > getSourcePriority(existing.source)) {
+      this.skillsMap.set(entry.name, entry);
+      logger2.debug(`[SkillScanner] Loaded skill: ${entry.name} (${source})`);
+    }
+  }
+  getSkills() {
+    return this.skillsMap;
+  }
+}
+
+// packages/core/src/env/skill/skill-config-registration.ts
+import path3 from "path";
+import os2 from "os";
+var SKILL_DEFAULTS = {
+  "skill.skillPaths": [
+    { type: "user", path: path3.join(os2.homedir(), ".config", "roy-agent", "skills") },
+    { type: "project", path: ".roy/skills" }
+  ],
+  "skill.recursive": true,
+  "skill.cacheEnabled": true
+};
+var SKILL_CONFIG_REGISTRATION = {
+  name: "skill",
+  sources: [
+    { type: "env", envPrefix: "SKILL", priority: 20, watch: false }
+  ],
+  keys: [
+    { key: "skill.skillPaths", sources: ["env", "file"] },
+    { key: "skill.recursive", sources: ["env", "file"] },
+    { key: "skill.cacheEnabled", sources: ["env", "file"] }
+  ]
+};
+
+// packages/core/src/env/skill/skill-component.ts
+var logger3 = createLogger("skill");
+
+class SkillComponent extends BaseComponent {
+  name = "skill";
+  version = "1.0.0";
+  config;
+  toolComponent;
+  scanner;
+  skillsMap = new Map;
+  configComponent;
+  configWatcher;
+  async init(config) {
+    await super.init(config);
+    const options = config?.options;
+    if (!options?.configComponent) {
+      throw new Error("ConfigComponent is required for SkillComponent initialization");
+    }
+    this.configComponent = options.configComponent;
+    await this.registerConfig(options);
+    this.scanner = new SkillScanner(this.config);
+    logger3.info("[SkillComponent] Initialized");
+  }
+  async registerConfig(options) {
+    const configComponent = this.configComponent;
+    if (!configComponent)
+      return;
+    const { configPath, envPrefix, config } = options;
+    const prefix = envPrefix ?? "SKILL";
+    configComponent.registerComponent(SKILL_CONFIG_REGISTRATION);
+    if (configPath) {
+      configComponent.registerSource({
+        type: "file",
+        relativePath: configPath,
+        optional: true,
+        watch: false
+      });
+    }
+    configComponent.registerSource({
+      type: "env",
+      envPrefix: prefix,
+      priority: 20,
+      watch: false
+    });
+    await configComponent.load("skill");
+    for (const envKey of Object.keys(process.env)) {
+      const configKey = envKeyToConfigKey(envKey, prefix, "skill");
+      if (!configKey)
+        continue;
+      const value = process.env[envKey];
+      if (value !== undefined) {
+        await configComponent.set(configKey, value);
+      }
+    }
+    for (const [key, value] of Object.entries(SKILL_DEFAULTS)) {
+      if (configComponent.get(key) === undefined) {
+        await configComponent.set(key, value);
+      }
+    }
+    if (config) {
+      const flatConfig = this.flattenConfig(config);
+      for (const [key, value] of Object.entries(flatConfig)) {
+        await configComponent.set(key, value);
+      }
+    }
+    this.registerConfigWatcher(configComponent);
+    this.buildConfig(configComponent);
+  }
+  buildConfig(configComponent) {
+    const recursive = configComponent.get("skill.recursive") ?? true;
+    const cacheEnabled = configComponent.get("skill.cacheEnabled") ?? true;
+    const skillPathsConfig = configComponent.get("skill.skillPaths");
+    let skillPaths = [];
+    if (Array.isArray(skillPathsConfig)) {
+      skillPaths = skillPathsConfig;
+    } else if (typeof skillPathsConfig === "string") {
+      try {
+        skillPaths = JSON.parse(skillPathsConfig);
+      } catch {
+        skillPaths = DEFAULT_SKILL_CONFIG.skillPaths;
+      }
+    }
+    if (skillPaths.length === 0) {
+      skillPaths = DEFAULT_SKILL_CONFIG.skillPaths;
+    }
+    this.config = {
+      skillPaths,
+      recursive,
+      cacheEnabled
+    };
+  }
+  flattenConfig(obj, prefix = "skill") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      const fullKey = `${prefix}.${key}`;
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        Object.assign(result, this.flattenConfig(value, fullKey));
+      } else {
+        result[fullKey] = value;
+      }
+    }
+    return result;
+  }
+  registerConfigWatcher(configComponent) {
+    if (typeof configComponent.watch !== "function") {
+      return;
+    }
+    this.configWatcher = configComponent.watch("skill.*", (event) => {
+      this.onConfigChange(event);
+    });
+  }
+  onConfigChange(event) {
+    logger3.info(`[SkillComponent] Config changed: ${event.key}`, {
+      oldValue: event.oldValue,
+      newValue: event.newValue
+    });
+    if (this.configComponent) {
+      this.buildConfig(this.configComponent);
+    }
+  }
+  async start() {
+    await super.start();
+    this.toolComponent = this.env?.getComponent("tool");
+    if (!this.toolComponent) {
+      logger3.warn("[SkillComponent] ToolComponent not found, skipping tool registration");
+      return;
+    }
+    await this.scanSkills();
+    await this.registerTool();
+    this.setStatus("running");
+    logger3.info(`[SkillComponent] Started with ${this.skillsMap.size} skills`);
+  }
+  async stop() {
+    if (this.configWatcher) {
+      this.configWatcher();
+      this.configWatcher = undefined;
+    }
+    if (this.toolComponent) {
+      this.toolComponent.unregister("skill");
+    }
+    await super.stop();
+    logger3.info("[SkillComponent] Stopped");
+  }
+  getSkill(name) {
+    return this.skillsMap.get(name);
+  }
+  getSkillList() {
+    return Array.from(this.skillsMap.values()).map((entry) => ({
+      name: entry.name,
+      description: entry.description,
+      source: entry.source
+    }));
+  }
+  hasSkill(name) {
+    return this.skillsMap.has(name);
+  }
+  getAllSkills() {
+    return Array.from(this.skillsMap.values());
+  }
+  async scanSkills() {
+    this.scanner = new SkillScanner(this.config);
+    this.skillsMap = await this.scanner.scan();
+    logger3.info(`[SkillComponent] Scanned ${this.skillsMap.size} skills`);
+  }
+  async reload() {
+    if (!this.toolComponent) {
+      throw new Error("ToolComponent not available");
+    }
+    logger3.info("[SkillComponent] Reloading skills...");
+    this.toolComponent.unregister("skill");
+    await this.scanSkills();
+    await this.registerTool();
+    logger3.info(`[SkillComponent] Reloaded ${this.skillsMap.size} skills`);
+  }
+  async registerTool() {
+    if (!this.toolComponent)
+      return;
+    const tool = createSkillTool(() => this.getSkillList(), (name) => this.getSkill(name));
+    this.toolComponent.register(tool);
+    logger3.info("[SkillComponent] Registered SkillTool");
+  }
+}
+export { parseFrontmatter, parseSkillFile, DEFAULT_SKILL_CONFIG, SOURCE_PRIORITY, getSourcePriority, SkillScanner, SkillComponent };

package/dist/shared/{chunk-1aakcfp1.js → @ai-setting/roy-agent-core-nczzf0ms.js}

@@ -3,9 +3,9 @@ import {
   getTracerProvider,
   init_tracer_provider,
   resetTracerProvider
-} from "./chunk-q9j99fsm.js";
-import"./chunk-1qwabsm0.js";
-import"./chunk-wbkh7wat.js";
+} from "./roy-agent-core-1k28kg7h.js";
+import"./roy-agent-core-j8zx62zr.js";
+import"./roy-agent-core-fs0mn2jk.js";
 init_tracer_provider();
 
 export {

package/dist/shared/@ai-setting/roy-agent-core-nfj6knp5.js

@@ -0,0 +1,36 @@
+import {
+  AskUserError,
+  init_workflow_hil
+} from "./roy-agent-core-8dvbn7tw.js";
+
+// packages/core/src/env/workflow/tools/ask-user-tool.ts
+init_workflow_hil();
+import { z } from "zod";
+var AskUserInputSchema = z.object({
+  query: z.string().describe("The question or request to ask the user"),
+  options: z.array(z.string()).optional().describe("Optional choices for the user"),
+  required_confirm: z.boolean().optional().describe("If true, user must explicitly confirm")
+});
+var askUserTool = {
+  name: "ask_user",
+  description: "Ask user for input or confirmation. Use this tool when you need user input or validation to continue the workflow.",
+  parameters: AskUserInputSchema,
+  async execute(args, context) {
+    const runId = context.metadata?.runId || "unknown";
+    const sessionId = context.metadata?.sessionId || `workflow_${runId}`;
+    const nodeId = context.metadata?.nodeId || "unknown";
+    let fullQuery = args.query;
+    if (args.options && args.options.length > 0) {
+      fullQuery = `${args.query} (选项: ${args.options.join(", ")})`;
+    }
+    throw new AskUserError(runId, sessionId, nodeId, "agent", fullQuery);
+  },
+  metadata: {
+    category: "workflow",
+    tags: ["human-in-loop", "user-input"],
+    version: "1.0.0"
+  }
+};
+var askUserToolInstance = askUserTool;
+
+export { AskUserInputSchema, askUserTool, askUserToolInstance };

package/dist/shared/@ai-setting/roy-agent-core-ntrp979d.js

@@ -0,0 +1,204 @@
+import {
+  TracedAs,
+  init_decorator
+} from "./roy-agent-core-04qgbjbe.js";
+import {
+  __legacyDecorateClassTS
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// packages/core/src/env/session/session-message-converter.ts
+init_decorator();
+import { randomUUID } from "crypto";
+var DEFAULT_REASONING_BUDGET_TOKENS = 1e4;
+
+class SessionMessageConverter {
+  toModelMessage(msg) {
+    if (msg.role === "assistant") {
+      const content = [];
+      for (const part of msg.parts || []) {
+        if (part.type === "text") {
+          const textPart = part;
+          content.push({
+            type: "text",
+            text: textPart.content,
+            ...textPart.synthetic !== undefined && { synthetic: textPart.synthetic }
+          });
+        } else if (part.type === "reasoning") {
+          const reasoningPart = part;
+          content.push({
+            type: "reasoning",
+            text: reasoningPart.content,
+            reasoningType: reasoningPart.reasoningType
+          });
+        } else if (part.type === "tool-call") {
+          const toolPart = part;
+          let parsedArgs = {};
+          if (typeof toolPart.arguments === "string") {
+            try {
+              parsedArgs = JSON.parse(toolPart.arguments);
+            } catch {
+              parsedArgs = { _raw: toolPart.arguments };
+            }
+          } else {
+            parsedArgs = toolPart.arguments;
+          }
+          content.push({
+            type: "tool-call",
+            toolCallId: toolPart.toolCallId,
+            toolName: toolPart.toolName,
+            input: parsedArgs
+          });
+        } else if (part.type === "file") {
+          const filePart = part;
+          content.push({
+            type: "file",
+            url: filePart.url,
+            mimeType: filePart.mime,
+            filename: filePart.filename
+          });
+        } else if (part.type === "tool-result" || part.type === "checkpoint") {} else {
+          console.debug(`[session-message-converter] Skipping unsupported part type in assistant: ${part.type}`);
+        }
+      }
+      if (content.length === 0 && msg.content) {
+        return { role: "assistant", content: msg.content };
+      }
+      return { role: "assistant", content };
+    }
+    if (msg.role === "tool") {
+      const toolPart = msg.parts?.find((p) => p.type === "tool-result");
+      return {
+        role: "tool",
+        content: [{
+          type: "tool-result",
+          toolCallId: toolPart?.toolCallId || "",
+          toolName: toolPart?.toolName || "",
+          output: toolPart?.output || msg.content || ""
+        }]
+      };
+    }
+    return {
+      role: msg.role,
+      content: msg.content || ""
+    };
+  }
+  fromModelMessage(aiMsg, options) {
+    const parts = [];
+    const content = typeof aiMsg.content === "string" || Array.isArray(aiMsg.content) ? aiMsg.content : "";
+    let hasToolCallPart = false;
+    let hasToolResultPart = false;
+    if (typeof content === "string") {
+      parts.push({ type: "text", content });
+    } else if (Array.isArray(content)) {
+      for (const part of content) {
+        const p = part;
+        if (p.type === "text") {
+          parts.push({ type: "text", content: p.text || "" });
+        } else if (p.type === "reasoning") {
+          parts.push({
+            type: "reasoning",
+            content: p.text || "",
+            reasoningType: p.reasoningType,
+            state: "completed"
+          });
+        } else if (p.type === "tool-call") {
+          hasToolCallPart = true;
+          parts.push({
+            type: "tool-call",
+            toolCallId: p.toolCallId,
+            toolName: p.toolName,
+            arguments: p.input,
+            state: "pending"
+          });
+        } else if (p.type === "tool-result") {
+          hasToolResultPart = true;
+          parts.push({
+            type: "tool-result",
+            toolCallId: p.toolCallId,
+            toolName: p.toolName,
+            output: typeof p.output === "string" ? p.output : JSON.stringify(p.output),
+            state: "completed"
+          });
+        } else if (p.type === "file") {
+          parts.push({
+            type: "file",
+            mime: p.mimeType || "application/octet-stream",
+            url: p.url,
+            filename: p.filename
+          });
+        } else {
+          console.debug(`[session-message-converter] Unknown part type: ${p.type}`);
+        }
+      }
+    }
+    let metadataType;
+    if (aiMsg.role === "assistant" && hasToolCallPart) {
+      metadataType = "tool_call";
+    } else if (aiMsg.role === "tool") {
+      metadataType = "tool_result";
+    }
+    const result = {
+      id: options?.messageID || `msg_${randomUUID()}`,
+      sessionID: options?.sessionID || "",
+      role: aiMsg.role,
+      timestamp: Date.now(),
+      parts,
+      content: typeof content === "string" ? content : ""
+    };
+    if (metadataType) {
+      result.metadata = { type: metadataType };
+    }
+    return result;
+  }
+  sessionToHistory(messages) {
+    return messages.filter((msg) => !msg.metadata?.isArchived && !msg.isArchived).map((msg) => this.toModelMessage(msg));
+  }
+  extractProviderOptions(msg) {
+    const options = {};
+    const reasoningParts = msg.parts?.filter((p) => p.type === "reasoning");
+    if (reasoningParts && reasoningParts.length > 0) {
+      const firstReasoning = reasoningParts[0];
+      if (firstReasoning.reasoningType) {
+        options.openai = {
+          thinking: {
+            type: firstReasoning.reasoningType === "effort" ? "extended" : "core"
+          }
+        };
+        if (firstReasoning.reasoningType === "effort") {
+          const budgetTokens = firstReasoning.metadata?.tokenCount || DEFAULT_REASONING_BUDGET_TOKENS;
+          options.anthropic = {
+            thinking: {
+              type: "enabled",
+              budgetTokens
+            }
+          };
+        }
+      }
+    }
+    return options;
+  }
+  migrateMessage(oldMsg) {
+    if (oldMsg.parts && oldMsg.parts.length > 0) {
+      const firstPart = oldMsg.parts[0];
+      if (firstPart && typeof firstPart.type === "string" && firstPart.type.length > 0) {
+        return {
+          ...oldMsg,
+          content: oldMsg.content || ""
+        };
+      }
+    }
+    return {
+      ...oldMsg,
+      content: oldMsg.content || "",
+      parts: oldMsg.content ? [{ type: "text", content: oldMsg.content }] : []
+    };
+  }
+}
+__legacyDecorateClassTS([
+  TracedAs("session-message-converter.toModelMessage", { recordParams: true, recordResult: true, log: true })
+], SessionMessageConverter.prototype, "toModelMessage", null);
+__legacyDecorateClassTS([
+  TracedAs("session-message-converter.fromModelMessage", { recordParams: true, recordResult: true, log: true })
+], SessionMessageConverter.prototype, "fromModelMessage", null);
+
+export { SessionMessageConverter };