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

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

@@ -0,0 +1,419 @@
+import {
+  envKeyToConfigKey
+} from "./roy-agent-core-qxhq8ven.js";
+import {
+  BaseComponent
+} from "./roy-agent-core-rbetrphj.js";
+import {
+  init_decorator
+} from "./roy-agent-core-35x0wrtt.js";
+import {
+  createLogger,
+  init_logger,
+  setConfigComponent,
+  setQuietMode
+} from "./roy-agent-core-j3wc4465.js";
+import {
+  getTracerProvider,
+  init_propagation,
+  init_tracer_provider,
+  init_types,
+  propagation
+} from "./roy-agent-core-fv32jaa8.js";
+import {
+  SQLiteSpanStorage,
+  init_span_storage
+} from "./roy-agent-core-bncgx3gb.js";
+import {
+  __require
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/log-trace/index.ts
+init_types();
+init_span_storage();
+
+// src/env/log-trace/log-trace-component.ts
+init_logger();
+init_tracer_provider();
+init_span_storage();
+import { z } from "zod";
+import { join } from "path";
+
+// src/env/log-trace/trace-context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var contextStore = new AsyncLocalStorage;
+function createLightweightContext() {
+  return new LightweightTraceContext;
+}
+
+class LightweightTraceContext {
+  getRequestId() {
+    return contextStore.getStore()?.requestId;
+  }
+  getSpanContext() {
+    return contextStore.getStore()?.spanContext;
+  }
+  setSpanContext(spanContext) {
+    const store = contextStore.getStore();
+    if (store) {
+      store.spanContext = spanContext;
+    }
+  }
+  runWithContext(fn) {
+    const store = contextStore.getStore();
+    if (store) {
+      return contextStore.run(store, fn);
+    }
+    return fn();
+  }
+  runWithNewContext(requestId, sessionId, fn) {
+    const context = {
+      requestId,
+      sessionId,
+      timestamp: Date.now(),
+      spanContext: {
+        traceId: requestId,
+        spanId: this.generateSpanId()
+      }
+    };
+    return contextStore.run(context, fn);
+  }
+  async runWithContextAsync(fn) {
+    const store = contextStore.getStore();
+    if (store) {
+      return contextStore.run(store, fn);
+    }
+    return fn();
+  }
+  async runWithNewContextAsync(requestId, sessionId, fn) {
+    const context = {
+      requestId,
+      sessionId,
+      timestamp: Date.now(),
+      spanContext: {
+        traceId: requestId,
+        spanId: this.generateSpanId()
+      }
+    };
+    return contextStore.run(context, fn);
+  }
+  generateRequestId() {
+    return `req_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+  }
+  generateSpanId() {
+    return `span_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+  }
+  initContext(requestId, sessionId) {
+    const context = {
+      requestId,
+      sessionId,
+      timestamp: Date.now(),
+      spanContext: {
+        traceId: requestId,
+        spanId: this.generateSpanId()
+      }
+    };
+    contextStore.enterWith(context);
+  }
+  startNewContext(requestId, sessionId) {
+    const context = {
+      requestId,
+      sessionId,
+      timestamp: Date.now(),
+      spanContext: {
+        traceId: requestId,
+        spanId: this.generateSpanId()
+      }
+    };
+    const previousStore = contextStore.getStore();
+    contextStore.enterWith(context);
+    return () => {
+      contextStore.enterWith(previousStore);
+    };
+  }
+}
+var traceContextImpl = null;
+function initTraceContext(options) {
+  traceContextImpl = createLightweightContext();
+  return traceContextImpl;
+}
+
+// src/env/log-trace/log-trace-config-registration.ts
+var LOG_TRACE_DEFAULTS = {
+  "log-trace.logging.enabled": true,
+  "log-trace.logging.level": "info",
+  "log-trace.logging.quiet": false,
+  "log-trace.tracing.enabled": true
+};
+var LOG_TRACE_CONFIG_REGISTRATION = {
+  name: "log-trace",
+  sources: [
+    { type: "env", envPrefix: "LOG_TRACE", priority: 20, watch: false }
+  ],
+  keys: [
+    { key: "log-trace.logging.enabled", sources: ["env", "file"] },
+    { key: "log-trace.logging.level", sources: ["env", "file"] },
+    { key: "log-trace.logging.quiet", sources: ["env", "file"] },
+    { key: "log-trace.logging.dir", sources: ["env", "file"] },
+    { key: "log-trace.logging.file", sources: ["env", "file"] },
+    { key: "log-trace.logging.maxOutput", sources: ["env", "file"] },
+    { key: "log-trace.tracing.enabled", sources: ["env", "file"] },
+    { key: "log-trace.tracing.dbPath", sources: ["env", "file"] }
+  ]
+};
+
+// src/env/log-trace/log-trace-component.ts
+function getDefaultDataDir() {
+  try {
+    const xdg = __require("xdg-basedir");
+    if (xdg.xdgData) {
+      return xdg.xdgData;
+    }
+  } catch {}
+  const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+  return join(home, ".local", "share");
+}
+function getDefaultLogDir() {
+  return join(getDefaultDataDir(), "roy-agent", "logs");
+}
+function getDefaultSpanDbPath() {
+  return join(getDefaultDataDir(), "roy-agent", "traces.db");
+}
+var LogTraceConfigSchema = z.object({
+  logging: z.object({
+    enabled: z.boolean().default(true),
+    level: z.enum(["debug", "info", "warn", "error"]).default("info"),
+    quiet: z.boolean().default(false),
+    file: z.string().default("app.log"),
+    dir: z.string().default(getDefaultLogDir()),
+    maxOutput: z.number().default(0)
+  }).default({}),
+  tracing: z.object({
+    enabled: z.boolean().default(true),
+    dbPath: z.string().optional()
+  }).default({}),
+  initContext: z.object({
+    requestId: z.string().optional(),
+    sessionId: z.string().optional()
+  }).optional()
+});
+
+class LogTraceComponent extends BaseComponent {
+  name = "log-trace";
+  version = "1.0.0";
+  config;
+  configComponent;
+  tracer;
+  traceContext;
+  configWatcher;
+  constructor() {
+    super();
+  }
+  async init(config) {
+    await super.init(config);
+    const options = config.options;
+    if (!options?.configComponent) {
+      throw new Error("ConfigComponent is required for LogTraceComponent initialization");
+    }
+    this.configComponent = options.configComponent;
+    await this.registerConfig(options);
+    this.traceContext = initTraceContext();
+    const provider = getTracerProvider();
+    const _unused = provider;
+    await provider.initialize();
+    this.tracer = provider.getTracer("roy-tracer");
+    this.configureLogging();
+    if (this.config?.initContext?.requestId) {
+      this.traceContext.initContext(this.config.initContext.requestId, this.config.initContext.sessionId);
+    }
+    this.setStatus("running");
+  }
+  async registerConfig(options) {
+    const configComponent = options.configComponent;
+    if (!configComponent)
+      return;
+    const { configPath, envPrefix, config } = options;
+    const prefix = envPrefix !== undefined ? envPrefix : "LOG_TRACE";
+    configComponent.registerComponent(LOG_TRACE_CONFIG_REGISTRATION);
+    if (configPath) {
+      configComponent.registerSource({
+        type: "file",
+        relativePath: configPath,
+        optional: true,
+        watch: false
+      });
+    }
+    configComponent.registerSource({
+      type: "env",
+      envPrefix: prefix,
+      priority: 20,
+      watch: false
+    });
+    await configComponent.load("log-trace");
+    for (const envKey of Object.keys(process.env)) {
+      const configKey = envKeyToConfigKey(envKey, prefix, "log-trace");
+      if (!configKey)
+        continue;
+      const value = process.env[envKey];
+      if (value !== undefined) {
+        await configComponent.set(configKey, value);
+      }
+    }
+    for (const [key, value] of Object.entries(LOG_TRACE_DEFAULTS)) {
+      if (configComponent.get(key) === undefined) {
+        await configComponent.set(key, value);
+      }
+    }
+    if (configComponent.get("log-trace.logging.dir") === undefined) {
+      await configComponent.set("log-trace.logging.dir", getDefaultLogDir());
+    }
+    if (configComponent.get("log-trace.logging.file") === undefined) {
+      await configComponent.set("log-trace.logging.file", "app.log");
+    }
+    if (configComponent.get("log-trace.logging.maxOutput") === undefined) {
+      await configComponent.set("log-trace.logging.maxOutput", 0);
+    }
+    if (configComponent.get("log-trace.tracing.dbPath") === undefined) {
+      await configComponent.set("log-trace.tracing.dbPath", getDefaultSpanDbPath());
+    }
+    if (config) {
+      const flatConfig = this.flattenConfig(config);
+      for (const [key, value] of Object.entries(flatConfig)) {
+        await configComponent.set(key, value);
+      }
+    }
+    this.registerConfigWatcher(configComponent);
+    setConfigComponent(configComponent);
+    const tracingDbPath = configComponent.get("log-trace.tracing.dbPath");
+    this.config = {
+      logging: {
+        enabled: configComponent.get("log-trace.logging.enabled") ?? true,
+        level: configComponent.get("log-trace.logging.level") ?? "info",
+        quiet: configComponent.get("log-trace.logging.quiet") ?? false,
+        file: configComponent.get("log-trace.logging.file") ?? "app.log",
+        dir: configComponent.get("log-trace.logging.dir") ?? getDefaultLogDir(),
+        maxOutput: configComponent.get("log-trace.logging.maxOutput") ?? 0
+      },
+      tracing: {
+        enabled: configComponent.get("log-trace.tracing.enabled") ?? true,
+        dbPath: tracingDbPath ?? getDefaultSpanDbPath()
+      }
+    };
+  }
+  flattenConfig(obj, prefix = "log-trace") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      const fullKey = `${prefix}.${key}`;
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        Object.assign(result, this.flattenConfig(value, fullKey));
+      } else {
+        result[fullKey] = value;
+      }
+    }
+    return result;
+  }
+  registerConfigWatcher(configComponent) {
+    if (typeof configComponent.watch !== "function") {
+      return;
+    }
+    this.configWatcher = configComponent.watch("log-trace.*", (event) => {
+      this.onConfigChange(event);
+    });
+  }
+  onConfigChange(event) {
+    if (event.key === "log-trace.logging.quiet") {
+      setQuietMode(event.newValue);
+    }
+  }
+  createStorage() {
+    if (this.configComponent) {
+      const dbPath = this.configComponent.get("log-trace.tracing.dbPath");
+      if (dbPath) {
+        return new SQLiteSpanStorage(dbPath);
+      }
+    }
+    if (this.config?.tracing?.dbPath) {
+      return new SQLiteSpanStorage(this.config.tracing.dbPath);
+    }
+    return new SQLiteSpanStorage(getDefaultSpanDbPath());
+  }
+  configureLogging() {
+    if (!this.config?.logging)
+      return;
+    if (this.config.logging.quiet) {
+      setQuietMode(true);
+    }
+  }
+  initContext(requestId, sessionId) {
+    if (!this.traceContext) {
+      throw new Error("Component not initialized");
+    }
+    this.traceContext.initContext(requestId, sessionId);
+  }
+  startContext(requestId, sessionId) {
+    if (!this.traceContext) {
+      throw new Error("Component not initialized");
+    }
+    return this.traceContext.startNewContext(requestId, sessionId);
+  }
+  getLogger(prefix) {
+    return createLogger(prefix || "app");
+  }
+  getTracer() {
+    if (!this.tracer) {
+      throw new Error("Component not initialized");
+    }
+    return this.tracer;
+  }
+  getTraceContext() {
+    return this.traceContext;
+  }
+  getRequestId() {
+    return this.traceContext?.getRequestId();
+  }
+  async onStop() {
+    this.configWatcher?.();
+    this.configWatcher = undefined;
+    this.tracer = undefined;
+    this.setStatus("stopped");
+  }
+}
+
+// src/env/log-trace/index.ts
+init_tracer_provider();
+init_propagation();
+
+// src/env/log-trace/opentelemetry/propagation-env.ts
+init_propagation();
+init_tracer_provider();
+function injectToEnv(env = {}) {
+  const provider = getTracerProvider();
+  const tracer = provider.getTracer("roy-tracer");
+  tracer.injectToEnv(env);
+  return env;
+}
+function injectToEnvWithContext(env, context) {
+  propagation.inject(env, context);
+  return env;
+}
+function injectToEnvFromCarrier(target, source) {
+  const extracted = propagation.extract(source);
+  if (extracted) {
+    const context = {
+      traceId: extracted.traceId,
+      spanId: extracted.spanId,
+      parentSpanId: undefined
+    };
+    propagation.inject(target, context);
+  }
+  return target;
+}
+function getTraceparentHeader() {
+  return propagation.getTraceparentHeader();
+}
+
+// src/env/log-trace/index.ts
+init_logger();
+init_decorator();
+
+export { getDefaultLogDir, getDefaultSpanDbPath, LogTraceConfigSchema, LogTraceComponent, injectToEnv, injectToEnvWithContext, injectToEnvFromCarrier, getTraceparentHeader };

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

