HarnessAgent في AI SDK 7: شغّل Claude Code وCodex داخل بيئات معزولة بـ TypeScript

mkdir pr-review-agent && cd pr-review-agent
pnpm init
pnpm add ai@latest zod
pnpm add @ai-sdk/anthropic @ai-sdk/openai
pnpm add @ai-sdk/sandbox @ai-sdk/workflow @ai-sdk/tui
pnpm add -D typescript tsx @types/node

{
  "compilerOptions": {
    "target": "ES2023",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "outDir": "dist"
  },
  "include": ["src"]
}

# .env
ANTHROPIC_API_KEY=sk-ant-...
OPENAI_API_KEY=sk-...
GITHUB_TOKEN=ghp_...
VERCEL_OIDC_TOKEN=...   # مطلوب فقط للبيئات المستضافة

import 'dotenv/config';
import { HarnessAgent } from 'ai';
import { claudeCode } from 'ai/harnesses';
 
const agent = new HarnessAgent({
  harness: claudeCode,
  instructions:
    'You are a careful code reviewer. Be concise and specific. ' +
    'Prefer concrete line references over general advice.',
});
 
const result = await agent.generate({
  prompt: 'Explain what a race condition is in a Node.js HTTP handler, in three sentences.',
});
 
console.log(result.text);

pnpm tsx src/hello-agent.ts

import { codex } from 'ai/harnesses';
 
const agent = new HarnessAgent({
  harness: codex,  // [!code highlight]
  instructions: 'You are a careful code reviewer...',
});

import 'dotenv/config';
import { HarnessAgent } from 'ai';
import { claudeCode } from 'ai/harnesses';
import { createVercelSandbox } from '@ai-sdk/sandbox';
 
const agent = new HarnessAgent({
  harness: claudeCode,
  sandbox: createVercelSandbox({
    runtime: 'node24',
    ports: [4000],
    timeoutMs: 10 * 60 * 1000,
  }),
  instructions:
    'You have a sandbox with Node 24. Use shell commands to inspect and test code. ' +
    'Always run the test suite before concluding that a change is safe.',
});
 
const result = await agent.generate({
  prompt:
    'Create a small Node script that computes the 40th Fibonacci number ' +
    'both recursively and iteratively, then benchmark both and report the difference.',
});
 
console.log(result.text);

import { createLocalSandbox } from '@ai-sdk/sandbox';
 
const sandbox = createLocalSandbox({
  cwd: './workspace',
  allowedCommands: ['node', 'npm', 'pnpm', 'git', 'ls', 'cat', 'grep'],
});

export const reviewPullRequestSkill = {
  name: 'review-github-pr',
  description:
    'Reviews a GitHub pull request against the team engineering standards. ' +
    'Use whenever the user asks for a PR review, code review, or diff assessment.',
  content: `
# Pull Request Review
 
## Procedure
 
1. Read the PR title, body, and linked issues to establish intent.
2. Read the full diff before commenting on any single file.
3. Check the diff against the review checklist below.
4. Verify claims by running code in the sandbox — never assert that a test
   passes without running it.
5. Produce the output in the required format.
 
## Review checklist
 
- **Correctness:** off-by-one errors, unhandled null and undefined,
  incorrect async ordering, missing await.
- **Error handling:** every catch block either handles or rethrows.
  Empty catch blocks are always a finding.
- **Security:** unvalidated input reaching a query, a shell command,
  or a filesystem path. Secrets in source.
- **Tests:** does each behavioural change have a corresponding test?
- **Scope:** does the diff do anything the PR description does not mention?
 
## Output format
 
For each finding emit exactly:
 
**[severity] file:line** — one-sentence description of the defect.
Then a concrete failure scenario: specific inputs leading to specific wrong output.
 
Severity is one of: blocker, major, minor, nit.
 
If you find nothing, say so plainly. Do not invent findings to appear thorough.
`,
};

const agent = new HarnessAgent({
  harness: claudeCode,
  sandbox: createVercelSandbox({ runtime: 'node24' }),
  skills: [reviewPullRequestSkill],  // [!code highlight]
  instructions: 'You are a senior engineer reviewing code for a TypeScript team.',
});

import { uploadSkill } from 'ai';
import { anthropic } from '@ai-sdk/anthropic';
import { readFileSync } from 'node:fs';
 
const { providerReference } = await uploadSkill({
  api: anthropic.skills(),
  files: [
    { path: 'review-pr/SKILL.md', content: readFileSync('./skills/review-pr/SKILL.md') },
  ],
  displayTitle: 'PR Review Standards',
});

import { tool } from 'ai';
import { z } from 'zod';
 
const GITHUB_API = 'https://api.github.com';
 
async function gh(path: string, token: string, init?: RequestInit) {
  const response = await fetch(`${GITHUB_API}${path}`, {
    ...init,
    headers: {
      Authorization: `Bearer ${token}`,
      Accept: 'application/vnd.github+json',
      'X-GitHub-Api-Version': '2022-11-28',
      ...init?.headers,
    },
  });
 
  if (!response.ok) {
    throw new Error(`GitHub ${response.status}: ${await response.text()}`);
  }
  return response;
}
 
export const readPullRequest = tool({
  description: 'Fetch a pull request title, body, author, and unified diff.',
  inputSchema: z.object({
    owner: z.string().describe('Repository owner, e.g. "vercel"'),
    repo: z.string().describe('Repository name, e.g. "ai"'),
    number: z.number().int().positive().describe('Pull request number'),
  }),
  contextSchema: z.object({ token: z.string() }),
  execute: async ({ owner, repo, number }, { context: { token } }) => {
    const meta = await gh(`/repos/${owner}/${repo}/pulls/${number}`, token).then((r) => r.json());
 
    const diff = await gh(`/repos/${owner}/${repo}/pulls/${number}`, token, {
      headers: { Accept: 'application/vnd.github.v3.diff' },
    }).then((r) => r.text());
 
    return {
      title: meta.title,
      body: meta.body ?? '',
      author: meta.user?.login,
      changedFiles: meta.changed_files,
      additions: meta.additions,
      deletions: meta.deletions,
      diff: diff.slice(0, 120_000),
    };
  },
});
 
