corent-sdk 0.1.0

package/README.md

@@ -0,0 +1,48 @@
+# Corent SDK
+
+One API for AI **image, video, and voice** generation. You pick a quality tier; Corent's router picks the best live model, reroutes failures, verifies the output, and returns the exact charge on every response. Failed generations are never billed.
+
+```bash
+npm install corent-sdk
+```
+
+```ts
+import { Corent } from "corent-sdk";
+
+const client = new Corent("co_live_..."); // get a key at https://corent.tech
+
+const image = await client.images.generate("a lighthouse at dusk", {
+  tier: "premium",
+  aspectRatio: "9:16",
+});
+console.log(image.url, image.width, image.height, image.costCents);
+
+const video = await client.videos.generate("a paper boat drifting across a puddle", {
+  tier: "premium",
+  durationS: 5,
+  resolution: "1080p",
+});
+console.log(video.url, video.resolution, video.costCents);
+
+const speech = await client.speech.generate("Welcome to Corent.");
+console.log(speech.url, speech.costCents);
+```
+
+## What the SDK handles for you
+
+- **Timeout-safe renders** — images submit as background jobs and are polled; a network hiccup can never lose a finished (and billed) result.
+- **Safe retries** — every generate call carries an auto idempotency key; retries can never double-charge.
+- **Backoff** — 429/5xx retried with `Retry-After` respected.
+- **Honest receipts** — `width`/`height` are the *measured* pixels of the delivered file; `costCents` is the exact charge.
+
+## Fine-grained control
+
+```ts
+const job = await client.images.generate("...", { tier: "max_pro", wait: false });
+const done = await client.jobs.wait(job.id); // resume any time
+
+await client.tiers();        // live catalog with honest min–max price ranges
+await client.balanceCents(); // prepaid balance
+```
+
+Tiers: `air` | `lite` | `premium` | `pro` | `max_pro` — see [corent.tech/pricing](https://corent.tech/pricing). Docs: [corent.tech/docs](https://corent.tech/docs). MCP server for agents: [`corent-mcp`](https://www.npmjs.com/package/corent-mcp).

package/dist/index.cjs

@@ -0,0 +1,260 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Corent: () => Corent,
+  CorentError: () => CorentError,
+  GenerationFailedError: () => GenerationFailedError,
+  InsufficientBalanceError: () => InsufficientBalanceError,
+  InvalidRequestError: () => InvalidRequestError,
+  RateLimitedError: () => RateLimitedError
+});
+module.exports = __toCommonJS(index_exports);
+var DEFAULT_BASE_URL = "https://api.corent.tech";
+var MAX_RETRIES = 3;
+var POLL_INTERVAL_MS = 3e3;
+var DEFAULT_WAIT_TIMEOUT_MS = 9e5;
+var CorentError = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "CorentError";
+  }
+  statusCode;
+};
+var InvalidRequestError = class extends CorentError {
+  name = "InvalidRequestError";
+};
+var InsufficientBalanceError = class extends CorentError {
+  name = "InsufficientBalanceError";
+};
+var RateLimitedError = class extends CorentError {
+  name = "RateLimitedError";
+};
+var GenerationFailedError = class extends CorentError {
+  name = "GenerationFailedError";
+};
+var Corent = class {
+  baseUrl;
+  apiKey;
+  fetchFn;
+  images;
+  videos;
+  speech;
+  jobs;
+  constructor(apiKey, options = {}) {
+    this.apiKey = apiKey;
+    this.baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+    this.fetchFn = options.fetch ?? fetch;
+    this.images = new Images(this);
+    this.videos = new Videos(this);
+    this.speech = new Speech(this);
+    this.jobs = new Jobs(this);
+  }
+  /** Prepaid balance in cents. */
+  async balanceCents() {
+    const r = await this.request("GET", "/v1/account/balance");
+    return r.balance_cents;
+  }
+  /** The live tier catalog with honest min–max price ranges. Public. */
+  async tiers() {
+    const r = await this.request("GET", "/v1/tiers");
+    return r.tiers;
+  }
+  /** @internal */
+  async request(method, path, body, idempotent = false) {
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      "User-Agent": "corent-js/0.1.0"
+    };
+    if (body) headers["Content-Type"] = "application/json";
+    if (idempotent) headers["Idempotency-Key"] = crypto.randomUUID();
+    let lastError;
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      let resp;
+      try {
+        resp = await this.fetchFn(`${this.baseUrl}${path}`, {
+          method,
+          headers,
+          body: body ? JSON.stringify(body) : void 0
+        });
+      } catch (err) {
+        lastError = err;
+        await sleep(Math.min(2 ** attempt * 1e3, 8e3));
+        continue;
+      }
+      if (resp.status < 400) return await resp.json();
+      if (resp.status === 429) {
+        const retryAfter = Number(resp.headers.get("Retry-After") ?? 2 ** (attempt + 1));
+        if (attempt < MAX_RETRIES) {
+          await sleep(Math.min(retryAfter * 1e3, 3e4));
+          continue;
+        }
+        throw new RateLimitedError("rate limited", 429);
+      }
+      if ((resp.status === 502 || resp.status === 503) && attempt < MAX_RETRIES) {
+        await sleep(Math.min(2 ** (attempt + 1) * 1e3, 8e3));
+        continue;
+      }
+      throw await errorFor(resp);
+    }
+    throw new CorentError(`request failed after ${MAX_RETRIES} retries: ${lastError}`);
+  }
+  /** @internal */
+  async waitForJob(jobId, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      const job = await this.request("GET", `/v1/jobs/${jobId}`);
+      if (job.status === "completed") return job;
+      if (job.status === "failed") {
+        throw new GenerationFailedError(job.error ?? "generation_failed");
+      }
+      await sleep(POLL_INTERVAL_MS);
+    }
+    throw new CorentError(
+      `job ${jobId} still processing after ${Math.round(timeoutMs / 1e3)}s; poll client.jobs.get("${jobId}") to resume`
+    );
+  }
+};
+var Images = class {
+  constructor(c) {
+    this.c = c;
+  }
+  c;
+  /** Render an image. Submits as a background job and polls, so a client
+   * timeout can never lose a finished render. Pass wait:false for the Job. */
+  async generate(prompt, options = {}) {
+    const body = {
+      prompt,
+      aspect_ratio: options.aspectRatio ?? "1:1",
+      async: true
+    };
+    if (options.tier) body.tier = options.tier;
+    if (options.style) body.style = options.style;
+    const submitted = await this.c.request("POST", "/v1/images/generate", body, true);
+    if (submitted.status === "completed") return imageFromJob(submitted);
+    if (options.wait === false) {
+      return { id: submitted.id, status: submitted.status, raw: submitted };
+    }
+    return imageFromJob(await this.c.waitForJob(submitted.id, options.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS));
+  }
+};
+var Videos = class {
+  constructor(c) {
+    this.c = c;
+  }
+  c;
+  /** Render a video (1–5 minutes typical). resolution: 720p | 1080p | 4k —
+   * tier-capped, clamped down rather than rejected. imageUrl animates an
+   * existing image (image-to-video). */
+  async generate(prompt, options = {}) {
+    const body = {
+      prompt,
+      aspect_ratio: options.aspectRatio ?? "16:9"
+    };
+    if (options.tier) body.tier = options.tier;
+    if (options.durationS !== void 0) body.duration_s = options.durationS;
+    if (options.resolution) body.resolution = options.resolution;
+    if (options.imageUrl) body.image_url = options.imageUrl;
+    const submitted = await this.c.request("POST", "/v1/videos/generate", body, true);
+    if (options.wait === false) {
+      return { id: submitted.id, status: submitted.status, raw: submitted };
+    }
+    return videoFromJob(await this.c.waitForJob(submitted.id, options.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS));
+  }
+};
+var Speech = class {
+  constructor(c) {
+    this.c = c;
+  }
+  c;
+  /** Text to speech; synchronous, returns the finished audio and exact charge. */
+  async generate(text, options = {}) {
+    const body = { text };
+    if (options.voiceId) body.voice_id = options.voiceId;
+    const r = await this.c.request("POST", "/v1/audio/speech", body, true);
+    const meta = r.meta ?? {};
+    return { id: r.id, url: r.audio_url, model: meta.model, costCents: meta.cost_cents };
+  }
+};
+var Jobs = class {
+  constructor(c) {
+    this.c = c;
+  }
+  c;
+  async get(jobId) {
+    const raw = await this.c.request("GET", `/v1/jobs/${jobId}`);
+    return { id: raw.id, status: raw.status, raw };
+  }
+  async wait(jobId, timeoutMs = DEFAULT_WAIT_TIMEOUT_MS) {
+    const raw = await this.c.waitForJob(jobId, timeoutMs);
+    return { id: raw.id, status: raw.status, raw };
+  }
+};
+async function errorFor(resp) {
+  let message;
+  try {
+    const parsed = await resp.json();
+    message = typeof parsed.detail === "string" ? parsed.detail : JSON.stringify(parsed.detail ?? parsed);
+  } catch {
+    message = `HTTP ${resp.status}`;
+  }
+  if (resp.status === 402) return new InsufficientBalanceError(message, 402);
+  if (resp.status === 400 || resp.status === 422) return new InvalidRequestError(message, resp.status);
+  return new CorentError(message, resp.status);
+}
+function imageFromJob(job) {
+  const image = (job.images ?? [{}])[0];
+  const meta = job.meta ?? {};
+  return {
+    id: job.id,
+    url: image.url,
+    width: image.width,
+    height: image.height,
+    model: meta.model,
+    costCents: meta.cost_cents
+  };
+}
+function videoFromJob(job) {
+  const video = (job.videos ?? [{}])[0];
+  const meta = job.meta ?? {};
+  return {
+    id: job.id,
+    url: video.url,
+    width: video.width,
+    height: video.height,
+    resolution: video.resolution,
+    durationS: video.duration_s,
+    model: meta.model,
+    costCents: meta.cost_cents
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Corent,
+  CorentError,
+  GenerationFailedError,
+  InsufficientBalanceError,
+  InvalidRequestError,
+  RateLimitedError
+});

