Trace an Agent Built with the OpenAI SDK

npm install openai \
  @arizeai/openinference-instrumentation-openai \
  @arizeai/openinference-semantic-conventions \
  @opentelemetry/api \
  @opentelemetry/exporter-trace-otlp-proto \
  @opentelemetry/instrumentation \
  @opentelemetry/resources \
  @opentelemetry/sdk-trace-base \
  @opentelemetry/sdk-trace-node \
  @opentelemetry/semantic-conventions

export ARIZE_SPACE_ID="<your-space-id>"
export ARIZE_API_KEY="<your-api-key>"
export ARIZE_PROJECT_NAME="openai-sdk-agent-example"
export OPENAI_API_KEY="<your-openai-api-key>"

// instrumentation.ts
import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
import { resourceFromAttributes } from "@opentelemetry/resources";
import { SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base";
import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
import {
  SEMRESATTRS_PROJECT_NAME,
} from "@arizeai/openinference-semantic-conventions";
import { registerInstrumentations } from "@opentelemetry/instrumentation";
import {
  OpenAIInstrumentation,
} from "@arizeai/openinference-instrumentation-openai";
import OpenAI from "openai";

const projectName =
  process.env.ARIZE_PROJECT_NAME ?? "openai-sdk-agent-example";

export const provider = new NodeTracerProvider({
  resource: resourceFromAttributes({
    [ATTR_SERVICE_NAME]: projectName,
    [SEMRESATTRS_PROJECT_NAME]: projectName,
  }),
  spanProcessors: [
    new SimpleSpanProcessor(
      new OTLPTraceExporter({
        url: "https://otlp.arize.com/v1/traces",
        headers: {
          "arize-space-id": process.env.ARIZE_SPACE_ID ?? "",
          "arize-api-key": process.env.ARIZE_API_KEY ?? "",
        },
      }),
    ),
  ],
});

provider.register();

// Auto-instrument the OpenAI SDK. Every Responses API call now
// emits an LLM span on its own.
const instrumentation = new OpenAIInstrumentation();
instrumentation.manuallyInstrument(OpenAI);
registerInstrumentations({ instrumentations: [instrumentation] });

console.log("Arize AX tracing initialized for the OpenAI SDK.");

// agent.ts
import { trace } from "@opentelemetry/api";
import {
  INPUT_VALUE,
  OUTPUT_VALUE,
  TOOL_NAME,
  OpenInferenceSpanKind,
  SemanticConventions,
} from "@arizeai/openinference-semantic-conventions";
import OpenAI from "openai";

// Uses the tracer provider registered in instrumentation.ts, so these
// manual spans join the same traces as the auto-instrumented calls.
const tracer = trace.getTracer("openai-sdk-agent");
const client = new OpenAI();
const MODEL = "gpt-5.5";

function solveEquation(equation: string): string {
  // Illustrative only: never call eval() on model-provided input in
  // production. Use a sandboxed math parser instead.
  return String(eval(equation));
}

// The tool schema advertised to the model on every request.
const tools: OpenAI.Responses.Tool[] = [
  {
    type: "function",
    name: "solve_equation",
    description:
      "Evaluate a math expression, such as '15 + 28', and " +
      "return the numeric result.",
    parameters: {
      type: "object",
      properties: {
        equation: {
          type: "string",
          description: "The expression to evaluate.",
        },
      },
      required: ["equation"],
      additionalProperties: false,
    },
    strict: true,
  },
];

export async function runAgent(question: string): Promise<string> {
  // The AGENT span is the root of the trajectory. Every LLM call
  // and tool execution below nests underneath it.
  return tracer.startActiveSpan("Math Solver Agent", async (span) => {
    span.setAttribute(
      SemanticConventions.OPENINFERENCE_SPAN_KIND,
      OpenInferenceSpanKind.AGENT,
    );
    span.setAttribute(INPUT_VALUE, question);

    const instructions =
      "You solve math problems. Use the solve_equation tool to " +
      "compute results instead of doing arithmetic yourself.";
    const input: OpenAI.Responses.ResponseInputItem[] = [
      { role: "user", content: question },
    ];

    while (true) {
      // Auto-instrumented: emits an LLM span on its own.
      const response = await client.responses.create({
        model: MODEL,
        instructions,
        input,
        tools,
      });

      // Carry the model's output items into the next turn's input.
      // The SDK's output-item type is wider than its input-item
      // type, but these items are valid input, so we assert the type.
      input.push(
        ...(response.output as OpenAI.Responses.ResponseInputItem[]),
      );

      const functionCalls = response.output.filter(
        (item) => item.type === "function_call",
      );

      // No function calls means this is the final answer.
      if (functionCalls.length === 0) {
        const answer = response.output_text;
        span.setAttribute(OUTPUT_VALUE, answer);
        span.end();
        return answer;
      }

      // Otherwise run each requested tool and feed results back.
      for (const call of functionCalls) {
        const args = JSON.parse(call.arguments);

        // Manual TOOL span: captures the execution the OpenAI
        // instrumentor cannot see, since it runs in our code.
        const result = tracer.startActiveSpan(call.name, (toolSpan) => {
          toolSpan.setAttribute(
            SemanticConventions.OPENINFERENCE_SPAN_KIND,
            OpenInferenceSpanKind.TOOL,
          );
          toolSpan.setAttribute(TOOL_NAME, call.name);
          toolSpan.setAttribute(INPUT_VALUE, call.arguments);
          const output = solveEquation(args.equation);
          toolSpan.setAttribute(OUTPUT_VALUE, output);
          toolSpan.end();
          return output;
        });

        input.push({
          type: "function_call_output",
          call_id: call.call_id,
          output: result,
        });
      }
    }
  });
}

// example.ts

// Import instrumentation first so tracing is set up before the
// OpenAI client is used.
import { provider } from "./instrumentation";

import { runAgent } from "./agent";

const answer = await runAgent("What is 15 + 28?");
console.log(answer);

// Flush any pending spans before the process exits.
await provider.forceFlush();