export const postReviewComment = tool({
  description:
    'Post a review comment on a pull request. This is publicly visible and cannot be undone.',
  inputSchema: z.object({
    owner: z.string(),
    repo: z.string(),
    number: z.number().int().positive(),
    body: z.string().min(1).describe('Markdown body of the review comment'),
  }),
  contextSchema: z.object({ token: z.string() }),
  execute: async ({ owner, repo, number, body }, { context: { token } }) => {
    const result = await gh(`/repos/${owner}/${repo}/issues/${number}/comments`, token, {
      method: 'POST',
      body: JSON.stringify({ body }),
    }).then((r) => r.json());
 
    return { url: result.html_url, id: result.id };
  },
});

import { HarnessAgent } from 'ai';
import { claudeCode } from 'ai/harnesses';
import { createVercelSandbox } from '@ai-sdk/sandbox';
import { readPullRequest, postReviewComment } from './tools/github.js';
import { reviewPullRequestSkill } from './skills/review-pr.js';
 
export const reviewAgent = new HarnessAgent({
  harness: claudeCode,
  sandbox: createVercelSandbox({ runtime: 'node24', timeoutMs: 15 * 60 * 1000 }),
  skills: [reviewPullRequestSkill],
  tools: { readPullRequest, postReviewComment },
  toolApproval: {
    postReviewComment: 'user-approval',  // [!code highlight]
  },
  toolContext: { token: process.env.GITHUB_TOKEN! },
  instructions:
    'You are a senior engineer reviewing code for a TypeScript team. ' +
    'Review thoroughly before posting anything. Post at most one comment per run.',
});

const stream = await reviewAgent.stream({
  prompt: 'Review pull request 412 in vercel/ai and post your findings.',
});
 
for await (const part of stream.fullStream) {
  if (part.type === 'tool-approval-request') {
    console.log(`\nAgent wants to call: ${part.toolName}`);
    console.log(JSON.stringify(part.input, null, 2));
 
    const approved = await askUser('Approve? (y/n) ');
    await stream.respondToApproval({ id: part.id, approved });
  }
 
  if (part.type === 'text-delta') process.stdout.write(part.text);
}

toolApproval: {
  postReviewComment: async ({ input }) =>
    input.body.length > 2000 ? 'user-approval' : 'auto-approve',
}

const result = await reviewAgent.generate({
  prompt: 'Review pull request 412 in vercel/ai.',
  timeout: {
    totalMs: 15 * 60 * 1000,   // التشغيل بالكامل
    stepMs: 90_000,            // أي خطوة مفردة
    chunkMs: 20_000,           // الفجوة بين أجزاء البث
    toolMs: 30_000,            // الافتراضي لكل استدعاء أداة
    tools: {
      readPullRequestMs: 45_000,  // الفروقات الكبيرة تحتاج وقتاً أطول
    },
  },
});

import { registerTelemetry } from 'ai';
import { OpenTelemetry } from '@ai-sdk/opentelemetry';
 
registerTelemetry(new OpenTelemetry());

const { performance } = await result.finalStep;
 
console.log({
  responseTimeMs: performance.responseTimeMs,
  outputTokensPerSecond: performance.outputTokensPerSecond,
  timeToFirstOutputMs: performance.timeToFirstOutputMs,
  totalTokens: result.usage.totalTokens,
});

import { WorkflowAgent } from '@ai-sdk/workflow';
import { claudeCode } from 'ai/harnesses';
import { createVercelSandbox } from '@ai-sdk/sandbox';
import { readPullRequest, postReviewComment } from './tools/github.js';
import { reviewPullRequestSkill } from './skills/review-pr.js';
 
export const durableReviewAgent = new WorkflowAgent({
  harness: claudeCode,
  sandbox: createVercelSandbox({ runtime: 'node24' }),
  skills: [reviewPullRequestSkill],
  tools: { readPullRequest, postReviewComment },
  toolApproval: { postReviewComment: 'user-approval' },
  toolContext: { token: process.env.GITHUB_TOKEN! },
  workflowId: (input) => `pr-review-${input.owner}-${input.repo}-${input.number}`,
});

// app/api/github-webhook/route.ts
import { durableReviewAgent } from '@/lib/review-agent';
 
export async function POST(req: Request) {
  const event = await req.json();
 
  if (event.action !== 'opened' && event.action !== 'synchronize') {
    return new Response('ignored', { status: 200 });
  }
 
  await durableReviewAgent.trigger({
    owner: event.repository.owner.login,
    repo: event.repository.name,
    number: event.pull_request.number,
    prompt: `Review pull request ${event.pull_request.number}.`,
  });
 
  return new Response('queued', { status: 202 });
}

// src/cli.ts
import 'dotenv/config';
import { runAgentTUI } from '@ai-sdk/tui';
import { reviewAgent } from './review-agent.js';
 
await runAgentTUI({
  agent: reviewAgent,
  title: 'PR Review Agent',
  onApprovalRequest: async ({ toolName, input }) => ({
    approved: await confirmInTerminal(`Call ${toolName}?`, input),
  }),
});

pnpm tsx src/cli.ts

curl -s -H "Authorization: Bearer $GITHUB_TOKEN" \
  "https://api.github.com/repos/OWNER/REPO/issues/412/comments" | jq 'length'

npx @ai-sdk/codemod v7