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

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

@@ -0,0 +1,368 @@
+import {
+  SQLiteSpanStorage,
+  init_span_storage
+} from "./roy-agent-core-j8zx62zr.js";
+import {
+  __esm,
+  __export,
+  __require
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// packages/core/src/env/log-trace/opentelemetry/propagation.ts
+function padLeft(str, length) {
+  return str.padStart(length, "0");
+}
+function isValidHex(str) {
+  return /^[0-9a-f]+$/i.test(str);
+}
+function serialize(context) {
+  const traceId = padLeft(context.traceId.toLowerCase(), TRACE_ID_LENGTH);
+  const spanId = padLeft(context.spanId.toLowerCase(), PARENT_SPAN_ID_LENGTH);
+  const parts = [
+    TRACE_CONTEXT_VERSION,
+    traceId,
+    spanId,
+    TRACE_FLAGS_SAMPLED
+  ];
+  return parts.join("-");
+}
+function parse(traceparent) {
+  if (!traceparent || typeof traceparent !== "string") {
+    return;
+  }
+  const trimmed = traceparent.trim();
+  const parts = trimmed.split("-");
+  if (parts.length !== 4) {
+    return;
+  }
+  const [version, traceId, senderSpanId, flags] = parts;
+  if (version !== TRACE_CONTEXT_VERSION) {
+    if (version > TRACE_CONTEXT_VERSION) {
+      return;
+    }
+  }
+  if (traceId.length !== TRACE_ID_LENGTH || !isValidHex(traceId)) {
+    return;
+  }
+  if (senderSpanId.length !== PARENT_SPAN_ID_LENGTH || !isValidHex(senderSpanId)) {
+    return;
+  }
+  if (flags.length !== FLAGS_LENGTH || !isValidHex(flags)) {
+    return;
+  }
+  return {
+    traceId: traceId.toLowerCase(),
+    spanId: senderSpanId.toLowerCase()
+  };
+}
+var TRACE_CONTEXT_VERSION = "00", TRACE_FLAGS_SAMPLED = "01", TRACEPARENT_HEADER = "TRACEPARENT", TRACE_ID_LENGTH = 32, PARENT_SPAN_ID_LENGTH = 16, FLAGS_LENGTH = 2, propagation;
+var init_propagation = __esm(() => {
+  propagation = {
+    inject(carrier, context) {
+      carrier[TRACEPARENT_HEADER] = serialize(context);
+    },
+    extract(carrier) {
+      const traceparent = carrier[TRACEPARENT_HEADER];
+      if (!traceparent) {
+        return;
+      }
+      return parse(traceparent);
+    },
+    getTraceparentHeader() {
+      return TRACEPARENT_HEADER;
+    }
+  };
+});
+
+// packages/core/src/env/log-trace/types.ts
+var SpanKind, SpanStatus;
+var init_types = __esm(() => {
+  ((SpanKind2) => {
+    SpanKind2["CLIENT"] = "client";
+    SpanKind2["SERVER"] = "server";
+    SpanKind2["INTERNAL"] = "internal";
+  })(SpanKind ||= {});
+  ((SpanStatus2) => {
+    SpanStatus2["OK"] = "ok";
+    SpanStatus2["ERROR"] = "error";
+  })(SpanStatus ||= {});
+});
+
+// packages/core/src/env/log-trace/opentelemetry/tracer-provider.ts
+var exports_tracer_provider = {};
+__export(exports_tracer_provider, {
+  resetTracerProvider: () => resetTracerProvider,
+  getTracerProvider: () => getTracerProvider,
+  OTelTracerProvider: () => OTelTracerProvider
+});
+
+class OTelSpanImpl {
+  name;
+  kind;
+  spanContext;
+  attributes = {};
+  startTime;
+  endTime;
+  error;
+  storage;
+  parentSpanContext;
+  onEnd;
+  constructor(name, spanContext, storage, parentSpanContext, onEnd) {
+    this.name = name;
+    this.kind = "internal";
+    this.spanContext = spanContext;
+    this.parentSpanContext = parentSpanContext;
+    this.startTime = Date.now();
+    this.storage = storage;
+    this.onEnd = onEnd;
+  }
+  setAttribute(key, value) {
+    this.attributes[key] = value;
+  }
+  addEvent(name, attributes) {
+    const events = this.attributes._events || [];
+    events.push({ name, attributes });
+    this.attributes._events = events;
+  }
+  end(result, error) {
+    this.endTime = Date.now();
+    if (error) {
+      this.error = error.message;
+    }
+    this.storage.save({
+      traceId: this.spanContext.traceId,
+      spanId: this.spanContext.spanId,
+      parentSpanId: this.spanContext.parentSpanId,
+      name: this.name,
+      kind: this.kind,
+      status: error ? "error" /* ERROR */ : "ok" /* OK */,
+      startTime: this.startTime,
+      endTime: this.endTime,
+      attributes: this.attributes,
+      result,
+      error: this.error
+    });
+    this.onEnd?.();
+  }
+}
+
+class OTelTracerImpl {
+  name;
+  version;
+  storage;
+  currentContext;
+  activeSpans = new Map;
+  onSpanEndCallback;
+  provider;
+  constructor(name, version, storage, provider) {
+    this.name = name;
+    this.version = version;
+    this.storage = storage;
+    this.provider = provider;
+  }
+  setOnSpanEndCallback(callback) {
+    this.onSpanEndCallback = callback;
+  }
+  getActiveSpanCount() {
+    return this.activeSpans.size;
+  }
+  startSpan(name, options) {
+    const parentFromOptions = options?.parent;
+    const hasExplicitParent = options && "parent" in options;
+    const globalContext = this.provider.getGlobalContext();
+    let effectiveParentContext;
+    if (hasExplicitParent) {
+      effectiveParentContext = parentFromOptions;
+    } else if (this.currentContext) {
+      effectiveParentContext = this.currentContext;
+    } else if (globalContext) {
+      effectiveParentContext = globalContext;
+    }
+    const traceId = effectiveParentContext?.traceId || this.generateTraceId();
+    const spanId = this.generateSpanId();
+    let parentSpanId;
+    if (hasExplicitParent && parentFromOptions) {
+      parentSpanId = parentFromOptions.parentSpanId || parentFromOptions.spanId;
+    } else if (this.currentContext) {
+      parentSpanId = this.currentContext.spanId;
+    } else if (globalContext) {
+      parentSpanId = globalContext.spanId;
+    }
+    const spanContext = {
+      traceId,
+      spanId,
+      parentSpanId
+    };
+    this.currentContext = {
+      traceId,
+      spanId,
+      parentSpanId
+    };
+    const span = new OTelSpanImpl(name, spanContext, this.storage, effectiveParentContext, () => this.handleSpanEnd(spanContext.spanId, effectiveParentContext?.spanId));
+    if (options?.attributes) {
+      for (const [key, value] of Object.entries(options.attributes)) {
+        span.setAttribute(key, value);
+      }
+    }
+    this.activeSpans.set(spanId, span);
+    return span;
+  }
+  injectToEnv(env) {
+    if (this.currentContext) {
+      propagation.inject(env, this.currentContext);
+    }
+  }
+  getCurrentContext() {
+    return this.currentContext;
+  }
+  setCurrentContext(context) {
+    this.currentContext = context;
+  }
+  endSpan(span) {
+    const spanContext = span.spanContext;
+    this.activeSpans.delete(spanContext.spanId);
+    const currentTraceId = this.currentContext?.traceId;
+    if (spanContext.parentSpanId) {
+      const parentSpan = this.activeSpans.get(spanContext.parentSpanId);
+      if (parentSpan) {
+        const parentContext = {
+          traceId: spanContext.traceId,
+          spanId: parentSpan.spanContext.spanId,
+          parentSpanId: parentSpan.spanContext.parentSpanId
+        };
+        this.currentContext = parentContext;
+        return parentContext;
+      }
+      if (currentTraceId) {
+        const parentContext = {
+          traceId: currentTraceId,
+          spanId: spanContext.parentSpanId,
+          parentSpanId: undefined
+        };
+        this.currentContext = parentContext;
+        return parentContext;
+      }
+    }
+    this.currentContext = undefined;
+    return;
+  }
+  generateTraceId() {
+    const timestamp = Date.now().toString(16).padStart(12, "0");
+    const random = Array.from({ length: 5 }, () => Math.floor(Math.random() * 4294967295).toString(16).padStart(8, "0")).join("");
+    return (timestamp + random).slice(0, 32).padStart(32, "0");
+  }
+  generateSpanId() {
+    return Math.floor(Math.random() * 18446744073709552000).toString(16).padStart(16, "0");
+  }
+  handleSpanEnd(spanId, parentSpanId) {
+    this.activeSpans.delete(spanId);
+    const currentTraceId = this.currentContext?.traceId;
+    if (parentSpanId) {
+      const parentSpan = this.activeSpans.get(parentSpanId);
+      if (parentSpan) {
+        this.currentContext = {
+          traceId: parentSpan.spanContext.traceId,
+          spanId: parentSpan.spanContext.spanId,
+          parentSpanId: parentSpan.spanContext.parentSpanId
+        };
+        return;
+      }
+      if (currentTraceId) {
+        this.currentContext = {
+          traceId: currentTraceId,
+          spanId: parentSpanId,
+          parentSpanId: undefined
+        };
+        return;
+      }
+    }
+    this.currentContext = undefined;
+  }
+}
+
+class OTelTracerProvider {
+  tracers = new Map;
+  storage;
+  initialized = false;
+  globalContext;
+  constructor(storage, dbPath) {
+    this.storage = storage || new SQLiteSpanStorage(dbPath || getDefaultDbPath());
+  }
+  async initialize() {
+    if (this.initialized)
+      return;
+    await this.storage.initialize();
+    this.initialized = true;
+  }
+  isInitialized() {
+    return this.initialized;
+  }
+  getGlobalContext() {
+    return this.globalContext;
+  }
+  setGlobalContext(context) {
+    this.globalContext = context;
+  }
+  getTracer(name, version) {
+    const key = `${name}@${version || "0.0.0"}`;
+    let tracer = this.tracers.get(key);
+    if (!tracer) {
+      tracer = new OTelTracerImpl(name, version, this.storage, this);
+      this.tracers.set(key, tracer);
+      if (this.initialized) {
+        this.restoreFromEnv(tracer);
+      }
+    }
+    return tracer;
+  }
+  restoreFromEnv(tracer) {
+    const extracted = propagation.extract(process.env);
+    if (extracted) {
+      tracer.setCurrentContext({
+        traceId: extracted.traceId,
+        spanId: extracted.spanId,
+        parentSpanId: undefined
+      });
+    }
+  }
+  shutdown() {
+    for (const tracer of this.tracers.values()) {}
+    this.tracers.clear();
+    this.storage.close();
+    this.initialized = false;
+    this.globalContext = undefined;
+    delete process.env["TRACEPARENT"];
+    delete process.env["TRACE_ID"];
+    delete process.env["LOG_TRACE_REQUEST_ID"];
+  }
+  getStorage() {
+    return this.storage;
+  }
+}
+function getTracerProvider() {
+  if (!providerInstance) {
+    providerInstance = new OTelTracerProvider;
+  }
+  return providerInstance;
+}
+function resetTracerProvider() {
+  if (providerInstance) {
+    providerInstance.shutdown();
+    providerInstance = null;
+  }
+}
+function getDefaultDbPath() {
+  const os = __require("os");
+  const path = __require("path");
+  const home = os.homedir();
+  const dataHome = process.env.XDG_DATA_HOME || path.join(home, ".local", "share");
+  return path.join(dataHome, "roy-agent", "traces.db");
+}
+var providerInstance = null;
+var init_tracer_provider = __esm(() => {
+  init_span_storage();
+  init_propagation();
+  init_types();
+});
+
+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-1z1zv5g8.js

@@ -0,0 +1,258 @@
+import {
+  DecoratorNode,
+  init_decorator_node
+} from "./roy-agent-core-3tnb2005.js";
+import {
+  __esm,
+  __export
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// packages/core/src/env/workflow/nodes/condition-node.ts
+class ConditionNode {
+  definition;
+  type = "condition";
+  id;
+  constructor(definition) {
+    this.definition = definition;
+    this.id = definition.id;
+  }
+  async execute(context) {
+    const startTime = Date.now();
+    try {
+      const conditionConfig = this.definition.config?.condition;
+      if (conditionConfig === undefined) {
+        return {
+          output: { success: true, condition: true },
+          error: undefined,
+          durationMs: Date.now() - startTime
+        };
+      }
+      const resolvedCondition = this.resolveCondition(conditionConfig, context);
+      const result = this.evaluateCondition(resolvedCondition);
+      return {
+        output: { success: result, condition: resolvedCondition },
+        error: undefined,
+        durationMs: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        output: undefined,
+        error: error instanceof Error ? error : new Error(String(error)),
+        durationMs: Date.now() - startTime
+      };
+    }
+  }
+  resolveCondition(condition, context) {
+    if (typeof condition === "string") {
+      const templateMatch = condition.match(/^\{\{([^}]+)\}\}$/);
+      if (templateMatch) {
+        const path = templateMatch[1].trim();
+        return this.resolveTemplate(path, context);
+      }
+      if (condition === "true")
+        return true;
+      if (condition === "false")
+        return false;
+      return condition;
+    }
+    return condition;
+  }
+  resolveTemplate(path, context) {
+    const trimmed = path.trim();
+    if (trimmed.startsWith("input.")) {
+      const key = trimmed.slice(6);
+      return context.input?.[key];
+    }
+    if (trimmed.startsWith("nodes.")) {
+      const rest = trimmed.slice(6);
+      const segments2 = rest.split(".");
+      const nodeId2 = segments2[0];
+      let nodeOutput2 = context.previousOutputs.get(nodeId2);
+      if (nodeOutput2 === undefined) {
+        const normalizedUnderscore = nodeId2.replace(/-/g, "_");
+        const normalizedHyphen = nodeId2.replace(/_/g, "-");
+        if (normalizedUnderscore !== nodeId2) {
+          nodeOutput2 = context.previousOutputs.get(normalizedUnderscore);
+        }
+        if (nodeOutput2 === undefined && normalizedHyphen !== nodeId2) {
+          nodeOutput2 = context.previousOutputs.get(normalizedHyphen);
+        }
+      }
+      if (nodeOutput2 === undefined)
+        return;
+      let value2 = nodeOutput2;
+      for (const segment of segments2.slice(1)) {
+        if (value2 && typeof value2 === "object") {
+          value2 = value2[segment];
+        } else {
+          return;
+        }
+      }
+      return value2;
+    }
+    const segments = trimmed.split(".");
+    const nodeId = segments[0];
+    let nodeOutput = context.previousOutputs.get(nodeId);
+    if (nodeOutput === undefined) {
+      const normalizedUnderscore = nodeId.replace(/-/g, "_");
+      const normalizedHyphen = nodeId.replace(/_/g, "-");
+      if (normalizedUnderscore !== nodeId) {
+        nodeOutput = context.previousOutputs.get(normalizedUnderscore);
+      }
+      if (nodeOutput === undefined && normalizedHyphen !== nodeId) {
+        nodeOutput = context.previousOutputs.get(normalizedHyphen);
+      }
+    }
+    if (nodeOutput === undefined)
+      return;
+    let value = nodeOutput;
+    for (const segment of segments.slice(1)) {
+      if (value && typeof value === "object") {
+        value = value[segment];
+      } else {
+        return;
+      }
+    }
+    return value;
+  }
+  evaluateCondition(value) {
+    if (typeof value === "boolean") {
+      return value;
+    }
+    if (typeof value === "string") {
+      return value.toLowerCase() === "true" || value === "1";
+    }
+    if (typeof value === "number") {
+      return value !== 0;
+    }
+    if (value === null || value === undefined) {
+      return false;
+    }
+    if (typeof value === "object") {
+      const obj = value;
+      if ("success" in obj) {
+        return Boolean(obj.success);
+      }
+      return Object.keys(obj).length > 0;
+    }
+    return Boolean(value);
+  }
+}
+var init_condition_node = () => {};
+
+// packages/core/src/env/workflow/nodes/merge-node.ts
+class MergeNode {
+  definition;
+  type = "merge";
+  id;
+  constructor(definition) {
+    this.definition = definition;
+    this.id = definition.id;
+  }
+  async execute(context) {
+    const startTime = Date.now();
+    try {
+      const strategy = this.definition.config?.strategy || "collect";
+      const deps = this.definition.depends_on || [];
+      const outputs = {};
+      for (const depId of deps) {
+        let output = context.previousOutputs.get(depId);
+        if (output === undefined) {
+          const normalizedUnderscore = depId.replace(/-/g, "_");
+          const normalizedHyphen = depId.replace(/_/g, "-");
+          if (normalizedUnderscore !== depId) {
+            output = context.previousOutputs.get(normalizedUnderscore);
+          }
+          if (output === undefined && normalizedHyphen !== depId) {
+            output = context.previousOutputs.get(normalizedHyphen);
+          }
+        }
+        if (output !== undefined) {
+          outputs[depId] = output;
+        }
+      }
+      let result;
+      switch (strategy) {
+        case "collect":
+          result = outputs;
+          break;
+        case "first":
+          const firstKey = Object.keys(outputs)[0];
+          result = firstKey ? outputs[firstKey] : undefined;
+          break;
+        case "last":
+          const lastKey = Object.keys(outputs).pop();
+          result = lastKey ? outputs[lastKey] : undefined;
+          break;
+        case "merge":
+          result = this.deepMerge(Object.values(outputs));
+          break;
+        default:
+          result = outputs;
+      }
+      return {
+        output: {
+          strategy,
+          results: result,
+          count: Object.keys(outputs).length
+        },
+        error: undefined,
+        durationMs: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        output: undefined,
+        error: error instanceof Error ? error : new Error(String(error)),
+        durationMs: Date.now() - startTime
+      };
+    }
+  }
+  deepMerge(objects) {
+    const result = {};
+    for (const obj of objects) {
+      if (obj && typeof obj === "object" && !Array.isArray(obj)) {
+        for (const [key, value] of Object.entries(obj)) {
+          if (result[key] && typeof result[key] === "object" && !Array.isArray(result[key]) && value && typeof value === "object" && !Array.isArray(value)) {
+            result[key] = this.deepMerge([result[key], value]);
+          } else {
+            result[key] = value;
+          }
+        }
+      }
+    }
+    return result;
+  }
+}
+var init_merge_node = () => {};
+
+// packages/core/src/env/workflow/utils/node-registry-helper.ts
+var exports_node_registry_helper = {};
+__export(exports_node_registry_helper, {
+  registerDecoratorNodeType: () => registerDecoratorNodeType,
+  hasDecoratorNodes: () => hasDecoratorNodes,
+  getDecoratorNodes: () => getDecoratorNodes
+});
+function registerDecoratorNodeType(registry) {
+  registry.register("decorator", (definition) => {
+    return new DecoratorNode(definition);
+  });
+  registry.register("condition", (definition) => {
+    return new ConditionNode(definition);
+  });
+  registry.register("merge", (definition) => {
+    return new MergeNode(definition);
+  });
+}
+function hasDecoratorNodes(nodes) {
+  return nodes.some((node) => node.type === "decorator");
+}
+function getDecoratorNodes(nodes) {
+  return nodes.filter((node) => node.type === "decorator");
+}
+var init_node_registry_helper = __esm(() => {
+  init_decorator_node();
+  init_condition_node();
+  init_merge_node();
+});
+
+export { registerDecoratorNodeType, hasDecoratorNodes, getDecoratorNodes, exports_node_registry_helper, init_node_registry_helper };