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

package/dist/env/hook/index.js

@@ -1,273 +0,0 @@
-// @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/hook/types.ts
-function createHook(meta, fn) {
-  return {
-    ...meta,
-    execute: fn
-  };
-}
-function createPriorityHook(name, fn, priority) {
-  return createHook({ name, priority }, fn);
-}
-// packages/core/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;
-    }
-  }
-}
-// packages/core/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 {
-  globalHookManager,
-  executeToolHook,
-  executeLLMHook,
-  executeAgentHookWithIntervention,
-  executeAgentHook,
-  createPriorityHook,
-  createHook,
-  ToolHookPoints,
-  LLMHookPoints,
-  HookManager,
-  AgentHookPoints
-};