بناء تطبيقات الذكاء الاصطناعي الوكيلة مع Claude Sonnet 5 وTypeScript

mkdir sonnet5-agent && cd sonnet5-agent
npm init -y
npm install @anthropic-ai/sdk
npm install -D typescript tsx @types/node
npx tsc --init --target ES2022 --module NodeNext --moduleResolution NodeNext --strict

echo "ANTHROPIC_API_KEY=sk-ant-..." > .env

{
  "scripts": {
    "dev": "tsx --env-file=.env src/index.ts",
    "test": "node --test --import tsx/esm --env-file=.env src/agent.test.ts"
  }
}

import Anthropic from "@anthropic-ai/sdk";
 
export const MODEL = "claude-sonnet-5";
 
export const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});
 
export async function chat(prompt: string): Promise<string> {
  const message = await client.messages.create({
    model: MODEL,
    max_tokens: 1024,
    messages: [{ role: "user", content: prompt }],
  });
 
  const block = message.content[0];
  if (block.type !== "text") throw new Error("Unexpected content type");
  return block.text;
}

import { chat } from "./client.js";
 
const answer = await chat("What is 2 + 2? Reply with just the number.");
console.log(answer); // 4

npm run dev

import { client, MODEL } from "./client.js";
 
export async function streamChat(
  prompt: string,
  onText?: (chunk: string) => void
): Promise<string> {
  let full = "";
 
  const stream = client.messages.stream({
    model: MODEL,
    max_tokens: 4096,
    messages: [{ role: "user", content: prompt }],
  });
 
  stream.on("text", (text) => {
    full += text;
    if (onText) onText(text);
    else process.stdout.write(text);
  });
 
  await stream.finalMessage();
  process.stdout.write("\n");
  return full;
}

import Anthropic from "@anthropic-ai/sdk";
import * as fs from "node:fs";
import * as path from "node:path";
 
export const TOOLS: Anthropic.Tool[] = [
  {
    name: "read_file",
    description: "Read the text content of a local file.",
    input_schema: {
      type: "object",
      properties: {
        file_path: {
          type: "string",
          description: "Relative path to the file from the project root.",
        },
      },
      required: ["file_path"],
    },
  },
  {
    name: "write_file",
    description: "Write or overwrite a local file with the given text content.",
    input_schema: {
      type: "object",
      properties: {
        file_path: {
          type: "string",
          description: "Relative path for the output file.",
        },
        content: {
          type: "string",
          description: "Full text content to write.",
        },
      },
      required: ["file_path", "content"],
    },
  },
  {
    name: "list_directory",
    description: "List the files and subdirectories inside a directory.",
    input_schema: {
      type: "object",
      properties: {
        dir_path: {
          type: "string",
          description: "Relative path of the directory to list.",
        },
      },
      required: ["dir_path"],
    },
  },
];
 
type ToolInput = Record<string, string>;
 
export function executeTool(name: string, input: ToolInput): string {
  switch (name) {
    case "read_file": {
      const absPath = path.resolve(input.file_path);
      if (!fs.existsSync(absPath)) return `File not found: ${input.file_path}`;
      return fs.readFileSync(absPath, "utf-8");
    }
    case "write_file": {
      const absPath = path.resolve(input.file_path);
      fs.mkdirSync(path.dirname(absPath), { recursive: true });
      fs.writeFileSync(absPath, input.content, "utf-8");
      return `Wrote ${input.content.length} characters to ${input.file_path}`;
    }
    case "list_directory": {
      const absPath = path.resolve(input.dir_path);
      if (!fs.existsSync(absPath))
        return `Directory not found: ${input.dir_path}`;
      return fs.readdirSync(absPath).join("\n");
    }
    default:
      return `Unknown tool: ${name}`;
  }
}

import Anthropic from "@anthropic-ai/sdk";
import { client, MODEL } from "./client.js";
import { TOOLS, executeTool } from "./tools.js";
 
export interface AgentResult {
  output: string;
  inputTokens: number;
  outputTokens: number;
  iterations: number;
}
 
export async function runAgent(
  task: string,
  maxIterations = 15
): Promise<AgentResult> {
  const messages: Anthropic.MessageParam[] = [
    { role: "user", content: task },
  ];
 
  let totalInput = 0;
  let totalOutput = 0;
  let iteration = 0;
 
  while (iteration < maxIterations) {
    iteration++;
 
    const response = await client.messages.create({
      model: MODEL,
      max_tokens: 4096,
      tools: TOOLS,
      messages,
    });
 
    totalInput += response.usage.input_tokens;
    totalOutput += response.usage.output_tokens;
 
    // أضف دور المساعد دائماً إلى السجل
    messages.push({ role: "assistant", content: response.content });
 
    if (response.stop_reason === "end_turn") {
      const finalText = response.content
        .filter((b): b is Anthropic.TextBlock => b.type === "text")
        .map((b) => b.text)
        .join("\n");
 
      return {
        output: finalText,
        inputTokens: totalInput,
        outputTokens: totalOutput,
        iterations: iteration,
      };
    }
 
    if (response.stop_reason === "tool_use") {
      const toolResults: Anthropic.ToolResultBlockParam[] = response.content
        .filter((b): b is Anthropic.ToolUseBlock => b.type === "tool_use")
        .map((b) => ({
          type: "tool_result" as const,
          tool_use_id: b.id,
          content: executeTool(b.name, b.input as Record<string, string>),
        }));
 
      messages.push({ role: "user", content: toolResults });
      continue;
    }
 
    break;
  }
 
  return {
    output: "Agent reached the iteration limit without completing the task.",
    inputTokens: totalInput,
    outputTokens: totalOutput,
    iterations: iteration,
  };
}

// التسعير التمهيدي ساري حتى 2026-08-31
const INTRO_INPUT_PER_TOKEN = 2 / 1_000_000;
const INTRO_OUTPUT_PER_TOKEN = 10 / 1_000_000;
 
export function calculateCost(inputTokens: number, outputTokens: number): number {
  return (
    inputTokens * INTRO_INPUT_PER_TOKEN +
    outputTokens * INTRO_OUTPUT_PER_TOKEN
  );
}

import { runAgent, calculateCost } from "./agent.js";
 
const result = await runAgent(
  "List the files in the src directory, read client.ts, and summarize " +
    "what it does in two sentences."
);
 
console.log("\n=== Agent Output ===");
console.log(result.output);
console.log("\n=== Usage ===");
console.log(`Iterations  : ${result.iterations}`);
console.log(`Input tokens: ${result.inputTokens.toLocaleString()}`);
console.log(`Output tokens: ${result.outputTokens.toLocaleString()}`);
console.log(
  `Estimated cost: $${calculateCost(result.inputTokens, result.outputTokens).toFixed(6)}`
);

npm run dev

// src/agent.test.ts
import { test } from "node:test";
import assert from "node:assert";
import { chat } from "./client.js";
import { executeTool } from "./tools.js";
 
test("chat returns a string response", async () => {
  const response = await chat("Say the exact string 'test-ok' and nothing else.");
  assert.ok(
    response.includes("test-ok"),
    `Expected 'test-ok' in response, got: ${response}`
  );
});
 
test("executeTool list_directory returns file names", () => {
  const result = executeTool("list_directory", { dir_path: "src" });
  assert.ok(result.includes("client.ts"), `Unexpected listing: ${result}`);
});
 
test("executeTool returns error for missing path", () => {
  const result = executeTool("read_file", { file_path: "nonexistent.ts" });
  assert.ok(result.startsWith("File not found"), `Unexpected: ${result}`);
});

npm test