@agent-inspect/openai-agents 1.8.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AgentInspect contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,581 @@
+'use strict';
+
+var writers = require('agent-inspect/writers');
+
+// packages/openai-agents/src/index.ts
+var OPENAI_AGENTS_SOURCE = {
+  type: "adapter",
+  name: "@agent-inspect/openai-agents",
+  version: "experimental"
+};
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function normalizeError(error) {
+  if (error instanceof Error && error.message.trim() !== "") {
+    return error.message;
+  }
+  if (typeof error === "string" && error.trim() !== "") {
+    return error;
+  }
+  return "Unknown OpenAI Agents processor error";
+}
+function durationMs(startedAt, endedAt) {
+  const started = Date.parse(startedAt);
+  const ended = Date.parse(endedAt);
+  if (!Number.isFinite(started) || !Number.isFinite(ended)) return void 0;
+  return Math.max(0, ended - started);
+}
+function countRecordKeys(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return void 0;
+  }
+  return Object.keys(value).length;
+}
+function normalizeMaxPreviewChars(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return void 0;
+  }
+  return Math.floor(value);
+}
+function summarizeUnknown(value) {
+  if (value === null) return { type: "null" };
+  if (Array.isArray(value)) return { type: "array", itemCount: value.length };
+  if (typeof value === "object") {
+    return { type: "object", keyCount: countRecordKeys(value) ?? 0 };
+  }
+  if (typeof value === "string") {
+    return { type: "string", length: value.length };
+  }
+  const valueType = typeof value;
+  if (valueType === "number" || valueType === "boolean" || valueType === "bigint") {
+    return { type: valueType };
+  }
+  if (valueType === "undefined") return { type: "undefined" };
+  return { type: "unknown" };
+}
+function summarizeOptionalUnknown(value) {
+  return value === void 0 ? void 0 : summarizeUnknown(value);
+}
+function summarizeError(error) {
+  if (!error?.message) return void 0;
+  return { message: error.message };
+}
+function summarizeUsage(usage) {
+  if (typeof usage !== "object" || usage === null || Array.isArray(usage)) {
+    return void 0;
+  }
+  const record = usage;
+  const tokenUsage = {};
+  if (typeof record.input_tokens === "number" && Number.isFinite(record.input_tokens)) {
+    tokenUsage.input = record.input_tokens;
+  }
+  if (typeof record.output_tokens === "number" && Number.isFinite(record.output_tokens)) {
+    tokenUsage.output = record.output_tokens;
+  }
+  if (tokenUsage.input !== void 0 || tokenUsage.output !== void 0) {
+    tokenUsage.total = (tokenUsage.input ?? 0) + (tokenUsage.output ?? 0);
+  }
+  const details = record.details;
+  if (typeof details === "object" && details !== null && !Array.isArray(details)) {
+    const detailRecord = details;
+    const cached = detailRecord.cached_tokens ?? detailRecord.cached_input_tokens;
+    if (typeof cached === "number" && Number.isFinite(cached)) {
+      tokenUsage.cached = cached;
+    }
+  }
+  return Object.keys(tokenUsage).length > 0 ? tokenUsage : void 0;
+}
+function spanKind(type) {
+  switch (type) {
+    case "agent":
+      return "AGENT";
+    case "generation":
+    case "response":
+    case "transcription":
+    case "speech":
+      return "LLM";
+    case "function":
+    case "mcp_tools":
+      return "TOOL";
+    case "handoff":
+    case "guardrail":
+      return "DECISION";
+    case "custom":
+    case "speech_group":
+      return "LOGIC";
+    default:
+      return "LOGIC";
+  }
+}
+function spanName(data) {
+  switch (data.type) {
+    case "agent":
+    case "function":
+    case "custom":
+    case "guardrail":
+      return data.name;
+    case "generation":
+      return data.model ? `generation:${data.model}` : "generation";
+    case "response":
+      return data.response_id ? `response:${data.response_id}` : "response";
+    case "handoff":
+      return data.to_agent ? `handoff:${data.to_agent}` : "handoff";
+    case "mcp_tools":
+      return data.server ? `mcp-tools:${data.server}` : "mcp-tools";
+    case "transcription":
+      return data.model ? `transcription:${data.model}` : "transcription";
+    case "speech":
+      return data.model ? `speech:${data.model}` : "speech";
+    case "speech_group":
+      return "speech-group";
+    default:
+      return "openai-agents-span";
+  }
+}
+function commonSpanAttributes(span) {
+  return {
+    legacyEvent: "step_started",
+    stepId: span.spanId,
+    stepType: mapSpanTypeToStepType(span.spanData.type),
+    spanType: span.spanData.type,
+    traceId: span.traceId,
+    spanId: span.spanId,
+    parentSpanId: span.parentId ?? void 0,
+    traceMetadataKeyCount: countRecordKeys(span.traceMetadata)
+  };
+}
+function specificSpanAttributes(data) {
+  switch (data.type) {
+    case "agent":
+      return {
+        agentName: data.name,
+        handoffCount: data.handoffs?.length ?? 0,
+        handoffNames: data.handoffs,
+        toolCount: data.tools?.length ?? 0,
+        toolNames: data.tools,
+        outputType: data.output_type
+      };
+    case "function":
+      return {
+        toolName: data.name,
+        hasInput: data.input !== void 0,
+        hasOutput: data.output !== void 0,
+        inputSummary: summarizeUnknown(data.input),
+        outputSummary: summarizeUnknown(data.output),
+        mcpDataSummary: summarizeOptionalUnknown(data.mcp_data)
+      };
+    case "generation":
+      return {
+        model: data.model,
+        modelConfigKeyCount: countRecordKeys(data.model_config),
+        inputSummary: summarizeOptionalUnknown(data.input),
+        outputSummary: summarizeOptionalUnknown(data.output),
+        usageDetailsKeyCount: countRecordKeys(data.usage?.details)
+      };
+    case "response":
+      return {
+        responseId: data.response_id,
+        inputSummary: summarizeOptionalUnknown(data._input),
+        responseSummary: summarizeOptionalUnknown(data._response)
+      };
+    case "handoff":
+      return {
+        fromAgent: data.from_agent,
+        toAgent: data.to_agent
+      };
+    case "custom":
+      return {
+        customName: data.name,
+        dataSummary: summarizeUnknown(data.data)
+      };
+    case "guardrail":
+      return {
+        guardrailName: data.name,
+        triggered: data.triggered
+      };
+    case "mcp_tools":
+      return {
+        server: data.server,
+        toolCount: data.result?.length ?? 0,
+        toolNames: data.result
+      };
+    case "transcription":
+      return {
+        model: data.model,
+        inputFormat: data.input.format,
+        inputSummary: summarizeUnknown(data.input.data),
+        outputSummary: summarizeOptionalUnknown(data.output),
+        modelConfigKeyCount: countRecordKeys(data.model_config)
+      };
+    case "speech":
+      return {
+        model: data.model,
+        inputSummary: summarizeOptionalUnknown(data.input),
+        outputFormat: data.output.format,
+        outputSummary: summarizeUnknown(data.output.data),
+        modelConfigKeyCount: countRecordKeys(data.model_config)
+      };
+    case "speech_group":
+      return {
+        inputSummary: summarizeOptionalUnknown(data.input)
+      };
+    default:
+      return {};
+  }
+}
+function mapSpanTypeToStepType(type) {
+  switch (type) {
+    case "generation":
+    case "response":
+    case "transcription":
+    case "speech":
+      return "llm";
+    case "function":
+    case "mcp_tools":
+      return "tool";
+    case "handoff":
+    case "guardrail":
+      return "decision";
+    case "agent":
+      return "logic";
+    case "custom":
+    case "speech_group":
+      return "custom";
+    default:
+      return "logic";
+  }
+}
+function spanInputSummary(data) {
+  switch (data.type) {
+    case "generation":
+      return summarizeOptionalUnknown(data.input);
+    case "function":
+      return summarizeUnknown(data.input);
+    case "response":
+      return summarizeOptionalUnknown(data._input);
+    case "custom":
+      return summarizeUnknown(data.data);
+    case "transcription":
+      return { format: data.input.format, ...summarizeUnknown(data.input.data) };
+    case "speech":
+    case "speech_group":
+      return summarizeOptionalUnknown(data.input);
+    default:
+      return void 0;
+  }
+}
+function spanOutputSummary(data) {
+  switch (data.type) {
+    case "generation":
+      return summarizeOptionalUnknown(data.output);
+    case "function":
+      return summarizeUnknown(data.output);
+    case "response":
+      return summarizeOptionalUnknown(data._response);
+    case "guardrail":
+      return { triggered: data.triggered };
+    case "mcp_tools":
+      return { toolCount: data.result?.length ?? 0 };
+    case "transcription":
+      return summarizeOptionalUnknown(data.output);
+    case "speech":
+      return { format: data.output.format, ...summarizeUnknown(data.output.data) };
+    default:
+      return void 0;
+  }
+}
+function traceEventId(traceId) {
+  return `openai_agents_trace:${traceId}`;
+}
+function spanEventId(spanId) {
+  return `openai_agents_span:${spanId}`;
+}
+var AgentInspectOpenAiAgentsTracingProcessor = class {
+  constructor(options) {
+    this.options = options;
+    this.requestedCapture = options.capture ?? "metadata-only";
+    this.writer = options.writer ?? (options.traceDir ? writers.fileWriter({ dir: options.traceDir }) : void 0);
+    for (const key of [
+      "options",
+      "writer",
+      "requestedCapture",
+      "effectiveCapture",
+      "diagnostics",
+      "activeTraces",
+      "activeSpans",
+      "closed"
+    ]) {
+      Object.defineProperty(this, key, { enumerable: false });
+    }
+    this.recordCaptureOptionWarnings();
+  }
+  options;
+  installMode = "setTraceProcessors";
+  localOnly = true;
+  writer;
+  requestedCapture;
+  effectiveCapture = "metadata-only";
+  diagnostics = {
+    writeFailures: 0,
+    lifecycleWarnings: 0,
+    flushFailures: 0,
+    shutdownFailures: 0,
+    runtimeMappingImplemented: true
+  };
+  activeTraces = /* @__PURE__ */ new Map();
+  activeSpans = /* @__PURE__ */ new Map();
+  closed = false;
+  start() {
+  }
+  async onTraceStart(trace) {
+    await this.handleLifecycle("onTraceStart", async () => {
+      if (this.closed) {
+        this.recordLifecycleWarning("onTraceStart ignored because processor is shut down.");
+        return;
+      }
+      const startedAt = nowIso();
+      const name = this.options.workflowName ?? trace.name ?? "openai-agents-run";
+      const eventId = traceEventId(trace.traceId);
+      this.activeTraces.set(trace.traceId, { eventId, startedAt, name });
+      await this.write({
+        schemaVersion: "0.2",
+        eventId,
+        runId: trace.traceId,
+        kind: "RUN",
+        name,
+        status: "running",
+        timestamp: startedAt,
+        startedAt,
+        confidence: "explicit",
+        source: OPENAI_AGENTS_SOURCE,
+        attributes: {
+          legacyEvent: "run_started",
+          installMode: this.installMode,
+          capture: this.effectiveCapture,
+          requestedCapture: this.requestedCapture === this.effectiveCapture ? void 0 : this.requestedCapture,
+          previewCaptureSupported: this.requestedCapture === "preview" ? false : void 0,
+          redactionProfile: this.options.redactionProfile,
+          maxPreviewChars: normalizeMaxPreviewChars(this.options.maxPreviewChars),
+          groupId: trace.groupId ?? void 0,
+          metadataKeyCount: countRecordKeys(trace.metadata)
+        },
+        trace: {
+          traceId: trace.traceId
+        }
+      });
+    });
+  }
+  async onTraceEnd(trace) {
+    await this.handleLifecycle("onTraceEnd", async () => {
+      if (this.closed) {
+        this.recordLifecycleWarning("onTraceEnd ignored because processor is shut down.");
+        return;
+      }
+      const active = this.activeTraces.get(trace.traceId);
+      if (!active) {
+        this.recordLifecycleWarning(
+          `onTraceEnd ignored because trace ${trace.traceId} has no matching start callback.`
+        );
+        return;
+      }
+      const endedAt = nowIso();
+      await this.write({
+        schemaVersion: "0.2",
+        eventId: active.eventId,
+        runId: trace.traceId,
+        kind: "RUN",
+        name: active.name,
+        status: "ok",
+        timestamp: endedAt,
+        startedAt: active.startedAt,
+        endedAt,
+        durationMs: durationMs(active.startedAt, endedAt),
+        confidence: "explicit",
+        source: OPENAI_AGENTS_SOURCE,
+        attributes: {
+          legacyEvent: "run_completed",
+          installMode: this.installMode,
+          groupId: trace.groupId ?? void 0,
+          metadataKeyCount: countRecordKeys(trace.metadata)
+        },
+        trace: {
+          traceId: trace.traceId
+        }
+      });
+      this.activeTraces.delete(trace.traceId);
+    });
+  }
+  async onSpanStart(span) {
+    await this.handleLifecycle("onSpanStart", async () => {
+      if (this.closed) {
+        this.recordLifecycleWarning("onSpanStart ignored because processor is shut down.");
+        return;
+      }
+      const startedAt = span.startedAt ?? nowIso();
+      const eventId = spanEventId(span.spanId);
+      const parentId = this.resolveParentEventId(span);
+      const kind = spanKind(span.spanData.type);
+      const name = spanName(span.spanData);
+      this.activeSpans.set(span.spanId, {
+        eventId,
+        runId: span.traceId,
+        parentId,
+        startedAt,
+        name,
+        kind
+      });
+      await this.write({
+        schemaVersion: "0.2",
+        eventId,
+        runId: span.traceId,
+        parentId,
+        kind,
+        name,
+        status: "running",
+        timestamp: startedAt,
+        startedAt,
+        confidence: "explicit",
+        source: OPENAI_AGENTS_SOURCE,
+        attributes: {
+          ...commonSpanAttributes(span),
+          ...specificSpanAttributes(span.spanData)
+        },
+        inputSummary: spanInputSummary(span.spanData),
+        tokenUsage: summarizeUsage(
+          span.spanData.type === "generation" ? span.spanData.usage : void 0
+        ),
+        trace: {
+          traceId: span.traceId,
+          spanId: span.spanId,
+          parentSpanId: span.parentId ?? void 0
+        }
+      });
+    });
+  }
+  async onSpanEnd(span) {
+    await this.handleLifecycle("onSpanEnd", async () => {
+      if (this.closed) {
+        this.recordLifecycleWarning("onSpanEnd ignored because processor is shut down.");
+        return;
+      }
+      const active = this.activeSpans.get(span.spanId);
+      if (!active) {
+        this.recordLifecycleWarning(
+          `onSpanEnd ignored because span ${span.spanId} has no matching start callback.`
+        );
+        return;
+      }
+      const endedAt = span.endedAt ?? nowIso();
+      const error = summarizeError(span.error);
+      await this.write({
+        schemaVersion: "0.2",
+        eventId: active.eventId,
+        runId: active.runId,
+        parentId: active.parentId,
+        kind: active.kind,
+        name: active.name,
+        status: error ? "error" : "ok",
+        timestamp: endedAt,
+        startedAt: active.startedAt,
+        endedAt,
+        durationMs: durationMs(active.startedAt, endedAt),
+        confidence: "explicit",
+        source: OPENAI_AGENTS_SOURCE,
+        attributes: {
+          ...commonSpanAttributes(span),
+          ...specificSpanAttributes(span.spanData),
+          legacyEvent: "step_completed",
+          errorDataSummary: summarizeOptionalUnknown(span.error?.data)
+        },
+        inputSummary: spanInputSummary(span.spanData),
+        outputSummary: spanOutputSummary(span.spanData),
+        error,
+        tokenUsage: summarizeUsage(
+          span.spanData.type === "generation" ? span.spanData.usage : void 0
+        ),
+        trace: {
+          traceId: span.traceId,
+          spanId: span.spanId,
+          parentSpanId: span.parentId ?? void 0
+        }
+      });
+      this.activeSpans.delete(span.spanId);
+    });
+  }
+  async forceFlush() {
+    try {
+      await this.writer?.flush?.();
+    } catch (error) {
+      this.diagnostics.flushFailures += 1;
+      this.diagnostics.lastError = normalizeError(error);
+    }
+  }
+  async shutdown(_timeout) {
+    if (this.closed) return;
+    try {
+      await this.writer?.close?.();
+    } catch (error) {
+      this.diagnostics.shutdownFailures += 1;
+      this.diagnostics.lastError = normalizeError(error);
+    } finally {
+      this.closed = true;
+      this.activeTraces.clear();
+      this.activeSpans.clear();
+    }
+  }
+  getDiagnostics() {
+    return { ...this.diagnostics };
+  }
+  getWriterStats() {
+    return this.writer?.getStats?.();
+  }
+  resolveParentEventId(span) {
+    if (span.parentId) return spanEventId(span.parentId);
+    return this.activeTraces.get(span.traceId)?.eventId;
+  }
+  async handleLifecycle(callbackName, run) {
+    try {
+      await run();
+    } catch (error) {
+      this.recordLifecycleWarning(`${callbackName}: ${normalizeError(error)}`);
+    }
+  }
+  recordLifecycleWarning(message) {
+    this.diagnostics.lifecycleWarnings += 1;
+    this.diagnostics.lastWarning = message;
+  }
+  recordCaptureOptionWarnings() {
+    const previewOnlyOptions = [];
+    if (this.requestedCapture === "preview") previewOnlyOptions.push("capture");
+    if (this.options.redactionProfile !== void 0) previewOnlyOptions.push("redactionProfile");
+    if (this.options.maxPreviewChars !== void 0) previewOnlyOptions.push("maxPreviewChars");
+    if (this.requestedCapture === "preview") {
+      this.recordLifecycleWarning(
+        `OpenAI Agents preview capture is not supported yet; falling back to metadata-only capture. Unsupported options: ${previewOnlyOptions.join(", ")}.`
+      );
+      return;
+    }
+    if (previewOnlyOptions.length > 0) {
+      this.recordLifecycleWarning(
+        `OpenAI Agents preview-only options have no effect in metadata-only capture: ${previewOnlyOptions.join(", ")}.`
+      );
+    }
+  }
+  async write(event) {
+    if (!this.writer) return;
+    try {
+      await this.writer.write(event);
+    } catch (error) {
+      this.diagnostics.writeFailures += 1;
+      this.diagnostics.lastError = normalizeError(error);
+    }
+  }
+};
+function agentInspectProcessor(options = {}) {
+  return new AgentInspectOpenAiAgentsTracingProcessor(options);
+}
+
+exports.agentInspectProcessor = agentInspectProcessor;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map