Concurrency

import axios from "axios";

const API_KEY = process.env.API_KEY;
const TASK_API = "https://api.cloro.dev/v1/async/task";

async function submitTasks(tasks, webhookUrl) {
  // Send API requests concurrently (one request per task)
  await Promise.all(
    tasks.map((task) =>
      axios.post(
        TASK_API,
        {
          taskType: "CHATGPT",
          webhook: { url: webhookUrl },
          payload: task,
        },
        {
          headers: { Authorization: `Bearer ${API_KEY}` },
        }
      )
    )
  );
}

// Webhook handler (Express.js)
app.post("/webhook-handler", (req, res) => {
  const { task, response } = req.body;
  console.log(`Task ${task.id} completed: ${response.text.slice(0, 100)}...`);

  // Process your result here
  saveResult(task.id, response);

  // Always respond quickly
  res.status(200).send();
});

// Usage
const tasks = [
  { prompt: "Analyze market trends", country: "US" },
  { prompt: "Research competitors", country: "US" },
  // ... hundreds more
];

submitTasks(tasks, "https://your-app.com/webhook-handler");

import axios from "axios";

const API_KEY = process.env.API_KEY;
const API_URL = "https://api.cloro.dev/v1/monitor/chatgpt";

async function makeRequest(id, prompt) {
  const start = Date.now();

  try {
    const response = await axios.post(API_URL, {
      prompt: prompt,
      country: "US",
    }, {
      headers: {
        Authorization: `Bearer ${API_KEY}`
      }
    });

    const latency = Date.now() - start;
    console.log(`Request #${id}: Success (${latency}ms)`);

    // Monitor concurrency usage
    const limit = parseInt(response.headers["x-concurrent-limit"]);
    const current = parseInt(response.headers["x-concurrent-current"]);
    const remaining = parseInt(response.headers["x-concurrent-remaining"]);

    return {
      success: true,
      latency,
      data: response.data,
      usage: { limit, current, remaining }
    };

  } catch (error) {
    const latency = Date.now() - start;
    console.log(`Request #${id}: Failed (${latency}ms)`);

    if (error.response?.status === 429) {
      console.log(`Rate limited - ${error.response.headers["retry-after"] || "unknown"} seconds`);
    }

    return { success: false, latency, error: error.message };
  }
}

async function runConcurrentRequests(prompts, concurrency = 10) {
  console.log(`Starting ${prompts.length} requests with ${concurrency} concurrent workers\n`);

  const startTime = Date.now();
  const results = [];
  let requestId = 0;

  // Worker function
  async function worker() {
    while (requestId < prompts.length) {
      const id = ++requestId;
      const result = await makeRequest(id, prompts[requestId - 1]);
      results.push(result);
    }
  }

  // Run concurrent workers
  await Promise.all(
    Array(concurrency).fill(0).map(() => worker())
  );

  const duration = Date.now() - startTime;
  const successful = results.filter(r => r.success).length;
  const rateLimited = results.filter(r => r.error?.includes('Rate limited')).length;

  console.log("\n" + "=".repeat(40));
  console.log(`Total: ${prompts.length}`);
  console.log(`Success: ${successful} (${((successful/prompts.length)*100).toFixed(1)}%)`);
  console.log(`Rate limited: ${rateLimited}`);
  console.log(`Duration: ${(duration/1000).toFixed(1)}s`);
  console.log(`RPS: ${(prompts.length/duration*1000).toFixed(1)}`);
  console.log("=".repeat(40));

  return results;
}

// Usage
const prompts = [
  "What is AI and how does it work?",
  "Explain machine learning basics",
  "What are neural networks?",
  "How does deep learning work?",
  "What is natural language processing?",
  // ... add more prompts as needed
];

runConcurrentRequests(prompts, 5) // Start with conservative concurrency
  .then(results => console.log(`Completed processing`))
  .catch(console.error);