Agent

import { Agent } from "agents";

class MyAgent extends Agent<Env, State> {
  initialState = { count: 0 };

  @callable()
  async increment() {
    this.setState({ count: this.state.count + 1 });
    return this.state.count;
  }
}

this.setState({ count: this.state.count + 1 });

const users = this.sql<{ id: number; name: string }>`
  SELECT * FROM users WHERE id = ${userId}
`;

// One-time scheduled task
await this.schedule("sendReminder", {
  time: new Date(Date.now() + 3600000),
  payload: { userId: "123" }
});

// Recurring cron task
await this.schedule("dailyBackup", {
  cron: "0 0 * * *",
  payload: { type: "full" }
});

// Interval task
await this.schedule("healthCheck", {
  intervalSeconds: 300
});

await this.queue("processUpload", {
  fileId: "abc123",
  userId: "user-456"
});

const result = await this.retry(
  async (attempt) => {
    return await fetchExternalAPI();
  },
  {
    maxAttempts: 5,
    shouldRetry: (err) => err instanceof NetworkError
  }
);

await this.replyToEmail(email, {
  fromName: "Support Team",
  body: "Thank you for your message!",
  secret: this.env.EMAIL_SECRET
});

const instanceId = await this.runWorkflow("ProcessingWorkflow", {
  taskId: "task-123",
  data: "input data"
});

const page = await this.getWorkflows({
  status: "running",
  limit: 10
});

await this.approveWorkflow(instanceId, { approvedBy: "admin" });

await this.rejectWorkflow(instanceId, "Insufficient permissions");

async onConnect(connection: Connection, ctx: ConnectionContext) {
  const userId = new URL(ctx.request.url).searchParams.get("user");
  connection.setState({ userId });
}

async onMessage(connection: Connection, message: string | ArrayBuffer) {
  if (typeof message === "string") {
    const data = JSON.parse(message);
    // Handle custom message
  }
}

async onClose(connection: Connection, code: number, reason: string) {
  console.log(`Connection ${connection.id} closed: ${reason}`);
}

async onRequest(request: Request) {
  if (request.method === "POST") {
    const data = await request.json();
    return new Response(JSON.stringify({ status: "ok" }));
  }
  return new Response("Method not allowed", { status: 405 });
}

async onStart(props?: Props) {
  // Initialize resources, restore state, etc.
}

async onEmail(email: AgentEmail) {
  const subject = email.headers.get("subject");
  await this.replyToEmail(email, {
    fromName: "Bot",
    body: `Received: ${subject}`,
    secret: this.env.EMAIL_SECRET
  });
}

async onStateChanged(state: State, source: Connection | "server") {
  // Log state changes, trigger side effects, etc.
}

validateStateChange(nextState: State, source: Connection | "server") {
  if (source !== "server" && nextState.adminOnly) {
    throw new Error("Only server can set adminOnly fields");
  }
}

async onWorkflowProgress(event: WorkflowProgressCallback) {
  console.log(`Workflow ${event.workflowId} progress:`, event.progress);
}

async onWorkflowComplete(event: WorkflowCompleteCallback) {
  console.log(`Workflow ${event.workflowId} completed:`, event.result);
}

async onWorkflowError(event: WorkflowErrorCallback) {
  console.error(`Workflow ${event.workflowId} failed:`, event.error);
}

async onError(error: unknown) {
  console.error("Agent error:", error);
  // Don't throw to suppress the error, or re-throw to propagate
  throw error;
}

const connections = this.getConnections();
for (const conn of connections) {
  conn.send("broadcast message");
}

this.broadcast(JSON.stringify({ event: "update", data }), [sourceConnectionId]);

this.setConnectionReadonly(connection, true);

if (this.isConnectionReadonly(connection)) {
  return new Response("Readonly connection", { status: 403 });
}

shouldConnectionBeReadonly(connection: Connection, ctx: ConnectionContext) {
  const url = new URL(ctx.request.url);
  return url.searchParams.get("readonly") === "true";
}