export abstract class AbstractAgent {
  // ... existing methods unchanged ...

  /**
   * Returns the agent's current capabilities.
   * Optional — agents that don't implement this return undefined.
   */
  async getCapabilities?(): Promise<AgentCapabilities>
}

interface AgentCapabilities {
  /** Agent identity and metadata */
  identity?: IdentityCapabilities

  /** Supported transport mechanisms */
  transport?: TransportCapabilities

  /** Tools the agent provides (not client-provided tools) */
  tools?: ToolsCapabilities

  /** Output format support */
  output?: OutputCapabilities

  /** State and memory management */
  state?: StateCapabilities

  /** Multi-agent coordination */
  multiAgent?: MultiAgentCapabilities

  /** Reasoning and thinking support */
  reasoning?: ReasoningCapabilities

  /** Multimodal input/output support */
  multimodal?: MultimodalCapabilities

  /** Execution control and limits */
  execution?: ExecutionCapabilities

  /** Human-in-the-loop support */
  humanInTheLoop?: HumanInTheLoopCapabilities

  /** Integration-specific capabilities */
  custom?: Record<string, unknown>
}

interface IdentityCapabilities {
  name?: string
  description?: string
  version?: string
  provider?: string
  documentationUrl?: string
  metadata?: Record<string, unknown>
}

interface TransportCapabilities {
  streaming?: boolean
  websocket?: boolean
  httpBinary?: boolean
  pushNotifications?: boolean
  resumable?: boolean
}

interface ToolsCapabilities {
  /** Whether the agent supports tool calling at all */
  supported?: boolean
  /** Tools the agent itself provides */
  items?: Tool[]
  /** Whether the agent can execute tools in parallel */
  parallelCalls?: boolean
  /** Whether the agent supports client-provided tools */
  clientProvided?: boolean
}

interface OutputCapabilities {
  structuredOutput?: boolean
  /** Supported output MIME types (e.g., "text/plain", "application/json") */
  supportedMimeTypes?: string[]
}

interface StateCapabilities {
  snapshots?: boolean
  deltas?: boolean
  memory?: boolean
  /** Whether state persists across runs within a thread */
  persistentState?: boolean
}

interface MultiAgentCapabilities {
  supported?: boolean
  delegation?: boolean
  handoffs?: boolean
  /** Sub-agents available (by name/id) */
  subAgents?: Array<{ name: string; description?: string }>
}

interface ReasoningCapabilities {
  supported?: boolean
  /** Whether reasoning tokens are streamed to the client */
  streaming?: boolean
  encrypted?: boolean
}

interface MultimodalCapabilities {
  imageInput?: boolean
  imageGeneration?: boolean
  audioInput?: boolean
  audioOutput?: boolean
  videoInput?: boolean
  pdfInput?: boolean
  fileInput?: boolean
}

interface ExecutionCapabilities {
  codeExecution?: boolean
  sandboxed?: boolean
  maxIterations?: number
  maxExecutionTime?: number
}

interface HumanInTheLoopCapabilities {
  supported?: boolean
  approvals?: boolean
  interventions?: boolean
  feedback?: boolean
}

interface HttpAgentConfig extends AgentConfig {
  url: string
  headers?: Record<string, string>
  /** Override the capabilities endpoint. Defaults to {url}/capabilities */
  capabilitiesUrl?: string
}

class HttpAgent extends AbstractAgent {
  async getCapabilities(): Promise<AgentCapabilities> {
    const url = this.capabilitiesUrl ?? `${this.url}/capabilities`
    const response = await fetch(url, {
      headers: this.headers,
    })
    return response.json()
  }
}

class MastraAgent extends AbstractAgent {
  async getCapabilities(): Promise<AgentCapabilities> {
    return {
      identity: {
        name: this.config.agent.name,
        description: this.config.agent.description,
      },
      transport: {
        streaming: true,
      },
      tools: {
        supported: true,
        items: this.config.agent.getTools(),
        clientProvided: true,
      },
      state: {
        snapshots: true,
        deltas: true,
        memory: this.config.agent.hasMemory(),
      },
      multiAgent: {
        supported: true,
        delegation: true,
        subAgents: this.config.agent.getSubAgents().map((a) => ({
          name: a.name,
          description: a.description,
        })),
      },
      reasoning: {
        supported: true,
        streaming: true,
      },
    }
  }
}

const agent = new HttpAgent({ url: "https://my-agent.example.com/api" })

const capabilities = await agent.getCapabilities?.()

if (capabilities?.tools?.supported) {
  console.log(`Agent provides ${capabilities.tools.items?.length} tools`)
}

if (capabilities?.reasoning?.supported) {
  // Show reasoning UI toggle
}

if (capabilities?.humanInTheLoop?.approvals) {
  // Prepare approval UI components
}

if (capabilities?.multiAgent?.subAgents?.length) {
  // Show sub-agent selector
}

const agent = new MastraAgent(config)

// Initially has 5 tools
let caps = await agent.getCapabilities()
console.log(caps.tools?.items?.length) // 5

// Register more tools at runtime
agent.registerTool(newTool1)
agent.registerTool(newTool2)

// Now reflects 7 tools
caps = await agent.getCapabilities()
console.log(caps.tools?.items?.length) // 7

class MyCustomAgent extends AbstractAgent {
  async getCapabilities(): Promise<AgentCapabilities> {
    return {
      transport: { streaming: true },
      tools: { supported: true, items: this.tools },
      custom: {
        rateLimit: { maxRequestsPerMinute: 60 },
        billing: { tier: "enterprise", creditsRemaining: 1000 },
        compliance: { gdpr: true, hipaa: false },
      },
    }
  }
}