@ai-setting/roy-agent-core 1.5.43 → 1.5.45

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

@@ -0,0 +1,441 @@
+import {
+  AskUserError,
+  init_workflow_hil
+} from "./roy-agent-core-e25xkv53.js";
+import {
+  __esm,
+  __require
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/workflow/types/edge.ts
+import { z } from "zod";
+var EdgeDefinitionSchema;
+var init_edge = __esm(() => {
+  EdgeDefinitionSchema = z.object({
+    from: z.string().min(1, "Edge source node ID is required"),
+    to: z.string().min(1, "Edge target node ID is required"),
+    when: z.string().optional()
+  });
+});
+
+// src/env/workflow/types/workflow.ts
+import { z as z2 } from "zod";
+async function getYamlParser() {
+  if (!yamlParser) {
+    yamlParser = await import("yaml");
+  }
+  return yamlParser;
+}
+async function parseWorkflowFile(content, filename) {
+  const isYaml = filename.endsWith(".yaml") || filename.endsWith(".yml");
+  const isJson = filename.endsWith(".json");
+  let definition;
+  if (isYaml) {
+    const yaml = await getYamlParser();
+    definition = WorkflowDefinitionSchema.parse(yaml.parse(content));
+  } else if (isJson) {
+    definition = WorkflowDefinitionSchema.parse(JSON.parse(content));
+  } else {
+    try {
+      definition = WorkflowDefinitionSchema.parse(JSON.parse(content));
+    } catch {
+      const yaml = await getYamlParser();
+      definition = WorkflowDefinitionSchema.parse(yaml.parse(content));
+    }
+  }
+  return {
+    format: isYaml ? "yaml" : "json",
+    definition
+  };
+}
+function parseWorkflowFileSync(content, filename) {
+  const isYaml = filename.endsWith(".yaml") || filename.endsWith(".yml");
+  const isJson = filename.endsWith(".json");
+  let definition;
+  if (isJson) {
+    definition = WorkflowDefinitionSchema.parse(JSON.parse(content));
+  } else if (isYaml) {
+    throw new Error("Synchronous YAML parsing not supported. Use parseWorkflowFile() instead.");
+  } else {
+    try {
+      definition = WorkflowDefinitionSchema.parse(JSON.parse(content));
+    } catch {
+      throw new Error("Cannot auto-detect format. Please use .yaml, .yml, or .json extension.");
+    }
+  }
+  return {
+    format: isJson ? "json" : "yaml",
+    definition
+  };
+}
+var DependsOnSchema, RetryConfigSchema, NodeDefinitionSchema, WorkflowConfigSchema, OutputDefinitionSchema, InputParameterSchema, WorkflowInputsSchema, WorkflowMetadataSchema, WorkflowDefinitionSchema, yamlParser = null;
+var init_workflow = __esm(() => {
+  init_edge();
+  DependsOnSchema = z2.array(z2.string());
+  RetryConfigSchema = z2.object({
+    max_attempts: z2.number().min(1).default(1),
+    backoff: z2.enum(["fixed", "exponential"]).default("exponential"),
+    initial_delay: z2.number().min(0).default(1000)
+  });
+  NodeDefinitionSchema = z2.object({
+    id: z2.string().min(1, "Node ID is required"),
+    type: z2.string().min(1, "Node type is required"),
+    name: z2.string().optional(),
+    config: z2.record(z2.string(), z2.unknown()).optional().default({}),
+    depends_on: z2.array(z2.string()).optional(),
+    condition: z2.string().optional(),
+    retry: RetryConfigSchema.optional(),
+    timeout: z2.number().optional()
+  });
+  WorkflowConfigSchema = z2.object({
+    parallel_limit: z2.number().nullable().optional(),
+    timeout: z2.number().nullable().optional(),
+    retry: RetryConfigSchema.optional(),
+    debug: z2.boolean().optional(),
+    strict: z2.boolean().optional(),
+    maxIterations: z2.number().optional().default(100),
+    loopEnabled: z2.boolean().optional().default(false)
+  });
+  OutputDefinitionSchema = z2.object({
+    name: z2.string(),
+    source: z2.string(),
+    path: z2.string()
+  });
+  InputParameterSchema = z2.object({
+    type: z2.enum(["string", "number", "boolean", "object", "array"]),
+    description: z2.string().optional(),
+    default: z2.unknown().optional(),
+    required: z2.boolean().default(false)
+  });
+  WorkflowInputsSchema = z2.record(z2.string(), InputParameterSchema);
+  WorkflowMetadataSchema = z2.object({
+    author: z2.string().optional(),
+    taskId: z2.number().optional(),
+    tags: z2.array(z2.string()).optional().default([]),
+    created_at: z2.string().optional(),
+    updated_at: z2.string().optional()
+  });
+  WorkflowDefinitionSchema = z2.object({
+    name: z2.string().min(1, "Workflow name is required"),
+    version: z2.string().default("1.0"),
+    description: z2.string().optional(),
+    config: WorkflowConfigSchema.optional().default({}),
+    nodes: z2.array(NodeDefinitionSchema).min(1, "At least one node is required"),
+    entry: z2.union([z2.string(), z2.array(z2.string())]).default("__default_entry__"),
+    outputs: z2.array(OutputDefinitionSchema).optional().default([]),
+    inputs: WorkflowInputsSchema.optional().default({}),
+    metadata: WorkflowMetadataSchema.optional().default({}),
+    edges: z2.array(EdgeDefinitionSchema).optional().default([])
+  });
+});
+
+// src/env/workflow/types/workflow-message.ts
+import { z as z3 } from "zod";
+var WorkflowMessageRoleSchema;
+var init_workflow_message = __esm(() => {
+  init_workflow_hil();
+  WorkflowMessageRoleSchema = z3.enum([
+    "workflow.node.start",
+    "workflow.node.interrupt",
+    "workflow.node.end",
+    "workflow.node.resume"
+  ]);
+});
+
+// src/env/workflow/types/workflow-session.ts
+function isWorkflowSessionMetadata(metadata) {
+  if (typeof metadata !== "object" || metadata === null || !("type" in metadata) || metadata.type !== "workflow") {
+    return false;
+  }
+  const m = metadata;
+  if (!m.workflowId || typeof m.workflowId !== "string") {
+    return false;
+  }
+  if (!m.workflowName || typeof m.workflowName !== "string") {
+    return false;
+  }
+  if (!m.status || typeof m.status !== "string") {
+    return false;
+  }
+  const validStatuses = ["running", "paused", "completed", "failed", "stopped"];
+  if (!validStatuses.includes(m.status)) {
+    return false;
+  }
+  return true;
+}
+function getWorkflowSessionStatus(metadata) {
+  return metadata.status || "running";
+}
+var init_workflow_session = () => {};
+
+// src/env/workflow/types/context.ts
+var init_context = () => {};
+
+// src/env/workflow/types/event.ts
+import { z as z4 } from "zod";
+function createWorkflowEvent(type, runId, data) {
+  return {
+    type,
+    run_id: runId,
+    timestamp: Date.now(),
+    ...data
+  };
+}
+var BaseEventSchema, WorkflowStartedEventSchema, WorkflowPausedEventSchema, WorkflowResumedEventSchema, WorkflowStoppedEventSchema, WorkflowCompletedEventSchema, WorkflowFailedEventSchema, WorkflowOutputEventSchema, NodeScheduledEventSchema, NodeStartedEventSchema, NodeProgressEventSchema, NodeCompletedEventSchema, NodeFailedEventSchema, NodeSkippedEventSchema, NodeDataEventSchema, NodeAddedEventSchema, NodeRemovedEventSchema, ControlPauseEventSchema, ControlResumeEventSchema, ControlStopEventSchema, NodeInterruptEventSchema, WorkflowAskUserEventSchema, WorkflowEventSchema;
+var init_event = __esm(() => {
+  BaseEventSchema = z4.object({
+    type: z4.string(),
+    run_id: z4.string(),
+    timestamp: z4.number()
+  });
+  WorkflowStartedEventSchema = BaseEventSchema.extend({
+    type: z4.literal("workflow.started"),
+    workflow_name: z4.string(),
+    input: z4.record(z4.string(), z4.unknown()).optional()
+  });
+  WorkflowPausedEventSchema = BaseEventSchema.extend({
+    type: z4.literal("workflow.paused")
+  });
+  WorkflowResumedEventSchema = BaseEventSchema.extend({
+    type: z4.literal("workflow.resumed")
+  });
+  WorkflowStoppedEventSchema = BaseEventSchema.extend({
+    type: z4.literal("workflow.stopped"),
+    reason: z4.string()
+  });
+  WorkflowCompletedEventSchema = BaseEventSchema.extend({
+    type: z4.literal("workflow.completed"),
+    result: z4.record(z4.string(), z4.unknown()).optional(),
+    duration_ms: z4.number()
+  });
+  WorkflowFailedEventSchema = BaseEventSchema.extend({
+    type: z4.literal("workflow.failed"),
+    error: z4.object({
+      message: z4.string(),
+      stack: z4.string().optional()
+    }),
+    failed_at: z4.string()
+  });
+  WorkflowOutputEventSchema = BaseEventSchema.extend({
+    type: z4.literal("workflow.output"),
+    output: z4.record(z4.string(), z4.unknown())
+  });
+  NodeScheduledEventSchema = BaseEventSchema.extend({
+    type: z4.literal("node.scheduled"),
+    node_id: z4.string()
+  });
+  NodeStartedEventSchema = BaseEventSchema.extend({
+    type: z4.literal("node.started"),
+    node_id: z4.string(),
+    input: z4.any().optional(),
+    agentSessionId: z4.string().optional(),
+    userQuery: z4.string().optional(),
+    userResponse: z4.string().optional()
+  });
+  NodeProgressEventSchema = BaseEventSchema.extend({
+    type: z4.literal("node.progress"),
+    node_id: z4.string(),
+    progress: z4.number(),
+    message: z4.string().optional()
+  });
+  NodeCompletedEventSchema = BaseEventSchema.extend({
+    type: z4.literal("node.completed"),
+    node_id: z4.string(),
+    output: z4.any(),
+    duration_ms: z4.number()
+  });
+  NodeFailedEventSchema = BaseEventSchema.extend({
+    type: z4.literal("node.failed"),
+    node_id: z4.string(),
+    error: z4.object({
+      message: z4.string(),
+      stack: z4.string().optional()
+    })
+  });
+  NodeSkippedEventSchema = BaseEventSchema.extend({
+    type: z4.literal("node.skipped"),
+    node_id: z4.string(),
+    reason: z4.string()
+  });
+  NodeDataEventSchema = BaseEventSchema.extend({
+    type: z4.literal("node.data"),
+    from_node: z4.string(),
+    to_node: z4.string(),
+    data: z4.any()
+  });
+  NodeAddedEventSchema = BaseEventSchema.extend({
+    type: z4.literal("node.added"),
+    node_id: z4.string(),
+    node: z4.any()
+  });
+  NodeRemovedEventSchema = BaseEventSchema.extend({
+    type: z4.literal("node.removed"),
+    node_id: z4.string()
+  });
+  ControlPauseEventSchema = BaseEventSchema.extend({
+    type: z4.literal("control.pause")
+  });
+  ControlResumeEventSchema = BaseEventSchema.extend({
+    type: z4.literal("control.resume")
+  });
+  ControlStopEventSchema = BaseEventSchema.extend({
+    type: z4.literal("control.stop")
+  });
+  NodeInterruptEventSchema = BaseEventSchema.extend({
+    type: z4.literal("node.interrupt"),
+    node_id: z4.string(),
+    node_type: z4.string(),
+    query: z4.string()
+  });
+  WorkflowAskUserEventSchema = BaseEventSchema.extend({
+    type: z4.literal("workflow.ask-user"),
+    session_id: z4.string(),
+    node_id: z4.string(),
+    node_type: z4.string(),
+    query: z4.string()
+  });
+  WorkflowEventSchema = z4.union([
+    WorkflowStartedEventSchema,
+    WorkflowPausedEventSchema,
+    WorkflowResumedEventSchema,
+    WorkflowStoppedEventSchema,
+    WorkflowCompletedEventSchema,
+    WorkflowFailedEventSchema,
+    WorkflowOutputEventSchema,
+    NodeScheduledEventSchema,
+    NodeStartedEventSchema,
+    NodeProgressEventSchema,
+    NodeCompletedEventSchema,
+    NodeFailedEventSchema,
+    NodeSkippedEventSchema,
+    NodeDataEventSchema,
+    NodeAddedEventSchema,
+    NodeRemovedEventSchema,
+    ControlPauseEventSchema,
+    ControlResumeEventSchema,
+    ControlStopEventSchema,
+    NodeInterruptEventSchema,
+    WorkflowAskUserEventSchema
+  ]);
+});
+
+// src/env/workflow/types/run.ts
+import { z as z5 } from "zod";
+function createNodeExecutionContext(params) {
+  return {
+    ...params,
+    askUser: (query) => {
+      throw new AskUserError(params.runId, params.sessionId, params.nodeId, "unknown", query);
+    }
+  };
+}
+var RunStatusSchema, NodeStatusSchema;
+var init_run = __esm(() => {
+  init_workflow_message();
+  RunStatusSchema = z5.enum([
+    "idle",
+    "running",
+    "paused",
+    "stopped",
+    "completed",
+    "failed"
+  ]);
+  NodeStatusSchema = z5.enum([
+    "pending",
+    "scheduled",
+    "started",
+    "running",
+    "completed",
+    "failed",
+    "skipped"
+  ]);
+});
+
+// src/env/workflow/types/workflow-error.ts
+import { z as z6 } from "zod";
+function nodeNotFound(referencedNodeId, unresolved) {
+  return new TemplateUnresolvedError(`Referenced node not found: ${referencedNodeId}`, unresolved, { nodeId: referencedNodeId, reason: "node_not_found" });
+}
+function pathNotFound(referencedNodeId, path, template) {
+  return new TemplateUnresolvedError(`Path not found in node ${referencedNodeId}: ${path}`, [template], { nodeId: referencedNodeId, path, reason: "path_not_found" });
+}
+function unresolvedVariable(template, path) {
+  const context = { template, reason: "unresolved_variable" };
+  if (path) {
+    context.path = path;
+  }
+  return new TemplateUnresolvedError(`Unresolved variable: ${template}`, [template], context);
+}
+var WorkflowErrorContextSchema, WorkflowError, TemplateUnresolvedError, WorkflowValidationError;
+var init_workflow_error = __esm(() => {
+  WorkflowErrorContextSchema = z6.record(z6.unknown());
+  WorkflowError = class WorkflowError extends Error {
+    context;
+    constructor(message, context = {}) {
+      super(message);
+      this.context = context;
+      Object.defineProperty(this, "name", {
+        value: this.constructor.name,
+        writable: true,
+        enumerable: false,
+        configurable: true
+      });
+      if (Error.captureStackTrace) {
+        Error.captureStackTrace(this, this.constructor);
+      }
+    }
+    toJSON() {
+      return {
+        name: this.name,
+        message: this.message,
+        context: this.context,
+        stack: this.stack
+      };
+    }
+  };
+  TemplateUnresolvedError = class TemplateUnresolvedError extends WorkflowError {
+    unresolved;
+    constructor(message, unresolved = [], context = {}) {
+      super(message, context);
+      this.unresolved = unresolved;
+    }
+    toJSON() {
+      return {
+        ...super.toJSON(),
+        unresolved: this.unresolved
+      };
+    }
+  };
+  WorkflowValidationError = class WorkflowValidationError extends WorkflowError {
+    field;
+    invalidValue;
+    constructor(message, field, invalidValue) {
+      super(message, { field });
+      this.field = field;
+      this.invalidValue = invalidValue;
+    }
+    toJSON() {
+      return {
+        ...super.toJSON(),
+        field: this.field,
+        invalidValue: this.invalidValue
+      };
+    }
+  };
+});
+
+// src/env/workflow/types/index.ts
+var init_types = __esm(() => {
+  init_run();
+  init_workflow_error();
+  init_edge();
+  init_workflow();
+  init_workflow_message();
+  init_workflow_session();
+  init_context();
+  init_workflow_hil();
+  init_event();
+  init_run();
+});
+
+export { BaseEventSchema, WorkflowStartedEventSchema, WorkflowPausedEventSchema, WorkflowResumedEventSchema, WorkflowStoppedEventSchema, WorkflowCompletedEventSchema, WorkflowFailedEventSchema, WorkflowOutputEventSchema, NodeScheduledEventSchema, NodeStartedEventSchema, NodeProgressEventSchema, NodeCompletedEventSchema, NodeFailedEventSchema, NodeSkippedEventSchema, NodeDataEventSchema, NodeAddedEventSchema, NodeRemovedEventSchema, ControlPauseEventSchema, ControlResumeEventSchema, ControlStopEventSchema, NodeInterruptEventSchema, WorkflowAskUserEventSchema, WorkflowEventSchema, createWorkflowEvent, init_event, EdgeDefinitionSchema, DependsOnSchema, RetryConfigSchema, NodeDefinitionSchema, WorkflowConfigSchema, OutputDefinitionSchema, InputParameterSchema, WorkflowInputsSchema, WorkflowMetadataSchema, WorkflowDefinitionSchema, parseWorkflowFile, parseWorkflowFileSync, WorkflowMessageRoleSchema, isWorkflowSessionMetadata, getWorkflowSessionStatus, RunStatusSchema, NodeStatusSchema, createNodeExecutionContext, WorkflowError, TemplateUnresolvedError, WorkflowValidationError, nodeNotFound, pathNotFound, unresolvedVariable, init_workflow_error, init_types };

package/dist/shared/@ai-setting/{roy-agent-core-ee6nnnqw.js → roy-agent-core-r9hq4cjx.js}

@@ -8,7 +8,10 @@ import {
 } from "./roy-agent-core-q5qj0fes.js";
 import {
   BaseComponent
-} from "./roy-agent-core-4jqq077c.js";
+} from "./roy-agent-core-6e3wz81d.js";
+import {
+  init_context
+} from "./roy-agent-core-rm3hay00.js";
 import {
   createLogger,
   init_logger
@@ -421,4 +424,8 @@ class BaseEnvironment extends BaseComponent {
 __legacyDecorateClassTS([
   TracedAs("env.handle_query", { recordParams: true, recordResult: true, log: true })
 ], BaseEnvironment.prototype, "handle_query", null);
+
+// src/env/index.ts
+init_context();
+
 export { generateId, generateDescendingId, BaseEnvironment };

package/dist/shared/@ai-setting/{roy-agent-core-jqy2mdyq.js → roy-agent-core-rgj6hq15.js}

@@ -1,6 +1,10 @@
 import {
-  getEnvContext
-} from "./roy-agent-core-z33en0cz.js";
+  getEnvContext,
+  init_context
+} from "./roy-agent-core-rm3hay00.js";
+import {
+  __esm
+} from "./roy-agent-core-fs0mn2jk.js";
 
 // src/env/hook/hook-manager.ts
 class HookManager {
@@ -163,45 +167,11 @@ class HookManager {
     }
   }
 }
