message TaskMessage {
  string task_id = 1;                                    // Unique identifier
  string task_type = 2;                                  // Type of task
  google.protobuf.Struct parameters = 3;                // Task parameters
  string requester_agent_id = 4;                        // ID of requesting agent
  string responder_agent_id = 5;                        // ID of target agent (optional)
  google.protobuf.Timestamp deadline = 6;               // Optional deadline
  Priority priority = 7;                                // Task priority
  google.protobuf.Struct metadata = 8;                  // Optional metadata
  google.protobuf.Timestamp created_at = 9;             // Creation timestamp
}

// Recommended formats:
taskID := fmt.Sprintf("task_%s_%d", taskType, time.Now().Unix())
taskID := fmt.Sprintf("task_%s_%s", taskType, uuid.New().String())
taskID := fmt.Sprintf("%s_%s_%d", requesterID, taskType, sequence)

message TaskResult {
  string task_id = 1;                                    // Reference to original task
  TaskStatus status = 2;                                 // Final status
  google.protobuf.Struct result = 3;                    // Task results
  string error_message = 4;                             // Error details if failed
  string executor_agent_id = 5;                         // ID of executing agent
  google.protobuf.Timestamp completed_at = 6;           // Completion timestamp
  google.protobuf.Struct execution_metadata = 7;        // Optional execution details
}

// Simple scalar result
result, _ := structpb.NewStruct(map[string]interface{}{
    "value": 42.0,
    "unit": "seconds",
})

// Complex structured result
result, _ := structpb.NewStruct(map[string]interface{}{
    "analysis": map[string]interface{}{
        "total_records": 1500,
        "mean_value": 42.7,
        "trends": []string{"increasing", "seasonal"},
    },
    "metadata": map[string]interface{}{
        "processing_time": "2.3s",
        "data_quality": "high",
    },
})

// File-based result
result, _ := structpb.NewStruct(map[string]interface{}{
    "output_file": "/tmp/results/analysis_20240115.json",
    "file_size": 2048576,
    "format": "json",
    "checksum": "sha256:abc123...",
})

message TaskProgress {
  string task_id = 1;                                    // Reference to original task
  TaskStatus status = 2;                                 // Current status
  string progress_message = 3;                           // Human-readable description
  int32 progress_percentage = 4;                         // Progress as percentage (0-100)
  google.protobuf.Struct progress_data = 5;             // Optional structured progress
  string executor_agent_id = 6;                         // ID of executing agent
  google.protobuf.Timestamp updated_at = 7;             // When this progress was reported
}

// Simple percentage progress
progress := &pb.TaskProgress{
    TaskId:             taskID,
    Status:             pb.TaskStatus_TASK_STATUS_IN_PROGRESS,
    ProgressMessage:    "Processing data",
    ProgressPercentage: 45,
    ExecutorAgentId:    agentID,
    UpdatedAt:          timestamppb.Now(),
}

// Detailed progress with structured data
progressData, _ := structpb.NewStruct(map[string]interface{}{
    "phase": "data_analysis",
    "records_processed": 750,
    "total_records": 1500,
    "current_operation": "correlation_analysis",
    "estimated_remaining": "2m30s",
})

progress := &pb.TaskProgress{
    TaskId:           taskID,
    Status:           pb.TaskStatus_TASK_STATUS_IN_PROGRESS,
    ProgressMessage:  "Analyzing correlations",
    ProgressPercentage: 50,
    ProgressData:     progressData,
    ExecutorAgentId:  agentID,
    UpdatedAt:        timestamppb.Now(),
}

enum Priority {
  PRIORITY_UNSPECIFIED = 0;  // Default value, treated as MEDIUM
  PRIORITY_LOW = 1;          // Low priority, can be delayed
  PRIORITY_MEDIUM = 2;       // Normal priority
  PRIORITY_HIGH = 3;         // High priority, expedited processing
  PRIORITY_CRITICAL = 4;     // Critical priority, immediate processing
}

enum TaskStatus {
  TASK_STATUS_UNSPECIFIED = 0;  // Invalid/unknown status
  TASK_STATUS_PENDING = 1;      // Waiting to be processed
  TASK_STATUS_IN_PROGRESS = 2;  // Currently being executed
  TASK_STATUS_COMPLETED = 3;    // Successfully completed
  TASK_STATUS_FAILED = 4;       // Failed during execution
  TASK_STATUS_CANCELLED = 5;    // Cancelled before/during execution
}

message PublishTaskRequest {
  TaskMessage task = 1;
}

message PublishTaskResultRequest {
  TaskResult result = 1;
}

