const agent = new SleepCoachAgent({
  spikeMcpUrl: process.env.SPIKE_MCP_URL,
  llmApiKey: process.env.ANTHROPIC_API_KEY,
  userId: "user_123",
  triggers: { schedule: "0 7 * * *" }, // Run daily at 7am
});

await agent.run(); // sense() -> think() -> act()

import { SleepCoachAgent } from "@agentkit/sleep-coach";

const agent = new SleepCoachAgent({
  spikeMcpUrl: process.env.SPIKE_MCP_URL!,
  llmApiKey: process.env.ANTHROPIC_API_KEY!,
  userId: "user_123",
  triggers: { schedule: "0 7 * * *" },
  thresholds: {
    minSleepHours: 7,
    maxSleepDebt: 5,
    targetBedtime: "23:00",
    targetWakeTime: "07:00",
    minDeepSleepPct: 15,
    minRemPct: 20,
  },
});

await agent.run();

abstract class BaseAgent<TConfig, TSenseData, TDecision, TAction = void> {
  protected spike: SpikeMcpClient;  // Health data client
  protected llm: LlmProvider;      // LLM abstraction
  protected config: TConfig;        // Validated agent config

  abstract sense(): Promise<TSenseData>;
  abstract think(data: TSenseData): Promise<TDecision>;
  abstract act(decision: TDecision): Promise<TAction>;

  async run(): Promise<TAction> {
    const data = await this.sense();
    const decision = await this.think(data);
    return this.act(decision);
  }

  protected dateRange(daysBack: number): DateRange;
}

const spike = new SpikeMcpClient("http://localhost:3001");

const sleep = await spike.getSleep(userId, { start: "2026-03-10", end: "2026-03-17" });
const hrv = await spike.getHrv(userId, dateRange);
const activity = await spike.getActivity(userId, dateRange);
const heartRate = await spike.getHeartRate(userId, dateRange);
const body = await spike.getBodyComposition(userId, dateRange);

const llm = createLlmProvider("claude", process.env.ANTHROPIC_API_KEY);
const response = await llm.complete([
  { role: "system", content: "You are a sleep expert." },
  { role: "user", content: "Analyze this sleep data..." },
], { temperature: 0.3 });

interface BaseAgentConfig {
  spikeMcpUrl: string;        // Spike MCP server URL
  llmApiKey: string;          // API key for the LLM provider
  llmProvider?: "claude" | "openai" | "gemini";  // Default: "claude"
  userId: string;             // User to fetch health data for
  triggers: {
    schedule: string;         // Cron expression for scheduled runs
  };
}

interface SleepCoachConfig extends BaseAgentConfig {
  thresholds: {
    minSleepHours: number;     // Default: 7
    maxSleepDebt: number;      // Default: 5 (hours, rolling 7d)
    targetBedtime: string;     // Default: "23:00"
    targetWakeTime: string;    // Default: "07:00"
    minDeepSleepPct: number;   // Default: 15
    minRemPct: number;         // Default: 20
  };
}

interface SleepSession {
  date: string;
  totalMinutes: number;
  deepMinutes: number;
  remMinutes: number;
  lightMinutes: number;
  awakeMinutes: number;
  efficiency: number;        // 0-100
  bedtime: string;           // "HH:mm"
  wakeTime: string;
  heartRateAvg: number;
  hrvAvg: number;
}

interface HrvReading       { timestamp: string; value: number; }
interface HeartRateReading  { timestamp: string; bpm: number; }
interface ActivitySummary   { date: string; steps: number; caloriesBurned: number; activeMinutes: number; strain: number; }
interface BodyComposition   { date: string; weight: number; bodyFat?: number; }

// agents/my-agent/src/config.ts
import { z } from "zod";
import { BaseAgentConfigSchema } from "@agentkit/core";

export const MyAgentConfigSchema = BaseAgentConfigSchema.extend({
  thresholds: z.object({
    myThreshold: z.number().default(42),
  }).default({}),
});

export type MyAgentConfig = z.infer<typeof MyAgentConfigSchema>;

// agents/my-agent/src/prompts.ts
import type { LlmMessage } from "@agentkit/core";

export const SYSTEM_PROMPT = `You are an expert health analyst...`;

export function buildPrompt(data: MySenseData): LlmMessage[] {
  return [
    { role: "system", content: SYSTEM_PROMPT },
    { role: "user", content: JSON.stringify(data) },
  ];
}

// agents/my-agent/src/agent.ts
import { BaseAgent } from "@agentkit/core";
import { MyAgentConfigSchema, type MyAgentConfig } from "./config.js";
import { buildPrompt } from "./prompts.js";

export class MyAgent extends BaseAgent<MyAgentConfig, MySenseData, MyDecision> {
  constructor(config: MyAgentConfig) {
    super(MyAgentConfigSchema.parse(config));
  }

  async sense(): Promise<MySenseData> {
    const sleep = await this.spike.getSleep(this.config.userId, this.dateRange(7));
    return { sleep };
  }

  async think(data: MySenseData): Promise<MyDecision> {
    const messages = buildPrompt(data);
    const raw = await this.llm.complete(messages);
    return JSON.parse(raw);
  }

  async act(decision: MyDecision): Promise<void> {
    console.log("Decision:", decision);
  }
}

// agents/my-agent/src/index.ts
export { MyAgent } from "./agent.js";
export type { MyAgentConfig } from "./config.js";