Anthropic TypeScript SDK

For fine-grained control, you can bypass the high-level worker() and drive the components separately. This is useful if you need to observe tool calls or manage the work lifecycle manually.

1. client.beta.environments.work.poller(...): A control-plane component that claims work items from an environment and yields them.
2. setupSkills(ctx): Fetches the session's agent and downloads skills into {workdir}/skills/<name>/. It returns a cleanupSkills function that must be called when work is finished.
3. client.beta.sessions.events.toolRunner(...): A SessionToolRunner that runs matching tools from your registry for each agent.tool_use event and yields DispatchedToolCall objects.

Note: The environmentKey should be used to scope a client via client.withOptions({ authToken: environmentKey }) to authenticate per-session calls.

import {
  betaAgentToolset20260401,
  setupSkills,
  type AgentToolContext,
} from '@anthropic-ai/sdk/tools/agent-toolset/node';

const environmentKey = process.env.ANTHROPIC_ENVIRONMENT_KEY!;
const sessionClient = client.withOptions({ authToken: environmentKey });

for await (const work of client.beta.environments.work.poller({
  environmentId: process.env.ANTHROPIC_ENVIRONMENT_ID!,
  environmentKey,
})) {
  if (work.data.type !== 'session') continue;

  const ctx: AgentToolContext = { workdir: '/workspace', client, sessionId: work.data.id };
  const cleanupSkills = await setupSkills(ctx);
  
  try {
    for await (const call of sessionClient.beta.sessions.events.toolRunner(work.data.id, {
      tools: betaAgentToolset20260401(ctx),
    })) {
      console.log(`${call.name} -> ${call.isError ? 'error' : 'ok'}`);
    }
  } finally {
    await cleanupSkills();
  }
}

The SDK supports three main ways to handle authentication with Google Cloud:

1. Default Authentication

Provide the region and projectId in the constructor. The client will use the default Google Cloud authentication flow (e.g., Application Default Credentials).

2. Custom GoogleAuth Configuration

Pass a googleAuth instance from the google-auth-library to specify custom scopes or a specific keyFile (service account JSON).

3. Pre-configured AuthClient

For advanced scenarios like service account impersonation, you can pass a pre-configured authClient directly to the constructor.

import { AnthropicVertex } from '@anthropic-ai/vertex-sdk';
import { GoogleAuth } from 'google-auth-library';

// --- Default Authentication ---
const clientDefault = new AnthropicVertex({
  region: 'us-central1',
  projectId: 'my-project-id',
});

// --- Custom GoogleAuth configuration ---
const clientCustomAuth = new AnthropicVertex({
  googleAuth: new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/cloud-platform',
    keyFile: '/path/to/service-account.json',
  }),
  region: 'us-central1',
  projectId: 'my-project-id',
});

// --- Pre-configured AuthClient (e.g., Impersonation) ---
import { Impersonated } from 'google-auth-library';

const authClient = new Impersonated({
  sourceClient: await new GoogleAuth().getClient(),
  targetPrincipal: 'impersonated-account@projectID.iam.gserviceaccount.com',
  lifetime: 30,
  delegates: [],
  targetScopes: ['https://www.googleapis.com/auth/cloud-platform'],
});

const clientImpersonated = new AnthropicVertex({
  authClient,
  region: 'us-central1',
  projectId: 'my-project-id',
});

The anthropic.beta.messages.toolRunner() method automates the loop of sending messages to the model, receiving tool calls, executing the tools, and sending the results back. It returns a BetaToolRunner which can be iterated over or awaited to get the final result.

import { betaZodTool } from '@anthropic-ai/sdk/helpers/beta/zod';
import { z } from 'zod';

const weatherTool = betaZodTool({
  name: 'get_weather',
  inputSchema: z.object({
    location: z.string(),
  }),
  description: 'Get the current weather in a given location',
  run: (input) => {
    return `The weather in ${input.location} is foggy and 60°F`;
  },
});

const finalMessage = await anthropic.beta.messages.toolRunner({
  model: 'claude-sonnet-5',
  max_tokens: 1000,
  messages: [{ role: 'user', content: 'What is the weather in San Francisco?' }],
  tools: [weatherTool],
});

console.log(finalMessage.content);

The SDK provides building blocks to serve managed-agents sessions in a self-hosted environment. The client.beta.environments.work.worker() method returns an EnvironmentWorker that automates the full lifecycle: polling for work, setting up a work directory, downloading agent skills, running tools against agent.tool_use events, heartbeating the work-item lease, and cleaning up on exit.

Requirements:

• To use the betaAgentToolset20260401 (which includes glob), you must use Node 22+. The rest of the SDK supports Node 18+.
• The environmentKey authenticates both the work-poll calls and all per-session calls (event stream, heartbeat, force-stop).

Usage Patterns:

• Full Worker: Use .run() to start a loop that polls, runs, and cleans up automatically.
• Single Item: Use .handleItem() if you have already claimed a work item (e.g., via a CLI command) and want to run just the per-item flow.

import Anthropic from '@anthropic-ai/sdk';
import { betaAgentToolset20260401 } from '@anthropic-ai/sdk/tools/agent-toolset/node';

const client = new Anthropic();

// One-stop worker: poll → run the toolset for each session → force-stop → loop.
await client.beta.environments.work
  .worker({
    environmentId: process.env.ANTHROPIC_ENVIRONMENT_ID!,
    environmentKey: process.env.ANTHROPIC_ENVIRONMENT_KEY!,
    workdir: '/workspace',
    tools: (ctx) => [...betaAgentToolset20260401(ctx), myCustomTool],
  })
  .run(AbortSignal.timeout(60 * 60_000));