@morsehq-dev/sdk 0.4.0-rc.1

package/dist/browser/openai-agents/index.cjs

@@ -0,0 +1,689 @@
+'use strict';
+
+var chunkMCJYZH6W_cjs = require('../chunk-MCJYZH6W.cjs');
+var chunkB7DEUDP6_cjs = require('../chunk-B7DEUDP6.cjs');
+var chunkSWQOPFE4_cjs = require('../chunk-SWQOPFE4.cjs');
+var chunkKRBADE6R_cjs = require('../chunk-KRBADE6R.cjs');
+var chunk3643DC7K_cjs = require('../chunk-3643DC7K.cjs');
+var chunkO4HG3OSK_cjs = require('../chunk-O4HG3OSK.cjs');
+
+// src/openai-agents/runner-wrapper.ts
+chunkO4HG3OSK_cjs.init_tracing();
+var WRAPPED_RUNNER = /* @__PURE__ */ Symbol.for("morse.openai-agents.wrapped");
+var INSTALL_SENTINEL = /* @__PURE__ */ Symbol.for("morse.openai-agents.installed");
+var ORIGINALS_SENTINEL = /* @__PURE__ */ Symbol.for("morse.openai-agents.originals");
+function wrapRunner(runner, options = {}) {
+  if (!runner || typeof runner !== "object") return runner;
+  if (runner[WRAPPED_RUNNER]) return runner;
+  const originalRun = runner.run?.bind(runner);
+  if (typeof originalRun !== "function") return runner;
+  const patchedRun = buildPatchedRun(
+    originalRun,
+    options
+  );
+  const wrapper = new Proxy(runner, {
+    get(target, prop, receiver) {
+      if (prop === WRAPPED_RUNNER) return true;
+      if (prop === "run") return patchedRun;
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value === "function") {
+        return value.bind(target);
+      }
+      return value;
+    }
+  });
+  return wrapper;
+}
+var instrumentOpenAIAgents = chunkKRBADE6R_cjs.absorbErrorsAsync(
+  async (runnerOrOptions = void 0, maybeOptions = {}) => {
+    if (runnerOrOptions && isRunner(runnerOrOptions)) {
+      const opts2 = maybeOptions ?? {};
+      return wrapRunner(runnerOrOptions, opts2);
+    }
+    const opts = runnerOrOptions ?? {};
+    const mod = await loadOpenAIAgentsModule(opts.openaiAgentsModule);
+    if (!mod) return false;
+    const installed = mod[INSTALL_SENTINEL] === true;
+    if (installed) return true;
+    const carrier = findRunnerPrototypeCarrier(mod);
+    if (!carrier) return false;
+    const originalRun = carrier.prototype.run;
+    if (typeof originalRun !== "function") return false;
+    const patchedRun = buildPatchedRun(function(agent, input, callOptions) {
+      return originalRun.call(
+        this,
+        agent,
+        input,
+        callOptions
+      );
+    }, opts);
+    carrier.prototype.run = patchedRun;
+    mod[ORIGINALS_SENTINEL] = {
+      protoRun: originalRun,
+      protoCarrier: carrier
+    };
+    mod[INSTALL_SENTINEL] = true;
+    return true;
+  },
+  { fingerprint: "morse.adapters.openai-agents.install" }
+);
+var uninstallOpenAIAgents = chunkKRBADE6R_cjs.absorbErrorsSync(
+  (openaiAgentsModule) => {
+    if (!openaiAgentsModule || typeof openaiAgentsModule !== "object") return;
+    const mod = openaiAgentsModule;
+    if (!mod[INSTALL_SENTINEL]) return;
+    const originals = mod[ORIGINALS_SENTINEL];
+    if (originals?.protoCarrier && originals.protoRun !== void 0) {
+      originals.protoCarrier.prototype.run = originals.protoRun;
+    }
+    mod[ORIGINALS_SENTINEL] = void 0;
+    mod[INSTALL_SENTINEL] = false;
+  },
+  { fingerprint: "morse.adapters.openai-agents.uninstall" }
+);
+function isOpenAIAgentsWrapped(runner) {
+  if (!runner || typeof runner !== "object") return false;
+  return runner[WRAPPED_RUNNER] === true;
+}
+function isRunner(x) {
+  if (!x || typeof x !== "object") return false;
+  const r = x.run;
+  return typeof r === "function";
+}
+async function loadOpenAIAgentsModule(explicit) {
+  if (explicit && typeof explicit === "object") return explicit;
+  try {
+    return await Function("m", "return import(m)")("@openai/agents");
+  } catch {
+    return null;
+  }
+}
+function findRunnerPrototypeCarrier(mod) {
+  if (!mod || typeof mod !== "object") return null;
+  const m = mod;
+  const candidates = [m.Runner, m.default?.Runner];
+  for (const c of candidates) {
+    if (c && typeof c === "function" && c.prototype && typeof c.prototype.run === "function") {
+      return c;
+    }
+  }
+  return null;
+}
+function stringifyModel(m) {
+  if (typeof m === "string" && m.length > 0) return m;
+  if (m && typeof m === "object" && typeof m.id === "string" && m.id.length > 0) return m.id;
+  return void 0;
+}
+function buildPatchedRun(original, options) {
+  return function patchedRun(agent, input, callOptions) {
+    const boundOriginal = (a, i, o) => original.call(this, a, i, o);
+    const agentName = (agent && typeof agent === "object" && typeof agent.name === "string" && agent.name.length > 0 ? agent.name : void 0) ?? options.defaultAgentName ?? "openai-agent";
+    const model = stringifyModel(agent?.model);
+    const runWithSpan = async () => {
+      const handle = chunkB7DEUDP6_cjs.emitAgentSpan({
+        adapter: "openai-agents",
+        agentName,
+        model
+      });
+      try {
+        const result = await boundOriginal(agent, input, callOptions);
+        try {
+          options.onRunResult?.(result, model);
+        } catch {
+        }
+        handle?.end();
+        return result;
+      } catch (err) {
+        handle?.end(err);
+        throw err;
+      }
+    };
+    if (chunkO4HG3OSK_cjs.getActiveTraceState() !== null) {
+      return runWithSpan();
+    }
+    return (async () => {
+      let captured;
+      let caughtErr;
+      const runResult = await chunkO4HG3OSK_cjs.runAsync({ agentName }, async (runHandle) => {
+        try {
+          captured = await runWithSpan();
+          runHandle.setOutcome(true);
+          return captured;
+        } catch (err) {
+          caughtErr = err;
+          throw err;
+        }
+      }).catch((err) => {
+        if (caughtErr === void 0) caughtErr = err;
+        return void 0;
+      });
+      if (caughtErr !== void 0) throw caughtErr;
+      return captured ?? runResult;
+    })();
+  };
+}
+
+// src/openai-agents/llm-and-tool.ts
+var ADAPTER = "openai-agents";
+function installLlmAndToolInstrumentation(runner, options) {
+  if (typeof runner?.on !== "function") {
+    return () => {
+    };
+  }
+  const opts = options ?? {};
+  const llmStack = [];
+  const toolStack = [];
+  const onLlmStart = chunkKRBADE6R_cjs.absorbErrorsSync(
+    (event) => {
+      const contextSegments = chunk3643DC7K_cjs.decomposeOpenAiMessages(event.llm?.messages, event.llm?.tools);
+      const handle = chunkB7DEUDP6_cjs.emitLlmSpan({
+        adapter: ADAPTER,
+        model: typeof event.llm?.model === "string" && event.llm.model.length > 0 ? event.llm.model : "unknown",
+        provider: typeof event.llm?.provider === "string" ? event.llm.provider : void 0,
+        contextSegments: contextSegments.length > 0 ? contextSegments : void 0
+      });
+      if (handle !== null) llmStack.push(handle);
+    },
+    { fingerprint: "morse.openai-agents.llm_call_start" }
+  );
+  const onLlmEnd = chunkKRBADE6R_cjs.absorbErrorsSync(
+    (event) => {
+      const handle = llmStack.shift();
+      if (handle === void 0) return;
+      const usage = event.llm?.usage;
+      if (usage !== void 0 && usage !== null) {
+        if (typeof usage.input_tokens === "number" && Number.isFinite(usage.input_tokens)) {
+          handle.span.input_tokens = usage.input_tokens;
+        }
+        if (typeof usage.output_tokens === "number" && Number.isFinite(usage.output_tokens)) {
+          handle.span.output_tokens = usage.output_tokens;
+        }
+        if (typeof usage.total_tokens === "number" && Number.isFinite(usage.total_tokens)) {
+          handle.span.total_tokens = usage.total_tokens;
+        } else if (handle.span.input_tokens !== void 0 && handle.span.output_tokens !== void 0) {
+          handle.span.total_tokens = handle.span.input_tokens + handle.span.output_tokens;
+        }
+        const cachedTokens = typeof usage.cached_tokens === "number" && Number.isFinite(usage.cached_tokens) ? usage.cached_tokens : 0;
+        if (handle.span.cost_usd === void 0 && handle.span.model && (handle.span.input_tokens !== void 0 || handle.span.output_tokens !== void 0)) {
+          const cost = chunkSWQOPFE4_cjs.calculateCost({
+            inputTokens: handle.span.input_tokens ?? 0,
+            outputTokens: handle.span.output_tokens ?? 0,
+            model: handle.span.model,
+            cachedInputTokens: cachedTokens
+          });
+          if (cost !== void 0) handle.span.cost_usd = cost;
+        }
+      }
+      handle.end();
+    },
+    { fingerprint: "morse.openai-agents.llm_call_end" }
+  );
+  const onToolStart = chunkKRBADE6R_cjs.absorbErrorsSync(
+    (event) => {
+      const toolName = typeof event.tool?.name === "string" && event.tool.name.length > 0 ? event.tool.name : "unknown";
+      const inputSummary = chunkMCJYZH6W_cjs.summarizeToolInput(
+        event.tool?.input,
+        opts.toolInputMaxBytes !== void 0 ? { maxBytes: opts.toolInputMaxBytes } : void 0
+      );
+      const handle = chunkB7DEUDP6_cjs.emitToolSpan({
+        adapter: ADAPTER,
+        toolName,
+        inputSummary
+      });
+      if (handle !== null) toolStack.push(handle);
+    },
+    { fingerprint: "morse.openai-agents.tool_call_start" }
+  );
+  const onToolEnd = chunkKRBADE6R_cjs.absorbErrorsSync(
+    (event) => {
+      const handle = toolStack.shift();
+      if (handle === void 0) return;
+      const outputSummary = chunkMCJYZH6W_cjs.summarizeToolOutput(
+        event.tool?.output,
+        opts.toolOutputMaxBytes !== void 0 ? { maxBytes: opts.toolOutputMaxBytes } : void 0
+      );
+      const success = typeof event.tool?.success === "boolean" ? event.tool.success : true;
+      const metadata = handle.span.metadata ?? {};
+      const tool = metadata.tool !== void 0 && metadata.tool !== null ? metadata.tool : {};
+      tool.output_summary = outputSummary;
+      tool.success = success;
+      if (typeof event.tool?.duration_ms === "number" && Number.isFinite(event.tool.duration_ms)) {
+        tool.duration_ms = event.tool.duration_ms;
+      }
+      metadata.tool = tool;
+      metadata.tool_output_summary = outputSummary;
+      handle.span.metadata = metadata;
+      if (success === false) {
+        handle.end(new Error("tool call reported failure"));
+      } else {
+        handle.end();
+      }
+    },
+    { fingerprint: "morse.openai-agents.tool_call_end" }
+  );
+  runner.on("llm_call_start", onLlmStart);
+  runner.on("llm_call_end", onLlmEnd);
+  runner.on("tool_call_start", onToolStart);
+  runner.on("tool_call_end", onToolEnd);
+  let unsubscribed = false;
+  return () => {
+    if (unsubscribed) return;
+    unsubscribed = true;
+    if (typeof runner.off === "function") {
+      runner.off("llm_call_start", onLlmStart);
+      runner.off("llm_call_end", onLlmEnd);
+      runner.off("tool_call_start", onToolStart);
+      runner.off("tool_call_end", onToolEnd);
+    }
+  };
+}
+
+// src/openai-agents/handoff.ts
+var _handleHandoffEvent = (event) => {
+  if (event === null || typeof event !== "object") return;
+  const handoff = event.handoff;
+  if (!handoff || typeof handoff !== "object") return;
+  const from = handoff.from_agent;
+  const to = handoff.to_agent;
+  if (typeof from !== "string" || from.length === 0) return;
+  if (typeof to !== "string" || to.length === 0) return;
+  const reason = typeof handoff.reason === "string" && handoff.reason.length > 0 ? handoff.reason : void 0;
+  const attributes = {
+    handoff_from: from
+  };
+  if (reason !== void 0) attributes.handoff_reason = reason;
+  const handle = chunkB7DEUDP6_cjs.emitSubagentSpan({
+    adapter: "openai-agents",
+    parentAgentName: from,
+    subagentName: to,
+    taskDescription: reason,
+    attributes
+  });
+  handle?.end();
+};
+var handleHandoffEvent = chunkKRBADE6R_cjs.absorbErrorsSync(_handleHandoffEvent, {
+  fingerprint: "morse.adapters.openai-agents.handoff.listener"
+});
+function installHandoffInstrumentation(runner) {
+  if (runner === null || typeof runner !== "object") return () => {
+  };
+  if (typeof runner.on !== "function") return () => {
+  };
+  try {
+    runner.on("handoff", handleHandoffEvent);
+  } catch {
+    return () => {
+    };
+  }
+  let active = true;
+  return () => {
+    if (!active) return;
+    active = false;
+    try {
+      runner.off?.("handoff", handleHandoffEvent);
+    } catch {
+    }
+  };
+}
+
+// src/openai-agents/guardrail.ts
+var _handleGuardrailEvent = (payload) => {
+  const guardrail = payload?.guardrail;
+  if (guardrail === void 0 || guardrail === null || typeof guardrail !== "object") {
+    return;
+  }
+  const name = typeof guardrail.name === "string" && guardrail.name.length > 0 ? guardrail.name : void 0;
+  const passed = guardrail.passed === true;
+  const reason = typeof guardrail.reason === "string" && guardrail.reason.length > 0 ? guardrail.reason : void 0;
+  const guardrailMeta = { passed };
+  if (name !== void 0) guardrailMeta.name = name;
+  if (reason !== void 0) guardrailMeta.reason = reason;
+  const handle = chunkB7DEUDP6_cjs.emitToolSpan({
+    adapter: "openai-agents",
+    toolName: `guardrail.${name ?? "anon"}`,
+    success: passed
+  });
+  if (handle === null || handle === void 0) return;
+  handle.span.metadata = {
+    ...handle.span.metadata ?? {},
+    tool_kind: "guardrail",
+    guardrail: guardrailMeta
+  };
+  if (passed) {
+    handle.end();
+  } else {
+    handle.end(new Error(`guardrail failed: ${reason ?? "no reason"}`));
+  }
+};
+var handleGuardrailEvent = chunkKRBADE6R_cjs.absorbErrorsSync(
+  _handleGuardrailEvent,
+  { fingerprint: "morse.openai-agents.guardrail.handle" }
+);
+function installGuardrailInstrumentation(runner) {
+  if (runner === null || typeof runner !== "object" || typeof runner.on !== "function") {
+    return () => {
+    };
+  }
+  const listener = (payload) => {
+    handleGuardrailEvent(payload);
+  };
+  try {
+    runner.on("guardrail_check", listener);
+  } catch {
+    return () => {
+    };
+  }
+  return () => {
+    try {
+      if (typeof runner.off === "function") {
+        runner.off("guardrail_check", listener);
+      }
+    } catch {
+    }
+  };
+}
+
+// src/openai-agents/trace-processor.ts
+var ADAPTER2 = "openai-agents";
+function safe(fn) {
+  try {
+    return fn();
+  } catch {
+    return void 0;
+  }
+}
+var MorseTraceProcessor = class {
+  options;
+  openSpans = /* @__PURE__ */ new Map();
+  /**
+   * MHQ-787: `'response'`-type spans (the SDK's default Responses-API path)
+   * carry a `response_id` but no `model`/`usage` of their own — that data
+   * only becomes available on `Runner.run()`'s resolved result
+   * (`result.rawResponses`), which arrives AFTER `onSpanEnd` already fired.
+   * Keep already-closed response spans around, keyed by `response_id`, so
+   * `enrichFromRunResult()` can patch them in place once the real usage
+   * data is available. Spans stay mutable (their span-tree object isn't
+   * exported until the outer trace closes), so a late patch still lands.
+   */
+  closedResponseSpans = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /**
+   * MHQ-787: called by `wrapRunnerWithFullInstrumentation` after each
+   * `Runner.run()` resolves. Matches `rawResponses[].responseId` back to
+   * the `'response'`-type span it belongs to and fills in the model/usage/
+   * cost fields `onSpanEnd` couldn't populate at the time. `fallbackModel`
+   * is the model configured on the `Agent` (known at call time in
+   * `runner-wrapper.ts`) — used only when the span still has no model.
+   * Never throws; a translation failure must not surface to the caller.
+   */
+  enrichFromRunResult(rawResponses, fallbackModel) {
+    safe(() => {
+      for (const raw of rawResponses) {
+        if (typeof raw.responseId !== "string") continue;
+        const handle = this.closedResponseSpans.get(raw.responseId);
+        if (!handle) continue;
+        this.closedResponseSpans.delete(raw.responseId);
+        if ((!handle.span.model || handle.span.model === "unknown") && fallbackModel) {
+          handle.span.model = fallbackModel;
+        }
+        const u = raw.usage;
+        if (u) {
+          if (typeof u.inputTokens === "number") handle.span.input_tokens = u.inputTokens;
+          if (typeof u.outputTokens === "number") handle.span.output_tokens = u.outputTokens;
+          if (typeof u.totalTokens === "number") {
+            handle.span.total_tokens = u.totalTokens;
+          } else if (handle.span.input_tokens !== void 0 && handle.span.output_tokens !== void 0) {
+            handle.span.total_tokens = handle.span.input_tokens + handle.span.output_tokens;
+          }
+        }
+        if (handle.span.cost_usd === void 0 && handle.span.model && handle.span.model !== "unknown" && (handle.span.input_tokens !== void 0 || handle.span.output_tokens !== void 0)) {
+          const cost = chunkSWQOPFE4_cjs.calculateCost({
+            inputTokens: handle.span.input_tokens ?? 0,
+            outputTokens: handle.span.output_tokens ?? 0,
+            model: handle.span.model
+          });
+          if (cost !== void 0) handle.span.cost_usd = cost;
+        }
+      }
+    });
+  }
+  /* -- TraceProcessor surface ---------------------------------------- */
+  onTraceStart(_trace) {
+  }
+  onTraceEnd(_trace) {
+  }
+  onSpanStart(span) {
+    safe(() => {
+      const handle = this.openSpanFor(span);
+      if (handle && span.spanId) {
+        this.openSpans.set(span.spanId, handle);
+      }
+    });
+  }
+  onSpanEnd(span) {
+    safe(() => {
+      if (!span.spanId) return;
+      const handle = this.openSpans.get(span.spanId);
+      if (!handle) return;
+      this.openSpans.delete(span.spanId);
+      this.populateSpanFromData(handle, span);
+      const d = span.spanData;
+      if (d?.type === "response" && typeof d.response_id === "string" && d.response_id.length > 0) {
+        this.closedResponseSpans.set(d.response_id, handle);
+      }
+      if (d?.type === "guardrail" && d.passed === false) {
+        safeEnd(handle, new Error(`guardrail failed: ${d.reason ?? "no reason"}`));
+        return;
+      }
+      if (span.error) {
+        safeEnd(handle, new Error(String(span.error)));
+        return;
+      }
+      safeEnd(handle);
+    });
+  }
+  async shutdown() {
+    for (const [, handle] of this.openSpans) {
+      safeEnd(handle, new Error("morse: processor shutdown before span ended"));
+    }
+    this.openSpans.clear();
+    this.closedResponseSpans.clear();
+  }
+  async forceFlush() {
+  }
+  /* -- Internals ------------------------------------------------------ */
+  openSpanFor(span) {
+    const d = span.spanData ?? {};
+    const type = typeof d.type === "string" ? d.type : "";
+    const name = typeof d.name === "string" && d.name.length > 0 ? d.name : void 0;
+    switch (type) {
+      case "agent":
+        return chunkB7DEUDP6_cjs.emitAgentSpan({
+          adapter: ADAPTER2,
+          agentName: name ?? "openai-agent"
+        });
+      case "generation":
+      case "response": {
+        const model = typeof d.model === "string" && d.model.length > 0 ? d.model : "unknown";
+        return chunkB7DEUDP6_cjs.emitLlmSpan({ adapter: ADAPTER2, model });
+      }
+      case "function": {
+        const inputOpts = this.options.toolInputMaxBytes ? { maxBytes: this.options.toolInputMaxBytes } : void 0;
+        return chunkB7DEUDP6_cjs.emitToolSpan({
+          adapter: ADAPTER2,
+          toolName: name ?? "function",
+          inputSummary: d.input !== void 0 ? chunkMCJYZH6W_cjs.summarizeToolInput(d.input, inputOpts) : void 0
+        });
+      }
+      case "handoff":
+        return chunkB7DEUDP6_cjs.emitSubagentSpan({
+          adapter: ADAPTER2,
+          parentAgentName: typeof d.from_agent === "string" ? d.from_agent : "unknown",
+          subagentName: typeof d.to_agent === "string" ? d.to_agent : name ?? "unknown",
+          taskDescription: typeof d.reason === "string" ? d.reason : void 0
+        });
+      case "guardrail": {
+        const handle = chunkB7DEUDP6_cjs.emitToolSpan({
+          adapter: ADAPTER2,
+          toolName: `guardrail.${name ?? "anon"}`
+        });
+        if (handle) {
+          handle.span.metadata = {
+            ...handle.span.metadata ?? {},
+            tool_kind: "guardrail",
+            guardrail: {
+              name: name ?? "anon",
+              passed: d.passed,
+              ...typeof d.reason === "string" ? { reason: d.reason } : {}
+            }
+          };
+        }
+        return handle;
+      }
+      case "mcp_list_tools":
+        return chunkB7DEUDP6_cjs.emitToolSpan({
+          adapter: ADAPTER2,
+          toolName: `mcp.list_tools.${name ?? "anon"}`
+        });
+      case "custom":
+        return chunkB7DEUDP6_cjs.emitToolSpan({
+          adapter: ADAPTER2,
+          toolName: `custom.${name ?? "anon"}`
+        });
+      default:
+        return chunkB7DEUDP6_cjs.emitToolSpan({
+          adapter: ADAPTER2,
+          toolName: `${type || "unknown"}.${name ?? "anon"}`
+        });
+    }
+  }
+  populateSpanFromData(handle, span) {
+    const d = span.spanData;
+    if (!d) return;
+    if (typeof d.model === "string" && d.model.length > 0) {
+      handle.span.model = d.model;
+    }
+    const u = d.usage;
+    if (u) {
+      const input = u.input_tokens ?? u.prompt_tokens;
+      const output = u.output_tokens ?? u.completion_tokens;
+      const total = u.total_tokens;
+      if (typeof input === "number") handle.span.input_tokens = input;
+      if (typeof output === "number") handle.span.output_tokens = output;
+      if (typeof total === "number") {
+        handle.span.total_tokens = total;
+      } else if (typeof input === "number" && typeof output === "number") {
+        handle.span.total_tokens = input + output;
+      }
+    }
+    if (d.output !== void 0) {
+      const outputOpts = this.options.toolOutputMaxBytes ? { maxBytes: this.options.toolOutputMaxBytes } : void 0;
+      handle.span.metadata = {
+        ...handle.span.metadata ?? {},
+        tool_output_summary: chunkMCJYZH6W_cjs.summarizeToolOutput(d.output, outputOpts)
+      };
+    }
+  }
+};
+async function installMorseTraceProcessor(options) {
+  const processor = new MorseTraceProcessor(options);
+  let mod = null;
+  try {
+    const dynamicImport = Function("m", "return import(m)");
+    mod = await dynamicImport("@openai/agents");
+  } catch {
+    return { installed: false, processor: null };
+  }
+  try {
+    if (typeof mod?.addTraceProcessor === "function") {
+      mod.addTraceProcessor(processor);
+      return { installed: true, processor };
+    }
+  } catch {
+  }
+  return { installed: false, processor: null };
+}
+function safeEnd(handle, err) {
+  try {
+    if (err !== void 0) {
+      handle.end(err);
+    } else {
+      handle.end();
+    }
+  } catch {
+  }
+}
+
+// src/openai-agents/index.ts
+function wrapRunnerWithFullInstrumentation(runner, options = {}) {
+  let installedProcessor = null;
+  const wrapped = wrapRunner(runner, {
+    defaultAgentName: options.defaultAgentName,
+    // MHQ-787: the SDK's own tracing spans for the Responses-API path
+    // carry no model/usage — only the resolved RunResult does. Patch
+    // already-closed LLM spans once we have it.
+    onRunResult: (result, model) => {
+      const rawResponses = result.rawResponses;
+      if (installedProcessor && Array.isArray(rawResponses)) {
+        installedProcessor.enrichFromRunResult(
+          rawResponses,
+          model
+        );
+      }
+    }
+  });
+  const llmAndToolOpts = {};
+  if (options.toolInputMaxBytes !== void 0) {
+    llmAndToolOpts.toolInputMaxBytes = options.toolInputMaxBytes;
+  }
+  if (options.toolOutputMaxBytes !== void 0) {
+    llmAndToolOpts.toolOutputMaxBytes = options.toolOutputMaxBytes;
+  }
+  const offLlmTool = installLlmAndToolInstrumentation(wrapped, llmAndToolOpts);
+  const offHandoff = installHandoffInstrumentation(wrapped);
+  const offGuardrail = installGuardrailInstrumentation(wrapped);
+  void installMorseTraceProcessor(llmAndToolOpts).then((result) => {
+    if (result.installed) {
+      installedProcessor = result.processor;
+    }
+  });
+  let disposed = false;
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    try {
+      offLlmTool();
+    } catch {
+    }
+    try {
+      offHandoff();
+    } catch {
+    }
+    try {
+      offGuardrail();
+    } catch {
+    }
+    if (installedProcessor) {
+      try {
+        void installedProcessor.shutdown();
+      } catch {
+      }
+    }
+  };
+  return { runner: wrapped, dispose };
+}
+
+exports.MorseTraceProcessor = MorseTraceProcessor;
+exports.installGuardrailInstrumentation = installGuardrailInstrumentation;
+exports.installHandoffInstrumentation = installHandoffInstrumentation;
+exports.installLlmAndToolInstrumentation = installLlmAndToolInstrumentation;
+exports.installMorseTraceProcessor = installMorseTraceProcessor;
+exports.instrumentOpenAIAgents = instrumentOpenAIAgents;
+exports.isOpenAIAgentsWrapped = isOpenAIAgentsWrapped;
+exports.uninstallOpenAIAgents = uninstallOpenAIAgents;
+exports.wrapRunner = wrapRunner;
+exports.wrapRunnerWithFullInstrumentation = wrapRunnerWithFullInstrumentation;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map