import { Parel } from "@parel-cloud/node";

const parel = new Parel(); // uses PAREL_API_KEY from env
const openai = await parel.openai;

const res = await openai.chat.completions.create({
  model: "qwen3.5-72b",
  messages: [{ role: "user", content: "Merhaba!" }],
});
console.log(res.choices[0].message.content);

import { Parel } from "@parel-cloud/node";

const parel = new Parel({ apiKey: process.env.PAREL_API_KEY });

// Budget snapshot
const credits = await parel.credits.get();
console.log(`$${credits.remaining_usd.toFixed(2)} remaining`);

// Model catalogue
const { data: models } = await parel.models.list();
console.log(`${models.length} models available`);

const parel = new Parel({ apiKey: "pk-live-..." });
// or
process.env.PAREL_API_KEY = "pk-live-...";
const parel = new Parel();

const openai = await parel.openai;

const completion = await openai.chat.completions.create({
  model: "qwen3.5-72b",
  messages: [{ role: "user", content: "Why is the sky blue?" }],
});

const stream = await openai.chat.completions.create({
  model: "qwen3.5-72b",
  messages: [{ role: "user", content: "Count to 5 slowly" }],
  stream: true,
});
for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

const res = await openai.chat.completions.create({
  model: "qwen3.5-72b",
  messages: [{ role: "user", content: "What's the weather in Istanbul?" }],
  tools: [
    {
      type: "function",
      function: {
        name: "get_weather",
        parameters: { type: "object", properties: { city: { type: "string" } } },
      },
    },
  ],
});

const res = await openai.chat.completions.create({
  model: "qwen3.5-vl-32b",
  messages: [
    {
      role: "user",
      content: [
        { type: "text", text: "What's in this image?" },
        { type: "image_url", image_url: { url: "https://example.com/cat.jpg" } },
      ],
    },
  ],
});

const emb = await openai.embeddings.create({
  model: "text-embedding-3-small",
  input: ["merhaba", "dünya"],
});

const mod = await openai.moderations.create({
  model: "omni-moderation-latest",
  input: "some user-generated content",
});

const audio = await openai.audio.speech.create({
  model: "elevenlabs-tts",
  voice: "alloy",
  input: "Parel'e hoş geldin.",
});
const buffer = Buffer.from(await audio.arrayBuffer());
await fs.writeFile("out.mp3", buffer);

const result = await parel.images.generate({
  model: "flux-schnell",
  prompt: "A minimalist watercolor of Istanbul at dawn, Bosphorus in fog",
  size: "1024x1024",
  n: 1,
  onTick: (task) => console.log(`[${task.progress}%] ${task.status}`),
});
// result.result.data[0].url → hosted PNG

const submission = await parel.images.generate({
  model: "flux-schnell",
  prompt: "a neon cyberpunk cat",
  async: true,
});
// submission.task_id → poll yourself, or:
const done = await parel.tasks.waitFor(submission.task_id);

const edit = await parel.images.edit({
  model: "recraft-v4-edit",
  image: { url: "https://example.com/portrait.png" },
  prompt: "add a red fez",
});

const video = await parel.videos.generate({
  model: "wan-2.6-t2v",
  prompt: "A robot tending a cherry tree in Kyoto",
  duration: 5,
  resolution: "1280x720",
  aspect_ratio: "16:9",
  timeoutMs: 30 * 60_000,
  onTick: (t) => console.log(`${t.progress}%`),
});
// video.result.data[0].url → MP4

const speech = await parel.audio.speech({
  model: "elevenlabs-tts",
  input: "Parel API'si ile bir dakikada modelini deploy et.",
  voice: "alloy",
  speed: 1.0,
});

const music = await parel.audio.music({
  model: "elevenlabs-music",
  prompt: "upbeat jazz piano, 120 bpm",
  duration: 30,
});

const transcript = await parel.audio.transcribe({
  model: "whisper-large-v3-turbo",
  file: base64WavData,
  language: "tr",
  response_format: "json",
});
console.log(transcript.text);

// 1. Validate the model and get a GPU tier recommendation
const hf = await parel.gpu.validateHuggingFace("meta-llama/Llama-3.1-8B-Instruct");
console.log(hf.recommended_gpu_tier); // e.g. "rtx4090_24gb"
console.log(hf.vram_fp16_gb);         // e.g. 16
console.log(hf.needs_new_vllm);       // e.g. false

