Cancel Task

async function cancelTask(taskId) {
  const API_KEY = "YOUR_API_KEY";
  const API_URL = `https://cloud.blackbox.ai/api/tasks/${taskId}`;
  
  try {
    const response = await fetch(API_URL, {
      method: "PATCH",
      headers: {
        Authorization: `Bearer ${API_KEY}`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({ action: "stop" }),
    });

    if (!response.ok) {
      const error = await response.json();
      throw new Error(error.error || "Failed to cancel task");
    }

    const data = await response.json();
    console.log(data.message); // "Task stopped successfully"
    return data.task;
  } catch (error) {
    console.error("Failed to cancel task:", error.message);
    throw error;
  }
}

// Usage
try {
  const stoppedTask = await cancelTask("9qQe2F8Z_nXx9-eJA0BD6");
  console.log(`Task ${stoppedTask.id} stopped at ${stoppedTask.completedAt}`);
} catch (error) {
  console.error("Error:", error.message);
}

async function runTaskWithTimeout(taskId, timeoutMs = 300000) {
  const API_KEY = "YOUR_API_KEY";
  
  // Start monitoring the task
  const timeoutPromise = new Promise((_, reject) => {
    setTimeout(() => reject(new Error("Task timeout")), timeoutMs);
  });
  
  const taskPromise = async () => {
    while (true) {
      const statusResponse = await fetch(
        `https://cloud.blackbox.ai/api/tasks/${taskId}/status`,
        {
          headers: { Authorization: `Bearer ${API_KEY}` },
        }
      );
      const status = await statusResponse.json();
      
      if (status.isDone) {
        return status;
      }
      
      await new Promise(resolve => setTimeout(resolve, 2000));
    }
  };
  
  try {
    return await Promise.race([taskPromise(), timeoutPromise]);
  } catch (error) {
    if (error.message === "Task timeout") {
      console.log("Task exceeded timeout, cancelling...");
      await cancelTask(taskId);
      throw new Error("Task was cancelled due to timeout");
    }
    throw error;
  }
}

// Usage
try {
  const result = await runTaskWithTimeout("9qQe2F8Z_nXx9-eJA0BD6", 300000);
  console.log("Task completed:", result);
} catch (error) {
  console.error("Task error:", error.message);
}

import requests

def cancel_task(task_id: str, api_key: str):
    """Cancel a running task"""
    url = f'https://cloud.blackbox.ai/api/tasks/{task_id}'
    headers = {
        'Authorization': f'Bearer {api_key}',
        'Content-Type': 'application/json'
    }
    data = {'action': 'stop'}
    
    response = requests.patch(url, headers=headers, json=data)
    
    if response.status_code == 200:
        result = response.json()
        print(f"Task stopped: {result['message']}")
        return result['task']
    else:
        error = response.json()
        raise Exception(error.get('error', 'Failed to cancel task'))

# Usage
try:
    stopped_task = cancel_task('9qQe2F8Z_nXx9-eJA0BD6', 'YOUR_API_KEY')
    print(f"Task {stopped_task['id']} status: {stopped_task['status']}")
except Exception as e:
    print(f"Error: {e}")

async function cancelMultipleTasks(taskIds) {
  const API_KEY = "YOUR_API_KEY";
  
  const cancelPromises = taskIds.map(async (taskId) => {
    try {
      const response = await fetch(
        `https://cloud.blackbox.ai/api/tasks/${taskId}`,
        {
          method: "PATCH",
          headers: {
            Authorization: `Bearer ${API_KEY}`,
            "Content-Type": "application/json",
          },
          body: JSON.stringify({ action: "stop" }),
        }
      );
      
      if (response.ok) {
        const data = await response.json();
        return { taskId, success: true, data };
      } else {
        const error = await response.json();
        return { taskId, success: false, error: error.error };
      }
    } catch (error) {
      return { taskId, success: false, error: error.message };
    }
  });
  
  const results = await Promise.all(cancelPromises);
  
  const successful = results.filter(r => r.success);
  const failed = results.filter(r => !r.success);
  
  console.log(`Cancelled ${successful.length} tasks`);
  if (failed.length > 0) {
    console.log(`Failed to cancel ${failed.length} tasks:`, failed);
  }
  
  return results;
}

// Usage
const taskIds = ["task1", "task2", "task3"];
const results = await cancelMultipleTasks(taskIds);

class TaskManager {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.activeTasks = new Set();
    
    // Handle process termination
    process.on('SIGINT', () => this.shutdown());
    process.on('SIGTERM', () => this.shutdown());
  }
  
  async startTask(taskId) {
    this.activeTasks.add(taskId);
    // ... start task logic
  }
  
  async shutdown() {
    console.log('Shutting down, cancelling active tasks...');
    
    const cancelPromises = Array.from(this.activeTasks).map(taskId =>
      fetch(`https://cloud.blackbox.ai/api/tasks/${taskId}`, {
        method: "PATCH",
        headers: {
          Authorization: `Bearer ${this.apiKey}`,
          "Content-Type": "application/json",
        },
        body: JSON.stringify({ action: "stop" }),
      })
    );
    
    await Promise.allSettled(cancelPromises);
    console.log('All tasks cancelled');
    process.exit(0);
  }
}

// Usage
const manager = new TaskManager("YOUR_API_KEY");