name = "my-agent-do"
main = "src/index.ts"
compatibility_date = "2024-03-01"

# Define Durable Object bindings
[[durable_objects.bindings]]
name = "AGENT"
class_name = "Agent"
script_name = "my-agent-do"

# KV for persistent storage
[[kv_namespaces]]
binding = "DATA"
id = "<your-kv-namespace-id>"

import { DurableObject } from "cloudflare:workers";
import { CrossmintWallets, createCrossmint, type Wallet } from "@crossmint/wallets-sdk";

export interface Env {
  CROSSMINT_API_KEY: string;
  DATA: KVNamespace;
}

interface Message {
  role: "user" | "assistant";
  content: string;
  timestamp: number;
}

export class Agent extends DurableObject<Env> {
  private wallet!: Wallet<any>;
  private messages: Message[] = [];
  private userId: string;
  private websockets: Set<WebSocket> = new Set();
  
  constructor(state: DurableObjectState, env: Env) {
    super(state, env);
    
    // Extract user ID from DO name
    this.userId = state.id.toString();
    
    console.log(`📦 Agent DO created for user: ${this.userId}`);
  }
  
  /**
   * Initialize wallet on first request
   */
  private async ensureWallet(): Promise<void> {
    if (this.wallet) return;
    
    console.log(`🔧 Creating wallet for ${this.userId}...`);
    
    const crossmint = createCrossmint({
      apiKey: this.env.CROSSMINT_API_KEY
    });
    
    const crossmintWallets = CrossmintWallets.from(crossmint);
    
    this.wallet = await crossmintWallets.createWallet({
      chain: "base-sepolia",
      signer: { type: "api-key" },
      owner: `user-${this.userId}`
    });
    
    console.log(`✅ Wallet ready: ${this.wallet.address}`);
  }
  
  /**
   * Load conversation history from KV
   */
  private async loadHistory(): Promise<void> {
    const stored = await this.env.DATA.get(`${this.userId}:messages`, "json");
    if (stored) {
      this.messages = stored as Message[];
      console.log(`📚 Loaded ${this.messages.length} messages from KV`);
    }
  }
  
  /**
   * Save conversation history to KV
   */
  private async saveHistory(): Promise<void> {
    await this.env.DATA.put(
      `${this.userId}:messages`,
      JSON.stringify(this.messages)
    );
  }
  
  /**
   * Broadcast message to all connected WebSockets
   */
  private broadcast(message: string): void {
    for (const ws of this.websockets) {
      try {
        ws.send(message);
      } catch (error) {
        console.error("Failed to send to WebSocket:", error);
        this.websockets.delete(ws);
      }
    }
  }
  
  /**
   * Handle incoming HTTP requests
   */
  async fetch(request: Request): Promise<Response> {
    await this.ensureWallet();
    
    const url = new URL(request.url);
    
    // WebSocket upgrade
    if (request.headers.get("Upgrade") === "websocket") {
      return this.handleWebSocket(request);
    }
    
    // GET /info - Return agent info
    if (url.pathname === "/info" && request.method === "GET") {
      return Response.json({
        userId: this.userId,
        walletAddress: this.wallet.address,
        messageCount: this.messages.length
      });
    }
    
    // POST /message - Send message to agent
    if (url.pathname === "/message" && request.method === "POST") {
      const { content } = await request.json() as { content: string };
      
      // Add user message
      const userMessage: Message = {
        role: "user",
        content,
        timestamp: Date.now()
      };
      this.messages.push(userMessage);
      
      // Generate agent response (simplified)
      const response = await this.generateResponse(content);
      
      const agentMessage: Message = {
        role: "assistant",
        content: response,
        timestamp: Date.now()
      };
      this.messages.push(agentMessage);
      
      // Save to KV
      await this.saveHistory();
      
      // Broadcast to WebSocket clients
      this.broadcast(JSON.stringify(agentMessage));
      
      return Response.json({
        response,
        messageCount: this.messages.length
      });
    }
    
    // GET /history - Get conversation history
    if (url.pathname === "/history" && request.method === "GET") {
      await this.loadHistory();
      return Response.json({
        messages: this.messages
      });
    }
    
    return new Response("Not Found", { status: 404 });
  }
  
