neatlogs 1.0.4 → 1.0.5

package/dist/mastra-wrap.cjs

@@ -0,0 +1,597 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/mastra-wrap.ts
+var mastra_wrap_exports = {};
+__export(mastra_wrap_exports, {
+  wrapMastra: () => wrapMastra,
+  wrapMastraRerank: () => wrapMastraRerank
+});
+module.exports = __toCommonJS(mastra_wrap_exports);
+var import_api = require("@opentelemetry/api");
+var TRACER_NAME = "neatlogs.mastra";
+var PATCH_FLAG = "_neatlogs_patched";
+function wrapMastra(entity) {
+  if (!entity || entity[PATCH_FLAG]) return entity;
+  const e = entity;
+  const className = entity.constructor?.name ?? "";
+  if (isRootMastra(e)) {
+    const proxied = wrapRootMastra(e);
+    markPatched(proxied);
+    return proxied;
+  }
+  if (isAgent(e, className)) {
+    patchAgent(e);
+  } else if (isWorkflow(e, className)) {
+    patchWorkflow(e);
+  } else if (isVector(e, className)) {
+    patchVector(e);
+  } else if (isMemory(e, className)) {
+    patchMemory(e);
+  } else if (isDocument(e, className)) {
+    patchDocument(e);
+  }
+  markPatched(e);
+  return entity;
+}
+function wrapMastraRerank(rerankFn) {
+  return (async function tracedRerank(...args) {
+    return withSpan("mastra.rerank", { "neatlogs.span.kind": "RERANKER" }, (span) => {
+      const results = args?.[0];
+      const query = args?.[1];
+      const options = args?.[3];
+      if (typeof query === "string") {
+        span.setAttribute("neatlogs.reranker.query", query.slice(0, 1e4));
+        span.setAttribute("input.value", query.slice(0, 1e4));
+      }
+      if (Array.isArray(results)) span.setAttribute("neatlogs.reranker.input_documents", safeStringify(results).slice(0, 1e4));
+      if (options?.topK != null) span.setAttribute("neatlogs.reranker.top_k", options.topK);
+      return Promise.resolve(rerankFn(...args)).then((result) => {
+        span.setAttribute("neatlogs.reranker.output_documents", safeStringify(result).slice(0, 1e4));
+        span.setAttribute("output.value", safeStringify(result).slice(0, 1e4));
+        return result;
+      });
+    });
+  });
+}
+function isRootMastra(e) {
+  return typeof e.getAgent === "function" && typeof e.getWorkflow === "function";
+}
+function isAgent(e, className) {
+  return className === "Agent" || typeof e.generate === "function" || typeof e.stream === "function";
+}
+function isWorkflow(e, className) {
+  return className === "Workflow" || typeof e.createRun === "function";
+}
+function isVector(e, className) {
+  return /Vector/.test(className) || typeof e.query === "function" && typeof e.upsert === "function";
+}
+function isMemory(e, className) {
+  return /Memory/.test(className) || typeof e.recall === "function" && typeof e.saveMessages === "function";
+}
+function isDocument(e, className) {
+  return className === "MDocument" || typeof e.chunk === "function" && typeof e.getDocs === "function";
+}
+function patchAgent(agent) {
+  patchAgentMethod(agent, "generate", false);
+  patchAgentMethod(agent, "stream", true);
+}
+function patchAgentMethod(agent, method, streaming) {
+  if (typeof agent[method] !== "function") return;
+  const orig = agent[method].bind(agent);
+  agent[method] = async function tracedAgentMethod(input, opts) {
+    const agentName = agent.name ?? agent.id ?? "mastra_agent";
+    const model = extractModelId(agent.model);
+    installAgentLlmHook(agent);
+    installAgentToolHooks(agent);
+    const attrs = {
+      "neatlogs.span.kind": "AGENT",
+      "neatlogs.agent.name": agentName,
+      "input.value": toInputValue(input)
+    };
+    if (model) attrs["neatlogs.llm.model_name"] = model;
+    if (agent.instructions && typeof agent.instructions === "string") {
+      attrs["neatlogs.llm.system_prompt"] = agent.instructions.slice(0, 5e3);
+    }
+    if (streaming) attrs["neatlogs.llm.is_streaming"] = true;
+    if (streaming) {
+      const tracer = import_api.trace.getTracer(TRACER_NAME);
+      const span = tracer.startSpan(`mastra.agent.${agentName}`, { attributes: attrs }, import_api.context.active());
+      const ctx = import_api.trace.setSpan(import_api.context.active(), span);
+      try {
+        const result = await import_api.context.with(ctx, () => orig(input, opts));
+        return wrapStreamingOutput(result, span, ctx);
+      } catch (err) {
+        recordError(span, err);
+        span.end();
+        throw err;
+      }
+    }
+    return withActiveSpan(`mastra.agent.${agentName}`, attrs, async (span) => {
+      const result = await orig(input, opts);
+      finalizeAgentResult(span, result);
+      return result;
+    });
+  };
+}
+function installAgentLlmHook(agent) {
+  if (agent.__neatlogs_llm_hook || typeof agent.getLLM !== "function") return;
+  agent.__neatlogs_llm_hook = true;
+  const origGetLLM = agent.getLLM.bind(agent);
+  agent.getLLM = function patchedGetLLM(...args) {
+    const out = origGetLLM(...args);
+    return Promise.resolve(out).then((llm) => {
+      try {
+        const model = typeof llm?.getModel === "function" ? llm.getModel() : llm;
+        patchModelInPlace(model);
+      } catch {
+      }
+      return llm;
+    });
+  };
+}
+function patchModelInPlace(model) {
+  if (!model || model.__neatlogs_model_patched) return;
+  model.__neatlogs_model_patched = true;
+  const modelId = model.modelId ?? model.modelName ?? "";
+  const provider = model.provider ?? "";
+  for (const fn of ["doGenerate", "doStream"]) {
+    if (typeof model[fn] !== "function") continue;
+    const orig = model[fn].bind(model);
+    const isStream = fn === "doStream";
+    model[fn] = function tracedModelCall(callOpts) {
+      const attrs = { "neatlogs.span.kind": "LLM" };
+      if (modelId) attrs["neatlogs.llm.model_name"] = modelId;
+      if (provider) attrs["neatlogs.llm.provider"] = provider;
+      if (isStream) attrs["neatlogs.llm.is_streaming"] = true;
+      const promptInput = callOpts?.prompt ?? callOpts?.messages;
+      if (promptInput !== void 0) attrs["input.value"] = safeStringify(promptInput).slice(0, 1e4);
+      captureInvocationParams(attrs, callOpts);
+      return withActiveSpan(`mastra.llm.${modelId || "model"}.${fn}`, attrs, async (span) => {
+        const result = await orig(callOpts);
+        if (!isStream) finalizeModelResult(span, result);
+        else if (result?.usage) recordUsage(span, result.usage);
+        return result;
+      });
+    };
+  }
+}
+function installAgentToolHooks(agent) {
+  if (agent.__neatlogs_tool_hook) return;
+  let tools;
+  try {
+    tools = typeof agent.listTools === "function" ? agent.listTools() : void 0;
+  } catch {
+    tools = void 0;
+  }
+  if (!tools || typeof tools !== "object") return;
+  agent.__neatlogs_tool_hook = true;
+  for (const [key, tool] of Object.entries(tools)) {
+    patchToolExecute(tool, key);
+  }
+}
+function patchToolExecute(tool, key) {
+  if (!tool || typeof tool.execute !== "function" || tool.__neatlogs_tool_patched) return;
+  tool.__neatlogs_tool_patched = true;
+  const toolName = tool.id ?? key;
+  const orig = tool.execute.bind(tool);
+  tool.execute = function tracedToolExecute(params, options) {
+    const attrs = {
+      "neatlogs.span.kind": "TOOL",
+      "neatlogs.tool.name": toolName,
+      "input.value": safeStringify(params).slice(0, 1e4)
+    };
+    if (tool.description) attrs["neatlogs.tool.description"] = String(tool.description).slice(0, 2e3);
+    return withActiveSpan(`mastra.tool.${toolName}`, attrs, async (span) => {
+      const result = await orig(params, options);
+      span.setAttribute("output.value", safeStringify(result).slice(0, 1e4));
+      return result;
+    });
+  };
+}
+function patchWorkflow(workflow) {
+  if (typeof workflow.createRun !== "function") return;
+  const origCreateRun = workflow.createRun.bind(workflow);
+  const workflowName = workflow.name ?? workflow.id ?? "mastra_workflow";
+  workflow.createRun = async function tracedCreateRun(...args) {
+    const run = await origCreateRun(...args);
+    if (!run) return run;
+    patchRunMethod(run, "start", workflowName);
+    patchRunMethod(run, "resume", workflowName);
+    return run;
+  };
+}
+function patchRunMethod(run, method, workflowName) {
+  if (typeof run[method] !== "function") return;
+  const orig = run[method].bind(run);
+  run[method] = async function tracedRunMethod(startOpts) {
+    const attrs = {
+      "neatlogs.span.kind": "WORKFLOW",
+      "neatlogs.workflow.name": workflowName
+    };
+    if (startOpts?.inputData !== void 0) {
+      attrs["input.value"] = safeStringify(startOpts.inputData).slice(0, 1e4);
+    }
+    return withActiveSpan(`mastra.workflow.${workflowName}`, attrs, async (span) => {
+      const result = await orig(startOpts);
+      if (result?.status) span.setAttribute("neatlogs.metadata", safeStringify({ status: result.status }));
+      if (result?.result !== void 0) {
+        span.setAttribute("output.value", safeStringify(result.result).slice(0, 1e4));
+      }
+      return result;
+    });
+  };
+}
+var VECTOR_READ_OPS = ["query"];
+var VECTOR_WRITE_OPS = ["upsert", "updateVector", "deleteVector", "createIndex", "deleteIndex"];
+function patchVector(vector) {
+  for (const op of VECTOR_READ_OPS) patchVectorOp(vector, op, "RETRIEVER");
+  for (const op of VECTOR_WRITE_OPS) patchVectorOp(vector, op, "VECTOR_STORE");
+}
+function patchVectorOp(vector, op, kind) {
+  if (typeof vector[op] !== "function") return;
+  const orig = vector[op].bind(vector);
+  const dbName = vector.constructor?.name ?? "vector";
+  vector[op] = async function tracedVectorOp(params) {
+    const attrs = {
+      "neatlogs.span.kind": kind,
+      "neatlogs.db.system": dbName,
+      "neatlogs.db.operation": op,
+      "input.value": safeStringify(params).slice(0, 1e4)
+    };
+    const indexName = params?.indexName;
+    if (indexName) attrs["neatlogs.vectordb.index_name"] = String(indexName);
+    if (kind === "RETRIEVER" && params?.topK != null) attrs["neatlogs.retriever.top_k"] = params.topK;
+    return withActiveSpan(`mastra.vector.${op}`, attrs, async (span) => {
+      const result = await orig(params);
+      span.setAttribute("output.value", safeStringify(result).slice(0, 1e4));
+      return result;
+    });
+  };
+}
+var MEMORY_OPS = ["recall", "saveMessages", "updateWorkingMemory", "deleteMessages"];
+function patchMemory(memory) {
+  for (const op of MEMORY_OPS) {
+    if (typeof memory[op] !== "function") continue;
+    const orig = memory[op].bind(memory);
+    memory[op] = async function tracedMemoryOp(...args) {
+      const attrs = {
+        "neatlogs.span.kind": "CHAIN",
+        "neatlogs.db.operation": op,
+        "input.value": safeStringify(args?.[0]).slice(0, 1e4)
+      };
+      return withActiveSpan(`mastra.memory.${op}`, attrs, async (span) => {
+        const result = await orig(...args);
+        span.setAttribute("output.value", safeStringify(result).slice(0, 8e3));
+        return result;
+      });
+    };
+  }
+}
+function patchDocument(doc) {
+  if (typeof doc.chunk !== "function") return;
+  const orig = doc.chunk.bind(doc);
+  doc.chunk = async function tracedChunk(...args) {
+    const attrs = {
+      "neatlogs.span.kind": "CHAIN",
+      "neatlogs.db.operation": "chunk"
+    };
+    return withActiveSpan("mastra.document.chunk", attrs, async (span) => {
+      const result = await orig(...args);
+      if (Array.isArray(result)) span.setAttribute("neatlogs.db.documents_count", result.length);
+      return result;
+    });
+  };
+}
+function wrapRootMastra(mastra) {
+  const AGENT_GETTERS = /* @__PURE__ */ new Set(["getAgent", "getAgentById"]);
+  const WORKFLOW_GETTERS = /* @__PURE__ */ new Set(["getWorkflow", "getWorkflowById"]);
+  return new Proxy(mastra, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value !== "function") return value;
+      const name = String(prop);
+      if (AGENT_GETTERS.has(name) || WORKFLOW_GETTERS.has(name)) {
+        return (...args) => {
+          const entity = value.apply(target, args);
+          return entity && typeof entity === "object" ? wrapMastra(entity) : entity;
+        };
+      }
+      return value.bind(target);
+    }
+  });
+}
+function wrapStreamingOutput(output, span, ctx) {
+  if (!output) {
+    span.setStatus({ code: import_api.SpanStatusCode.OK });
+    span.end();
+    return output;
+  }
+  let ended = false;
+  const endOnce = (err) => {
+    if (ended) return;
+    ended = true;
+    if (err) recordError(span, err);
+    else span.setStatus({ code: import_api.SpanStatusCode.OK });
+    span.end();
+  };
+  if (output.text && typeof output.text.then === "function") {
+    const finalize = async () => {
+      try {
+        const [text, usage, finishReason] = await Promise.all([
+          Promise.resolve(output.text).catch(() => void 0),
+          Promise.resolve(output.usage).catch(() => void 0),
+          Promise.resolve(output.finishReason).catch(() => void 0)
+        ]);
+        if (typeof text === "string" && text) {
+          span.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
+          span.setAttribute("neatlogs.llm.output_messages.0.content", text.slice(0, 1e4));
+        }
+        if (usage) recordUsage(span, usage);
+        if (finishReason) span.setAttribute("neatlogs.llm.stop_reason", normalizeFinishReason(finishReason));
+        endOnce();
+      } catch (err) {
+        endOnce(err);
+      }
+    };
+    void finalize();
+    return rebindStreamContext(output, ctx);
+  }
+  if (output[Symbol.asyncIterator]) {
+    const origIterator = output[Symbol.asyncIterator].bind(output);
+    const textParts = [];
+    const wrapped = Object.create(Object.getPrototypeOf(output));
+    Object.assign(wrapped, output);
+    wrapped[Symbol.asyncIterator] = function() {
+      const iterator = origIterator();
+      const finish = () => {
+        if (textParts.length) {
+          span.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
+          span.setAttribute("neatlogs.llm.output_messages.0.content", textParts.join("").slice(0, 1e4));
+        }
+        endOnce();
+      };
+      return {
+        async next() {
+          try {
+            const r = await iterator.next();
+            if (r.done) {
+              finish();
+              return r;
+            }
+            const chunk = r.value;
+            if (typeof chunk === "string") textParts.push(chunk);
+            else if (chunk?.text) textParts.push(chunk.text);
+            else if (chunk?.delta) textParts.push(chunk.delta);
+            return r;
+          } catch (err) {
+            endOnce(err);
+            throw err;
+          }
+        },
+        async return(value) {
+          finish();
+          return iterator.return?.(value) ?? { done: true, value: void 0 };
+        },
+        async throw(err) {
+          endOnce(err);
+          return iterator.throw?.(err) ?? { done: true, value: void 0 };
+        }
+      };
+    };
+    return wrapped;
+  }
+  if (typeof output.then === "function") {
+    return output.then((resolved) => {
+      finalizeAgentResult(span, resolved);
+      endOnce();
+      return resolved;
+    }).catch((err) => {
+      endOnce(err);
+      throw err;
+    });
+  }
+  endOnce();
+  return output;
+}
+function rebindStreamContext(output, ctx) {
+  const STREAM_PROPS = /* @__PURE__ */ new Set(["textStream", "fullStream", "objectStream", "elementStream"]);
+  return new Proxy(output, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof prop === "string" && STREAM_PROPS.has(prop) && value && value[Symbol.asyncIterator]) {
+        const origIterator = value[Symbol.asyncIterator].bind(value);
+        return {
+          [Symbol.asyncIterator]() {
+            return import_api.context.with(ctx, () => origIterator());
+          }
+        };
+      }
+      if (typeof value === "function") return value.bind(target);
+      return value;
+    }
+  });
+}
+function finalizeAgentResult(span, result) {
+  if (!result) return;
+  if (result.text) {
+    span.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
+    span.setAttribute("neatlogs.llm.output_messages.0.content", String(result.text).slice(0, 1e4));
+  }
+  if (Array.isArray(result.toolCalls)) {
+    for (let i = 0; i < result.toolCalls.length; i++) {
+      const tc = result.toolCalls[i];
+      const p = tc.payload ?? tc;
+      setToolCall(span, i, p.toolName ?? p.name, p.args ?? p.arguments, p.toolCallId ?? p.id);
+    }
+  }
+  if (result.usage) recordUsage(span, result.usage);
+  if (result.finishReason) span.setAttribute("neatlogs.llm.stop_reason", normalizeFinishReason(result.finishReason));
+  if (result.model) span.setAttribute("neatlogs.llm.model_name", result.model);
+}
+function finalizeModelResult(span, result) {
+  if (!result) return;
+  if (typeof result.text === "string" && result.text) {
+    span.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
+    span.setAttribute("neatlogs.llm.output_messages.0.content", result.text.slice(0, 1e4));
+  } else if (Array.isArray(result.content)) {
+    const text = result.content.filter((p) => p?.type === "text" && typeof p.text === "string").map((p) => p.text).join("");
+    if (text) {
+      span.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
+      span.setAttribute("neatlogs.llm.output_messages.0.content", text.slice(0, 1e4));
+    }
+    const toolCalls = result.content.filter((p) => p?.type === "tool-call");
+    for (let i = 0; i < toolCalls.length; i++) {
+      const tc = toolCalls[i];
+      setToolCall(span, i, tc.toolName, tc.input ?? tc.args, tc.toolCallId);
+    }
+    span.setAttribute("output.value", safeStringify(result.content).slice(0, 1e4));
+  }
+  if (result.usage) recordUsage(span, result.usage);
+  span.setAttribute("neatlogs.llm.stop_reason", normalizeFinishReason(result.finishReason));
+}
+function normalizeFinishReason(fr) {
+  if (fr == null) return "";
+  if (typeof fr === "string") return fr;
+  return String(fr.unified ?? fr.reason ?? fr.type ?? safeStringify(fr));
+}
+function tokenValue(v) {
+  if (v == null) return void 0;
+  if (typeof v === "number") return v;
+  if (typeof v === "object" && typeof v.total === "number") return v.total;
+  const n = Number(v);
+  return Number.isFinite(n) ? n : void 0;
+}
+function captureInvocationParams(attrs, callOpts) {
+  if (!callOpts) return;
+  const map = [
+    ["temperature", "neatlogs.llm.temperature"],
+    ["maxOutputTokens", "neatlogs.llm.max_tokens"],
+    ["maxTokens", "neatlogs.llm.max_tokens"],
+    ["topP", "neatlogs.llm.top_p"],
+    ["topK", "neatlogs.llm.top_k"],
+    ["frequencyPenalty", "neatlogs.llm.frequency_penalty"],
+    ["presencePenalty", "neatlogs.llm.presence_penalty"]
+  ];
+  const invocation = {};
+  for (const [src, target] of map) {
+    const v = callOpts[src];
+    if (v != null) {
+      attrs[target] = v;
+      invocation[src] = v;
+    }
+  }
+  if (Array.isArray(callOpts.stopSequences) && callOpts.stopSequences.length) {
+    attrs["neatlogs.llm.stop_sequences"] = safeStringify(callOpts.stopSequences);
+    invocation.stopSequences = callOpts.stopSequences;
+  }
+  if (Array.isArray(callOpts.tools)) {
+    for (let i = 0; i < callOpts.tools.length; i++) {
+      attrs[`neatlogs.llm.tools.${i}`] = safeStringify(callOpts.tools[i]).slice(0, 4e3);
+    }
+    invocation.toolChoice = callOpts.toolChoice;
+  }
+  if (Object.keys(invocation).length) {
+    attrs["neatlogs.llm.invocation_parameters"] = safeStringify(invocation).slice(0, 4e3);
+  }
+}
+function setToolCall(span, i, name, args, id) {
+  span.setAttribute(`neatlogs.llm.tool_calls.${i}.name`, name ?? "");
+  span.setAttribute(`neatlogs.llm.tool_calls.${i}.arguments`, safeStringify(args ?? {}));
+  if (id) span.setAttribute(`neatlogs.llm.tool_calls.${i}.id`, id);
+}
+function recordUsage(span, usage) {
+  if (!usage) return;
+  const prompt = tokenValue(usage.promptTokens ?? usage.inputTokens ?? usage.input_tokens);
+  const completion = tokenValue(usage.completionTokens ?? usage.outputTokens ?? usage.output_tokens);
+  const total = tokenValue(usage.totalTokens);
+  if (prompt != null) span.setAttribute("neatlogs.llm.token_count.prompt", prompt);
+  if (completion != null) span.setAttribute("neatlogs.llm.token_count.completion", completion);
+  if (total != null) span.setAttribute("neatlogs.llm.token_count.total", total);
+  else if (prompt != null && completion != null) {
+    span.setAttribute("neatlogs.llm.token_count.total", prompt + completion);
+  }
+}
+function withActiveSpan(name, attrs, fn) {
+  const tracer = import_api.trace.getTracer(TRACER_NAME);
+  const span = tracer.startSpan(name, { attributes: attrs }, import_api.context.active());
+  const ctx = import_api.trace.setSpan(import_api.context.active(), span);
+  return import_api.context.with(ctx, async () => {
+    try {
+      const result = await fn(span);
+      span.setStatus({ code: import_api.SpanStatusCode.OK });
+      return result;
+    } catch (err) {
+      recordError(span, err);
+      throw err;
+    } finally {
+      span.end();
+    }
+  });
+}
+function withSpan(name, attrs, fn) {
+  const tracer = import_api.trace.getTracer(TRACER_NAME);
+  const span = tracer.startSpan(name, { attributes: attrs }, import_api.context.active());
+  return Promise.resolve().then(() => fn(span)).then((result) => {
+    span.setStatus({ code: import_api.SpanStatusCode.OK });
+    span.end();
+    return result;
+  }).catch((err) => {
+    recordError(span, err);
+    span.end();
+    throw err;
+  });
+}
+function markPatched(e) {
+  try {
+    Object.defineProperty(e, PATCH_FLAG, { value: true, enumerable: false, configurable: true });
+  } catch {
+    e[PATCH_FLAG] = true;
+  }
+}
+function extractModelId(model) {
+  if (!model) return "";
+  if (typeof model === "string") return model;
+  return model.modelId ?? model.name ?? "";
+}
+function toInputValue(input) {
+  return (typeof input === "string" ? input : safeStringify(input)).slice(0, 1e4);
+}
+function safeStringify(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return "";
+  }
+}
+function recordError(span, err) {
+  if (err instanceof Error) {
+    span.setStatus({ code: import_api.SpanStatusCode.ERROR, message: err.message });
+    span.recordException(err);
+  } else {
+    span.setStatus({ code: import_api.SpanStatusCode.ERROR, message: String(err) });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  wrapMastra,
+  wrapMastraRerank
+});
+//# sourceMappingURL=mastra-wrap.cjs.map