+var init_hook_manager = __esm(() => {
+  init_context();
+});
 
 // 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) {
@@ -212,7 +182,6 @@ function setupAliasHooks() {
     }
   };
 }
-setupAliasHooks();
 async function executeAgentHook(hookPoint, data, metadata = {}) {
   await globalHookManager.execute(hookPoint, data, metadata);
 }
@@ -225,5 +194,47 @@ async function executeLLMHook(hookPoint, data, metadata = {}) {
 async function executeToolHook(hookPoint, data, metadata = {}) {
   await globalHookManager.execute(hookPoint, data, metadata);
 }
+var globalHookManager, AgentHookPoints, LLMHookPoints, ToolHookPoints, hookPointAliases;
+var init_global_hook_manager = __esm(() => {
+  init_hook_manager();
+  globalHookManager = new HookManager;
+  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"
+  };
+  LLMHookPoints = {
+    BEFORE_INVOKE: "llm:before.invoke",
+    AFTER_INVOKE: "llm:after.invoke",
+    ON_STREAM: "llm:on.stream"
+  };
+  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"
+  };
+  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"
+  };
+  setupAliasHooks();
+});
 
-export { HookManager, globalHookManager, AgentHookPoints, LLMHookPoints, ToolHookPoints, executeAgentHook, executeAgentHookWithIntervention, executeLLMHook, executeToolHook };
+export { HookManager, init_hook_manager, globalHookManager, AgentHookPoints, LLMHookPoints, ToolHookPoints, executeAgentHook, executeAgentHookWithIntervention, executeLLMHook, executeToolHook, init_global_hook_manager };

