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

package/dist/shared/{chunk-q9j99fsm.js → @ai-setting/roy-agent-core-fv32jaa8.js}

@@ -1,12 +1,12 @@
 import {
   SQLiteSpanStorage,
   init_span_storage
-} from "./chunk-1qwabsm0.js";
+} from "./roy-agent-core-bncgx3gb.js";
 import {
   __esm,
   __export,
   __require
-} from "./chunk-wbkh7wat.js";
+} from "./roy-agent-core-fs0mn2jk.js";
 
 // src/env/log-trace/opentelemetry/propagation.ts
 function padLeft(str, length) {
@@ -365,4 +365,4 @@ var init_tracer_provider = __esm(() => {
   init_types();
 });
 
-export { propagation, init_propagation, SpanKind, SpanStatus, init_types, OTelTracerProvider, getTracerProvider, resetTracerProvider, exports_tracer_provider, init_tracer_provider };
+export { serialize, parse, propagation, init_propagation, SpanKind, SpanStatus, init_types, OTelTracerProvider, getTracerProvider, resetTracerProvider, exports_tracer_provider, init_tracer_provider };

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

@@ -0,0 +1,171 @@
+// src/env/memory/built-in/record-memory.ts
+import { z } from "zod";
+var RecordMemorySchema = z.object({
+  scope: z.enum(["project", "global"]).describe("作用域: project/global"),
+  mode: z.enum(["append", "prepend", "overwrite", "delete"]).describe("模式: append(追加)/prepend(插入)/overwrite(覆盖)/delete(删除)"),
+  content: z.string().optional().describe("记忆内容"),
+  title: z.string().optional().describe("章节标题")
+});
+function createRecordMemoryTool(recordMemory, getMemoryPaths, getMemoryFile) {
+  return {
+    name: "record_memory",
+    description: buildDescription(getMemoryPaths, getMemoryFile),
+    parameters: RecordMemorySchema,
+    execute: async (args, _ctx) => {
+      const params = RecordMemorySchema.parse(args);
+      const startTime = Date.now();
+      try {
+        const result = await recordMemory({
+          scope: params.scope,
+          mode: params.mode,
+          content: params.content,
+          title: params.title
+        });
+        if (!result) {
+          return {
+            success: false,
+            output: "",
+            error: "未配置 memory 路径，无法记录记忆",
+            metadata: { execution_time_ms: Date.now() - startTime }
+          };
+        }
+        const actionMessages = {
+          created: "已创建记忆文件",
+          overwrite: "已覆盖记忆文件",
+          append: "已追加内容到记忆文件",
+          prepend: "已插入内容到记忆文件开头",
+          delete: "已删除记忆文件"
+        };
+        return {
+          success: true,
+          output: `${actionMessages[result.action]}: ${result.path}`,
+          metadata: {
+            execution_time_ms: Date.now() - startTime,
+            path: result.path,
+            action: result.action
+          }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      }
+    }
+  };
+}
+function buildDescription(getMemoryPaths, getMemoryFile) {
+  const paths = getMemoryPaths();
+  const memoryFile = getMemoryFile();
+  const lines = [
+    `# Record Memory Tool`,
+    "",
+    `Record memory to file. Writes to the memory.md file in the specified scope.`,
+    "",
+    `## Modes`,
+    "",
+    "| Mode | Description |",
+    "|------|-------------|",
+    "| **append** | 追加内容到 ${memoryFile} 尾部 |",
+    "| **prepend** | 插入内容到 ${memoryFile} 开头 |",
+    "| **overwrite** | 覆盖 ${memoryFile} |",
+    "| **delete** | 删除 ${memoryFile} |",
+    "",
+    `## Parameters`,
+    "",
+    "- **scope** (required): 作用域 - project 或 global",
+    "- **mode** (required): 操作模式",
+    "- **content** (optional): 记忆内容",
+    "- **title** (optional): 章节标题",
+    "",
+    `## Memory Paths`,
+    ""
+  ];
+  if (paths.length === 0) {
+    lines.push("No memory paths configured.");
+  } else {
+    lines.push("Files will be written to:");
+    for (const p of paths) {
+      lines.push(`- **[${p.type}]** ${p.path}/${memoryFile}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+
+// src/env/memory/built-in/recall-memory.ts
+import { z as z2 } from "zod";
+var RecallMemorySchema = z2.object({
+  scope: z2.enum(["project", "global"]).optional().describe("作用域（可选，不传则读取所有）")
+});
+function createRecallMemoryTool(recallMemory, getMemoryPaths, getMemoryFile) {
+  return {
+    name: "recall_memory",
+    description: buildDescription2(getMemoryPaths, getMemoryFile),
+    parameters: RecallMemorySchema,
+    execute: async (args, _ctx) => {
+      const params = RecallMemorySchema.parse(args);
+      const startTime = Date.now();
+      try {
+        const content = await recallMemory(params.scope);
+        if (!content) {
+          return {
+            success: true,
+            output: "(No memory files found)",
+            metadata: { execution_time_ms: Date.now() - startTime }
+          };
+        }
+        return {
+          success: true,
+          output: content,
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      }
+    }
+  };
+}
+function buildDescription2(getMemoryPaths, getMemoryFile) {
+  const paths = getMemoryPaths();
+  const memoryFile = getMemoryFile();
+  const lines = [
+    `# Recall Memory Tool`,
+    "",
+    `Recall memory from memory files. Reads from the memory.md file in the specified scope.`,
+    "",
+    `## Parameters`,
+    "",
+    "- **scope** (optional): 作用域 - project 或 global（不传则读取所有）",
+    "",
+    `## Memory Files`,
+    ""
+  ];
+  if (paths.length === 0) {
+    lines.push("No memory paths configured.");
+  } else {
+    lines.push("Files will be read from:");
+    for (const p of paths) {
+      lines.push(`- **[${p.type}]** ${p.path}/${memoryFile}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+
+// src/env/memory/built-in/index.ts
+function createMemoryTools(recordMemory, recallMemory, config) {
+  return [
+    createRecordMemoryTool(recordMemory, config.getMemoryPaths, config.getMemoryFile),
+    createRecallMemoryTool(recallMemory, config.getMemoryPaths, config.getMemoryFile)
+  ];
+}
+
+export { RecordMemorySchema, RecallMemorySchema, createMemoryTools };

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

@@ -0,0 +1,202 @@
+// src/env/hook/hook-manager.ts
+class HookManager {
+  _hooks = new Map;
+  componentName;
+  componentVersion;
+  defaultPriority;
+  constructor(options = {}) {
+    this.componentName = options.componentName ?? "unknown";
+    this.componentVersion = options.componentVersion ?? "0.0.0";
+    this.defaultPriority = options.defaultPriority ?? 0;
+  }
+  register(hookPoint, hook) {
+    const hooks = this.getOrCreateHooks(hookPoint);
+    hooks.push(hook);
+  }
+  registerMany(hookPoint, hooks) {
+    const hookList = this.getOrCreateHooks(hookPoint);
+    hookList.push(...hooks);
+  }
+  unregister(hookPoint, name) {
+    const hooks = this._hooks.get(hookPoint);
+    if (!hooks)
+      return false;
+    const index = hooks.findIndex((h) => h.name === name);
+    if (index === -1)
+      return false;
+    hooks.splice(index, 1);
+    return true;
+  }
+  unregisterAll(hookPoint) {
+    this._hooks.delete(hookPoint);
+  }
+  async execute(hookPoint, data, metadata = {}) {
+    const hooks = this._hooks.get(hookPoint);
+    if (!hooks || hooks.length === 0)
+      return;
+    const sortedHooks = this.sortHooks(hooks);
+    const ctx = this.createContext(hookPoint, data, metadata, "before");
+    for (const hook of sortedHooks) {
+      await this.safeExecute(hook, ctx);
+    }
+  }
+  async executeAndCollect(hookPoint, data, metadata = {}) {
+    const hooks = this._hooks.get(hookPoint);
+    if (!hooks || hooks.length === 0)
+      return [];
+    const sortedHooks = this.sortHooks(hooks);
+    const ctx = this.createContext(hookPoint, data, metadata, "before");
+    const results = [];
+    for (const hook of sortedHooks) {
+      const result = await this.safeExecuteAndReturn(hook, ctx);
+      if (result !== undefined) {
+        results.push(result);
+      }
+    }
+    return results;
+  }
+  count(hookPoint) {
+    return this._hooks.get(hookPoint)?.length ?? 0;
+  }
+  clear() {
+    this._hooks.clear();
+  }
+  getHookPoints() {
+    return Array.from(this._hooks.keys());
+  }
+  hasHooks(hookPoint) {
+    return this.count(hookPoint) > 0;
+  }
+  setComponentInfo(name, version) {
+    this.componentName = name;
+    this.componentVersion = version;
+  }
+  get hooks() {
+    return this._hooks;
+  }
+  async executeWithIntervention(hookPoint, data, metadata = {}) {
+    const hooks = this._hooks.get(hookPoint);
+    if (!hooks || hooks.length === 0) {
+      return { stopped: false, results: [] };
+    }
+    const sortedHooks = this.sortHooks(hooks);
+    const ctx = this.createContext(hookPoint, data, metadata, "before");
+    const results = [];
+    let stopped = false;
+    let action;
+    for (const hook of sortedHooks) {
+      if (stopped)
+        break;
+      const result = await this.safeExecuteAndReturn(hook, ctx);
+      results.push(result);
+      if (result && typeof result === "object" && "stopped" in result) {
+        const hookResult = result;
+        if (hookResult.stopped) {
+          stopped = true;
+          action = hookResult.action;
+        }
+      }
+    }
+    return { stopped, action, results };
+  }
+  getOrCreateHooks(hookPoint) {
+    let hooks = this._hooks.get(hookPoint);
+    if (!hooks) {
+      hooks = [];
+      this._hooks.set(hookPoint, hooks);
+    }
+    return hooks;
+  }
+  sortHooks(hooks) {
+    return [...hooks].sort((a, b) => {
+      const priorityA = a.priority ?? this.defaultPriority;
+      const priorityB = b.priority ?? this.defaultPriority;
+      return priorityA - priorityB;
+    });
+  }
+  createContext(hookPoint, data, metadata, phase) {
+    return {
+      component: {
+        name: this.componentName,
+        version: this.componentVersion
+      },
+      data,
+      metadata,
+      phase,
+      hookPoint
+    };
+  }
+  async safeExecute(hook, ctx) {
+    try {
+      await hook.execute(ctx);
+    } catch (error) {
+      console.error(`Hook "${hook.name}" failed:`, error);
+    }
+  }
+  async safeExecuteAndReturn(hook, ctx) {
+    try {
+      return await hook.execute(ctx);
+    } catch (error) {
+      console.error(`Hook "${hook.name}" failed:`, error);
+      return;
+    }
+  }
+}
+
+// src/env/hook/global-hook-manager.ts
+var globalHookManager = new HookManager;
+var AgentHookPoints = {
+  BEFORE_START: "agent:before.start",
+  BEFORE_LLM: "agent:before.llm",
+  AFTER_LLM: "agent:after.llm",
+  BEFORE_TOOL: "agent:before.tool",
+  AFTER_TOOL: "agent:after.tool",
+  ON_ITERATION: "agent:on.iteration",
+  ON_THRESHOLD: "agent:on.threshold",
+  AFTER_COMPLETE: "agent:after.complete",
+  ON_ERROR: "agent:on.error"
+};
+var LLMHookPoints = {
+  BEFORE_INVOKE: "llm:before.invoke",
+  AFTER_INVOKE: "llm:after.invoke",
+  ON_STREAM: "llm:on.stream"
+};
+var ToolHookPoints = {
+  BEFORE_EXECUTE: "tool:before.execute",
+  AFTER_EXECUTE: "tool:after.execute",
+  BEFORE_REGISTER: "tool:before.register",
+  AFTER_REGISTER: "tool:after.register",
+  ON_ERROR: "tool:on.error"
+};
+var hookPointAliases = {
+  "before.tool": "tool:before.execute",
+  "after.tool": "tool:after.execute",
+  "llm.before-invoke": "llm:before.invoke",
+  "llm.after-invoke": "llm:after.invoke",
+  "llm.stream": "llm:on.stream"
+};
+function setupAliasHooks() {
+  const originalRegister = globalHookManager.register.bind(globalHookManager);
+  globalHookManager.register = function(hookPoint, hook) {
+    originalRegister(hookPoint, hook);
+    const alias = hookPointAliases[hookPoint];
+    if (alias) {
+      originalRegister(alias, hook);
+    }
+  };
+}
+setupAliasHooks();
+async function executeAgentHook(hookPoint, data, metadata = {}) {
+  await globalHookManager.execute(hookPoint, data, metadata);
+}
+async function executeAgentHookWithIntervention(hookPoint, data, metadata = {}) {
+  return globalHookManager.executeWithIntervention(hookPoint, data, metadata);
+}
+async function executeLLMHook(hookPoint, data, metadata = {}) {
+  await globalHookManager.execute(hookPoint, data, metadata);
+}
+async function executeToolHook(hookPoint, data, metadata = {}) {
+  await globalHookManager.execute(hookPoint, data, metadata);
+}
+
+export { HookManager, globalHookManager, AgentHookPoints, LLMHookPoints, ToolHookPoints, executeAgentHook, executeAgentHookWithIntervention, executeLLMHook, executeToolHook };