@@ -0,0 +1,266 @@
+import {
+  exports_node_registry_helper,
+  init_node_registry_helper
+} from "./roy-agent-core-0rtxwr28.js";
+import {
+  WorkflowService
+} from "./roy-agent-core-4t40mkpv.js";
+import {
+  askUserTool
+} from "./roy-agent-core-0vbdz0x7.js";
+import {
+  WorkflowEngine,
+  exports_engine,
+  init_engine
+} from "./roy-agent-core-fdb6m4e4.js";
+import {
+  BaseComponent
+} from "./roy-agent-core-rbetrphj.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-j3wc4465.js";
+import {
+  __require,
+  __toCommonJS
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/workflow/workflow-component.ts
+import"reflect-metadata";
+init_engine();
+init_logger();
+init_engine();
+init_node_registry_helper();
+var componentLogger = createLogger("workflow");
+
+class SkillRegistryAdapter {
+  skillComponent;
+  constructor(skillComponent) {
+    this.skillComponent = skillComponent;
+  }
+  getSkill(name) {
+    const entry = this.skillComponent.getSkill(name);
+    if (!entry)
+      return;
+    return {
+      name: entry.name,
+      invoke: async (input, context) => {
+        return entry.content;
+      }
+    };
+  }
+  hasSkill(name) {
+    return this.skillComponent.hasSkill(name);
+  }
+}
+
+class WorkflowComponent extends BaseComponent {
+  name = "workflow";
+  version = "1.0.0";
+  workflowService = null;
+  sessionComponent = null;
+  nodeRegistry = null;
+  decoratorsRegistered = false;
+  getService() {
+    return this.workflowService;
+  }
+  toolComponent;
+  llmComponent;
+  logTraceComponent;
+  _workflowEnv;
+  skillRegistry;
+  agentRunner;
+  async init(options) {
+    const opts = options;
+    this._status = "initializing";
+    componentLogger.info("Initializing WorkflowComponent...");
+    this.toolComponent = opts.toolComponent;
+    this.llmComponent = opts.llmComponent;
+    this.logTraceComponent = opts.logTraceComponent;
+    this._workflowEnv = opts.env;
+    this.skillRegistry = opts.skillRegistry;
+    this.agentRunner = opts.agentRunner;
+    try {
+      if (opts.autoRegisterDecorators !== false) {
+        await this.registerDecorators();
+      }
+      this._status = "ready";
+      componentLogger.info("WorkflowComponent initialized successfully");
+    } catch (error) {
+      this._status = "error";
+      componentLogger.error("Failed to initialize WorkflowComponent:", error);
+      throw error;
+    }
+  }
+  async registerDecorators() {
+    if (this.decoratorsRegistered)
+      return;
+    try {
+      const { NodeRegistry } = await import("../../env/workflow/engine/index.js");
+      const { registerDecoratorNodeType: registerDecoratorNodeType2 } = await import("./roy-agent-core-9yxb3ty9.js");
+      this.nodeRegistry = new NodeRegistry;
+      registerDecoratorNodeType2(this.nodeRegistry);
+      this.decoratorsRegistered = true;
+      componentLogger.info("Decorator node type registered");
+    } catch (error) {
+      componentLogger.error("Failed to register decorator node type:", error);
+      throw error;
+    }
+  }
+  createService(options) {
+    const skillRegistryAdapter = options.skillRegistry ? new SkillRegistryAdapter(options.skillRegistry) : undefined;
+    const sessionComponentForEngine = options.sessionComponent;
+    const engineFactory = (workflow, opts) => {
+      const { NodeRegistry, WorkflowEngine: WorkflowEngine2 } = (init_engine(), __toCommonJS(exports_engine));
+      const registry = new NodeRegistry({
+        toolRegistry: options.toolComponent,
+        agentComponent: options.env?.getComponent("agent"),
+        skillRegistry: skillRegistryAdapter,
+        sessionComponent: sessionComponentForEngine
+      });
+      const { registerDecoratorNodeType: registerDecoratorNodeType2 } = (init_node_registry_helper(), __toCommonJS(exports_node_registry_helper));
+      registerDecoratorNodeType2(registry);
+      return new WorkflowEngine2(registry, sessionComponentForEngine, options.workflowRepository);
+    };
+    this.workflowService = new WorkflowService(options.workflowRepository, engineFactory, options.sessionComponent);
+    return this.workflowService;
+  }
+  async runWorkflow(definition, input, options) {
+    const { NodeRegistry } = await import("../../env/workflow/engine/index.js");
+    const { registerDecoratorNodeType: registerDecoratorNodeType2 } = await import("./roy-agent-core-9yxb3ty9.js");
+    const toolComponent = this.toolComponent || this._workflowEnv?.getComponent("tool");
+    const skillComponent = this._workflowEnv?.getComponent("skill");
+    let agentRunner = this.agentRunner;
+    if (!agentRunner && this._workflowEnv) {
+      const agentComponent = this._workflowEnv.getComponent("agent");
+      if (agentComponent) {
+        const { AgentComponentAdapter } = await import("./roy-agent-core-z2t8hse8.js");
+        agentRunner = new AgentComponentAdapter(agentComponent);
+      }
+    }
+    const registry = new NodeRegistry({
+      toolRegistry: toolComponent,
+      skillRegistry: skillComponent,
+      agentRunner
+    });
+    registerDecoratorNodeType2(registry);
+    const engine = new WorkflowEngine(registry);
+    return engine.runWorkflow(definition, { ...options, input });
+  }
+  async onStop() {
+    componentLogger.info("[WorkflowComponent] Stopping and cleaning up resources...");
+    if (this.nodeRegistry) {
+      this.nodeRegistry = null;
+    }
+    if (this.workflowService) {
+      this.workflowService = null;
+      try {
+        const { closeDatabase } = await import("./roy-agent-core-q779wnwm.js");
+        closeDatabase();
+        componentLogger.info("[WorkflowComponent] SQLite database closed");
+      } catch (error) {
+        componentLogger.warn("[WorkflowComponent] Failed to close SQLite database:", error);
+      }
+    }
+    this._status = "stopped";
+    componentLogger.info("[WorkflowComponent] Cleanup completed");
+  }
+  async start() {
+    await super.start();
+    await this.initSqliteService();
+    await this.registerAskUserTool();
+  }
+  async registerAskUserTool() {
+    try {
+      const toolComponent = this.toolComponent || this._workflowEnv?.getComponent("tool");
+      if (!toolComponent) {
+        componentLogger.warn("ToolComponent not available, cannot register ask_user tool");
+        return;
+      }
+      if (typeof toolComponent.register === "function") {
+        toolComponent.register(askUserTool);
+        componentLogger.info("ask_user tool registered to ToolComponent");
+      } else if (typeof toolComponent.registerMany === "function") {
+        toolComponent.registerMany([askUserTool]);
+        componentLogger.info("ask_user tool registered to ToolComponent");
+      } else {
+        componentLogger.warn("ToolComponent does not support tool registration");
+      }
+    } catch (error) {
+      componentLogger.warn("Failed to register ask_user tool:", error);
+    }
+  }
+  async initSqliteService() {
+    try {
+      const { getDatabase, initializeTables } = await import("./roy-agent-core-q779wnwm.js");
+      const { WorkflowRepository } = await import("./roy-agent-core-rft3fmp0.js");
+      const db = getDatabase();
+      initializeTables();
+      const workflowRepository = new WorkflowRepository(db);
+      const toolComponent = this.toolComponent || this._workflowEnv?.getComponent("tool");
+      const llmComponent = this.llmComponent || this._workflowEnv?.getComponent("llm");
+      const agentComponent = this._workflowEnv?.getComponent("agent");
+      const skillComponent = this.skillRegistry || this._workflowEnv?.getComponent("skill");
+      const sessionComponent = this._workflowEnv?.getComponent("session");
+      componentLogger.info(`initSqliteService - toolComponent: ${!!toolComponent}, llmComponent: ${!!llmComponent}, skillRegistry: ${!!skillComponent}, sessionComponent: ${!!sessionComponent}`);
+      this.createService({
+        workflowRepository,
+        toolComponent,
+        llmComponent,
+        env: this._workflowEnv,
+        skillRegistry: skillComponent,
+        sessionComponent
+      });
+      this.sessionComponent = sessionComponent;
+      await this.registerAskUserTool();
+      componentLogger.info("SQLite WorkflowService initialized successfully");
+    } catch (error) {
+      componentLogger.error("Failed to initialize SQLite WorkflowService:", error);
+      await this.createInMemoryService();
+    }
+  }
+  createInMemoryService() {
+    const workflows = new Map;
+    const workflowRepository = {
+      create: (wf) => {
+        const id = wf.id || `wf_${Date.now()}`;
+        const record = { ...wf, id, createdAt: new Date, updatedAt: new Date };
+        workflows.set(id, record);
+        return record;
+      },
+      getById: (id) => workflows.get(id) || null,
+      getByName: (name) => {
+        for (const wf of workflows.values()) {
+          if (wf.name === name)
+            return wf;
+        }
+        return null;
+      },
+      list: () => Array.from(workflows.values()),
+      update: (id, updates) => {
+        const wf = workflows.get(id);
+        if (!wf)
+          return null;
+        const updated = { ...wf, ...updates, updatedAt: new Date };
+        workflows.set(id, updated);
+        return updated;
+      },
+      delete: (id) => workflows.delete(id)
+    };
+    const sessionComponent = this._workflowEnv?.getComponent("session");
+    return this.createService({
+      workflowRepository,
+      sessionComponent
+    });
+  }
+  async stop() {
+    componentLogger.info("Stopping WorkflowComponent...");
+    this._status = "stopping";
+    this.workflowService = null;
+    this.nodeRegistry = null;
+    this._status = "stopped";
+    componentLogger.info("WorkflowComponent stopped");
+  }
+}
+
+export { WorkflowComponent };