message PublishTaskProgressRequest {
  TaskProgress progress = 1;
}

message SubscribeToTasksRequest {
  string agent_id = 1;                   // Agent ID to receive tasks for
  repeated string task_types = 2;        // Optional: filter by task types
}

// Subscribe to all tasks for this agent
req := &pb.SubscribeToTasksRequest{
    AgentId: "data_processor_01",
}

// Subscribe only to specific task types
req := &pb.SubscribeToTasksRequest{
    AgentId:   "image_processor",
    TaskTypes: []string{"image.generation", "image.enhancement"},
}

message SubscribeToTaskResultsRequest {
  string requester_agent_id = 1;         // Agent ID that requested tasks
  repeated string task_ids = 2;          // Optional: filter by specific task IDs
}

// Subscribe to all results for tasks this agent requested
req := &pb.SubscribeToTaskResultsRequest{
    RequesterAgentId: "workflow_orchestrator",
}

// Subscribe only to specific task results
req := &pb.SubscribeToTaskResultsRequest{
    RequesterAgentId: "workflow_orchestrator",
    TaskIds: []string{"task_analysis_123", "task_report_456"},
}

rpc PublishTask (PublishTaskRequest) returns (PublishResponse);

task := &pb.TaskMessage{
    TaskId:           "task_analysis_123",
    TaskType:         "data.analysis",
    RequesterAgentId: "orchestrator",
    // ... other fields
}

req := &pb.PublishTaskRequest{Task: task}
res, err := client.PublishTask(ctx, req)

rpc PublishTaskResult (PublishTaskResultRequest) returns (PublishResponse);

rpc PublishTaskProgress (PublishTaskProgressRequest) returns (PublishResponse);

rpc SubscribeToTasks (SubscribeToTasksRequest) returns (stream TaskMessage);

req := &pb.SubscribeToTasksRequest{AgentId: "processor_01"}
stream, err := client.SubscribeToTasks(ctx, req)

for {
    task, err := stream.Recv()
    if err != nil {
        break
    }
    go processTask(task)
}

rpc SubscribeToTaskResults (SubscribeToTaskResultsRequest) returns (stream TaskResult);

rpc SubscribeToTaskProgress (SubscribeToTaskResultsRequest) returns (stream TaskProgress);

{
  "dataset_path": "/data/sales_2024.csv",
  "analysis_type": "summary_statistics|trend_analysis|correlation",
  "time_period": "daily|weekly|monthly|quarterly",
  "output_format": "json|csv|html"
}

{
  "analysis_type": "summary_statistics",
  "total_records": 1500,
  "metrics": {
    "mean": 42.7,
    "median": 41.2,
    "std_dev": 8.3
  },
  "charts": ["/tmp/chart1.png", "/tmp/chart2.png"]
}

{
  "input_path": "/data/input.csv",
  "output_path": "/data/output.json",
  "transformation_rules": {
    "format": "csv_to_json",
    "schema_mapping": {...}
  }
}

{
  "prompt": "A futuristic cityscape at sunset",
  "style": "photorealistic|artistic|cartoon",
  "resolution": "1920x1080",
  "quality": "low|medium|high"
}

{
  "image_path": "/tmp/generated_image.png",
  "resolution": "1920x1080",
  "file_size": 2048576,
  "generation_time": "15.2s"
}

{
  "operation": "add|subtract|multiply|divide|power",
  "operands": [42.0, 58.0],
  "precision": 2
}

{
  "operation": "add",
  "operands": [42.0, 58.0],
  "result": 100.0
}

{
  "to": ["user@example.com"],
  "subject": "Task Completed",
  "body": "Your analysis task has completed successfully.",
  "template": "task_completion",
  "attachments": ["/tmp/report.pdf"]
}

{
  "error_code": "INVALID_PARAMETERS",
  "error_message": "Required parameter 'dataset_path' is missing",
  "details": {
    "missing_parameters": ["dataset_path"],
    "invalid_parameters": {"timeout": "must be positive integer"}
  }
}

{
  "error_code": "RESOURCE_UNAVAILABLE",
  "error_message": "Cannot access dataset file",
  "details": {
    "resource_type": "file",
    "resource_path": "/data/sales_2024.csv",
    "error_details": "File not found"
  }
}

{
  "error_code": "DEADLINE_EXCEEDED",
  "error_message": "Task deadline exceeded during processing",
  "details": {
    "deadline": "2024-01-15T11:00:00Z",
    "actual_completion": "2024-01-15T11:05:00Z",
    "phase": "data_analysis"
  }
}