Agents Built with the Anthropic SDK

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

export ARIZE_SPACE_ID="<your-space-id>"
export ARIZE_API_KEY="<your-api-key>"
export ARIZE_PROJECT_NAME="anthropic-sdk-agent"
export ANTHROPIC_API_KEY="<your-anthropic-api-key>"

import { provider } from "./instrumentation"; // runs the tracing setup first

import Anthropic from "@anthropic-ai/sdk";
import { trace, SpanStatusCode } from "@opentelemetry/api";
import {
  SemanticConventions,
  OpenInferenceSpanKind,
} from "@arizeai/openinference-semantic-conventions";

const client = new Anthropic();
const tracer = trace.getTracer("nutrition-agent");

const tools: Anthropic.Tool[] = [
  {
    name: "get_daily_calories",
    description:
      "Recommended daily calorie intake for an age and activity level.",
    input_schema: {
      type: "object",
      properties: {
        age: { type: "integer" },
        activity_level: { type: "string", enum: ["low", "moderate", "high"] },
      },
      required: ["age", "activity_level"],
    },
  },
];

function runTool(name: string, args: any): string {
  // Replace with your real tool implementation.
  if (name === "get_daily_calories") {
    const table: Record<string, number> = {
      low: 1800,
      moderate: 2200,
      high: 2600,
    };
    const base = table[args.activity_level];
    return JSON.stringify({ recommended_calories: base });
  }
  return JSON.stringify({ error: `unknown tool ${name}` });
}

async function runAgent(userInput: string): Promise<string> {
  return tracer.startActiveSpan("nutrition-agent", async (agentSpan) => {
    agentSpan.setAttribute(
      SemanticConventions.OPENINFERENCE_SPAN_KIND,
      OpenInferenceSpanKind.AGENT,
    );
    agentSpan.setAttribute(SemanticConventions.INPUT_VALUE, userInput);

    const messages: Anthropic.MessageParam[] = [
      { role: "user", content: userInput },
    ];
    let response: Anthropic.Message;

    while (true) {
      // Auto-instrumented: each call appears as a child LLM span.
      response = await client.messages.create({
        model: "claude-opus-4-8",
        max_tokens: 1024,
        tools,
        messages,
      });
      messages.push({ role: "assistant", content: response.content });

      if (response.stop_reason !== "tool_use") break;

      const toolResults: Anthropic.ToolResultBlockParam[] = [];
      for (const block of response.content) {
        if (block.type === "tool_use") {
          // Manual TOOL span for each tool execution.
          await tracer.startActiveSpan(block.name, async (toolSpan) => {
            toolSpan.setAttribute(
              SemanticConventions.OPENINFERENCE_SPAN_KIND,
              OpenInferenceSpanKind.TOOL,
            );
            toolSpan.setAttribute(SemanticConventions.TOOL_NAME, block.name);
            toolSpan.setAttribute(
              SemanticConventions.INPUT_VALUE,
              JSON.stringify(block.input),
            );
            const result = runTool(block.name, block.input);
            toolSpan.setAttribute(SemanticConventions.OUTPUT_VALUE, result);
            toolSpan.end();
            toolResults.push({
              type: "tool_result",
              tool_use_id: block.id,
              content: result,
            });
          });
        }
      }
      messages.push({ role: "user", content: toolResults });
    }

    const finalText = response.content
      .filter((b): b is Anthropic.TextBlock => b.type === "text")
      .map((b) => b.text)
      .join("");
    agentSpan.setAttribute(SemanticConventions.OUTPUT_VALUE, finalText);
    agentSpan.setStatus({ code: SpanStatusCode.OK });
    agentSpan.end();
    return finalText;
  });
}

runAgent(
  "I'm 34 and moderately active. What's my daily calorie target?",
).then(async (answer) => {
  console.log(answer);
  // Short-lived script: wait for pending span exports to finish before exit.
  await provider.forceFlush();
});

import { context } from "@opentelemetry/api";
import { setSession } from "@arizeai/openinference-core";

async function handleTurn(sessionId: string, userInput: string): Promise<string> {
  return context.with(setSession(context.active(), { sessionId }), () =>
    runAgent(userInput),
  );
}