@ai-setting/roy-agent-core 1.5.15-test → 1.5.16-test

package/dist/index.js

@@ -0,0 +1,399 @@
+import {
+  CommandsComponent
+} from "./shared/@ai-setting/roy-agent-core-f7q2x5z6.js";
+import {
+  LogTraceComponent,
+  LogTraceConfigSchema
+} from "./shared/@ai-setting/roy-agent-core-xq8hhqb8.js";
+import {
+  ToolComponent,
+  ToolRegistry,
+  ToolValidator
+} from "./shared/@ai-setting/roy-agent-core-qqceba6k.js";
+import {
+  bashTool,
+  editFileTool,
+  getAllBuiltInTools,
+  getBuiltInTool,
+  globTool,
+  grepTool,
+  readFileTool,
+  writeFileTool
+} from "./shared/@ai-setting/roy-agent-core-satmq6sh.js";
+import {
+  PromptComponent,
+  getBuiltInPrompt,
+  getBuiltInPromptNames
+} from "./shared/@ai-setting/roy-agent-core-93zfb3r1.js";
+import {
+  LLMComponent,
+  LLMConfigSchema,
+  LLMDefaultConfigSchema,
+  ModelLimitsSchema,
+  ProviderCapabilitiesSchema,
+  ProviderConfigSchema,
+  createInvokeConfig,
+  invoke,
+  invokeNonStream,
+  parseModelString
+} from "./shared/@ai-setting/roy-agent-core-vkz81f7v.js";
+import {
+  ConfigComponent
+} from "./shared/@ai-setting/roy-agent-core-vn2bc59q.js";
+import {
+  MemoryComponent
+} from "./shared/@ai-setting/roy-agent-core-4txzpsbt.js";
+import"./shared/@ai-setting/roy-agent-core-g1s2h0e5.js";
+import {
+  MemoryPlugin,
+  createMemoryPlugin
+} from "./shared/@ai-setting/roy-agent-core-6kvtahqv.js";
+import {
+  TaskPlugin,
+  TaskTagPlugin
+} from "./shared/@ai-setting/roy-agent-core-3jywqmdd.js";
+import {
+  DebugComponent
+} from "./shared/@ai-setting/roy-agent-core-g99pxzn5.js";
+import {
+  ReplFormatter,
+  TraceFormatter,
+  TreeFormatter
+} from "./shared/@ai-setting/roy-agent-core-rvv6ydff.js";
+import {
+  BaseEnvironment,
+  EventSourceAgentHandler,
+  EventSourceComponent,
+  generateDescendingId,
+  generateId
+} from "./shared/@ai-setting/roy-agent-core-gbqcyegm.js";
+import {
+  XDG_PATHS,
+  getXDGPath,
+  getXDGPaths
+} from "./shared/@ai-setting/roy-agent-core-qxnbvgwe.js";
+import {
+  WorkflowComponent
+} from "./shared/@ai-setting/roy-agent-core-rhmtwnw1.js";
+import {
+  init_node_registry_helper,
+  registerDecoratorNodeType
+} from "./shared/@ai-setting/roy-agent-core-0rtxwr28.js";
+import"./shared/@ai-setting/roy-agent-core-wrcy0h6z.js";
+import"./shared/@ai-setting/roy-agent-core-69jskqjg.js";
+import"./shared/@ai-setting/roy-agent-core-4t40mkpv.js";
+import"./shared/@ai-setting/roy-agent-core-jvatggbb.js";
+import"./shared/@ai-setting/roy-agent-core-5x94xmt6.js";
+import"./shared/@ai-setting/roy-agent-core-0vbdz0x7.js";
+import {
+  Edge,
+  NodeAs,
+  Workflow,
+  WorkflowEdges,
+  createWorkflowFromClass
+} from "./shared/@ai-setting/roy-agent-core-7fgf85wc.js";
+import"./shared/@ai-setting/roy-agent-core-1ce3fqrk.js";
+import {
+  AgentComponent,
+  AgentComponentConfigSchema
+} from "./shared/@ai-setting/roy-agent-core-b0x5dda6.js";
+import {
+  AskUserError,
+  init_workflow_hil
+} from "./shared/@ai-setting/roy-agent-core-e25xkv53.js";
+import {
+  TaskComponent
+} from "./shared/@ai-setting/roy-agent-core-gwc4h96n.js";
+import"./shared/@ai-setting/roy-agent-core-vf215qfv.js";
+import"./shared/@ai-setting/roy-agent-core-bvr1761x.js";
+import"./shared/@ai-setting/roy-agent-core-wa1kzqky.js";
+import"./shared/@ai-setting/roy-agent-core-t94ktchq.js";
+import {
+  TaskHookPoints
+} from "./shared/@ai-setting/roy-agent-core-92z6t4he.js";
+import"./shared/@ai-setting/roy-agent-core-8gxth0eh.js";
+import {
+  SkillComponent
+} from "./shared/@ai-setting/roy-agent-core-zbkpc41z.js";
+import"./shared/@ai-setting/roy-agent-core-psvxt4c9.js";
+import {
+  McpComponent
+} from "./shared/@ai-setting/roy-agent-core-pjr12nnd.js";
+import {
+  AgentError,
+  ComponentError,
+  ContextError,
+  ErrorCodes,
+  LLMError,
+  RoyError,
+  ToolError,
+  getErrorCode,
+  isRoyError
+} from "./shared/@ai-setting/roy-agent-core-ctdhjv68.js";
+import"./shared/@ai-setting/roy-agent-core-1akcqxj9.js";
+import {
+  SessionComponent
+} from "./shared/@ai-setting/roy-agent-core-81w1963m.js";
+import"./shared/@ai-setting/roy-agent-core-rvxg1wps.js";
+import"./shared/@ai-setting/roy-agent-core-eajcvp4e.js";
+import"./shared/@ai-setting/roy-agent-core-qxhq8ven.js";
+import {
+  BaseComponent
+} from "./shared/@ai-setting/roy-agent-core-kkbwepqb.js";
+import {
+  createHook,
+  createPriorityHook
+} from "./shared/@ai-setting/roy-agent-core-2dhd60aw.js";
+import {
+  HookManager,
+  globalHookManager
+} from "./shared/@ai-setting/roy-agent-core-gjq1yk68.js";
+import {
+  MemorySessionStore
+} from "./shared/@ai-setting/roy-agent-core-d7cyjkf7.js";
+import"./shared/@ai-setting/roy-agent-core-jfh9q2qh.js";
+import {
+  Traced,
+  TracedAs,
+  TracedLightweight,
+  wrapFunction
+} from "./shared/@ai-setting/roy-agent-core-zgypchmt.js";
+import {
+  createLogger,
+  getLogDir,
+  getLogLevel,
+  getLogLevels,
+  isQuietMode,
+  setConfigComponent,
+  setLogDirOverride,
+  setQuietMode
+} from "./shared/@ai-setting/roy-agent-core-44hnfb02.js";
+import {
+  OTelTracerProvider,
+  SpanKind,
+  SpanStatus,
+  getTracerProvider,
+  propagation,
+  resetTracerProvider
+} from "./shared/@ai-setting/roy-agent-core-xs5rsgat.js";
+import {
+  SQLiteSpanStorage
+} from "./shared/@ai-setting/roy-agent-core-psv4v63c.js";
+import"./shared/@ai-setting/roy-agent-core-fs0mn2jk.js";
+// src/env/memory/tools/memory-agent-tools.ts
+import { z } from "zod";
+var SearchSessionsSchema = z.object({
+  query: z.string().describe("搜索关键词"),
+  session_id: z.string().optional().describe("可选：限制特定 session"),
+  limit: z.number().optional().default(10).describe("返回数量限制")
+});
+var GetSessionSchema = z.object({
+  session_id: z.string().describe("Session ID")
+});
+var WriteMemorySchema = z.object({
+  scope: z.enum(["project", "global"]).describe("作用域"),
+  content: z.string().describe("新的记忆内容（Markdown 格式）")
+});
+function createMemoryAgentTools(deps) {
+  const searchSessions = {
+    name: "search_sessions",
+    description: "搜索会话历史，返回匹配的会话摘要列表",
+    parameters: SearchSessionsSchema,
+    execute: async (args, ctx) => {
+      try {
+        const params = SearchSessionsSchema.parse(args);
+        const results = await deps.sessionComponent.searchSessions(params.query, {
+          session_id: params.session_id,
+          limit: params.limit
+        });
+        return {
+          success: true,
+          output: JSON.stringify(results, null, 2),
+          metadata: {
+            execution_time_ms: 0,
+            count: results.length
+          }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 }
+        };
+      }
+    }
+  };
+  const getSession = {
+    name: "get_session",
+    description: "获取指定会话的完整内容",
+    parameters: GetSessionSchema,
+    execute: async (args, ctx) => {
+      try {
+        const params = GetSessionSchema.parse(args);
+        const session = await deps.sessionComponent.getSession(params.session_id);
+        if (!session) {
+          return {
+            success: false,
+            output: "",
+            error: `Session not found: ${params.session_id}`,
+            metadata: { execution_time_ms: 0 }
+          };
+        }
+        return {
+          success: true,
+          output: JSON.stringify(session, null, 2),
+          metadata: {
+            execution_time_ms: 0,
+            session_id: session.sessionId
+          }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 }
+        };
+      }
+    }
+  };
+  const writeMemory = {
+    name: "write_memory",
+    description: "写入记忆文件（覆盖模式）",
+    parameters: WriteMemorySchema,
+    execute: async (args, ctx) => {
+      try {
+        const params = WriteMemorySchema.parse(args);
+        await deps.memoryComponent.recordMemory({
+          mode: "overwrite",
+          content: params.content,
+          scope: params.scope
+        });
+        return {
+          success: true,
+          output: `Memory updated successfully (${params.scope})`,
+          metadata: {
+            execution_time_ms: 0,
+            scope: params.scope
+          }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 }
+        };
+      }
+    }
+  };
+  return {
+    searchSessions,
+    getSession,
+    writeMemory,
+    bash: bashTool,
+    read_file: readFileTool
+  };
+}
+
+// src/index.ts
+init_workflow_hil();
+init_node_registry_helper();
+export {
+  writeFileTool,
+  wrapFunction,
+  setQuietMode,
+  setConfigComponent as setLoggerConfigComponent,
+  setLogDirOverride,
+  resetTracerProvider,
+  registerDecoratorNodeType,
+  readFileTool,
+  propagation,
+  parseModelString,
+  isRoyError,
+  isQuietMode,
+  invokeNonStream,
+  invoke,
+  grepTool,
+  globalHookManager,
+  globTool,
+  getXDGPaths,
+  getXDGPath,
+  getTracerProvider,
+  getLogLevels,
+  getLogLevel,
+  getLogDir,
+  getErrorCode,
+  getBuiltInTool,
+  getBuiltInPromptNames,
+  getBuiltInPrompt,
+  getAllBuiltInTools,
+  generateId,
+  generateDescendingId,
+  editFileTool,
+  createWorkflowFromClass,
+  createPriorityHook,
+  createMemoryPlugin,
+  createMemoryAgentTools,
+  createLogger,
+  createInvokeConfig,
+  createHook,
+  bashTool,
+  XDG_PATHS,
+  WorkflowEdges,
+  WorkflowComponent,
+  Workflow,
+  TreeFormatter,
+  TracedLightweight,
+  TracedAs,
+  Traced,
+  TraceFormatter,
+  ToolValidator,
+  ToolRegistry,
+  ToolError,
+  ToolComponent,
+  TaskTagPlugin,
+  TaskPlugin,
+  TaskHookPoints,
+  TaskComponent,
+  SpanStatus,
+  SpanKind,
+  SkillComponent,
+  SessionComponent,
+  SQLiteSpanStorage,
+  RoyError,
+  ReplFormatter,
+  ProviderConfigSchema,
+  ProviderCapabilitiesSchema,
+  PromptComponent,
+  OTelTracerProvider,
+  NodeAs,
+  ModelLimitsSchema,
+  MemorySessionStore,
+  MemoryPlugin,
+  MemoryComponent,
+  McpComponent,
+  LogTraceConfigSchema,
+  LogTraceComponent,
+  LLMError,
+  LLMDefaultConfigSchema,
+  LLMConfigSchema,
+  LLMComponent,
+  HookManager,
+  EventSourceComponent,
+  EventSourceAgentHandler,
+  ErrorCodes,
+  Edge,
+  DebugComponent,
+  ContextError,
+  ConfigComponent,
+  ComponentError,
+  CommandsComponent,
+  BaseEnvironment,
+  BaseComponent,
+  AskUserError,
+  AgentError,
+  AgentComponentConfigSchema,
+  AgentComponent
+};

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