package/dist/shared/@ai-setting/{roy-agent-core-z33en0cz.js → roy-agent-core-rm3hay00.js}

@@ -1,6 +1,9 @@
+import {
+  __esm
+} from "./roy-agent-core-fs0mn2jk.js";
+
 // src/env/context/env-context.ts
 import { AsyncLocalStorage } from "async_hooks";
-var envContextStorage = new AsyncLocalStorage;
 function getEnvContext() {
   return envContextStorage.getStore();
 }
@@ -41,4 +44,14 @@ function mergeEnvContext(partial) {
     Object.assign(current, partial);
   }
 }
-export { envContextStorage, getEnvContext, getEnvContextOrEmpty, hasEnvContext, runWithEnvContext, runWithEnvContextAsync, createEnvContext, mergeEnvContext };
+var envContextStorage;
+var init_env_context = __esm(() => {
+  envContextStorage = new AsyncLocalStorage;
+});
+
+// src/env/context/index.ts
+var init_context = __esm(() => {
+  init_env_context();
+});
+
+export { envContextStorage, getEnvContext, getEnvContextOrEmpty, hasEnvContext, runWithEnvContext, runWithEnvContextAsync, createEnvContext, mergeEnvContext, init_context };

package/dist/shared/@ai-setting/{roy-agent-core-e130w7mv.js → roy-agent-core-rx74rye7.js}

@@ -8,11 +8,12 @@ import {
 } from "./roy-agent-core-qxhq8ven.js";
 import {
   BaseComponent
-} from "./roy-agent-core-4jqq077c.js";
+} from "./roy-agent-core-6e3wz81d.js";
 import {
   ToolHookPoints,
-  globalHookManager
-} from "./roy-agent-core-jqy2mdyq.js";
+  globalHookManager,
+  init_global_hook_manager
+} from "./roy-agent-core-rgj6hq15.js";
 import {
   createLogger,
   init_logger
@@ -140,6 +141,7 @@ class ToolValidator {
 
 // src/env/tool/tool-component.ts
 init_logger();
+init_global_hook_manager();
 
 // src/env/tool/tool-config-registration.ts
 var TOOL_DEFAULTS = {

package/dist/shared/@ai-setting/{roy-agent-core-pxcrzyv9.js → roy-agent-core-sk535ft2.js}

@@ -6,7 +6,7 @@ import {
 } from "./roy-agent-core-qxhq8ven.js";
 import {
   BaseComponent
-} from "./roy-agent-core-4jqq077c.js";
+} from "./roy-agent-core-6e3wz81d.js";
 import {
   createLogger,
   init_logger