@agent-inspect/openai-agents 6.31.34 → 6.31.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-inspect/openai-agents",
-  "version": "6.31.34",
+  "version": "6.31.36",
   "license": "MIT",
   "type": "module",
   "description": "OpenAI Agents JS processor integration for AgentInspect local traces and TraceContract checks",
@@ -38,7 +38,7 @@
     "@openai/agents": "^0.12.0"
   },
   "dependencies": {
-    "agent-inspect": "6.31.34"
+    "agent-inspect": "6.31.36"
   },
   "publishConfig": {
     "access": "public"

package/dist/index.cjs

@@ -1,668 +0,0 @@
-'use strict';
-
-var advanced = require('agent-inspect/advanced');
-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 readFiniteNonNegative(value) {
-  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
-}
-function applyCachedAndReasoningFromDetails(tokenUsage, detailRecord) {
-  if (tokenUsage.cached === void 0) {
-    const cached = readFiniteNonNegative(
-      detailRecord.cached_tokens ?? detailRecord.cached_input_tokens
-    );
-    if (cached !== void 0) {
-      tokenUsage.cached = cached;
-    }
-  }
-  if (tokenUsage.cacheWrite === void 0) {
-    const cacheWrite = readFiniteNonNegative(
-      detailRecord.cache_creation_tokens ?? detailRecord.cached_creation_tokens ?? detailRecord.cache_write_tokens
-    );
-    if (cacheWrite !== void 0) {
-      tokenUsage.cacheWrite = cacheWrite;
-    }
-  }
-  if (tokenUsage.reasoning !== void 0) {
-    return;
-  }
-  const reasoning = detailRecord.reasoning_tokens ?? detailRecord.output_tokens_details;
-  const asNumber = readFiniteNonNegative(reasoning);
-  if (asNumber !== void 0) {
-    tokenUsage.reasoning = asNumber;
-    return;
-  }
-  if (typeof reasoning === "object" && reasoning !== null && !Array.isArray(reasoning)) {
-    const nested = readFiniteNonNegative(
-      reasoning.reasoning_tokens
-    );
-    if (nested !== void 0) {
-      tokenUsage.reasoning = nested;
-    }
-  }
-}
-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 inputDetails = record.input_tokens_details;
-  if (typeof inputDetails === "object" && inputDetails !== null && !Array.isArray(inputDetails)) {
-    applyCachedAndReasoningFromDetails(
-      tokenUsage,
-      inputDetails
-    );
-  }
-  const details = record.details;
-  if (typeof details === "object" && details !== null && !Array.isArray(details)) {
-    applyCachedAndReasoningFromDetails(tokenUsage, details);
-  }
-  const outputDetails = record.output_tokens_details;
-  if (typeof outputDetails === "object" && outputDetails !== null && !Array.isArray(outputDetails)) {
-    const nested = readFiniteNonNegative(
-      outputDetails.reasoning_tokens
-    );
-    if (nested !== void 0 && tokenUsage.reasoning === void 0) {
-      tokenUsage.reasoning = nested;
-    }
-  }
-  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 spanPreviewSources(data, phase) {
-  const withPhase = (input, output) => phase === "start" ? { input } : { input, output };
-  switch (data.type) {
-    case "generation":
-      return withPhase(data.input, data.output);
-    case "function":
-      return withPhase(data.input, data.output);
-    case "response":
-      return withPhase(data._input, data._response);
-    case "transcription":
-      return withPhase(data.input.data, data.output);
-    case "speech":
-      return withPhase(data.input, data.output.data);
-    case "custom":
-      return { input: data.data };
-    case "speech_group":
-      return { input: data.input };
-    default:
-      return {};
-  }
-}
-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.preview = advanced.createAdapterPreviewCapture({
-      capture: this.requestedCapture,
-      redactionProfile: options.redactionProfile,
-      maxPreviewChars: options.maxPreviewChars,
-      onDiagnostic: options.onDiagnostic
-    });
-    this.effectiveCapture = this.preview.capture;
-    this.writer = options.writer ?? (options.traceDir ? writers.fileWriter({ dir: options.traceDir }) : void 0);
-    for (const key of [
-      "options",
-      "writer",
-      "requestedCapture",
-      "preview",
-      "effectiveCapture",
-      "diagnostics",
-      "activeTraces",
-      "activeSpans",
-      "closed"
-    ]) {
-      Object.defineProperty(this, key, { enumerable: false });
-    }
-    this.recordCaptureOptionWarnings();
-  }
-  options;
-  installMode = "setTraceProcessors";
-  localOnly = true;
-  writer;
-  requestedCapture;
-  preview;
-  effectiveCapture;
-  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: true,
-          // Preview rows report the effective bound/profile, which the
-          // `share` and `strict` profiles can lower below the request.
-          redactionProfile: this.preview.previewEnabled ? this.preview.redactionProfile : this.options.redactionProfile,
-          maxPreviewChars: this.preview.previewEnabled ? this.preview.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),
-          ...this.previewAttributes(span, "start")
-        },
-        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),
-          ...this.previewAttributes(span, "end")
-        },
-        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, capture: this.preview.getDiagnostics() };
-  }
-  /** Bounded preview attributes for one span phase (empty unless enabled). */
-  previewAttributes(span, phase) {
-    if (!this.preview.previewEnabled) return {};
-    return this.preview.applyPreviewFields(
-      {},
-      spanPreviewSources(span.spanData, phase)
-    );
-  }
-  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() {
-    if (this.effectiveCapture === "preview") return;
-    const previewOnlyOptions = [];
-    if (this.options.redactionProfile !== void 0) previewOnlyOptions.push("redactionProfile");
-    if (this.options.maxPreviewChars !== void 0) previewOnlyOptions.push("maxPreviewChars");
-    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