// 2. Optional: warm the S3 cache in the background so the first boot is faster
await parel.gpu.prefetch("meta-llama/Llama-3.1-8B-Instruct");

// 3. Create the deployment
const dep = await parel.gpu.create({
  huggingface_id: "meta-llama/Llama-3.1-8B-Instruct",
  gpu_tier: hf.recommended_gpu_tier ?? "rtx4090_24gb",
  idle_timeout_minutes: 15, // stop billing after idle
  budget_limit_usd: 5,      // hard stop when exceeded
});

// 4. Wait until it's running
await parel.gpu.waitForRunning(dep.id, {
  timeoutMs: 15 * 60_000,
  onTick: (d) => console.log(`[${d.status}] ${d.name}`),
});

// 5. Inference — OpenAI-compatible chat body
const answer = await parel.gpu.chat(dep.id, {
  messages: [{ role: "user", content: "Write a haiku about Istanbul" }],
  max_tokens: 200,
});

// 6. Cleanup
await parel.gpu.stop(dep.id);     // keep snapshot, resumable
// await parel.gpu.delete(dep.id); // full teardown

const tiers = await parel.gpu.tiers();
// [{ id: "rtx4090_24gb", gpu_name: "RTX 4090", vram_gb: 24, price_per_hour_usd: 0.44, ... }]

const run = await parel.compare.run({
  models: ["qwen3.5-72b", "gpt-4o-mini", "claude-3-5-sonnet", "gemini-2.5-pro"],
  prompt: "Summarize in 3 bullets: why KVKK compliance matters for Turkish SaaS",
  timeoutMs: 10 * 60_000,
  onTick: (r) => console.log(r.status),
});
console.log(run.results);

const conv = await parel.compare.createConversation({ models: ["a", "b"] });
await parel.compare.addTurn(conv.id, { role: "user", content: "Hello" });

const snap = await parel.credits.get();
// { limit_usd, spent_usd, remaining_usd, updated_at, version, tenant_id }

if (snap.remaining_usd < 1) {
  console.log("Top up: https://parel.cloud/billing");
}

// Cancel a task that's still pending or processing (refunds the credit)
const cancel = await parel.tasks.cancel(taskId);
console.log(`refunded $${cancel.refund_amount_usd}`);

// Poll until terminal
const done = await parel.tasks.waitFor(taskId, {
  timeoutMs: 600_000,
  intervalMs: 3_000,
  onTick: (t) => console.log(t.progress),
});

// List recent tasks
const { tasks } = await parel.tasks.list({ task_type: "video", limit: 20 });

// Fetch one
const task = await parel.tasks.get(taskId);

import {
  ParelError,
  ParelAuthenticationError,
  ParelPermissionError,
  ParelBudgetExceededError,
  ParelRateLimitError,
  ParelConflictError,
  ParelNotFoundError,
  ParelValidationError,
  ParelTimeoutError,
  ParelConnectionError,
  ParelServerError,
} from "@parel-cloud/node";

try {
  await parel.images.generate({ model: "flux-schnell", prompt: "cat" });
} catch (err) {
  if (err instanceof ParelBudgetExceededError) {
    // 402 — top up at https://parel.cloud/billing
  } else if (err instanceof ParelRateLimitError) {
    // 429 — respect err.retryAfter (seconds)
    await sleep(err.retryAfter! * 1000);
  } else if (err instanceof ParelConflictError && err.code === "task_not_cancellable") {
    // 409 on /tasks/{id}/cancel when task already completed
  } else if (err instanceof ParelTimeoutError) {
    // polling/request deadline exceeded
  } else if (err instanceof ParelError) {
    console.error(err.status, err.code, err.message, err.requestId);
  } else {
    throw err;
  }
}

new Parel({
  apiKey: "pk-live-...",              // or PAREL_API_KEY env
  baseUrl: "https://api.parel.cloud", // override for self-hosted or staging
  timeoutMs: 60_000,                  // per-request timeout
  maxRetries: 2,                      // on 429 / 5xx / network, idempotent verbs only
  fetch: globalThis.fetch,            // polyfill slot
  userAgent: "my-app/1.0",            // appended to User-Agent
});

const ac = new AbortController();
setTimeout(() => ac.abort(), 60_000);
await parel.images.generate({ model, prompt, signal: ac.signal });

const parel = new Parel();
const openai = await parel.openai; // already pointed at Parel