Skip to content

secondsky/claude-skills / plugins/cloudflare-agents/skills/cloudflare-agents

cloudflare-agents

Verified

Build AI agents on Cloudflare Workers with MCP integration, tool use, and LLM providers.

templates/calling-agents-worker.ts

View on GitHub
// Worker that calls Agents using routeAgentRequest and getAgentByName

import { Agent, AgentNamespace, routeAgentRequest, getAgentByName } from 'agents';

interface Env {
  MyAgent: AgentNamespace<MyAgent>;
  ChatAgent: AgentNamespace<ChatAgent>;
}

// Worker fetch handler
export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const url = new URL(request.url);

    // Pattern 1: Automatic routing with routeAgentRequest
    // Routes to: /agents/:agent-name/:instance-name
    // Example: /agents/my-agent/user-123
    if (url.pathname.startsWith('/agents/')) {
      const response = await routeAgentRequest(request, env);

      if (response) {
        return response;
      }

      return new Response("Agent not found", { status: 404 });
    }

    // Pattern 2: Custom routing with getAgentByName
    // Example: /user/:userId/profile
    if (url.pathname.startsWith('/user/')) {
      const userId = url.pathname.split('/')[2];

      // Authenticate first (CRITICAL)
      const authHeader = request.headers.get('Authorization');
      if (!authHeader) {
        return new Response("Unauthorized", { status: 401 });
      }

      // Verify token and get authenticated userId
      const authenticatedUserId = await verifyToken(authHeader);
      if (!authenticatedUserId || authenticatedUserId !== userId) {
        return new Response("Forbidden", { status: 403 });
      }

      // Get or create agent for this user
      const agent = getAgentByName<Env, MyAgent>(env.MyAgent, `user-${userId}`);

      // Pass request to agent
      return (await agent).fetch(request);
    }

    // Pattern 3: Call agent methods directly (RPC)
    if (url.pathname === '/api/process') {
      const { userId, data } = await request.json();

      const agent = getAgentByName<Env, MyAgent>(env.MyAgent, `user-${userId}`);

      // Call custom method on agent
      const result = await (await agent).processData(data);

      return Response.json({ result });
    }

    // Pattern 4: Multi-agent communication
    if (url.pathname === '/api/chat-with-context') {
      const { userId, message } = await request.json();

      // Get user agent
      const userAgent = getAgentByName<Env, MyAgent>(env.MyAgent, `user-${userId}`);

      // Get chat agent
      const chatAgent = getAgentByName<Env, ChatAgent>(env.ChatAgent, `chat-${userId}`);

      // User agent prepares context
      const context = await (await userAgent).getContext();

      // Chat agent generates response
      const response = await (await chatAgent).chat(message, context);

      return Response.json({ response });
    }

    return new Response("Not Found", { status: 404 });
  }
} satisfies ExportedHandler<Env>;

// Helper: Verify JWT token
async function verifyToken(token: string): Promise<string | null> {
  try {
    // Implement your token verification logic
    // Example: JWT verification, session validation, etc.
    return "user-123";  // Return userId if valid
  } catch (e) {
    return null;
  }
}

// Agent definitions

export class MyAgent extends Agent<Env> {
  async onRequest(request: Request): Promise<Response> {
    return Response.json({
      agent: this.name,
      message: "Hello from MyAgent"
    });
  }

  async processData(data: any): Promise<any> {
    return { processed: true, data };
  }

  async getContext(): Promise<any> {
    return { user: this.name, preferences: this.state };
  }
}

export class ChatAgent extends Agent<Env> {
  async onRequest(request: Request): Promise<Response> {
    return Response.json({ agent: this.name });
  }

  async chat(message: string, context: any): Promise<string> {
    return `Response to: ${message} (with context: ${JSON.stringify(context)})`;
  }
}
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 322kUpdated Claude CodeCodexVerifiedInstall