  /**
   * Handle WebSocket connections
   */
  private handleWebSocket(request: Request): Response {
    const pair = new WebSocketPair();
    const [client, server] = Object.values(pair);
    
    // Accept the connection
    server.accept();
    this.websockets.add(server);
    
    console.log(`🔌 WebSocket connected (total: ${this.websockets.size})`);
    
    // Send welcome message
    server.send(JSON.stringify({
      type: "welcome",
      userId: this.userId,
      walletAddress: this.wallet.address,
      messageCount: this.messages.length
    }));
    
    // Handle incoming messages
    server.addEventListener("message", async (event) => {
      try {
        const data = JSON.parse(event.data as string);
        
        if (data.type === "message") {
          // Process message
          const response = await this.generateResponse(data.content);
          
          // Send response
          server.send(JSON.stringify({
            type: "message",
            role: "assistant",
            content: response,
            timestamp: Date.now()
          }));
        }
      } catch (error) {
        console.error("WebSocket message error:", error);
      }
    });
    
    // Handle disconnection
    server.addEventListener("close", () => {
      this.websockets.delete(server);
      console.log(`🔌 WebSocket disconnected (total: ${this.websockets.size})`);
    });
    
    return new Response(null, {
      status: 101,
      webSocket: client
    });
  }
  
  /**
   * Generate agent response (integrate with Claude, GPT, etc.)
   */
  private async generateResponse(userMessage: string): Promise<string> {
    // This is where you'd call Claude, GPT, or your LLM
    // For now, simple echo with context
    
    const context = this.messages.length > 0
      ? `I remember our conversation (${this.messages.length} messages).`
      : "This is our first message.";
    
    return `${context} You said: "${userMessage}". My wallet is ${this.wallet.address.slice(0, 10)}...`;
  }
}

import { Agent, type Env } from "./agent";

export { Agent };

export default {
  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
    const url = new URL(request.url);
    
    // Extract user ID from path: /agent/{userId}
    const pathMatch = url.pathname.match(/^\/agent\/([^\/]+)/);
    
    if (!pathMatch) {
      return new Response("Usage: /agent/{userId}", { status: 400 });
    }
    
    const userId = pathMatch[1];
    
    // Get Durable Object for this user
    const doId = env.AGENT.idFromName(userId);
    const agentDO = env.AGENT.get(doId);
    
    // Remove /agent/{userId} prefix from path
    const newUrl = new URL(request.url);
    newUrl.pathname = url.pathname.replace(`/agent/${userId}`, "") || "/";
    
    const newRequest = new Request(newUrl, request);
    
    // Forward to Durable Object
    return agentDO.fetch(newRequest);
  }
} satisfies ExportedHandler<Env>;

import { withX402 } from "agents/x402";
import { createX402Signer } from "./x402Adapter";

export class Agent extends DurableObject<Env> {
  private mcpServer!: McpServer;
  
  async ensureWallet(): Promise<void> {
    if (this.wallet) return;
    
    // ... create wallet ...
    
    // Create MCP server with x402 support
    this.mcpServer = new McpServer({
      name: `Agent-${this.userId}`,
      version: "1.0.0"
    });
    
    // Add x402 payment middleware
    this.mcpServer.withX402({
      wallet: createX402Signer(this.wallet),
      facilitator: "https://x402.org/facilitator",
      network: "base-sepolia",
      usdcAddress: "0x036CbD53842c5426634e7929541eC2318f3dCF7e"
    });
    
    // Register paid tools
    this.mcpServer.paidTool(
      "premium_analysis",
      "Advanced analysis with AI",
      0.10, // $0.10 per call
      { query: z.string() },
      {},
      async ({ query }) => {
        // Only called after payment verified!
        return await this.runPremiumAnalysis(query);
      }
    );
  }
  
  async fetch(request: Request): Promise<Response> {
    await this.ensureWallet();
    
    // Handle MCP requests
    if (url.pathname === "/mcp") {
      return this.mcpServer.handleRequest(request);
    }
    
    // ... rest of handlers ...
  }
}