@@ -0,0 +1,258 @@
+import {
+  DecoratorNode,
+  init_decorator_node
+} from "./roy-agent-core-1ce3fqrk.js";
+import {
+  __esm,
+  __export
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/workflow/nodes/condition-node.ts
+class ConditionNode {
+  definition;
+  type = "condition";
+  id;
+  constructor(definition) {
+    this.definition = definition;
+    this.id = definition.id;
+  }
+  async execute(context) {
+    const startTime = Date.now();
+    try {
+      const conditionConfig = this.definition.config?.condition;
+      if (conditionConfig === undefined) {
+        return {
+          output: { success: true, condition: true },
+          error: undefined,
+          durationMs: Date.now() - startTime
+        };
+      }
+      const resolvedCondition = this.resolveCondition(conditionConfig, context);
+      const result = this.evaluateCondition(resolvedCondition);
+      return {
+        output: { success: result, condition: resolvedCondition },
+        error: undefined,
+        durationMs: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        output: undefined,
+        error: error instanceof Error ? error : new Error(String(error)),
+        durationMs: Date.now() - startTime
+      };
+    }
+  }
+  resolveCondition(condition, context) {
+    if (typeof condition === "string") {
+      const templateMatch = condition.match(/^\{\{([^}]+)\}\}$/);
+      if (templateMatch) {
+        const path = templateMatch[1].trim();
+        return this.resolveTemplate(path, context);
+      }
+      if (condition === "true")
+        return true;
+      if (condition === "false")
+        return false;
+      return condition;
+    }
+    return condition;
+  }
+  resolveTemplate(path, context) {
+    const trimmed = path.trim();
+    if (trimmed.startsWith("input.")) {
+      const key = trimmed.slice(6);
+      return context.input?.[key];
+    }
+    if (trimmed.startsWith("nodes.")) {
+      const rest = trimmed.slice(6);
+      const segments2 = rest.split(".");
+      const nodeId2 = segments2[0];
+      let nodeOutput2 = context.previousOutputs.get(nodeId2);
+      if (nodeOutput2 === undefined) {
+        const normalizedUnderscore = nodeId2.replace(/-/g, "_");
+        const normalizedHyphen = nodeId2.replace(/_/g, "-");
+        if (normalizedUnderscore !== nodeId2) {
+          nodeOutput2 = context.previousOutputs.get(normalizedUnderscore);
+        }
+        if (nodeOutput2 === undefined && normalizedHyphen !== nodeId2) {
+          nodeOutput2 = context.previousOutputs.get(normalizedHyphen);
+        }
+      }
+      if (nodeOutput2 === undefined)
+        return;
+      let value2 = nodeOutput2;
+      for (const segment of segments2.slice(1)) {
+        if (value2 && typeof value2 === "object") {
+          value2 = value2[segment];
+        } else {
+          return;
+        }
+      }
+      return value2;
+    }
+    const segments = trimmed.split(".");
+    const nodeId = segments[0];
+    let nodeOutput = context.previousOutputs.get(nodeId);
+    if (nodeOutput === undefined) {
+      const normalizedUnderscore = nodeId.replace(/-/g, "_");
+      const normalizedHyphen = nodeId.replace(/_/g, "-");
+      if (normalizedUnderscore !== nodeId) {
+        nodeOutput = context.previousOutputs.get(normalizedUnderscore);
+      }
+      if (nodeOutput === undefined && normalizedHyphen !== nodeId) {
+        nodeOutput = context.previousOutputs.get(normalizedHyphen);
+      }
+    }
+    if (nodeOutput === undefined)
+      return;
+    let value = nodeOutput;
+    for (const segment of segments.slice(1)) {
+      if (value && typeof value === "object") {
+        value = value[segment];
+      } else {
+        return;
+      }
+    }
+    return value;
+  }
+  evaluateCondition(value) {
+    if (typeof value === "boolean") {
+      return value;
+    }
+    if (typeof value === "string") {
+      return value.toLowerCase() === "true" || value === "1";
+    }
+    if (typeof value === "number") {
+      return value !== 0;
+    }
+    if (value === null || value === undefined) {
+      return false;
+    }
+    if (typeof value === "object") {
+      const obj = value;
+      if ("success" in obj) {
+        return Boolean(obj.success);
+      }
+      return Object.keys(obj).length > 0;
+    }
+    return Boolean(value);
+  }
+}
+var init_condition_node = () => {};
+
+// src/env/workflow/nodes/merge-node.ts
+class MergeNode {
+  definition;
+  type = "merge";
+  id;
+  constructor(definition) {
+    this.definition = definition;
+    this.id = definition.id;
+  }
+  async execute(context) {
+    const startTime = Date.now();
+    try {
+      const strategy = this.definition.config?.strategy || "collect";
+      const deps = this.definition.depends_on || [];
+      const outputs = {};
+      for (const depId of deps) {
+        let output = context.previousOutputs.get(depId);
+        if (output === undefined) {
+          const normalizedUnderscore = depId.replace(/-/g, "_");
+          const normalizedHyphen = depId.replace(/_/g, "-");
+          if (normalizedUnderscore !== depId) {
+            output = context.previousOutputs.get(normalizedUnderscore);
+          }
+          if (output === undefined && normalizedHyphen !== depId) {
+            output = context.previousOutputs.get(normalizedHyphen);
+          }
+        }
+        if (output !== undefined) {
+          outputs[depId] = output;
+        }
+      }
+      let result;
+      switch (strategy) {
+        case "collect":
+          result = outputs;
+          break;
+        case "first":
+          const firstKey = Object.keys(outputs)[0];
+          result = firstKey ? outputs[firstKey] : undefined;
+          break;
+        case "last":
+          const lastKey = Object.keys(outputs).pop();
+          result = lastKey ? outputs[lastKey] : undefined;
+          break;
+        case "merge":
+          result = this.deepMerge(Object.values(outputs));
+          break;
+        default:
+          result = outputs;
+      }
+      return {
+        output: {
+          strategy,
+          results: result,
+          count: Object.keys(outputs).length
+        },
+        error: undefined,
+        durationMs: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        output: undefined,
+        error: error instanceof Error ? error : new Error(String(error)),
+        durationMs: Date.now() - startTime
+      };
+    }
+  }
+  deepMerge(objects) {
+    const result = {};
+    for (const obj of objects) {
+      if (obj && typeof obj === "object" && !Array.isArray(obj)) {
+        for (const [key, value] of Object.entries(obj)) {
+          if (result[key] && typeof result[key] === "object" && !Array.isArray(result[key]) && value && typeof value === "object" && !Array.isArray(value)) {
+            result[key] = this.deepMerge([result[key], value]);
+          } else {
+            result[key] = value;
+          }
+        }
+      }
+    }
+    return result;
+  }
+}
+var init_merge_node = () => {};
+
+// src/env/workflow/utils/node-registry-helper.ts
+var exports_node_registry_helper = {};
+__export(exports_node_registry_helper, {
+  registerDecoratorNodeType: () => registerDecoratorNodeType,
+  hasDecoratorNodes: () => hasDecoratorNodes,
+  getDecoratorNodes: () => getDecoratorNodes
+});
+function registerDecoratorNodeType(registry) {
+  registry.register("decorator", (definition) => {
+    return new DecoratorNode(definition);
+  });
+  registry.register("condition", (definition) => {
+    return new ConditionNode(definition);
+  });
+  registry.register("merge", (definition) => {
+    return new MergeNode(definition);
+  });
+}
+function hasDecoratorNodes(nodes) {
+  return nodes.some((node) => node.type === "decorator");
+}
+function getDecoratorNodes(nodes) {
+  return nodes.filter((node) => node.type === "decorator");
+}
+var init_node_registry_helper = __esm(() => {
+  init_decorator_node();
+  init_condition_node();
+  init_merge_node();
+});
+
+export { registerDecoratorNodeType, hasDecoratorNodes, getDecoratorNodes, exports_node_registry_helper, init_node_registry_helper };

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

@@ -0,0 +1,36 @@
+import {
+  AskUserError,
+  init_workflow_hil
+} from "./roy-agent-core-e25xkv53.js";
+
+// 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 };