elsabro 2.3.0 → 3.7.0

package/references/agent-protocol.md

@@ -0,0 +1,1126 @@
+# Agent Protocol REST API (v3.2)
+
+Sistema de interoperabilidad basado en el estándar Agent Protocol para comunicación con otros frameworks de agentes.
+
+## Arquitectura
+
+```
+┌─────────────────────────────────────────────────────────────────────────┐
+│                      AGENT PROTOCOL LAYER                                │
+├─────────────────────────────────────────────────────────────────────────┤
+│                                                                          │
+│  ┌─────────────────────────────────────────────────────────────────┐    │
+│  │                     REST API SERVER                              │    │
+│  │  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────────────┐    │    │
+│  │  │ /tasks  │  │ /steps  │  │/artifacts│  │  /agent-info    │    │    │
+│  │  │  CRUD   │  │  CRUD   │  │   CRUD   │  │   metadata      │    │    │
+│  │  └─────────┘  └─────────┘  └─────────┘  └─────────────────┘    │    │
+│  └─────────────────────────────────────────────────────────────────┘    │
+│                                    │                                     │
+│                                    ▼                                     │
+│  ┌─────────────────────────────────────────────────────────────────┐    │
+│  │                    PROTOCOL ADAPTER                              │    │
+│  │  ┌─────────────────┐  ┌─────────────────┐  ┌────────────────┐   │    │
+│  │  │  Task Mapper    │  │  Step Mapper    │  │ Artifact Store │   │    │
+│  │  │ Protocol↔ELSABRO│  │ Protocol↔Flow   │  │   File-based   │   │    │
+│  │  └─────────────────┘  └─────────────────┘  └────────────────┘   │    │
+│  └─────────────────────────────────────────────────────────────────┘    │
+│                                    │                                     │
+│                                    ▼                                     │
+│  ┌─────────────────────────────────────────────────────────────────┐    │
+│  │                  ELSABRO CORE SYSTEMS                            │    │
+│  │  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────────────┐    │    │
+│  │  │ Tasks   │  │ Flows   │  │ Agents  │  │   Checkpoints   │    │    │
+│  │  │  API    │  │ Engine  │  │  Pool   │  │     System      │    │    │
+│  │  └─────────┘  └─────────┘  └─────────┘  └─────────────────┘    │    │
+│  └─────────────────────────────────────────────────────────────────┘    │
+│                                                                          │
+└─────────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Especificación OpenAPI
+
+```yaml
+openapi: 3.1.0
+info:
+  title: ELSABRO Agent Protocol API
+  version: 1.0.0
+  description: Agent Protocol implementation for ELSABRO framework interoperability
+
+servers:
+  - url: http://localhost:8080/api/v1
+    description: Local development server
+
+paths:
+  /agent:
+    get:
+      summary: Get agent information
+      operationId: getAgentInfo
+      responses:
+        '200':
+          description: Agent information
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/AgentInfo'
+
+  /tasks:
+    get:
+      summary: List all tasks
+      operationId: listTasks
+      parameters:
+        - name: status
+          in: query
+          schema:
+            type: string
+            enum: [pending, in_progress, completed, failed]
+        - name: limit
+          in: query
+          schema:
+            type: integer
+            default: 50
+        - name: offset
+          in: query
+          schema:
+            type: integer
+            default: 0
+      responses:
+        '200':
+          description: List of tasks
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/TaskList'
+
+    post:
+      summary: Create a new task
+      operationId: createTask
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/TaskCreate'
+      responses:
+        '201':
+          description: Task created
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Task'
+
+  /tasks/{taskId}:
+    get:
+      summary: Get task details
+      operationId: getTask
+      parameters:
+        - name: taskId
+          in: path
+          required: true
+          schema:
+            type: string
+      responses:
+        '200':
+          description: Task details
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Task'
+        '404':
+          description: Task not found
+
+  /tasks/{taskId}/steps:
+    get:
+      summary: List task steps
+      operationId: listSteps
+      parameters:
+        - name: taskId
+          in: path
+          required: true
+          schema:
+            type: string
+      responses:
+        '200':
+          description: List of steps
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/StepList'
+
+    post:
+      summary: Execute next step
+      operationId: executeStep
+      parameters:
+        - name: taskId
+          in: path
+          required: true
+          schema:
+            type: string
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/StepRequest'
+      responses:
+        '200':
+          description: Step executed
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Step'
+
+  /tasks/{taskId}/steps/{stepId}:
+    get:
+      summary: Get step details
+      operationId: getStep
+      parameters:
+        - name: taskId
+          in: path
+          required: true
+          schema:
+            type: string
+        - name: stepId
+          in: path
+          required: true
+          schema:
+            type: string
+      responses:
+        '200':
+          description: Step details
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Step'
+
+  /tasks/{taskId}/artifacts:
+    get:
+      summary: List task artifacts
+      operationId: listArtifacts
+      parameters:
+        - name: taskId
+          in: path
+          required: true
+          schema:
+            type: string
+      responses:
+        '200':
+          description: List of artifacts
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ArtifactList'
+
+    post:
+      summary: Upload artifact
+      operationId: uploadArtifact
+      parameters:
+        - name: taskId
+          in: path
+          required: true
+          schema:
+            type: string
+      requestBody:
+        required: true
+        content:
+          multipart/form-data:
+            schema:
+              type: object
+              properties:
+                file:
+                  type: string
+                  format: binary
+                relative_path:
+                  type: string
+      responses:
+        '201':
+          description: Artifact uploaded
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Artifact'
+
+  /tasks/{taskId}/artifacts/{artifactId}:
+    get:
+      summary: Download artifact
+      operationId: downloadArtifact
+      parameters:
+        - name: taskId
+          in: path
+          required: true
+          schema:
+            type: string
+        - name: artifactId
+          in: path
+          required: true
+          schema:
+            type: string
+      responses:
+        '200':
+          description: Artifact content
+          content:
+            application/octet-stream:
+              schema:
+                type: string
+                format: binary
+
+components:
+  schemas:
+    AgentInfo:
+      type: object
+      required:
+        - name
+        - version
+        - protocol_version
+      properties:
+        name:
+          type: string
+          example: "ELSABRO"
+        version:
+          type: string
+          example: "3.2.0"
+        protocol_version:
+          type: string
+          example: "1.0.0"
+        description:
+          type: string
+        capabilities:
+          type: array
+          items:
+            type: string
+          example:
+            - "checkpointing"
+            - "memory"
+            - "flows"
+            - "time-travel"
+            - "streaming"
+
+    TaskCreate:
+      type: object
+      required:
+        - input
+      properties:
+        input:
+          type: string
+          description: Task input/prompt
+        additional_input:
+          type: object
+          description: Additional parameters
+
+    Task:
+      type: object
+      required:
+        - task_id
+        - input
+        - status
+        - created_at
+      properties:
+        task_id:
+          type: string
+        input:
+          type: string
+        additional_input:
+          type: object
+        status:
+          type: string
+          enum: [pending, in_progress, completed, failed]
+        output:
+          type: string
+        additional_output:
+          type: object
+        artifacts:
+          type: array
+          items:
+            $ref: '#/components/schemas/Artifact'
+        created_at:
+          type: string
+          format: date-time
+        updated_at:
+          type: string
+          format: date-time
+
+    TaskList:
+      type: object
+      properties:
+        tasks:
+          type: array
+          items:
+            $ref: '#/components/schemas/Task'
+        total:
+          type: integer
+        has_more:
+          type: boolean
+
+    StepRequest:
+      type: object
+      properties:
+        input:
+          type: string
+        additional_input:
+          type: object
+
+    Step:
+      type: object
+      required:
+        - step_id
+        - task_id
+        - status
+        - created_at
+      properties:
+        step_id:
+          type: string
+        task_id:
+          type: string
+        name:
+          type: string
+        status:
+          type: string
+          enum: [pending, running, completed, failed]
+        input:
+          type: string
+        output:
+          type: string
+        additional_output:
+          type: object
+        artifacts:
+          type: array
+          items:
+            $ref: '#/components/schemas/Artifact'
+        is_last:
+          type: boolean
+        created_at:
+          type: string
+          format: date-time
+        completed_at:
+          type: string
+          format: date-time
+
+    StepList:
+      type: object
+      properties:
+        steps:
+          type: array
+          items:
+            $ref: '#/components/schemas/Step'
+        total:
+          type: integer
+
+    Artifact:
+      type: object
+      required:
+        - artifact_id
+        - file_name
+        - created_at
+      properties:
+        artifact_id:
+          type: string
+        file_name:
+          type: string
+        relative_path:
+          type: string
+        content_type:
+          type: string
+        size_bytes:
+          type: integer
+        created_at:
+          type: string
+          format: date-time
+
+    ArtifactList:
+      type: object
+      properties:
+        artifacts:
+          type: array
+          items:
+            $ref: '#/components/schemas/Artifact'
+        total:
+          type: integer
+```
+
+---
+
+## Implementación del Servidor
+
+### AgentProtocolServer
+
+```typescript
+class AgentProtocolServer {
+  private port: number;
+  private taskMapper: TaskMapper;
+  private stepMapper: StepMapper;
+  private artifactStore: ArtifactStore;
+
+  constructor(config: AgentProtocolConfig) {
+    this.port = config.port || 8080;
+    this.taskMapper = new TaskMapper();
+    this.stepMapper = new StepMapper();
+    this.artifactStore = new ArtifactStore(config.artifactsDir);
+  }
+
+  // GET /agent
+  async getAgentInfo(): Promise<AgentInfo> {
+    return {
+      name: "ELSABRO",
+      version: "3.2.0",
+      protocol_version: "1.0.0",
+      description: "AI-powered development orchestration framework",
+      capabilities: [
+        "checkpointing",
+        "multi-level-memory",
+        "flow-orchestration",
+        "error-contracts",
+        "interrupts",
+        "observability",
+        "streaming",
+        "output-schemas",
+        "time-travel",
+        "agent-protocol"
+      ]
+    };
+  }
+
+  // POST /tasks
+  async createTask(request: TaskCreate): Promise<Task> {
+    // Map to ELSABRO task
+    const elsabroTask = await this.taskMapper.fromProtocol(request);
+
+    // Create in Tasks API
+    const taskId = await TaskCreate({
+      subject: this.extractSubject(request.input),
+      description: request.input,
+      metadata: {
+        protocol: "agent-protocol",
+        additional_input: request.additional_input
+      }
+    });
+
+    return this.taskMapper.toProtocol(elsabroTask, taskId);
+  }
+
+  // GET /tasks
+  async listTasks(options: ListOptions): Promise<TaskList> {
+    const tasks = await TaskList();
+
+    // Filter by status if provided
+    let filtered = tasks;
+    if (options.status) {
+      filtered = tasks.filter(t =>
+        this.mapStatus(t.status) === options.status
+      );
+    }
+
+    // Pagination
+    const offset = options.offset || 0;
+    const limit = options.limit || 50;
+    const paginated = filtered.slice(offset, offset + limit);
+
+    return {
+      tasks: paginated.map(t => this.taskMapper.toProtocol(t)),
+      total: filtered.length,
+      has_more: offset + limit < filtered.length
+    };
+  }
+
+  // GET /tasks/:taskId
+  async getTask(taskId: string): Promise<Task | null> {
+    const task = await TaskGet({ taskId });
+    if (!task) return null;
+    return this.taskMapper.toProtocol(task);
+  }
+
+  // POST /tasks/:taskId/steps
+  async executeStep(taskId: string, request: StepRequest): Promise<Step> {
+    const task = await TaskGet({ taskId });
+    if (!task) throw new NotFoundError('Task not found');
+
+    // Get current flow state
+    const flowState = await this.getFlowState(taskId);
+
+    // Execute next node in flow
+    const result = await FlowEngine.executeNext(flowState, {
+      input: request.input,
+      additional_input: request.additional_input
+    });
+
+    // Map to protocol step
+    const step = this.stepMapper.toProtocol(result, taskId);
+
+    // Create checkpoint after step
+    await CheckpointManager.save({
+      type: 'auto',
+      reason: `Step ${step.step_id} completed`
+    });
+
+    return step;
+  }
+
+  // GET /tasks/:taskId/steps
+  async listSteps(taskId: string): Promise<StepList> {
+    const task = await TaskGet({ taskId });
+    if (!task) throw new NotFoundError('Task not found');
+
+    // Get flow execution history
+    const history = await this.getFlowHistory(taskId);
+
+    return {
+      steps: history.map((h, i) => this.stepMapper.toProtocol(h, taskId, i)),
+      total: history.length
+    };
+  }
+
+  // GET /tasks/:taskId/steps/:stepId
+  async getStep(taskId: string, stepId: string): Promise<Step | null> {
+    const history = await this.getFlowHistory(taskId);
+    const step = history.find(h => h.id === stepId);
+    if (!step) return null;
+    return this.stepMapper.toProtocol(step, taskId);
+  }
+
+  // POST /tasks/:taskId/artifacts
+  async uploadArtifact(
+    taskId: string,
+    file: Buffer,
+    filename: string,
+    relativePath?: string
+  ): Promise<Artifact> {
+    const artifact = await this.artifactStore.save(taskId, file, filename, relativePath);
+    return artifact;
+  }
+
+  // GET /tasks/:taskId/artifacts
+  async listArtifacts(taskId: string): Promise<ArtifactList> {
+    const artifacts = await this.artifactStore.list(taskId);
+    return {
+      artifacts,
+      total: artifacts.length
+    };
+  }
+
+  // GET /tasks/:taskId/artifacts/:artifactId
+  async downloadArtifact(taskId: string, artifactId: string): Promise<Buffer> {
+    return this.artifactStore.get(taskId, artifactId);
+  }
+
+  // Helper methods
+  private mapStatus(elsabroStatus: string): string {
+    const mapping: Record<string, string> = {
+      'pending': 'pending',
+      'in_progress': 'in_progress',
+      'completed': 'completed',
+      'failed': 'failed',
+      'blocked': 'pending'
+    };
+    return mapping[elsabroStatus] || 'pending';
+  }
+
+  private extractSubject(input: string): string {
+    // Extract first line or first 100 chars
+    const firstLine = input.split('\n')[0];
+    return firstLine.length > 100 ? firstLine.slice(0, 100) + '...' : firstLine;
+  }
+
+  private async getFlowState(taskId: string): Promise<FlowState> {
+    // Load flow state from checkpoint or create new
+    const checkpoint = await CheckpointManager.getLatest(taskId);
+    if (checkpoint?.flow_state) {
+      return checkpoint.flow_state;
+    }
+    return FlowEngine.createState('development-flow');
+  }
+
+  private async getFlowHistory(taskId: string): Promise<FlowHistoryEntry[]> {
+    // Load execution history from checkpoints
+    const checkpoints = await CheckpointManager.list({ taskId });
+    return checkpoints.flatMap(cp => cp.history || []);
+  }
+}
+```
+
+---
+
+## Mappers
+
+### TaskMapper
+
+```typescript
+class TaskMapper {
+  // Convert Protocol Task to ELSABRO format
+  fromProtocol(protocolTask: TaskCreate): ElsabroTask {
+    return {
+      subject: this.extractSubject(protocolTask.input),
+      description: protocolTask.input,
+      metadata: {
+        type: 'protocol_task',
+        source: 'agent-protocol',
+        additional_input: protocolTask.additional_input || {}
+      }
+    };
+  }
+
+  // Convert ELSABRO Task to Protocol format
+  toProtocol(elsabroTask: ElsabroTask, taskId?: string): Task {
+    return {
+      task_id: taskId || elsabroTask.id,
+      input: elsabroTask.description,
+      additional_input: elsabroTask.metadata?.additional_input || {},
+      status: this.mapStatus(elsabroTask.status),
+      output: elsabroTask.result || null,
+      additional_output: elsabroTask.metadata?.output || {},
+      artifacts: [],  // Populated separately
+      created_at: elsabroTask.created_at,
+      updated_at: elsabroTask.updated_at
+    };
+  }
+
+  private mapStatus(status: string): TaskStatus {
+    const mapping: Record<string, TaskStatus> = {
+      'pending': 'pending',
+      'in_progress': 'in_progress',
+      'completed': 'completed',
+      'failed': 'failed',
+      'blocked': 'pending',
+      'deleted': 'failed'
+    };
+    return mapping[status] || 'pending';
+  }
+
+  private extractSubject(input: string): string {
+    const firstLine = input.split('\n')[0].trim();
+    return firstLine.length > 100 ? firstLine.slice(0, 97) + '...' : firstLine;
+  }
+}
+```
+
+### StepMapper
+
+```typescript
+class StepMapper {
+  // Convert Flow node execution to Protocol Step
+  toProtocol(
+    flowResult: FlowNodeResult,
+    taskId: string,
+    index?: number
+  ): Step {
+    return {
+      step_id: flowResult.node_id || `step_${index}`,
+      task_id: taskId,
+      name: flowResult.node_name || `Step ${index + 1}`,
+      status: this.mapStatus(flowResult.status),
+      input: flowResult.input || '',
+      output: flowResult.output || '',
+      additional_output: {
+        agent: flowResult.agent,
+        model: flowResult.model,
+        duration_ms: flowResult.duration_ms,
+        tokens: flowResult.tokens
+      },
+      artifacts: flowResult.artifacts || [],
+      is_last: flowResult.is_terminal || false,
+      created_at: flowResult.started_at,
+      completed_at: flowResult.completed_at
+    };
+  }
+
+  private mapStatus(status: string): StepStatus {
+    const mapping: Record<string, StepStatus> = {
+      'pending': 'pending',
+      'running': 'running',
+      'completed': 'completed',
+      'failed': 'failed',
+      'skipped': 'completed'
+    };
+    return mapping[status] || 'pending';
+  }
+}
+```
+
+---
+
+## Artifact Store
+
+```typescript
+class ArtifactStore {
+  private baseDir: string;
+
+  constructor(baseDir: string = '.elsabro/artifacts') {
+    this.baseDir = baseDir;
+  }
+
+  async save(
+    taskId: string,
+    content: Buffer,
+    filename: string,
+    relativePath?: string
+  ): Promise<Artifact> {
+    const artifactId = this.generateId();
+    const taskDir = path.join(this.baseDir, taskId);
+
+    // Ensure directory exists
+    await fs.mkdir(taskDir, { recursive: true });
+
+    // Determine final path
+    const finalPath = relativePath
+      ? path.join(taskDir, relativePath, filename)
+      : path.join(taskDir, filename);
+
+    // Ensure subdirectory exists if relativePath provided
+    if (relativePath) {
+      await fs.mkdir(path.dirname(finalPath), { recursive: true });
+    }
+
+    // Write file
+    await fs.writeFile(finalPath, content);
+
+    // Get content type
+    const contentType = this.getContentType(filename);
+
+    // Create artifact record
+    const artifact: Artifact = {
+      artifact_id: artifactId,
+      file_name: filename,
+      relative_path: relativePath || '',
+      content_type: contentType,
+      size_bytes: content.length,
+      created_at: new Date().toISOString()
+    };
+
+    // Save artifact metadata
+    await this.saveMetadata(taskId, artifact);
+
+    return artifact;
+  }
+
+  async get(taskId: string, artifactId: string): Promise<Buffer> {
+    const metadata = await this.getMetadata(taskId);
+    const artifact = metadata.find(a => a.artifact_id === artifactId);
+
+    if (!artifact) {
+      throw new NotFoundError('Artifact not found');
+    }
+
+    const filePath = path.join(
+      this.baseDir,
+      taskId,
+      artifact.relative_path,
+      artifact.file_name
+    );
+
+    return fs.readFile(filePath);
+  }
+
+  async list(taskId: string): Promise<Artifact[]> {
+    return this.getMetadata(taskId);
+  }
+
+  async delete(taskId: string, artifactId: string): Promise<void> {
+    const metadata = await this.getMetadata(taskId);
+    const artifact = metadata.find(a => a.artifact_id === artifactId);
+
+    if (!artifact) {
+      throw new NotFoundError('Artifact not found');
+    }
+
+    const filePath = path.join(
+      this.baseDir,
+      taskId,
+      artifact.relative_path,
+      artifact.file_name
+    );
+
+    await fs.unlink(filePath);
+    await this.removeMetadata(taskId, artifactId);
+  }
+
+  private generateId(): string {
+    return `art_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  private getContentType(filename: string): string {
+    const ext = path.extname(filename).toLowerCase();
+    const types: Record<string, string> = {
+      '.json': 'application/json',
+      '.md': 'text/markdown',
+      '.txt': 'text/plain',
+      '.ts': 'text/typescript',
+      '.js': 'text/javascript',
+      '.py': 'text/x-python',
+      '.html': 'text/html',
+      '.css': 'text/css',
+      '.png': 'image/png',
+      '.jpg': 'image/jpeg',
+      '.gif': 'image/gif',
+      '.pdf': 'application/pdf',
+      '.zip': 'application/zip'
+    };
+    return types[ext] || 'application/octet-stream';
+  }
+
+  private async getMetadataPath(taskId: string): Promise<string> {
+    return path.join(this.baseDir, taskId, '.artifacts.json');
+  }
+
+  private async getMetadata(taskId: string): Promise<Artifact[]> {
+    const metaPath = await this.getMetadataPath(taskId);
+    try {
+      const content = await fs.readFile(metaPath, 'utf-8');
+      return JSON.parse(content);
+    } catch {
+      return [];
+    }
+  }
+
+  private async saveMetadata(taskId: string, artifact: Artifact): Promise<void> {
+    const metadata = await this.getMetadata(taskId);
+    metadata.push(artifact);
+    const metaPath = await this.getMetadataPath(taskId);
+    await fs.writeFile(metaPath, JSON.stringify(metadata, null, 2));
+  }
+
+  private async removeMetadata(taskId: string, artifactId: string): Promise<void> {
+    const metadata = await this.getMetadata(taskId);
+    const filtered = metadata.filter(a => a.artifact_id !== artifactId);
+    const metaPath = await this.getMetadataPath(taskId);
+    await fs.writeFile(metaPath, JSON.stringify(filtered, null, 2));
+  }
+}
+```
+
+---
+
+## Integración con ELSABRO
+
+### Uso desde Comandos
+
+```typescript
+// En /elsabro:start - exponer API opcional
+if (config.agentProtocol?.enabled) {
+  const server = new AgentProtocolServer(config.agentProtocol);
+  await server.start();
+  console.log(`Agent Protocol API running on port ${config.agentProtocol.port}`);
+}
+```
+
+### Uso como Cliente
+
+```typescript
+// Conectar a otro agente que implemente Agent Protocol
+class AgentProtocolClient {
+  private baseUrl: string;
+
+  constructor(baseUrl: string) {
+    this.baseUrl = baseUrl;
+  }
+
+  async createTask(input: string): Promise<Task> {
+    const response = await fetch(`${this.baseUrl}/tasks`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ input })
+    });
+    return response.json();
+  }
+
+  async executeStep(taskId: string, input?: string): Promise<Step> {
+    const response = await fetch(`${this.baseUrl}/tasks/${taskId}/steps`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ input })
+    });
+    return response.json();
+  }
+
+  async runToCompletion(taskId: string): Promise<Task> {
+    let step: Step;
+    do {
+      step = await this.executeStep(taskId);
+    } while (!step.is_last);
+
+    return this.getTask(taskId);
+  }
+
+  async getTask(taskId: string): Promise<Task> {
+    const response = await fetch(`${this.baseUrl}/tasks/${taskId}`);
+    return response.json();
+  }
+
+  async getAgentInfo(): Promise<AgentInfo> {
+    const response = await fetch(`${this.baseUrl}/agent`);
+    return response.json();
+  }
+}
+```
+
+---
+
+## WebSocket Streaming (Extensión)
+
+Para soporte de streaming en tiempo real:
+
+```typescript
+// WebSocket endpoint para streaming de steps
+// ws://localhost:8080/ws/tasks/{taskId}/steps
+
+interface StepStreamMessage {
+  type: 'step_started' | 'step_progress' | 'step_completed' | 'step_failed';
+  task_id: string;
+  step_id: string;
+  data: {
+    progress?: number;
+    output_chunk?: string;
+    error?: string;
+    step?: Step;
+  };
+}
+
+class AgentProtocolWebSocket {
+  private wss: WebSocketServer;
+  private connections: Map<string, Set<WebSocket>>;
+
+  constructor(server: http.Server) {
+    this.wss = new WebSocketServer({ server, path: '/ws' });
+    this.connections = new Map();
+
+    this.wss.on('connection', (ws, req) => {
+      const taskId = this.extractTaskId(req.url);
+      if (taskId) {
+        this.subscribe(taskId, ws);
+        ws.on('close', () => this.unsubscribe(taskId, ws));
+      }
+    });
+  }
+
+  subscribe(taskId: string, ws: WebSocket): void {
+    if (!this.connections.has(taskId)) {
+      this.connections.set(taskId, new Set());
+    }
+    this.connections.get(taskId)!.add(ws);
+  }
+
+  unsubscribe(taskId: string, ws: WebSocket): void {
+    this.connections.get(taskId)?.delete(ws);
+  }
+
+  broadcast(taskId: string, message: StepStreamMessage): void {
+    const sockets = this.connections.get(taskId);
+    if (sockets) {
+      const data = JSON.stringify(message);
+      sockets.forEach(ws => {
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.send(data);
+        }
+      });
+    }
+  }
+
+  // Emit from StreamManager integration
+  emitProgress(taskId: string, stepId: string, progress: number): void {
+    this.broadcast(taskId, {
+      type: 'step_progress',
+      task_id: taskId,
+      step_id: stepId,
+      data: { progress }
+    });
+  }
+
+  emitChunk(taskId: string, stepId: string, chunk: string): void {
+    this.broadcast(taskId, {
+      type: 'step_progress',
+      task_id: taskId,
+      step_id: stepId,
+      data: { output_chunk: chunk }
+    });
+  }
+
+  private extractTaskId(url: string | undefined): string | null {
+    if (!url) return null;
+    const match = url.match(/\/tasks\/([^/]+)/);
+    return match ? match[1] : null;
+  }
+}
+```
+
+---
+
+## Configuración
+
+```json
+{
+  "agentProtocol": {
+    "enabled": true,
+    "port": 8080,
+    "host": "localhost",
+    "basePath": "/api/v1",
+    "artifactsDir": ".elsabro/artifacts",
+    "cors": {
+      "enabled": true,
+      "origins": ["*"]
+    },
+    "auth": {
+      "enabled": false,
+      "type": "bearer",
+      "token": null
+    },
+    "websocket": {
+      "enabled": true,
+      "path": "/ws"
+    },
+    "rateLimit": {
+      "enabled": true,
+      "windowMs": 60000,
+      "maxRequests": 100
+    }
+  }
+}
+```
+
+---
+
+## Compatibilidad
+
+### Frameworks Compatibles
+
+| Framework | Versión | Notas |
+|-----------|---------|-------|
+| Auto-GPT | 0.5+ | Full compatibility |
+| BabyAGI | Latest | Full compatibility |
+| AgentGPT | Latest | Full compatibility |
+| SuperAGI | Latest | Full compatibility |
+| Custom Agents | N/A | Implement protocol |
+
+### Limitaciones Conocidas
+
+1. **Streaming**: WebSocket es extensión, no parte del protocol estándar
+2. **Authentication**: No definida en protocol base
+3. **Batch operations**: No soportadas en protocol estándar
+4. **Cancellation**: Task cancellation es custom extension
+
+---
+
+## Testing
+
+```bash
+# Test agent info
+curl http://localhost:8080/api/v1/agent
+
+# Create task
+curl -X POST http://localhost:8080/api/v1/tasks \
+  -H "Content-Type: application/json" \
+  -d '{"input": "Build a login page"}'
+
+# Execute steps until completion
+curl -X POST http://localhost:8080/api/v1/tasks/{taskId}/steps
+
+# List artifacts
+curl http://localhost:8080/api/v1/tasks/{taskId}/artifacts
+```
+
+---
+
+## Changelog
+
+- **v3.2.0**: Initial Agent Protocol implementation
+  - Full OpenAPI 3.1 spec
+  - Task/Step/Artifact CRUD
+  - WebSocket streaming extension
+  - Integration with ELSABRO core systems