package/dist/index.d.cts

@@ -0,0 +1,125 @@
+/**
+ * Corent TypeScript SDK — one API for AI image, video, and voice.
+ *
+ *   import { Corent } from "corent-sdk";
+ *   const client = new Corent("co_live_...");
+ *   const image = await client.images.generate("a lighthouse", { tier: "premium" });
+ *
+ * What it handles for you: auth, auto idempotency keys (retries can never
+ * double-charge), 429/5xx backoff, and job polling. Images submit as
+ * background jobs so a network timeout can never lose a finished render.
+ */
+type Tier = "air" | "lite" | "premium" | "pro" | "max_pro";
+interface GeneratedImage {
+    id: string;
+    url: string;
+    /** MEASURED pixels of the delivered file — Corent parses the file, never echoes the request. */
+    width?: number;
+    height?: number;
+    model?: string;
+    costCents?: number;
+}
+interface GeneratedVideo {
+    id: string;
+    url: string;
+    width?: number;
+    height?: number;
+    resolution?: string;
+    durationS?: number;
+    model?: string;
+    costCents?: number;
+}
+interface GeneratedSpeech {
+    id: string;
+    url: string;
+    model?: string;
+    costCents?: number;
+}
+interface Job {
+    id: string;
+    status: "processing" | "completed" | "failed";
+    raw: Record<string, unknown>;
+}
+declare class CorentError extends Error {
+    statusCode?: number;
+    constructor(message: string, statusCode?: number);
+}
+declare class InvalidRequestError extends CorentError {
+    name: string;
+}
+declare class InsufficientBalanceError extends CorentError {
+    name: string;
+}
+declare class RateLimitedError extends CorentError {
+    name: string;
+}
+declare class GenerationFailedError extends CorentError {
+    name: string;
+}
+interface ClientOptions {
+    baseUrl?: string;
+    fetch?: typeof fetch;
+}
+declare class Corent {
+    private baseUrl;
+    private apiKey;
+    private fetchFn;
+    readonly images: Images;
+    readonly videos: Videos;
+    readonly speech: Speech;
+    readonly jobs: Jobs;
+    constructor(apiKey: string, options?: ClientOptions);
+    /** Prepaid balance in cents. */
+    balanceCents(): Promise<number>;
+    /** The live tier catalog with honest min–max price ranges. Public. */
+    tiers(): Promise<Record<string, unknown>[]>;
+    /** @internal */
+    request(method: string, path: string, body?: Record<string, unknown>, idempotent?: boolean): Promise<Record<string, any>>;
+    /** @internal */
+    waitForJob(jobId: string, timeoutMs: number): Promise<Record<string, any>>;
+}
+declare class Images {
+    private c;
+    constructor(c: Corent);
+    /** Render an image. Submits as a background job and polls, so a client
+     * timeout can never lose a finished render. Pass wait:false for the Job. */
+    generate(prompt: string, options?: {
+        tier?: Tier;
+        style?: string;
+        aspectRatio?: string;
+        wait?: false | true;
+        timeoutMs?: number;
+    }): Promise<GeneratedImage | Job>;
+}
+declare class Videos {
+    private c;
+    constructor(c: Corent);
+    /** Render a video (1–5 minutes typical). resolution: 720p | 1080p | 4k —
+     * tier-capped, clamped down rather than rejected. imageUrl animates an
+     * existing image (image-to-video). */
+    generate(prompt: string, options?: {
+        tier?: Tier;
+        aspectRatio?: string;
+        durationS?: number;
+        resolution?: "720p" | "1080p" | "4k";
+        imageUrl?: string;
+        wait?: false | true;
+        timeoutMs?: number;
+    }): Promise<GeneratedVideo | Job>;
+}
+declare class Speech {
+    private c;
+    constructor(c: Corent);
+    /** Text to speech; synchronous, returns the finished audio and exact charge. */
+    generate(text: string, options?: {
+        voiceId?: string;
+    }): Promise<GeneratedSpeech>;
+}
+declare class Jobs {
+    private c;
+    constructor(c: Corent);
+    get(jobId: string): Promise<Job>;
+    wait(jobId: string, timeoutMs?: number): Promise<Job>;
+}
+
+export { Corent, CorentError, type GeneratedImage, type GeneratedSpeech, type GeneratedVideo, GenerationFailedError, InsufficientBalanceError, InvalidRequestError, type Job, RateLimitedError, type Tier };

