@ai-setting/roy-agent-core 1.7.55 → 1.7.57

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

@@ -0,0 +1,578 @@
+import {
+  createLogger,
+  getMaxOutput,
+  getTracerProvider,
+  init_logger,
+  init_tracer_provider,
+  simplifyFilePath
+} from "./roy-agent-core-rt115qfc.js";
+import {
+  __esm
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/log-trace/trace-filters.ts
+function resetTraceFullModeCache() {
+  traceFullModeCache = undefined;
+}
+function isTraceFullMode() {
+  if (traceFullModeCache !== undefined)
+    return traceFullModeCache;
+  const raw = process.env.ROY_TRACE_FULL?.trim().toLowerCase();
+  traceFullModeCache = raw === "1" || raw === "true" || raw === "yes";
+  return traceFullModeCache;
+}
+function safeLen(value) {
+  if (typeof value === "string")
+    return value.length;
+  if (value === null || value === undefined)
+    return 0;
+  if (Array.isArray(value))
+    return value.length;
+  return 0;
+}
+function totalMessageChars(messages) {
+  let n = 0;
+  for (const m of messages) {
+    if (!m)
+      continue;
+    const c = m.content;
+    if (typeof c === "string") {
+      n += c.length;
+    } else if (Array.isArray(c)) {
+      for (const part of c) {
+        if (typeof part === "string")
+          n += part.length;
+        else if (part && typeof part.text === "string")
+          n += part.text.length;
+      }
+    }
+  }
+  return n;
+}
+function safeJsonLen(value) {
+  if (value === null || value === undefined)
+    return 0;
+  if (typeof value === "string")
+    return value.length;
+  try {
+    return JSON.stringify(value)?.length ?? 0;
+  } catch {
+    return 0;
+  }
+}
+function llmInvokeParamFilter(args) {
+  if (isTraceFullMode()) {
+    return { args };
+  }
+  const p = (args ?? [])[0];
+  const ctx = p?.context ?? p?.ctx ?? null;
+  const msgs = Array.isArray(p?.messages) ? p.messages : [];
+  return {
+    model: p?.model ?? p?.modelId ?? ctx?.model ?? null,
+    provider: p?.provider ?? p?.providerId ?? null,
+    sessionId: ctx?.sessionId ?? p?.sessionId ?? null,
+    messageCount: msgs.length,
+    totalChars: totalMessageChars(msgs),
+    tools: Array.isArray(p?.tools) ? p.tools.length : 0,
+    maxTokens: p?.maxTokens ?? null,
+    temperature: p?.temperature ?? null
+  };
+}
+function llmInvokeResultFilter(r) {
+  if (isTraceFullMode()) {
+    return { result: r };
+  }
+  const output = r?.output ?? r;
+  const text = typeof output?.content === "string" ? output.content : "";
+  const toolCalls = Array.isArray(output?.toolCalls) ? output.toolCalls : [];
+  return {
+    finishReason: output?.finishReason ?? r?.finishReason ?? null,
+    outputChars: text.length || safeLen(output?.content),
+    reasoningChars: typeof output?.reasoning === "string" ? output.reasoning.length : 0,
+    toolCallCount: toolCalls.length,
+    usage: output?.usage ?? r?.usage ?? null,
+    providerId: r?.providerId ?? null,
+    model: r?.model ?? output?.model ?? null,
+    latencyMs: r?.latencyMs ?? null
+  };
+}
+function messagesParamFilter(args) {
+  if (isTraceFullMode()) {
+    return { args };
+  }
+  const a0 = (args ?? [])[0];
+  const msgs = Array.isArray(a0) ? a0 : Array.isArray(a0?.messages) ? a0.messages : [];
+  return {
+    messageCount: msgs.length,
+    totalChars: totalMessageChars(msgs),
+    roles: msgs.length ? String(msgs[0]?.role ?? "") : null
+  };
+}
+function toolExecParamFilter(args) {
+  if (isTraceFullMode()) {
+    return { args };
+  }
+  const ctx = (args ?? [])[0];
+  const toolCall = ctx?.currentToolCall ?? ctx?.toolCall ?? ctx;
+  const toolName = toolCall?.toolName ?? toolCall?.name ?? toolCall?.tool ?? null;
+  const rawArgs = readToolArgs(toolCall);
+  let argKeys = [];
+  if (rawArgs && typeof rawArgs === "object" && !Array.isArray(rawArgs)) {
+    argKeys = Object.keys(rawArgs);
+  }
+  return {
+    tool: toolName,
+    toolCallId: toolCall?.toolCallId ?? toolCall?.id ?? null,
+    argKeys,
+    argCount: argKeys.length
+  };
+}
+function readToolArgs(toolCall) {
+  if (!toolCall || typeof toolCall !== "object")
+    return;
+  for (const key of ["args", "arguments", "input", "parameters"]) {
+    try {
+      const v = toolCall[key];
+      if (v !== undefined && v !== null)
+        return v;
+    } catch {}
+  }
+  return;
+}
+function embedParamFilter(args) {
+  if (isTraceFullMode()) {
+    return { args };
+  }
+  const req = (args ?? [])[0];
+  const input = req?.input ?? req?.texts ?? req?.value;
+  const arr = Array.isArray(input) ? input : input === undefined ? [] : [input];
+  let chars = 0;
+  for (const s of arr)
+    if (typeof s === "string")
+      chars += s.length;
+  return {
+    provider: req?.provider ?? null,
+    modelId: req?.modelId ?? req?.model ?? null,
+    inputCount: arr.length,
+    totalChars: chars
+  };
+}
+function embedResultFilter(r) {
+  if (isTraceFullMode()) {
+    return { result: r };
+  }
+  const embs = Array.isArray(r?.embeddings) ? r.embeddings : [];
+  const dims = embs.length && Array.isArray(embs[0]) ? embs[0].length : 0;
+  return {
+    embeddingCount: embs.length,
+    dimensions: dims,
+    usage: r?.usage ?? null
+  };
+}
+function toolExecResultFilter(r) {
+  if (isTraceFullMode()) {
+    return { result: r };
+  }
+  const inner = r && typeof r === "object" && r.result && typeof r.result === "object" ? r.result : r;
+  const output = inner?.output ?? inner?.content ?? inner?.text;
+  const text = typeof output === "string" ? output : "";
+  const outputJsonChars = output && typeof output === "object" ? safeJsonLen(output) : 0;
+  const metadata = inner?.metadata ?? r?.metadata;
+  const stdout = typeof metadata?.stdout === "string" ? metadata.stdout : "";
+  const stderr = typeof metadata?.stderr === "string" ? metadata.stderr : "";
+  const error = inner?.error ?? r?.error;
+  return {
+    success: r?.success ?? inner?.success ?? null,
+    tool: r?.name ?? r?.toolName ?? null,
+    outputChars: text.length || outputJsonChars,
+    outputHead: text.slice(0, 500),
+    stdoutChars: stdout.length,
+    stderrChars: stderr.length,
+    exitCode: metadata?.exit_code ?? null,
+    timedOut: metadata?.timed_out ?? null,
+    executionTimeMs: metadata?.execution_time_ms ?? null,
+    error: error ? String(error).slice(0, 500) : null
+  };
+}
+function toolInvokeParamFilter(args) {
+  if (isTraceFullMode()) {
+    return { args };
+  }
+  const a0 = (args ?? [])[0];
+  const command = typeof a0?.command === "string" ? a0.command : null;
+  const toolName = a0?.name ?? a0?.toolName ?? null;
+  const rawArgs = a0?.args;
+  let argKeys = [];
+  if (rawArgs && typeof rawArgs === "object" && !Array.isArray(rawArgs)) {
+    argKeys = Object.keys(rawArgs);
+  }
+  return {
+    tool: toolName,
+    command: command === null ? null : command.slice(0, MAX_COMMAND_CHARS),
+    commandChars: command === null ? null : command.length,
+    commandTruncated: command !== null && command.length > MAX_COMMAND_CHARS,
+    argKeys,
+    argCount: argKeys.length,
+    timeout: a0?.timeout ?? null
+  };
+}
+function envQueryParamFilter(args) {
+  if (isTraceFullMode()) {
+    return { args };
+  }
+  const a = args ?? [];
+  const isWorkflowEntry = a.length >= 3 && typeof a[0] === "string";
+  const agentName = isWorkflowEntry ? a[0] : null;
+  const query = isWorkflowEntry ? a[1] : a[0];
+  const context = isWorkflowEntry ? a[3] : a[1];
+  const isArray = Array.isArray(query);
+  const parts = isArray ? query : [];
+  let chars = 0;
+  if (typeof query === "string") {
+    chars = query.length;
+  } else {
+    for (const p of parts) {
+      if (typeof p === "string")
+        chars += p.length;
+      else if (typeof p?.text === "string")
+        chars += p.text.length;
+    }
+  }
+  return {
+    agentName,
+    queryChars: chars,
+    queryParts: isArray ? parts.length : 0,
+    isMultimodal: isArray,
+    contextKeys: context && typeof context === "object" ? Object.keys(context) : []
+  };
+}
+function agentRunParamFilter(args) {
+  if (isTraceFullMode()) {
+    return { args };
+  }
+  const a = args ?? [];
+  const agentName = typeof a[0] === "string" ? a[0] : null;
+  const query = a[1];
+  const isArray = Array.isArray(query);
+  let chars = 0;
+  if (typeof query === "string")
+    chars = query.length;
+  else if (isArray) {
+    for (const p of query) {
+      if (typeof p === "string")
+        chars += p.length;
+      else if (typeof p?.text === "string")
+        chars += p.text.length;
+    }
+  }
+  const ctx = a[2];
+  return {
+    agentName,
+    queryChars: chars,
+    queryParts: isArray ? query.length : 0,
+    isMultimodal: isArray,
+    contextKeys: ctx && typeof ctx === "object" ? Object.keys(ctx) : []
+  };
+}
+function recordSessionMessagesParamFilter(args) {
+  if (isTraceFullMode()) {
+    return { args };
+  }
+  const a = args ?? [];
+  const sessionId = typeof a[0] === "string" ? a[0] : null;
+  const msgs = Array.isArray(a[1]) ? a[1] : [];
+  let chars = 0;
+  for (const m of msgs) {
+    if (typeof m?.content === "string")
+      chars += m.content.length;
+  }
+  return {
+    sessionId,
+    messageCount: msgs.length,
+    totalChars: chars
+  };
+}
+var traceFullModeCache, MAX_COMMAND_CHARS = 2000;
+var init_trace_filters = () => {};
+
+// src/env/log-trace/decorator.ts
+function Traced(options) {
+  const buildOptions = () => ({
+    recordParams: options?.recordParams ?? true,
+    recordResult: options?.recordResult ?? false,
+    recordResultToDb: options?.recordResultToDb ?? false,
+    logResult: options?.logResult,
+    recordError: options?.recordError ?? true,
+    log: options?.log ?? false,
+    maxLogSize: options?.maxLogSize,
+    paramFilter: options?.paramFilter,
+    resultFilter: options?.resultFilter,
+    flattenParamFilter: options?.flattenParamFilter,
+    errorIf: options?.errorIf
+  });
+  return function(target, propertyKey, descriptor) {
+    if (descriptor !== undefined && descriptor !== null && typeof descriptor === "object" && "value" in descriptor) {
+      const originalFn = descriptor.value;
+      const spanName = options?.name || String(propertyKey);
+      descriptor.value = wrapFunction(originalFn, spanName, buildOptions());
+      return descriptor;
+    }
+    const value = target;
+    const context = propertyKey || {};
+    if (typeof value === "function") {
+      const spanName = options?.name || (context?.name ? String(context.name) : "anonymous");
+      return wrapFunction(value, spanName, buildOptions());
+    }
+    return value;
+  };
+}
+function TracedAs(name, options) {
+  return Traced({ name, ...options });
+}
+function TracedLightweight(options) {
+  return Traced({ recordParams: false, recordResult: false, log: options?.log ?? false, maxLogSize: options?.maxLogSize });
+}
+function wrapFunction(fn, name, options) {
+  const opts = {
+    recordParams: options?.recordParams ?? true,
+    recordResult: options?.recordResult ?? true,
+    recordResultToDb: options?.recordResultToDb ?? false,
+    logResult: options?.logResult,
+    recordError: options?.recordError ?? true,
+    log: options?.log ?? false,
+    maxLogSize: options?.maxLogSize,
+    paramFilter: options?.paramFilter,
+    resultFilter: options?.resultFilter,
+    flattenParamFilter: options?.flattenParamFilter ?? false,
+    errorIf: options?.errorIf
+  };
+  const shouldLog = opts.log;
+  const getMaxLogSize = () => {
+    if (opts.maxLogSize !== undefined) {
+      return opts.maxLogSize;
+    }
+    const configMaxOutput = getMaxOutput();
+    return configMaxOutput !== undefined ? configMaxOutput : 500;
+  };
+  const truncate = (obj) => {
+    if (obj === undefined)
+      return;
+    if (obj === null)
+      return null;
+    const maxLogSize = getMaxLogSize();
+    let str;
+    try {
+      str = typeof obj === "string" ? obj : JSON.stringify(obj, null, 0).replace(/\n/g, "");
+    } catch (e) {
+      str = `[Object with circular reference: ${e instanceof Error ? e.message : String(e)}]`;
+    }
+    if (maxLogSize > 0 && str.length > maxLogSize) {
+      return str.slice(0, maxLogSize) + " [TRUNCATED]";
+    }
+    try {
+      return JSON.parse(str);
+    } catch {
+      return str;
+    }
+  };
+  const truncateString = (obj) => {
+    if (obj === undefined)
+      return "undefined";
+    if (obj === null)
+      return "null";
+    const maxLogSize = getMaxLogSize();
+    let str;
+    try {
+      str = typeof obj === "string" ? obj : JSON.stringify(obj, null, 0).replace(/\n/g, "");
+    } catch (e) {
+      str = `[Object with circular reference: ${e instanceof Error ? e.message : String(e)}]`;
+    }
+    return maxLogSize > 0 && str.length > maxLogSize ? str.slice(0, maxLogSize) + " [TRUNCATED]" : str;
+  };
+  const toDbValue = (obj) => {
+    if (obj === undefined)
+      return;
+    if (obj === null)
+      return null;
+    if (typeof obj === "string")
+      return obj;
+    try {
+      return JSON.parse(JSON.stringify(obj));
+    } catch (e) {
+      return `[Object with circular reference: ${e instanceof Error ? e.message : String(e)}]`;
+    }
+  };
+  const TRACE_LOG_PREFIX = "[TRACE]";
+  const safeRunFilter = (fn2) => {
+    try {
+      return fn2();
+    } catch (e) {
+      try {
+        createLogger("traced:" + name).warn(`[trace] filter threw, ignoring: ${e instanceof Error ? e.message : String(e)}`);
+      } catch {}
+      return;
+    }
+  };
+  const resolveDbResult = (result, precomputedFiltered) => {
+    if (opts.recordResultToDb === true) {
+      return { value: result, store: true };
+    }
+    if (isTraceFullMode()) {
+      return { value: result, store: true };
+    }
+    if (opts.resultFilter) {
+      const filtered = precomputedFiltered?.ran ? precomputedFiltered.value : safeRunFilter(() => opts.resultFilter(result));
+      if (filtered && typeof filtered === "object" && !Array.isArray(filtered)) {
+        return { value: filtered, store: true };
+      }
+    }
+    if (opts.recordResult === false) {
+      return { value: undefined, store: false };
+    }
+    return { value: result, store: true };
+  };
+  const getCallerLocation = () => {
+    const originalLimit = Error.stackTraceLimit;
+    Error.stackTraceLimit = 15;
+    const err = new Error;
+    Error.captureStackTrace(err, getCallerLocation);
+    const stack = err.stack?.split(`
+`) || [];
+    Error.stackTraceLimit = originalLimit;
+    for (let i = 1;i < stack.length; i++) {
+      const line = stack[i];
+      if (line.includes("decorator.ts") || line.includes("decorator.js") || line.includes("logFn") || line.includes("getCallerLocation"))
+        continue;
+      const match = line.match(/at\s+.+\s+\((.+):(\d+):\d+\)/) || line.match(/at\s+(.+):(\d+):\d+/);
+      if (match) {
+        const filePath = match[1];
+        if (!filePath || filePath === "native")
+          continue;
+        const relativePath = simplifyFilePath(filePath);
+        return `${relativePath}:${match[2]}`;
+      }
+    }
+    return "";
+  };
+  const logFn = (event, argsOrData, callerLocation) => {
+    if (!shouldLog)
+      return;
+    const logger = createLogger("traced:" + name);
+    const tag = event === "enter" ? ">>>" : event === "quit" ? "<<<" : "!!!";
+    const prefix = `${TRACE_LOG_PREFIX} ${tag} ${name}`;
+    const originalFnLocation = callerLocation || getCallerLocation();
+    const logMessage = (msg, data) => {
+      if (data !== undefined) {
+        logger.info(`${prefix} ${msg}: ${truncateString(data)}`, { callerLocation: originalFnLocation });
+      } else {
+        logger.info(`${prefix} ${msg}`, { callerLocation: originalFnLocation });
+      }
+    };
+    if (event === "enter") {
+      logMessage("enter", argsOrData);
+    } else if (event === "quit") {
+      logMessage("quit", opts.logResult ?? opts.recordResult ? argsOrData : undefined);
+    } else {
+      logMessage("error", argsOrData);
+    }
+  };
+  return function(...args) {
+    const tracer = getTracerProvider().getTracer("roy-tracer");
+    const attributes = {};
+    if (opts.recordParams !== false) {
+      if (opts.paramFilter) {
+        const filtered = safeRunFilter(() => opts.paramFilter(args));
+        attributes["params"] = toDbValue(filtered);
+        if (opts.flattenParamFilter && filtered && typeof filtered === "object" && !Array.isArray(filtered)) {
+          for (const [key, value] of Object.entries(filtered)) {
+            if (!(key in attributes)) {
+              attributes[key] = toDbValue(value);
+            }
+          }
+        }
+      } else {
+        attributes["params"] = toDbValue(args);
+      }
+    }
+    const callerLocation = getCallerLocation();
+    let span;
+    try {
+      span = tracer.startSpan(name, { attributes });
+    } catch {}
+    logFn("enter", args, callerLocation);
+    try {
+      const result = fn.call(this, ...args);
+      if (result && typeof result === "object" && typeof result.then === "function") {
+        return result.then((resolved) => {
+          if (span) {
+            const filterRan = opts.resultFilter !== undefined;
+            const filteredResult = opts.resultFilter ? safeRunFilter(() => opts.resultFilter(resolved)) : undefined;
+            if (filteredResult && typeof filteredResult === "object" && !Array.isArray(filteredResult)) {
+              for (const [key, value] of Object.entries(filteredResult)) {
+                span.setAttribute(key, toDbValue(value));
+              }
+            }
+            const dbResult = resolveDbResult(resolved, { ran: filterRan, value: filteredResult });
+            if (dbResult.store) {
+              span.setAttribute("result", JSON.stringify(toDbValue(dbResult.value)));
+            }
+            const resultError = opts.errorIf ? safeRunFilter(() => opts.errorIf(resolved)) : undefined;
+            if (resultError) {
+              const err = resultError instanceof Error ? resultError : new Error(String(resultError));
+              span.setAttribute("error", err.message);
+              span.end(undefined, err);
+            } else {
+              span.end(dbResult.store ? dbResult.value : undefined);
+            }
+          }
+          logFn("quit", opts.logResult ?? opts.recordResult ? resolved : undefined, callerLocation);
+          return resolved;
+        }, (rejected) => {
+          if (span) {
+            span.setAttribute("error", String(rejected));
+            span.end(undefined, rejected instanceof Error ? rejected : new Error(String(rejected)));
+          }
+          logFn("error", rejected.message, callerLocation);
+          throw rejected;
+        });
+      }
+      if (span) {
+        const syncFilterRan = opts.resultFilter !== undefined;
+        const syncFilteredResult = opts.resultFilter ? safeRunFilter(() => opts.resultFilter(result)) : undefined;
+        if (syncFilteredResult && typeof syncFilteredResult === "object" && !Array.isArray(syncFilteredResult)) {
+          for (const [key, value] of Object.entries(syncFilteredResult)) {
+            span.setAttribute(key, toDbValue(value));
+          }
+        }
+        const syncDbResult = resolveDbResult(result, { ran: syncFilterRan, value: syncFilteredResult });
+        if (syncDbResult.store) {
+          span.setAttribute("result", JSON.stringify(toDbValue(syncDbResult.value)));
+        }
+        const syncResultError = opts.errorIf ? safeRunFilter(() => opts.errorIf(result)) : undefined;
+        if (syncResultError) {
+          const err = syncResultError instanceof Error ? syncResultError : new Error(String(syncResultError));
+          span.setAttribute("error", err.message);
+          span.end(undefined, err);
+        } else {
+          span.end(syncDbResult.store ? syncDbResult.value : undefined);
+        }
+      }
+      logFn("quit", opts.logResult ?? opts.recordResult ? result : undefined, callerLocation);
+      return result;
+    } catch (error) {
+      if (span) {
+        span.setAttribute("error", String(error));
+        span.end(undefined, error instanceof Error ? error : new Error(String(error)));
+      }
+      logFn("error", error.message, callerLocation);
+      throw error;
+    }
+  };
+}
+var init_decorator = __esm(() => {
+  init_tracer_provider();
+  init_logger();
+  init_trace_filters();
+});
+
+export { resetTraceFullModeCache, isTraceFullMode, llmInvokeParamFilter, llmInvokeResultFilter, messagesParamFilter, toolExecParamFilter, embedParamFilter, embedResultFilter, toolExecResultFilter, toolInvokeParamFilter, envQueryParamFilter, agentRunParamFilter, recordSessionMessagesParamFilter, init_trace_filters, Traced, TracedAs, TracedLightweight, wrapFunction, init_decorator };

package/dist/shared/@ai-setting/{roy-agent-core-7evvpfwc.js → roy-agent-core-9zhkdg6w.js}

@@ -4,11 +4,11 @@ import {
 import {
   TracedAs,
   init_decorator
-} from "./roy-agent-core-dsevjbck.js";
+} from "./roy-agent-core-8p63s836.js";
 import {
   createLogger,
   init_logger
-} from "./roy-agent-core-8seq65bp.js";
+} from "./roy-agent-core-rt115qfc.js";
 import {
   __legacyDecorateClassTS
 } from "./roy-agent-core-fs0mn2jk.js";

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

@@ -6,11 +6,11 @@ import {
 } from "./roy-agent-core-7hh0brvs.js";
 import {
   BaseComponent
-} from "./roy-agent-core-tdbv7ff4.js";
+} from "./roy-agent-core-0kn3zt1t.js";
 import {
   createLogger,
   init_logger
-} from "./roy-agent-core-8seq65bp.js";
+} from "./roy-agent-core-rt115qfc.js";
 
 // src/env/memory/types.ts
 import { z } from "zod";