MCPClientManager

class MyAgent extends Agent {
  async onStart() {
    // Register an MCP server
    const serverId = await this.mcp.registerServer("weather-server", {
      url: "https://weather-mcp.example.com",
      name: "Weather Server"
    });

    // Connect to the server
    await this.mcp.connectToServer(serverId);

    // Discover capabilities
    await this.mcp.discoverIfConnected(serverId);
  }

  @callable()
  async getWeather(location: string) {
    const result = await this.mcp.callTool({
      serverId: "weather-server",
      name: "get_weather",
      arguments: { location }
    });
    return result;
  }
}

const serverId = await this.mcp.registerServer("my-server", {
  url: "https://mcp-server.example.com",
  name: "My MCP Server",
  transport: {
    headers: {
      "Authorization": "Bearer token"
    },
    type: "streamable-http"
  },
  retry: {
    maxAttempts: 5,
    baseDelayMs: 200
  }
});

const result = await this.mcp.connectToServer("my-server");

if (result.state === "authenticating") {
  console.log("OAuth required:", result.authUrl);
} else if (result.state === "connected") {
  console.log("Connected!");
} else if (result.state === "failed") {
  console.error("Connection failed:", result.error);
}

const result = await this.mcp.discoverIfConnected("my-server");

if (result.success) {
  console.log("Discovery complete!");
  const tools = this.mcp.listTools();
  console.log("Available tools:", tools);
} else {
  console.error("Discovery failed:", result.error);
}

await this.mcp.removeServer("my-server");

const tools = this.mcp.listTools();
tools.forEach(tool => {
  console.log(`[${tool.serverId}] ${tool.name}: ${tool.description}`);
});

const prompts = this.mcp.listPrompts();
for (const prompt of prompts) {
  console.log(`${prompt.name}: ${prompt.description}`);
}

const resources = this.mcp.listResources();
for (const resource of resources) {
  console.log(`${resource.uri}: ${resource.name}`);
}

const templates = this.mcp.listResourceTemplates();

const servers = this.mcp.listServers();
for (const server of servers) {
  console.log(`${server.name}: ${server.server_url}`);
}

const result = await this.mcp.callTool({
  serverId: "weather-server",
  name: "get_weather",
  arguments: { location: "San Francisco" }
});

console.log("Result:", result);

const prompt = await this.mcp.getPrompt({
  serverId: "my-server",
  name: "summarize",
  arguments: { text: "Long text to summarize..." }
});

const resource = await this.mcp.readResource({
  serverId: "my-server",
  uri: "file:///data.json"
});

import { generateText } from "ai";

const tools = this.mcp.getAITools();

const result = await generateText({
  model: this.env.AI.run("@cf/meta/llama-3.3-70b-instruct-fp8-fast"),
  messages: [
    { role: "user", content: "What's the weather in SF?" }
  ],
  tools
});

// Wait for all connections to complete
await this.mcp.waitForConnections({ timeout: 10000 });

// Now safe to use getAITools()
const tools = this.mcp.getAITools();

await this.mcp.closeConnection("my-server");

await this.mcp.closeAllConnections();

this.mcp.configureOAuthCallback({
  successRedirect: "/dashboard",
  errorRedirect: "/error"
});

async onRequest(request: Request) {
  if (this.mcp.isCallbackRequest(request)) {
    const result = await this.mcp.handleCallbackRequest(request);
    if (result.authSuccess) {
      // OAuth complete, establish connection
      await this.mcp.establishConnection(result.serverId);
      return new Response("Connected!");
    }
    return new Response(result.authError, { status: 400 });
  }
}

const result = await this.mcp.handleCallbackRequest(request);

if (result.authSuccess) {
  await this.mcp.establishConnection(result.serverId);
  return new Response("Success!");
} else {
  return new Response(result.authError, { status: 400 });
}

await this.mcp.establishConnection("my-server");

// In your Agent
await this.mcp.addRpcMcpServer(
  "internal-server",
  this.env.INTERNAL_MCP_SERVER,
  { props: { config: "value" } }
);

const tools = this.mcp.listTools();

import { Agent, callable } from "agents";
import { generateText } from "ai";

class WeatherAgent extends Agent {
  async onStart() {
    // Register weather MCP server
    await this.mcp.registerServer("weather", {
      url: "https://weather-mcp.example.com",
      name: "Weather Server"
    });

    // Connect and discover
    const connected = await this.mcp.connectToServer("weather");
    if (connected.state === "connected") {
      await this.mcp.discoverIfConnected("weather");
    }

    // Wait for all connections
    await this.mcp.waitForConnections({ timeout: 5000 });

    // List available tools
    const tools = this.mcp.listTools();
    console.log("Available tools:", tools.map(t => t.name));
  }

  @callable()
  async chat(message: string) {
    const tools = this.mcp.getAITools();

    const result = await generateText({
      model: this.env.AI.run("@cf/meta/llama-3.3-70b-instruct-fp8-fast"),
      messages: [
        { role: "user", content: message }
      ],
      tools,
      maxSteps: 5
    });

    return result.text;
  }
}

const unsubscribe = this.mcp.onServerStateChanged(() => {
  console.log("MCP server state changed!");
  this.broadcastMcpServers();
});

// Clean up
unsubscribe();

const unsubscribe = this.mcp.onObservabilityEvent((event) => {
  console.log("MCP event:", event.type, event.payload);
});