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

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

@@ -1,208 +0,0 @@
-// 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",
-  "prompt.before-render": "prompt:before.render",
-  "prompt.after-render": "prompt:after.render",
-  "prompt:before.render": "prompt.before-render",
-  "prompt:after.render": "prompt.after-render",
-  "prompt:after-render": "prompt.after-render",
-  "prompt:before-render": "prompt.before-render"
-};
-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 };

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

@@ -1,139 +0,0 @@
-import {
-  __esm
-} from "./roy-agent-core-fs0mn2jk.js";
-
-// src/env/workflow/utils/session-recovery.ts
-function inferNextNode(messages, definition) {
-  if (messages.length === 0) {
-    return { type: "entry_node", nodeId: definition.entryNode };
-  }
-  const lastMessage = messages[messages.length - 1];
-  const metadata = lastMessage.metadata;
-  switch (metadata?.type) {
-    case "workflow.node.start":
-      return {
-        type: "resume_node",
-        nodeId: metadata.workflowNodeId,
-        agentSessionId: metadata.agentSessionId
-      };
-    case "workflow.node.interrupt":
-      return {
-        type: "ask_user",
-        nodeId: metadata.workflowNodeId,
-        agentSessionId: metadata.agentSessionId
-      };
-    case "workflow.node.end":
-      return getNextNodes(metadata.workflowNodeId, definition);
-    default:
-      const lastStart = findLastStartMessage(messages);
-      if (lastStart) {
-        const startMetadata = lastStart.metadata;
-        return {
-          type: "resume_node",
-          nodeId: startMetadata.workflowNodeId,
-          agentSessionId: startMetadata.agentSessionId
-        };
-      }
-      return { type: "entry_node", nodeId: definition.entryNode };
-  }
-}
-function getNextNodes(completedNodeId, definition) {
-  if (!definition.edges) {
-    return { type: "next_nodes", nodeIds: [] };
-  }
-  const nextNodeIds = definition.edges.filter((edge) => edge.from === completedNodeId).map((edge) => edge.to);
-  return { type: "next_nodes", nodeIds: nextNodeIds };
-}
-function findLastInterruptMessage(messages) {
-  for (let i = messages.length - 1;i >= 0; i--) {
-    const msg = messages[i];
-    if (msg.metadata?.type === "workflow.node.interrupt") {
-      return msg;
-    }
-  }
-  return null;
-}
-function findLastStartMessage(messages) {
-  for (let i = messages.length - 1;i >= 0; i--) {
-    const msg = messages[i];
-    if (msg.metadata?.type === "workflow.node.start") {
-      return msg;
-    }
-  }
-  return null;
-}
-function parseNodeOutputs(messages) {
-  const outputs = new Map;
-  let lastStartNodeId = null;
-  for (const msg of messages) {
-    const metadata = msg.metadata;
-    if (metadata?.type === "workflow.node.start") {
-      lastStartNodeId = metadata.workflowNodeId;
-    } else if (metadata?.type === "workflow.node.end" && lastStartNodeId) {
-      try {
-        outputs.set(lastStartNodeId, JSON.parse(msg.content));
-      } catch {
-        outputs.set(lastStartNodeId, msg.content);
-      }
-      lastStartNodeId = null;
-    }
-  }
-  return outputs;
-}
-function hasPendingAskUser(messages) {
-  if (messages.length === 0)
-    return false;
-  const lastMessage = messages[messages.length - 1];
-  const metadata = lastMessage.metadata;
-  return metadata?.type === "workflow.node.interrupt";
-}
-function getAgentSessionIdFromInterrupt(messages) {
-  const lastInterrupt = findLastInterruptMessage(messages);
-  if (!lastInterrupt)
-    return null;
-  const metadata = lastInterrupt.metadata;
-  return metadata?.agentSessionId || null;
-}
-function extractResumeInfo(messages) {
-  const nodeOutputs = parseNodeOutputs(messages);
-  let pendingNodeId;
-  let agentSessionId;
-  let hasInterrupt = false;
-  let lastInterruptQuery;
-  for (const msg of messages) {
-    const metadata = msg.metadata;
-    if (metadata?.type === "workflow.node.start") {
-      pendingNodeId = metadata.workflowNodeId;
-      if (metadata?.agentSessionId && !agentSessionId) {
-        agentSessionId = metadata.agentSessionId;
-      }
-    } else if (metadata?.type === "workflow.node.end") {
-      pendingNodeId = undefined;
-      agentSessionId = undefined;
-    } else if (metadata?.type === "workflow.node.interrupt") {
-      pendingNodeId = metadata.workflowNodeId;
-      agentSessionId = metadata.agentSessionId;
-      hasInterrupt = true;
-      lastInterruptQuery = msg.content;
-    }
-  }
-  return {
-    pendingNodeId,
-    agentSessionId,
-    hasInterrupt,
-    nodeOutputs,
-    lastInterruptQuery
-  };
-}
-var init_session_recovery = () => {};
-init_session_recovery();
-
-export {
-  parseNodeOutputs,
-  inferNextNode,
-  hasPendingAskUser,
-  getAgentSessionIdFromInterrupt,
-  findLastStartMessage,
-  findLastInterruptMessage,
-  extractResumeInfo
-};