package/dist/index.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Corent TypeScript SDK — one API for AI image, video, and voice.
+ *
+ *   import { Corent } from "corent-sdk";
+ *   const client = new Corent("co_live_...");
+ *   const image = await client.images.generate("a lighthouse", { tier: "premium" });
+ *
+ * What it handles for you: auth, auto idempotency keys (retries can never
+ * double-charge), 429/5xx backoff, and job polling. Images submit as
+ * background jobs so a network timeout can never lose a finished render.
+ */
+type Tier = "air" | "lite" | "premium" | "pro" | "max_pro";
+interface GeneratedImage {
+    id: string;
+    url: string;
+    /** MEASURED pixels of the delivered file — Corent parses the file, never echoes the request. */
+    width?: number;
+    height?: number;
+    model?: string;
+    costCents?: number;
+}
+interface GeneratedVideo {
+    id: string;
+    url: string;
+    width?: number;
+    height?: number;
+    resolution?: string;
+    durationS?: number;
+    model?: string;
+    costCents?: number;
+}
+interface GeneratedSpeech {
+    id: string;
+    url: string;
+    model?: string;
+    costCents?: number;
+}
+interface Job {
+    id: string;
+    status: "processing" | "completed" | "failed";
+    raw: Record<string, unknown>;
+}
+declare class CorentError extends Error {
+    statusCode?: number;
+    constructor(message: string, statusCode?: number);
+}
+declare class InvalidRequestError extends CorentError {
+    name: string;
+}
+declare class InsufficientBalanceError extends CorentError {
+    name: string;
+}
+declare class RateLimitedError extends CorentError {
+    name: string;
+}
+declare class GenerationFailedError extends CorentError {
+    name: string;
+}
+interface ClientOptions {
+    baseUrl?: string;
+    fetch?: typeof fetch;
+}
+declare class Corent {
+    private baseUrl;
+    private apiKey;
+    private fetchFn;
+    readonly images: Images;
+    readonly videos: Videos;
+    readonly speech: Speech;
+    readonly jobs: Jobs;
+    constructor(apiKey: string, options?: ClientOptions);
+    /** Prepaid balance in cents. */
+    balanceCents(): Promise<number>;
+    /** The live tier catalog with honest min–max price ranges. Public. */
+    tiers(): Promise<Record<string, unknown>[]>;
+    /** @internal */
+    request(method: string, path: string, body?: Record<string, unknown>, idempotent?: boolean): Promise<Record<string, any>>;
+    /** @internal */
+    waitForJob(jobId: string, timeoutMs: number): Promise<Record<string, any>>;
+}
+declare class Images {
+    private c;
+    constructor(c: Corent);
+    /** Render an image. Submits as a background job and polls, so a client
+     * timeout can never lose a finished render. Pass wait:false for the Job. */
+    generate(prompt: string, options?: {
+        tier?: Tier;
+        style?: string;
+        aspectRatio?: string;
+        wait?: false | true;
+        timeoutMs?: number;
+    }): Promise<GeneratedImage | Job>;
+}
+declare class Videos {
+    private c;
+    constructor(c: Corent);
+    /** Render a video (1–5 minutes typical). resolution: 720p | 1080p | 4k —
+     * tier-capped, clamped down rather than rejected. imageUrl animates an
+     * existing image (image-to-video). */
+    generate(prompt: string, options?: {
+        tier?: Tier;
+        aspectRatio?: string;
+        durationS?: number;
+        resolution?: "720p" | "1080p" | "4k";
+        imageUrl?: string;
+        wait?: false | true;
+        timeoutMs?: number;
+    }): Promise<GeneratedVideo | Job>;
+}
+declare class Speech {
+    private c;
+    constructor(c: Corent);
+    /** Text to speech; synchronous, returns the finished audio and exact charge. */
+    generate(text: string, options?: {
+        voiceId?: string;
+    }): Promise<GeneratedSpeech>;
+}
+declare class Jobs {
+    private c;
+    constructor(c: Corent);
+    get(jobId: string): Promise<Job>;
+    wait(jobId: string, timeoutMs?: number): Promise<Job>;
+}
+
+export { Corent, CorentError, type GeneratedImage, type GeneratedSpeech, type GeneratedVideo, GenerationFailedError, InsufficientBalanceError, InvalidRequestError, type Job, RateLimitedError, type Tier };

