One key for everything Entelecy can do

const BASE = 'https://api.entelecy.ai';
const KEY  = process.env.ENTELECY_API_KEY;

/**
 * Chat com streaming. Devolve o texto completo e o usage do ultimo chunk.
 * O gateway sempre pede usage no fim do stream — nao e preciso configurar nada.
 */
export async function chatStream(messages, { effort = 'high', onDelta } = {}) {
  const res = await fetch(`${BASE}/v1/chat/completions`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${KEY}`,
      'Content-Type': 'application/json',
    },
    // model e effort sao eixos separados: o nome escolhe a faixa, o effort a profundidade
    body: JSON.stringify({ model: 'loom-flash', effort, stream: true, messages }),
  });

  if (!res.ok) {
    // 402 = saldo insuficiente; o corpo traz balance/required/upgrade_url
    const err = await res.json().catch(() => ({}));
    throw new Error(`${res.status} ${err?.error?.type ?? 'erro'}: ${err?.error?.message ?? ''}`);
  }

  const reader  = res.body.getReader();
  const decoder = new TextDecoder();
  let buffer = '', text = '', usage = null;

  while (true) {
    const { value, done } = await reader.read();
    if (done) break;
    buffer += decoder.decode(value, { stream: true });

    // SSE: eventos separados por linha; so nos importam as linhas "data: "
    const lines = buffer.split('\n');
    buffer = lines.pop() ?? '';

    for (const line of lines) {
      if (!line.startsWith('data: ')) continue;
      const payload = line.slice(6).trim();
      if (payload === '[DONE]') continue;

      let chunk;
      try { chunk = JSON.parse(payload); } catch { continue; }   // chunk partido

      const delta = chunk.choices?.[0]?.delta?.content;
      if (delta) { text += delta; onDelta?.(delta); }
      if (chunk.usage) usage = chunk.usage;                      // ultimo chunk
    }
  }

  return { text, usage };
}

import { writeFile } from 'node:fs/promises';

export async function gerarImagem(prompt, { size = '1024x1024' } = {}) {
  const res = await fetch(`${BASE}/v1/images/generations`, {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${KEY}`, 'Content-Type': 'application/json' },
    body: JSON.stringify({ model: 'loom-image', prompt, size, n: 1 }),
  });

  const body = await res.json();
  if (!res.ok) {
    // gateway_invalid_size chega aqui ANTES de custar credito
    throw new Error(`${body.error?.code ?? res.status}: ${body.error?.message}`);
  }

  await writeFile('saida.png', Buffer.from(body.data[0].b64_json, 'base64'));
  return body.usage;
}

import json, os, requests

BASE = "https://api.entelecy.ai"
KEY  = os.environ["ENTELECY_API_KEY"]


def chat_stream(messages, effort: str = "high"):
    """Chat com streaming. Retorna (texto, usage)."""
    with requests.post(
        f"{BASE}/v1/chat/completions",
        headers={
            "Authorization": f"Bearer {KEY}",
            "Content-Type": "application/json",
        },
        json={"model": "loom-flash", "effort": effort, "stream": True, "messages": messages},
        stream=True,
        timeout=(10, 600),          # conexao curta, leitura longa
    ) as res:
        if res.status_code == 402:
            raise RuntimeError(f"saldo insuficiente: {res.json()['error']}")
        res.raise_for_status()

        texto, usage = [], None
        for raw in res.iter_lines(decode_unicode=True):
            if not raw or not raw.startswith("data: "):
                continue
            payload = raw[6:].strip()
            if payload == "[DONE]":
                break
            chunk = json.loads(payload)
            if chunk.get("choices"):
                delta = chunk["choices"][0].get("delta", {}).get("content")
                if delta:
                    texto.append(delta)
                    print(delta, end="", flush=True)
            if chunk.get("usage"):
                usage = chunk["usage"]

        return "".join(texto), usage

def transcrever(caminho: str, language: str = "pt") -> str:
    with open(caminho, "rb") as f:
        res = requests.post(
            f"{BASE}/v1/audio/transcriptions",
            headers={"Authorization": f"Bearer {KEY}"},
            files={"file": (os.path.basename(caminho), f, "audio/m4a")},
            data={"model": "loom-audio", "language": language},
            timeout=(10, 300),
        )
    res.raise_for_status()
    return res.text          # o endpoint devolve texto puro, nao JSON

using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;

public sealed class EntelecyClient(HttpClient http, string apiKey)
{
    private static readonly JsonSerializerOptions Json = new(JsonSerializerDefaults.Web);

    /// <summary>Chat com streaming: entrega cada delta no callback e devolve o usage final.</summary>
    public async Task<JsonElement?> ChatStreamAsync(
        object[] messages, Action<string> onDelta, string effort = "high", CancellationToken ct = default)
    {
        var body = JsonSerializer.Serialize(new { model = "loom-flash", effort, stream = true, messages });

        using var req = new HttpRequestMessage(HttpMethod.Post, "/v1/chat/completions")
        {
            Content = new StringContent(body, Encoding.UTF8, "application/json")
        };
        req.Headers.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);

        using var res = await http.SendAsync(req, HttpCompletionOption.ResponseHeadersRead, ct);
        if (!res.IsSuccessStatusCode)
            throw new InvalidOperationException(
                $"{(int)res.StatusCode}: {await res.Content.ReadAsStringAsync(ct)}");

        await using var stream = await res.Content.ReadAsStreamAsync(ct);
        using var reader = new StreamReader(stream);

        JsonElement? usage = null;
        while (await reader.ReadLineAsync(ct) is { } line)
        {
            if (!line.StartsWith("data: ", StringComparison.Ordinal)) continue;
            var payload = line[6..].Trim();
            if (payload == "[DONE]") break;

            JsonDocument doc;
            try { doc = JsonDocument.Parse(payload); } catch (JsonException) { continue; }
            using (doc)
            {
                if (doc.RootElement.TryGetProperty("choices", out var choices)
                    && choices.GetArrayLength() > 0
                    && choices[0].TryGetProperty("delta", out var delta)
                    && delta.TryGetProperty("content", out var content))
                {
                    onDelta(content.GetString() ?? "");
                }
                if (doc.RootElement.TryGetProperty("usage", out var u))
                    usage = u.Clone();
            }
        }
        return usage;
    }
}