Build a Claude tool-use support agent with approval gates

{
  "name": "claude-support-tool-agent",
  "private": true,
  "type": "module",
  "scripts": {
    "check": "node --check src/agent-loop.mjs",
    "smoke": "node --env-file=.env test/smoke.mjs",
    "test:failures": "node test/failures.mjs",
    "eval": "node eval/run.mjs"
  },
  "dependencies": {
    "@anthropic-ai/sdk": "0.115.0",
    "zod": "4.4.3"
  }
}

import Anthropic from "@anthropic-ai/sdk";
import { z } from "zod";

const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
const lookupSchema = z.object({
  customerId: z.string().regex(/^cus_[a-z0-9]+$/),
  fields: z.array(z.enum(["plan", "status", "open_cases"])).max(3)
}).strict();

const tools = [{
  name: "lookup_customer",
  description: "Read the current authorized customer's support-safe fields.",
  strict: true,
  input_schema: {
    type: "object",
    properties: {
      customerId: { type: "string", pattern: "^cus_[a-z0-9]+$" },
      fields: {
        type: "array",
        items: { enum: ["plan", "status", "open_cases"] },
        maxItems: 3
      }
    },
    required: ["customerId", "fields"],
    additionalProperties: false
  }
}];

export async function runAgent({ actor, messages }) {
  for (let turn = 0; turn < 6; turn += 1) {
    const response = await anthropic.messages.create({
      model: process.env.CLAUDE_MODEL,
      max_tokens: 1200,
      system: "Use tools only for the authorized customer. Never claim a tool succeeded without its result.",
      tools,
      messages
    });
    messages.push({ role: "assistant", content: response.content });
    if (response.stop_reason !== "tool_use") return response;

    const calls = response.content.filter((block) => block.type === "tool_use");
    const results = await Promise.all(calls.map(async (call) => {
      try {
        const input = lookupSchema.parse(call.input);
        await authorizeCustomer(actor, input.customerId);
        const value = await executeReadOnlyLookup(input, { timeoutMs: 3000 });
        return { type: "tool_result", tool_use_id: call.id, content: JSON.stringify(value) };
      } catch (error) {
        return {
          type: "tool_result",
          tool_use_id: call.id,
          is_error: true,
          content: sanitizeToolError(error)
        };
      }
    }));
    messages.push({ role: "user", content: results });
  }
  throw new Error("tool_iteration_limit");
}

import { z } from "zod";
export const resultSchema = z.object({
  status: z.enum(["completed", "needs_review", "refused", "failed"]),
  summary: z.string().max(8000),
  evidence: z.array(z.object({
    locator: z.string().max(500),
    note: z.string().max(1000)
  })).max(100),
  warnings: z.array(z.string().max(500)).max(20)
}).strict();

import assert from "node:assert/strict";
import { runFixture } from "../src/test-harness.mjs";

const result = await runFixture("authorized-plan-lookup");
assert.equal(result.final.stopReason, "end_turn");
assert.equal(result.toolCalls.length, 1);
assert.equal(result.toolCalls[0].name, "lookup_customer");
assert.equal(result.toolCalls[0].authorized, true);
assert.match(result.final.text, /enterprise/i);
console.log("SMOKE_OK id=" + result.requestId + " evidence=4 artifact=claude-tool-agent");