package/dist/index.js

@@ -0,0 +1,231 @@
+// src/index.ts
+var DEFAULT_BASE_URL = "https://api.corent.tech";
+var MAX_RETRIES = 3;
+var POLL_INTERVAL_MS = 3e3;
+var DEFAULT_WAIT_TIMEOUT_MS = 9e5;
+var CorentError = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "CorentError";
+  }
+  statusCode;
+};
+var InvalidRequestError = class extends CorentError {
+  name = "InvalidRequestError";
+};
+var InsufficientBalanceError = class extends CorentError {
+  name = "InsufficientBalanceError";
+};
+var RateLimitedError = class extends CorentError {
+  name = "RateLimitedError";
+};
+var GenerationFailedError = class extends CorentError {
+  name = "GenerationFailedError";
+};
+var Corent = class {
+  baseUrl;
+  apiKey;
+  fetchFn;
+  images;
+  videos;
+  speech;
+  jobs;
+  constructor(apiKey, options = {}) {
+    this.apiKey = apiKey;
+    this.baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+    this.fetchFn = options.fetch ?? fetch;
+    this.images = new Images(this);
+    this.videos = new Videos(this);
+    this.speech = new Speech(this);
+    this.jobs = new Jobs(this);
+  }
+  /** Prepaid balance in cents. */
+  async balanceCents() {
+    const r = await this.request("GET", "/v1/account/balance");
+    return r.balance_cents;
+  }
+  /** The live tier catalog with honest min–max price ranges. Public. */
+  async tiers() {
+    const r = await this.request("GET", "/v1/tiers");
+    return r.tiers;
+  }
+  /** @internal */
+  async request(method, path, body, idempotent = false) {
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      "User-Agent": "corent-js/0.1.0"
+    };
+    if (body) headers["Content-Type"] = "application/json";
+    if (idempotent) headers["Idempotency-Key"] = crypto.randomUUID();
+    let lastError;
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      let resp;
+      try {
+        resp = await this.fetchFn(`${this.baseUrl}${path}`, {
+          method,
+          headers,
+          body: body ? JSON.stringify(body) : void 0
+        });
+      } catch (err) {
+        lastError = err;
+        await sleep(Math.min(2 ** attempt * 1e3, 8e3));
+        continue;
+      }
+      if (resp.status < 400) return await resp.json();
+      if (resp.status === 429) {
+        const retryAfter = Number(resp.headers.get("Retry-After") ?? 2 ** (attempt + 1));
+        if (attempt < MAX_RETRIES) {
+          await sleep(Math.min(retryAfter * 1e3, 3e4));
+          continue;
+        }
+        throw new RateLimitedError("rate limited", 429);
+      }
+      if ((resp.status === 502 || resp.status === 503) && attempt < MAX_RETRIES) {
+        await sleep(Math.min(2 ** (attempt + 1) * 1e3, 8e3));
+        continue;
+      }
+      throw await errorFor(resp);
+    }
+    throw new CorentError(`request failed after ${MAX_RETRIES} retries: ${lastError}`);
+  }
+  /** @internal */
+  async waitForJob(jobId, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      const job = await this.request("GET", `/v1/jobs/${jobId}`);
+      if (job.status === "completed") return job;
+      if (job.status === "failed") {
+        throw new GenerationFailedError(job.error ?? "generation_failed");
+      }
+      await sleep(POLL_INTERVAL_MS);
+    }
+    throw new CorentError(
+      `job ${jobId} still processing after ${Math.round(timeoutMs / 1e3)}s; poll client.jobs.get("${jobId}") to resume`
+    );
+  }
+};
+var Images = class {
+  constructor(c) {
+    this.c = c;
+  }
+  c;
+  /** Render an image. Submits as a background job and polls, so a client
+   * timeout can never lose a finished render. Pass wait:false for the Job. */
+  async generate(prompt, options = {}) {
+    const body = {
+      prompt,
+      aspect_ratio: options.aspectRatio ?? "1:1",
+      async: true
+    };
+    if (options.tier) body.tier = options.tier;
+    if (options.style) body.style = options.style;
+    const submitted = await this.c.request("POST", "/v1/images/generate", body, true);
+    if (submitted.status === "completed") return imageFromJob(submitted);
+    if (options.wait === false) {
+      return { id: submitted.id, status: submitted.status, raw: submitted };
+    }
+    return imageFromJob(await this.c.waitForJob(submitted.id, options.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS));
+  }
+};
+var Videos = class {
+  constructor(c) {
+    this.c = c;
+  }
+  c;
+  /** Render a video (1–5 minutes typical). resolution: 720p | 1080p | 4k —
+   * tier-capped, clamped down rather than rejected. imageUrl animates an
+   * existing image (image-to-video). */
+  async generate(prompt, options = {}) {
+    const body = {
+      prompt,
+      aspect_ratio: options.aspectRatio ?? "16:9"
+    };
+    if (options.tier) body.tier = options.tier;
+    if (options.durationS !== void 0) body.duration_s = options.durationS;
+    if (options.resolution) body.resolution = options.resolution;
+    if (options.imageUrl) body.image_url = options.imageUrl;
+    const submitted = await this.c.request("POST", "/v1/videos/generate", body, true);
+    if (options.wait === false) {
+      return { id: submitted.id, status: submitted.status, raw: submitted };
+    }
+    return videoFromJob(await this.c.waitForJob(submitted.id, options.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS));
+  }
+};
+var Speech = class {
+  constructor(c) {
+    this.c = c;
+  }
+  c;
+  /** Text to speech; synchronous, returns the finished audio and exact charge. */
+  async generate(text, options = {}) {
+    const body = { text };
+    if (options.voiceId) body.voice_id = options.voiceId;
+    const r = await this.c.request("POST", "/v1/audio/speech", body, true);
+    const meta = r.meta ?? {};
+    return { id: r.id, url: r.audio_url, model: meta.model, costCents: meta.cost_cents };
+  }
+};
+var Jobs = class {
+  constructor(c) {
+    this.c = c;
+  }
+  c;
+  async get(jobId) {
+    const raw = await this.c.request("GET", `/v1/jobs/${jobId}`);
+    return { id: raw.id, status: raw.status, raw };
+  }
+  async wait(jobId, timeoutMs = DEFAULT_WAIT_TIMEOUT_MS) {
+    const raw = await this.c.waitForJob(jobId, timeoutMs);
+    return { id: raw.id, status: raw.status, raw };
+  }
+};
+async function errorFor(resp) {
+  let message;
+  try {
+    const parsed = await resp.json();
+    message = typeof parsed.detail === "string" ? parsed.detail : JSON.stringify(parsed.detail ?? parsed);
+  } catch {
+    message = `HTTP ${resp.status}`;
+  }
+  if (resp.status === 402) return new InsufficientBalanceError(message, 402);
+  if (resp.status === 400 || resp.status === 422) return new InvalidRequestError(message, resp.status);
+  return new CorentError(message, resp.status);
+}
+function imageFromJob(job) {
+  const image = (job.images ?? [{}])[0];
+  const meta = job.meta ?? {};
+  return {
+    id: job.id,
+    url: image.url,
+    width: image.width,
+    height: image.height,
+    model: meta.model,
+    costCents: meta.cost_cents
+  };
+}
+function videoFromJob(job) {
+  const video = (job.videos ?? [{}])[0];
+  const meta = job.meta ?? {};
+  return {
+    id: job.id,
+    url: video.url,
+    width: video.width,
+    height: video.height,
+    resolution: video.resolution,
+    durationS: video.duration_s,
+    model: meta.model,
+    costCents: meta.cost_cents
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export {
+  Corent,
+  CorentError,
+  GenerationFailedError,
+  InsufficientBalanceError,
+  InvalidRequestError,
+  RateLimitedError
+};

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "corent-sdk",
+  "version": "0.1.0",
+  "description": "Official TypeScript/JavaScript SDK for Corent — one API for AI image, video, and voice generation with built-in routing, failover, and exact receipts.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": ["dist", "README.md"],
+  "engines": { "node": ">=18" },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "test": "npm run build && node --test test/*.test.js"
+  },
+  "keywords": ["ai", "image-generation", "video-generation", "text-to-speech", "api", "corent"],
+  "homepage": "https://corent.tech/docs",
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0"
+  }
+}