When a single Claude prompt is enough — and when you need an agent

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

type TicketCategory = "billing" | "technical" | "account" | "other";

interface ClassificationResult {
  category: TicketCategory;
  confidence: "high" | "medium" | "low";
  summary: string;
}

async function classifyTicket(
  ticketText: string
): Promise<ClassificationResult> {
  const message = await client.messages.create({
    model: "claude-opus-4-5",
    max_tokens: 256,
    system:
      "You are a support ticket classifier. " +
      "Return ONLY valid JSON matching this shape: " +
      "{ category: 'billing'|'technical'|'account'|'other', " +
      "confidence: 'high'|'medium'|'low', summary: string }. " +
      "No prose, no markdown fences.",
    messages: [
      {
        role: "user",
        content: ticketText
      }
    ]
  });

  const raw = message.content[0];
  if (raw.type !== "text") throw new Error("Unexpected content type");

  return JSON.parse(raw.text) as ClassificationResult;
}

const result = await classifyTicket(
  "I was charged twice for my subscription this month."
);
console.log(result);
// { category: 'billing', confidence: 'high', summary: 'Duplicate charge reported' }

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

function getStockPrice(ticker: string): string {
  const prices: Record<string, number> = {
    AAPL: 213.4,
    MSFT: 415.2,
    TSLA: 177.9
  };
  const price = prices[ticker.toUpperCase()];
  return price
    ? `${ticker.toUpperCase()}: $${price}`
    : `${ticker}: not found`;
}

const tools: Anthropic.Tool[] = [
  {
    name: "get_stock_price",
    description: "Returns the current stock price for a given ticker symbol.",
    input_schema: {
      type: "object" as const,
      properties: {
        ticker: { type: "string", description: "Stock ticker, e.g. AAPL" }
      },
      required: ["ticker"]
    }
  }
];

async function runStockAgent(userQuery: string): Promise<string> {
  const messages: Anthropic.MessageParam[] = [
    { role: "user", content: userQuery }
  ];

  while (true) {
    const response = await client.messages.create({
      model: "claude-opus-4-5",
      max_tokens: 1024,
      tools,
      messages
    });

    messages.push({ role: "assistant", content: response.content });

    if (response.stop_reason === "end_turn") {
      const textBlock = response.content.find((b) => b.type === "text");
      return textBlock && textBlock.type === "text"
        ? textBlock.text
        : "No response";
    }

    if (response.stop_reason === "tool_use") {
      const toolResults: Anthropic.ToolResultBlockParam[] = response.content
        .filter((b): b is Anthropic.ToolUseBlock => b.type === "tool_use")
        .map((toolUse) => {
          const input = toolUse.input as { ticker: string };
          const result = getStockPrice(input.ticker);
          return {
            type: "tool_result" as const,
            tool_use_id: toolUse.id,
            content: result
          };
        });

      messages.push({ role: "user", content: toolResults });
      continue;
    }

    throw new Error(`Unexpected stop_reason: ${response.stop_reason}`);
  }
}

const answer = await runStockAgent(
  "Compare the current prices of Apple and Tesla and tell me which is higher."
);
console.log(answer);

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

async function singleCall(system: string, user: string): Promise<string> {
  const msg = await client.messages.create({
    model: "claude-opus-4-5",
    max_tokens: 512,
    system,
    messages: [{ role: "user", content: user }]
  });
  const block = msg.content[0];
  if (block.type !== "text") throw new Error("Expected text block");
  return block.text;
}

async function classifySentiment(review: string): Promise<string> {
  return singleCall(
    "Classify the sentiment of the review. Return ONLY one word: positive, negative, or neutral.",
    review
  );
}

async function draftResponse(
  review: string,
  sentiment: string
): Promise<string> {
  return singleCall(
    `You are a customer support agent. The review sentiment is ${sentiment}. Write a concise, empathetic reply in max 3 sentences.`,
    review
  );
}

async function reviewPipeline(
  review: string
): Promise<{ sentiment: string; reply: string }> {
  const sentiment = await classifySentiment(review);
  const reply = await draftResponse(review, sentiment);
  return { sentiment, reply };
}

const output = await reviewPipeline(
  "The onboarding was confusing and I could not find the export button anywhere."
);
console.log(output);
// { sentiment: 'negative', reply: '...' }