@mynthio/sdk 0.0.1

package/README.md

@@ -0,0 +1,197 @@
+# @mynthio/sdk
+
+Official SDK for the [Mynth](https://mynth.io) AI image generation API.
+
+## Installation
+
+```bash
+// Bun
+bun add @mynthio/sdk
+
+// PNPM
+pnpm add @mynthio/sdk
+
+// NPM
+npm install @mynthio/sdk
+
+// Yarn
+yarn add @mynthio/sdk
+```
+
+## Quick Start
+
+Add `MYNTH_API_KEY` to your environment variables:
+
+```env
+MYNTH_API_KEY=mak_...
+```
+
+Create mynth client. For example inside `/lib`
+
+```typescript
+// lib/mynth.ts
+import Mynth from "@mynthio/sdk";
+
+export const mynth = new Mynth();
+```
+
+Use client to generate images:
+
+```typescript
+import { mynth } from "./lib/mynth";
+
+// Generate an image (by default it waits for completion)
+const task = await mynth.generate({
+  prompt: "A beautiful sunset over mountains",
+  model: "black-forest-labs/flux.1-dev",
+});
+
+console.log(task.result.images);
+```
+
+Under the hood we poll for the status of the task, waiting until it's completed. When it's done, the `Task` instance is returned.
+
+## Async Mode
+
+Sometimes you don't want to wait for the task, and you just want to trigger generation. For example:
+
+- You use webhooks to save data, and you just trigger generation
+- You want to poll for images on client side
+
+```typescript
+import { mynth } from "./lib/mynth";
+
+const taskAsync = await mynth.generate(
+  {
+    prompt: "A futuristic cityscape",
+    model: "black-forest-labs/flux.1-dev",
+  },
+  { mode: "async" },
+);
+
+console.log("Task started:", taskAsync.id);
+
+// If you want to to get the result later, use .toTask()
+const completedTask = await taskAsync.toTask();
+```
+
+Async mode is especially useful for a client side polling. We support public access tokens, and fetching statuses from client side:
+
+```typescript
+import { mynth } from "./lib/mynth";
+
+const taskAsync = await mynth.generate(
+  {
+    prompt: "A futuristic cityscape",
+    model: "black-forest-labs/flux.1-dev",
+  },
+  { mode: "async" },
+);
+
+return {
+  id: taskAsync.id,
+  access: taskAsync.access;
+}
+
+// In frontend:
+// TODO: Do proper example for SWR
+const { data, error, isLoading } = useSWR(`/api/tasks/${response.id}/images`, fetcher, {
+  refreshInterval: 1000 // Poll every 1 second
+  // Token
+})
+```
+
+## Available Models
+
+We provide a helpful object with all supported models, including display names and capabilities so you can use it for validation or generating UIs.
+
+```typescript
+import { AVAILABLE_MODELS } from "@mynthio/sdk";
+
+console.log(AVAILABLE_MODELS);
+// [
+//   {
+//     id: "black-forest-labs/flux.1-dev",
+//     label: "FLUX.1 Dev",
+//     capabilities: ["magic_prompt", "steps"],
+//   },
+//  ...
+```
+
+## Request Options
+
+```typescript
+const task = await mynth.generate({
+  prompt: {
+    positive: "A serene lake at dawn",
+    negative: "people, buildings", // Will be used only if supported by model
+    magic: false, // Default `true`
+  },
+  model: "black-forest-labs/flux.1-dev",
+  size: "landscape", //Default: "auto", Examples: "portrait", "square", "instagram", { width: 1024, height: 768 }
+  count: 1, // Default 1
+  output: {
+    format: "webp", // Default "webp", Examples: "png", "jpg", "webp"
+    quality: 80,
+    upscale: 2, // 2x or 4x upscaling
+  },
+  webhook: {
+    enabled: true, // Setting to false will disable webhooks set in dashboard and webhooks configured as `custom` in request
+    custom: [{ url: "https://your-webhook.com/endpoint" }],
+  },
+  /**
+   * Single level deep metadata you can attach. It will be send with webhook and returned with result.
+   */
+  metadata: {
+    internalGenerationId: "gen_123",
+    userId: "user_...",
+  },
+});
+```
+
+## Convex Integration
+
+The SDK includes a Convex webhook handler for easy integration:
+
+```typescript
+import { mynthWebhookAction } from "@mynthio/sdk/convex";
+
+export const mynthWebhook = mynthWebhookAction({
+  imageTaskCompleted: async (payload, { context }) => {
+    console.log("Image generated:", payload.result.images);
+  },
+});
+```
+
+Set `MYNTH_WEBHOOK_SECRET` in your environment variables.
+
+## Error Handling
+
+```typescript
+import {
+  Mynth,
+  TaskAsyncTimeoutError,
+  TaskAsyncUnauthorizedError,
+  TaskAsyncFetchError,
+} from "@mynthio/sdk";
+
+try {
+  const task = await mynth.generate({ ... });
+} catch (error) {
+  if (error instanceof TaskAsyncTimeoutError) {
+    console.error("Task polling timed out");
+  } else if (error instanceof TaskAsyncUnauthorizedError) {
+    console.error("Invalid API key or access denied");
+  } else if (error instanceof TaskAsyncFetchError) {
+    console.error("Network error while polling task status");
+  }
+}
+```
+
+## Documentation
+
+For full documentation, visit [docs.mynth.io](https://docs.mynth.io).
+
+## License
+
+MIT

package/dist/client.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Error thrown when an API request fails.
+ */
+export declare class MynthAPIError extends Error {
+    /** HTTP status code of the failed request */
+    readonly status: number;
+    /** Error code from the API response, if available */
+    readonly code?: string;
+    constructor(message: string, status: number, code?: string);
+}
+/**
+ * Internal HTTP client for making API requests.
+ * @internal
+ */
+declare class MynthClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    constructor(options: {
+        apiKey: string;
+        baseUrl?: string;
+    });
+    getAuthHeaders(override?: {
+        accessToken?: string;
+    }): {
+        Authorization: string;
+    };
+    getUrl(path: string): string;
+    post<DataType>(path: string, data: unknown): Promise<DataType>;
+    get<DataType>(path: string, { headers, accessToken, }?: {
+        headers?: Record<string, string>;
+        accessToken?: string;
+    }): Promise<{
+        data: DataType;
+        status: number;
+        ok: boolean;
+    }>;
+}
+export { MynthClient };
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,qBAAa,aAAc,SAAQ,KAAK;IACtC,6CAA6C;IAC7C,SAAgB,MAAM,EAAE,MAAM,CAAC;IAC/B,qDAAqD;IACrD,SAAgB,IAAI,CAAC,EAAE,MAAM,CAAC;gBAElB,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM;CAM3D;AAQD;;;GAGG;AACH,cAAM,WAAW;IACf,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;gBAErB,OAAO,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE;IASzD,cAAc,CAAC,QAAQ,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE;;;IAMlD,MAAM,CAAC,IAAI,EAAE,MAAM;IAIN,IAAI,CAAC,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC;IAwB9D,GAAG,CAAC,QAAQ,EACvB,IAAI,EAAE,MAAM,EACZ,EACE,OAAO,EACP,WAAW,GACZ,GAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAO,GACjE,OAAO,CAAC;QAAE,IAAI,EAAE,QAAQ,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,OAAO,CAAA;KAAE,CAAC;CAY5D;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/constants.d.ts

@@ -0,0 +1,32 @@
+/** Base URL for the Mynth API */
+export declare const API_URL = "https://api.mynth.io";
+/** Environment variable name for the API key */
+export declare const API_KEY_ENV_VAR = "MYNTH_API_KEY";
+export declare const GENERATE_IMAGE_PATH = "/image/generate";
+export declare const TASK_PATH = "/tasks";
+export declare const TASK_DETAILS_PATH: (id: string) => string;
+export declare const TASK_STATUS_PATH: (id: string) => string;
+/**
+ * Model capabilities that affect available generation options.
+ * - `magic_prompt`: Supports automatic prompt enhancement
+ * - `negative_prompt`: Supports negative prompts to exclude elements
+ * - `steps`: Supports custom inference step count
+ */
+export type ModelCapability = "magic_prompt" | "negative_prompt" | "steps";
+/**
+ * Information about an available image generation model.
+ */
+export type AvailableModel = {
+    /** Unique model identifier used in API requests */
+    id: string;
+    /** Human-readable display name */
+    label: string;
+    /** List of supported capabilities */
+    capabilities: readonly ModelCapability[];
+};
+/**
+ * List of all available image generation models with their capabilities.
+ * Use this to build model selectors or validate model IDs.
+ */
+export declare const AVAILABLE_MODELS: readonly AvailableModel[];
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,iCAAiC;AACjC,eAAO,MAAM,OAAO,yBAAyB,CAAC;AAE9C,gDAAgD;AAChD,eAAO,MAAM,eAAe,kBAAkB,CAAC;AAE/C,eAAO,MAAM,mBAAmB,oBAAoB,CAAC;AACrD,eAAO,MAAM,SAAS,WAAW,CAAC;AAClC,eAAO,MAAM,iBAAiB,GAAI,IAAI,MAAM,WAAyB,CAAC;AACtE,eAAO,MAAM,gBAAgB,GAAI,IAAI,MAAM,WAAgC,CAAC;AAE5E;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG,cAAc,GAAG,iBAAiB,GAAG,OAAO,CAAC;AAE3E;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,mDAAmD;IACnD,EAAE,EAAE,MAAM,CAAC;IACX,kCAAkC;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,qCAAqC;IACrC,YAAY,EAAE,SAAS,eAAe,EAAE,CAAC;CAC1C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,SAAS,cAAc,EA8CrD,CAAC"}

package/dist/convex/index.d.ts

@@ -0,0 +1,51 @@
+import type { GenericActionCtx } from "convex/server";
+import type { MynthSDKTypes } from "../types";
+/**
+ * Event handlers for Mynth webhook events.
+ */
+export type EventHandlers<T extends GenericActionCtx<any> = GenericActionCtx<any>> = {
+    /** Called when an image generation task completes successfully */
+    imageTaskCompleted?: (payload: MynthSDKTypes.WebhookTaskImageCompletedPayload, context: {
+        context: T;
+        request: Request;
+    }) => Promise<void>;
+    /** Called when an image generation task fails */
+    imageTaskFailed?: (payload: MynthSDKTypes.WebhookTaskImageFailedPayload, context: {
+        context: T;
+        request: Request;
+    }) => Promise<void>;
+};
+/**
+ * Options for configuring the webhook action.
+ */
+export type MynthWebhookActionOptions = {
+    /** Webhook secret for signature verification. Defaults to MYNTH_WEBHOOK_SECRET env var. */
+    webhookSecret?: string;
+};
+/**
+ * Creates a Convex HTTP action handler for Mynth webhooks.
+ *
+ * @param eventHandlers - Handlers for different webhook events
+ * @param options - Configuration options
+ * @returns A Convex HTTP action handler
+ *
+ * @example
+ * ```typescript
+ * // In convex/http.ts
+ * import { mynthWebhookAction } from "@mynthio/sdk/convex";
+ *
+ * export const mynthWebhook = mynthWebhookAction({
+ *   imageTaskCompleted: async (payload, { context }) => {
+ *     await context.runMutation(internal.images.save, {
+ *       taskId: payload.task.id,
+ *       images: payload.result.images,
+ *     });
+ *   },
+ *   imageTaskFailed: async (payload, { context }) => {
+ *     console.error("Task failed:", payload.errors);
+ *   },
+ * });
+ * ```
+ */
+export declare const mynthWebhookAction: (eventHandlers: EventHandlers, options?: MynthWebhookActionOptions) => (ctx: GenericActionCtx<any>, request: Request) => Promise<Response>;
+//# sourceMappingURL=index.d.ts.map

package/dist/convex/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/convex/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAO9C;;GAEG;AAEH,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,gBAAgB,CAAC,GAAG,CAAC,GAAG,gBAAgB,CAAC,GAAG,CAAC,IAAI;IACnF,kEAAkE;IAClE,kBAAkB,CAAC,EAAE,CACnB,OAAO,EAAE,aAAa,CAAC,gCAAgC,EACvD,OAAO,EAAE;QAAE,OAAO,EAAE,CAAC,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,KACtC,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,iDAAiD;IACjD,eAAe,CAAC,EAAE,CAChB,OAAO,EAAE,aAAa,CAAC,6BAA6B,EACpD,OAAO,EAAE;QAAE,OAAO,EAAE,CAAC,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,KACtC,OAAO,CAAC,IAAI,CAAC,CAAC;CACpB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,yBAAyB,GAAG;IACtC,2FAA2F;IAC3F,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,kBAAkB,GAC7B,eAAe,aAAa,EAC5B,UAAU,yBAAyB,MAcjC,KAAK,gBAAgB,CAAC,GAAG,CAAC,EAC1B,SAAS,OAAO,KACf,OAAO,CAAC,QAAQ,CAyCpB,CAAC"}

package/dist/convex/index.js

@@ -0,0 +1,2 @@
+// @bun
+var $=()=>{if(typeof process<"u"&&process.env)return process.env.MYNTH_WEBHOOK_SECRET;return};function I(J){let L=J.split(","),z,j;for(let M of L){let[P,Q]=M.split("=");if(P==="t")z=Q;else if(P==="v1")j=Q}if(!z||!j)return null;return{timestamp:z,signature:j}}async function C(J,L,z){let j=I(L);if(!j)return!1;let{timestamp:M,signature:P}=j,Q=`${M}.${J}`,X=new TextEncoder,Z=await crypto.subtle.importKey("raw",X.encode(z),{name:"HMAC",hash:"SHA-256"},!1,["sign"]),Y=await crypto.subtle.sign("HMAC",Z,X.encode(Q)),F=U(new Uint8Array(Y));return V(F,P)}function U(J){let L="";for(let z of J)L+=z.toString(16).padStart(2,"0");return L}function V(J,L){if(J.length!==L.length)return!1;let z=0;for(let j=0;j<J.length;j++)z|=J.charCodeAt(j)^L.charCodeAt(j);return z===0}var B="X-Mynth-Event",D="X-Mynth-Signature",N=(J,L)=>{let z=L?.webhookSecret??$();if(!z)throw Error("MYNTH_WEBHOOK_SECRET is required. Either pass it as an option or set the environment variable.");return async(j,M)=>{let P=M.headers.get(D);if(!P)return new Response("Unauthorized",{status:401});if(!M.headers.get(B))return new Response("Unauthorized",{status:401});let X=await M.text();if(!await C(X,P,z))return new Response("Unauthorized",{status:401});let Y=JSON.parse(X);switch(Y.event){case"task.image.completed":await J.imageTaskCompleted?.(Y,{context:j,request:M});break;case"task.image.failed":await J.imageTaskFailed?.(Y,{context:j,request:M});break;default:return new Response("Unauthorized",{status:401})}return new Response(void 0,{status:200})}};export{N as mynthWebhookAction};

package/dist/convex/utils.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Attempts to read the webhook secret from environment variables.
+ * @internal
+ */
+export declare const tryToGetWebhookSecretFromEnv: () => string | undefined;
+/**
+ * Verifies the HMAC-SHA256 signature of a webhook payload.
+ * Uses timing-safe comparison to prevent timing attacks.
+ *
+ * @param body - The raw request body
+ * @param signatureHeader - The X-Mynth-Signature header value
+ * @param secret - The webhook secret
+ * @returns True if the signature is valid
+ * @internal
+ */
+export declare function verifySignature(body: string, signatureHeader: string, secret: string): Promise<boolean>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/convex/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/convex/utils.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,eAAO,MAAM,4BAA4B,QAAO,MAAM,GAAG,SAKxD,CAAC;AA8BF;;;;;;;;;GASG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,MAAM,EACZ,eAAe,EAAE,MAAM,EACvB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,OAAO,CAAC,CAyBlB"}

package/dist/index.d.ts

@@ -0,0 +1,135 @@
+import { MynthAPIError } from "./client";
+import type { AvailableModel, ModelCapability } from "./constants";
+import { AVAILABLE_MODELS } from "./constants";
+import type { Task } from "./task";
+import type { TaskAsyncAccess } from "./task-async";
+import { TaskAsync, TaskAsyncFetchError, TaskAsyncTaskFailedError, TaskAsyncTaskFetchError, TaskAsyncTimeoutError, TaskAsyncUnauthorizedError } from "./task-async";
+import type { MynthSDKTypes } from "./types";
+/**
+ * Options for the generate method.
+ */
+type GenerateOptions = {
+    /** Whether to wait for completion ("sync") or return immediately ("async") */
+    mode?: "sync" | "async";
+};
+/**
+ * Configuration options for the Mynth client.
+ */
+type MynthOptions = {
+    /**
+     * Your Mynth API key. If not provided, reads from MYNTH_API_KEY environment variable.
+     */
+    apiKey?: string;
+    /**
+     * Custom base URL for the API. Useful for proxies or testing.
+     */
+    baseUrl?: string;
+};
+type ExtractMetadata<T extends MynthSDKTypes.ImageGenerationRequest> = T["metadata"];
+type ExtractContentRatingConfig<T extends MynthSDKTypes.ImageGenerationRequest> = T["content_rating"];
+type ExtractContentRatingLevels<T extends MynthSDKTypes.ImageGenerationRequest> = ExtractContentRatingConfig<T> extends {
+    levels: readonly (infer L)[];
+} ? L : ExtractContentRatingConfig<T> extends {
+    levels: (infer L)[];
+} ? L : never;
+type ExtractContentRatingLevelValues<T extends MynthSDKTypes.ImageGenerationRequest> = ExtractContentRatingLevels<T> extends {
+    value: infer V;
+} ? V extends string ? V : never : never;
+type IsContentRatingCustom<T extends MynthSDKTypes.ImageGenerationRequest> = ExtractContentRatingConfig<T> extends {
+    levels: readonly any[] | any[];
+} ? true : false;
+type ExtractContentRatingResponse<T extends MynthSDKTypes.ImageGenerationRequest> = IsContentRatingCustom<T> extends true ? {
+    mode: "custom";
+    level: ExtractContentRatingLevelValues<T>;
+} : ExtractContentRatingConfig<T> extends {
+    enabled?: true;
+} ? {
+    mode: "default";
+    level: MynthSDKTypes.ImageResultContentRatingDefaultLevel;
+} : MynthSDKTypes.ImageResultContentRating | undefined;
+/**
+ * Main client for interacting with the Mynth image generation API.
+ *
+ * @example
+ * ```typescript
+ * // Using environment variable (MYNTH_API_KEY)
+ * const mynth = new Mynth();
+ *
+ * // Or with explicit API key
+ * const mynth = new Mynth({ apiKey: "mak_..." });
+ *
+ * // Generate an image
+ * const task = await mynth.generate({
+ *   prompt: "A beautiful sunset over mountains",
+ *   model: "black-forest-labs/flux.1-dev",
+ * });
+ *
+ * console.log(task.urls); // ["https://..."]
+ * ```
+ */
+declare class Mynth {
+    private readonly client;
+    /**
+     * Creates a new Mynth client instance.
+     *
+     * @param options - Configuration options
+     * @param options.apiKey - Your API key (defaults to MYNTH_API_KEY env var)
+     * @param options.baseUrl - Custom API base URL
+     * @throws {Error} If no API key is provided and MYNTH_API_KEY is not set
+     */
+    constructor(options?: MynthOptions);
+    /**
+     * Generate images from a text prompt.
+     *
+     * @param request - Image generation request parameters
+     * @returns A completed Task with the generation results
+     *
+     * @example
+     * ```typescript
+     * const task = await mynth.generate({
+     *   prompt: "A serene lake at dawn",
+     *   model: "black-forest-labs/flux.1-dev",
+     * });
+     * console.log(task.urls);
+     * ```
+     */
+    generate<const T extends MynthSDKTypes.ImageGenerationRequest>(request: T): Promise<Task<ExtractMetadata<T>, ExtractContentRatingResponse<T>>>;
+    /**
+     * Generate images asynchronously without waiting for completion.
+     *
+     * @param request - Image generation request parameters
+     * @param opts - Options with mode set to "async"
+     * @returns A TaskAsync that can be polled for completion
+     *
+     * @example
+     * ```typescript
+     * const taskAsync = await mynth.generate(
+     *   { prompt: "A futuristic cityscape" },
+     *   { mode: "async" }
+     * );
+     *
+     * // Return task ID for client-side polling
+     * return { id: taskAsync.id, access: taskAsync.access };
+     *
+     * // Or wait for completion later
+     * const task = await taskAsync.toTask();
+     * ```
+     */
+    generate<const T extends MynthSDKTypes.ImageGenerationRequest>(request: T, opts: {
+        mode: "async";
+    }): Promise<TaskAsync<ExtractMetadata<T>, ExtractContentRatingResponse<T>>>;
+    /**
+     * Generate images synchronously, waiting for completion.
+     *
+     * @param request - Image generation request parameters
+     * @param opts - Options with mode set to "sync"
+     * @returns A completed Task with the generation results
+     */
+    generate<const T extends MynthSDKTypes.ImageGenerationRequest>(request: T, opts: {
+        mode: "sync";
+    }): Promise<Task<ExtractMetadata<T>, ExtractContentRatingResponse<T>>>;
+}
+export { Mynth, AVAILABLE_MODELS, MynthAPIError, TaskAsyncTimeoutError, TaskAsyncUnauthorizedError, TaskAsyncFetchError, TaskAsyncTaskFetchError, TaskAsyncTaskFailedError, };
+export type { MynthSDKTypes, MynthOptions, GenerateOptions, TaskAsyncAccess, AvailableModel, ModelCapability, };
+export default Mynth;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,2 @@
+// @bun
+var V="https://api.mynth.io",X="MYNTH_API_KEY",b="/image/generate";var v=(J)=>`/tasks/${J}`,G=(J)=>`/tasks/${J}/status`,P=[{id:"auto",label:"Auto",capabilities:[]},{id:"black-forest-labs/flux.1-dev",label:"FLUX.1 Dev",capabilities:["magic_prompt","steps"]},{id:"black-forest-labs/flux-1-schnell",label:"FLUX.1 Schnell",capabilities:["magic_prompt"]},{id:"tongyi-mai/z-image-turbo",label:"Z Image Turbo",capabilities:["magic_prompt","steps"]},{id:"black-forest-labs/flux.2-dev",label:"FLUX.2 Dev",capabilities:["magic_prompt","steps"]},{id:"john6666/bismuth-illustrious-mix",label:"Bismuth Illustrious Mix",capabilities:["magic_prompt","negative_prompt","steps"]},{id:"google/gemini-3-pro-image-preview",label:"Nano Banana Pro",capabilities:[]},{id:"wan/wan2.6-image",label:"Wan 2.6 Image",capabilities:[]},{id:"xai/grok-imagine-image",label:"Grok Imagine Image",capabilities:[]}];class Y extends Error{status;code;constructor(J,Q,Z){super(J);this.name="MynthAPIError",this.status=Q,this.code=Z}}class H{apiKey;baseUrl;constructor(J){this.apiKey=J.apiKey,this.baseUrl=J.baseUrl?J.baseUrl.endsWith("/")?J.baseUrl.slice(0,-1):J.baseUrl:V}getAuthHeaders(J){return{Authorization:`Bearer ${J?.accessToken??this.apiKey}`}}getUrl(J){return`${this.baseUrl}${J}`}async post(J,Q){let Z=await fetch(this.getUrl(J),{method:"POST",headers:{"Content-Type":"application/json",...this.getAuthHeaders()},body:JSON.stringify(Q)}),$=await Z.json();if(!Z.ok){let x=$,B=x.error||x.message||`Request failed with status ${Z.status}`;throw new Y(B,Z.status,x.code)}return $}async get(J,{headers:Q,accessToken:Z}={}){let $=await fetch(this.getUrl(J),{headers:{...this.getAuthHeaders({accessToken:Z}),...Q}});return{data:await $.json(),status:$.status,ok:$.ok}}}class j{data;constructor(J){this.data=J}get id(){return this.data.id}get status(){return this.data.status}get result(){return this.data.result}get isCompleted(){return this.data.status==="completed"}get isFailed(){return this.data.status==="failed"}get urls(){return this.data.result?.images.filter((J)=>J.status==="succeeded").map((J)=>J.url)??[]}getImages(J={}){if(J.includeFailed)return this.data.result?.images??[];return this.data.result?.images.filter((Q)=>Q.status==="succeeded")??[]}getMetadata(){return this.data.request?.metadata}}var D=300000,g=12000,L=2500,M=5000,_=7;class f extends Error{constructor(J){super(`Task ${J} polling timed out after ${D}ms`);this.name="TaskAsyncTimeoutError"}}class W extends Error{constructor(J){super(`Unauthorized access to task ${J}`);this.name="TaskAsyncUnauthorizedError"}}class q extends Error{constructor(J,Q){super(`Failed to fetch status for task ${J} after multiple retries`);this.name="TaskAsyncFetchError",this.cause=Q}}class w extends Error{constructor(J,Q){let Z=Q?` (status ${Q})`:"";super(`Failed to fetch task ${J}${Z}`);this.name="TaskAsyncTaskFetchError"}}class z extends Error{constructor(J){super(`Task ${J} failed during generation`);this.name="TaskAsyncTaskFailedError"}}class C{id;client;_access;_completionPromise=null;constructor(J,Q){this.id=J,this.client=Q.client,this._access={publicAccessToken:Q.pat}}get access(){return this._access}toString(){return this.id}async toTask(){if(!this._completionPromise)this._completionPromise=this.pollUntilCompleted();return this._completionPromise}async pollUntilCompleted(){let J=Date.now(),Q=0,Z=!1,$;while(!0){let x=Date.now()-J;if(x>=D)throw new f(this.id);let B=await this.fetchStatus(Z);if(B.ok){if(Q=0,B.status==="completed"){let U=await this.fetchTask();return new j(U)}if(B.status==="failed")throw new z(this.id)}else{if(B.unauthorized){if(this._access.publicAccessToken&&!Z){Z=!0;continue}throw new W(this.id)}if(B.retryable){if(Q++,$=B.error,Q>=_)throw new q(this.id,$)}}let R=x<g?L:M,N=Math.random()*500,O=R+N,F=D-x,S=Math.min(O,F);await this.sleep(S)}}async fetchStatus(J){let Q=J||!this._access.publicAccessToken?void 0:this._access.publicAccessToken;try{let Z=await this.client.get(G(this.id),{accessToken:Q});if(Z.ok)return{ok:!0,status:Z.data.status};if(Z.status===401||Z.status===403)return{ok:!1,unauthorized:!0,retryable:!1};if(Z.status===404)return{ok:!1,unauthorized:!0,retryable:!1};if(Z.status>=500)return{ok:!1,unauthorized:!1,retryable:!0};return{ok:!1,unauthorized:!1,retryable:!1}}catch(Z){return{ok:!1,unauthorized:!1,retryable:!0,error:Z instanceof Error?Z:Error(String(Z))}}}async fetchTask(){let J=await this.client.get(v(this.id));if(J.ok)return J.data;if(J.status===401||J.status===403)throw new W(this.id);if(J.status===404)throw new W(this.id);throw new w(this.id,J.status)}sleep(J){return new Promise((Q)=>setTimeout(Q,J))}}function m(){if(typeof process<"u"&&process.env)return process.env[X];return}class K{client;constructor(J={}){let Q=J.apiKey??m();if(!Q)throw Error(`Mynth API key is required. Either pass it as an option or set the ${X} environment variable.`);this.client=new H({apiKey:Q,baseUrl:J.baseUrl})}async generate(J,Q={}){let Z=Q.mode??"sync",$=await this.client.post(b,J),x=new C($.taskId,{client:this.client,pat:$.access?.publicAccessToken});if(Z==="async")return x;return x.toTask()}}var i=K;export{i as default,W as TaskAsyncUnauthorizedError,f as TaskAsyncTimeoutError,w as TaskAsyncTaskFetchError,z as TaskAsyncTaskFailedError,q as TaskAsyncFetchError,Y as MynthAPIError,K as Mynth,P as AVAILABLE_MODELS};

package/dist/task-async.d.ts

@@ -0,0 +1,79 @@
+import type { MynthClient } from "./client";
+import { Task } from "./task";
+import type { MynthSDKTypes } from "./types";
+/**
+ * Error thrown when task polling exceeds the maximum timeout duration.
+ */
+export declare class TaskAsyncTimeoutError extends Error {
+    constructor(taskId: string);
+}
+/**
+ * Error thrown when access to a task is denied (invalid API key or PAT).
+ */
+export declare class TaskAsyncUnauthorizedError extends Error {
+    constructor(taskId: string);
+}
+/**
+ * Error thrown when fetching task status fails after multiple retries.
+ */
+export declare class TaskAsyncFetchError extends Error {
+    constructor(taskId: string, cause?: Error);
+}
+/**
+ * Error thrown when fetching full task data fails.
+ */
+export declare class TaskAsyncTaskFetchError extends Error {
+    constructor(taskId: string, status?: number);
+}
+/**
+ * Error thrown when a task fails during generation.
+ */
+export declare class TaskAsyncTaskFailedError extends Error {
+    constructor(taskId: string);
+}
+/**
+ * Public access information for a task, used for client-side polling.
+ */
+export type TaskAsyncAccess = {
+    /** Public access token for client-side status polling */
+    publicAccessToken?: string;
+};
+/**
+ * Represents an async task that can be polled for completion.
+ * Use `toTask()` to wait for completion and get the full task result.
+ *
+ * @template MetadataT - Type of the metadata attached to the request
+ * @template ContentRatingT - Type of the content rating response
+ */
+export declare class TaskAsync<MetadataT = Record<string, unknown> | undefined, ContentRatingT = MynthSDKTypes.ImageResultContentRating | undefined> {
+    /** The unique identifier for this task */
+    readonly id: string;
+    private readonly client;
+    private readonly _access;
+    private _completionPromise;
+    constructor(id: string, options: {
+        client: MynthClient;
+        pat?: string;
+    });
+    /**
+     * Public access information for client-side polling.
+     * Contains the public access token if one was generated.
+     */
+    get access(): TaskAsyncAccess;
+    toString(): string;
+    /**
+     * Polls the task until completion and returns the full Task object.
+     * Multiple calls to this method return the same promise.
+     *
+     * @throws {TaskAsyncTimeoutError} If polling exceeds the timeout
+     * @throws {TaskAsyncUnauthorizedError} If access is denied
+     * @throws {TaskAsyncFetchError} If fetching status fails repeatedly
+     * @throws {TaskAsyncTaskFailedError} If the task fails during generation
+     */
+    toTask(): Promise<Task<MetadataT, ContentRatingT>>;
+    private pollUntilCompleted;
+    private fetchStatus;
+    private fetchTask;
+    private sleep;
+}
+//# sourceMappingURL=task-async.d.ts.map

package/dist/task-async.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-async.d.ts","sourceRoot":"","sources":["../src/task-async.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAQ7C;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;gBAClC,MAAM,EAAE,MAAM;CAI3B;AAED;;GAEG;AACH,qBAAa,0BAA2B,SAAQ,KAAK;gBACvC,MAAM,EAAE,MAAM;CAI3B;AAED;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;gBAChC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK;CAK1C;AAED;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,KAAK;gBACpC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM;CAK5C;AAED;;GAEG;AACH,qBAAa,wBAAyB,SAAQ,KAAK;gBACrC,MAAM,EAAE,MAAM;CAI3B;AAMD;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,yDAAyD;IACzD,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF;;;;;;GAMG;AACH,qBAAa,SAAS,CACpB,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC/C,cAAc,GAAG,aAAa,CAAC,wBAAwB,GAAG,SAAS;IAEnE,0CAA0C;IAC1C,SAAgB,EAAE,EAAE,MAAM,CAAC;IAE3B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IAErC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkB;IAE1C,OAAO,CAAC,kBAAkB,CACnB;gBAEK,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,MAAM,EAAE,WAAW,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE;IAOtE;;;OAGG;IACH,IAAI,MAAM,IAAI,eAAe,CAE5B;IAED,QAAQ,IAAI,MAAM;IAIlB;;;;;;;;OAQG;IACU,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC;YASjD,kBAAkB;YA+DlB,WAAW;YA6CX,SAAS;IAoBvB,OAAO,CAAC,KAAK;CAGd"}

package/dist/task.d.ts

@@ -0,0 +1,58 @@
+import type { MynthSDKTypes } from "./types";
+/** Typed image result with custom content rating type */
+type TypedImageResultImageSuccess<ContentRatingT> = Omit<MynthSDKTypes.ImageResultImageSuccess, "content_rating"> & {
+    content_rating?: ContentRatingT;
+};
+type TypedImageResultImageFailure = MynthSDKTypes.ImageResultImageFailure;
+type TypedImageResultImage<ContentRatingT> = TypedImageResultImageSuccess<ContentRatingT> | TypedImageResultImageFailure;
+/** Typed result with custom content rating type on images */
+type TypedImageResult<ContentRatingT> = Omit<MynthSDKTypes.ImageResult, "images"> & {
+    images: TypedImageResultImage<ContentRatingT>[];
+};
+/**
+ * Represents a completed image generation task.
+ *
+ * @template MetadataT - Type of the metadata attached to the request
+ * @template ContentRatingT - Type of the content rating response
+ */
+export declare class Task<MetadataT = Record<string, unknown> | undefined, ContentRatingT = MynthSDKTypes.ImageResultContentRating | undefined> {
+    /** Raw task data from the API */
+    readonly data: MynthSDKTypes.TaskData;
+    constructor(data: MynthSDKTypes.TaskData);
+    /** Unique identifier for this task */
+    get id(): string;
+    /** Current status of the task */
+    get status(): MynthSDKTypes.TaskStatus;
+    /**
+     * The generation result containing images, cost, and model info.
+     * Returns `null` if the task hasn't completed yet.
+     */
+    get result(): TypedImageResult<ContentRatingT> | null;
+    /** Whether the task completed successfully */
+    get isCompleted(): boolean;
+    /** Whether the task failed */
+    get isFailed(): boolean;
+    /**
+     * Get all successfully generated image URLs.
+     * Convenience method that extracts just the URLs from successful images.
+     */
+    get urls(): string[];
+    /**
+     * Get generated images from the task result.
+     *
+     * @param options.includeFailed - If true, includes failed image results
+     * @returns Array of image results
+     */
+    getImages(options: {
+        includeFailed: true;
+    }): TypedImageResultImage<ContentRatingT>[];
+    getImages(options?: {
+        includeFailed?: false;
+    }): TypedImageResultImageSuccess<ContentRatingT>[];
+    /**
+     * Get the metadata that was attached to the generation request.
+     */
+    getMetadata(): MetadataT;
+}
+export {};
+//# sourceMappingURL=task.d.ts.map

package/dist/task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../src/task.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C,yDAAyD;AACzD,KAAK,4BAA4B,CAAC,cAAc,IAAI,IAAI,CACtD,aAAa,CAAC,uBAAuB,EACrC,gBAAgB,CACjB,GAAG;IACF,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC,CAAC;AAEF,KAAK,4BAA4B,GAAG,aAAa,CAAC,uBAAuB,CAAC;AAE1E,KAAK,qBAAqB,CAAC,cAAc,IACrC,4BAA4B,CAAC,cAAc,CAAC,GAC5C,4BAA4B,CAAC;AAEjC,6DAA6D;AAC7D,KAAK,gBAAgB,CAAC,cAAc,IAAI,IAAI,CAC1C,aAAa,CAAC,WAAW,EACzB,QAAQ,CACT,GAAG;IACF,MAAM,EAAE,qBAAqB,CAAC,cAAc,CAAC,EAAE,CAAC;CACjD,CAAC;AAEF;;;;;GAKG;AACH,qBAAa,IAAI,CACf,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC/C,cAAc,GAAG,aAAa,CAAC,wBAAwB,GAAG,SAAS;IAEnE,iCAAiC;IACjC,SAAgB,IAAI,EAAE,aAAa,CAAC,QAAQ,CAAC;gBAEjC,IAAI,EAAE,aAAa,CAAC,QAAQ;IAIxC,sCAAsC;IACtC,IAAI,EAAE,IAAI,MAAM,CAEf;IAED,iCAAiC;IACjC,IAAI,MAAM,IAAI,aAAa,CAAC,UAAU,CAErC;IAED;;;OAGG;IACH,IAAI,MAAM,IAAI,gBAAgB,CAAC,cAAc,CAAC,GAAG,IAAI,CAEpD;IAED,8CAA8C;IAC9C,IAAI,WAAW,IAAI,OAAO,CAEzB;IAED,8BAA8B;IAC9B,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED;;;OAGG;IACH,IAAI,IAAI,IAAI,MAAM,EAAE,CASnB;IAED;;;;;OAKG;IACH,SAAS,CAAC,OAAO,EAAE;QACjB,aAAa,EAAE,IAAI,CAAC;KACrB,GAAG,qBAAqB,CAAC,cAAc,CAAC,EAAE;IAC3C,SAAS,CAAC,OAAO,CAAC,EAAE;QAClB,aAAa,CAAC,EAAE,KAAK,CAAC;KACvB,GAAG,4BAA4B,CAAC,cAAc,CAAC,EAAE;IAelD;;OAEG;IACH,WAAW,IAAI,SAAS;CAGzB"}

package/dist/types.d.ts

@@ -0,0 +1,272 @@
+/**
+ * Type definitions for the Mynth SDK.
+ * Import as `import type { MynthSDKTypes } from "@mynthio/sdk"`.
+ */
+export declare namespace MynthSDKTypes {
+    /** Status of a generation task */
+    type TaskStatus = "pending" | "completed" | "failed";
+    /** Type of task (currently only "image" is supported) */
+    type TaskType = "image";
+    /** Full task data returned from the API */
+    type TaskData = {
+        /** Unique task identifier */
+        id: string;
+        /** Current status of the task */
+        status: TaskStatus;
+        /** Type of task */
+        type: TaskType;
+        /** ID of the API key used (null for public access) */
+        apiKeyId: string | null;
+        /** ID of the user who created the task */
+        userId: string;
+        /** Total cost in string format (null if not yet calculated) */
+        cost: string | null;
+        /** Generation result (null if not completed) */
+        result: ImageResult | null;
+        /** Original generation request (null if not available) */
+        request: ImageGenerationRequestDb | null;
+        /** ISO 8601 timestamp of creation */
+        createdAt: string;
+        /** ISO 8601 timestamp of last update */
+        updatedAt: string;
+    };
+    /** Available model identifiers */
+    type ImageGenerationModelId = "black-forest-labs/flux.1-dev" | "black-forest-labs/flux-1-schnell" | "black-forest-labs/flux.2-dev" | "google/gemini-3-pro-image-preview" | "tongyi-mai/z-image-turbo" | "john6666/bismuth-illustrious-mix" | "wan/wan2.6-image" | "xai/grok-imagine-image";
+    /** Model to use for generation ("auto" lets the system choose) */
+    type ImageGenerationModel = ImageGenerationModelId | "auto";
+    /** Structured prompt with positive and optional negative text */
+    type PromptStructured = {
+        /** Main prompt describing what to generate */
+        positive: string;
+        /** Elements to exclude from the generation */
+        negative?: string;
+    };
+    type GenerateImageOptionsIn = {
+        prompt: string | PromptStructured;
+    };
+    type GenerateImageOptions = {
+        prompt: PromptStructured;
+    };
+    /**
+     * Prompt input for image generation.
+     * Can be a simple string or structured with positive/negative prompts.
+     */
+    type ImageGenerationRequestPrompt = string | {
+        /** Main prompt describing what to generate */
+        positive: string;
+        /** Elements to exclude (model support varies) */
+        negative?: string;
+        /** Enable AI prompt enhancement (default: true) */
+        magic?: boolean;
+    };
+    /** Access configuration for the generated task */
+    type ImageGenerationRequestAccess = {
+        /** Public access token configuration */
+        pat?: {
+            /** Generate a public access token for client-side polling */
+            enabled?: boolean;
+        };
+    };
+    /** Output image format */
+    type ImageGenerationRequestOutputFormat = "png" | "jpg" | "webp";
+    /** Upscale configuration */
+    type ImageGenerationRequestUpscale = 2 | 4 | {
+        enabled?: boolean;
+        factor?: 2 | 4;
+    };
+    /** Output configuration for generated images */
+    type ImageGenerationRequestOutput = {
+        /** Image format (default: "webp") */
+        format?: ImageGenerationRequestOutputFormat;
+        /** Quality 1-100 (default varies by format) */
+        quality?: number;
+        /** Upscale factor (2x or 4x) */
+        upscale?: ImageGenerationRequestUpscale;
+    };
+    /** Custom webhook endpoint configuration */
+    type ImageGenerationRequestCustomWebhook = {
+        /** URL to receive webhook notifications */
+        url: string;
+    };
+    /** Webhook configuration */
+    type ImageGenerationRequestWebhook = {
+        /** Enable/disable webhooks (disabling overrides dashboard settings) */
+        enabled?: boolean;
+        /** Additional custom webhook endpoints */
+        custom?: ImageGenerationRequestCustomWebhook[];
+    };
+    /** Custom content rating level definition */
+    type ImageGenerationRequestContentRatingLevel<T extends string = string> = {
+        /** Level identifier returned in the result */
+        value: T;
+        /** Human-readable description for the AI classifier */
+        description: string;
+    };
+    /** Content rating configuration */
+    type ImageGenerationRequestContentRating = {
+        /** Enable content rating classification */
+        enabled?: boolean;
+        /** Custom rating levels (uses default sfw/nsfw if not provided) */
+        levels?: readonly ImageGenerationRequestContentRatingLevel[];
+    };
+    /**
+     * Image size specification.
+     * Can be a preset name, dimension string, or explicit dimensions.
+     */
+    type ImageGenerationRequestSize = "instagram" | "square" | "portrait" | "landscape" | `${number}x${number}` | {
+        width: number;
+        height: number;
+        mode?: "strict" | "preset" | "aligned";
+    } | "auto";
+    /**
+     * Image generation request parameters.
+     */
+    type ImageGenerationRequest = {
+        /** Text prompt or structured prompt object */
+        prompt: ImageGenerationRequestPrompt;
+        /** Model to use (default: "auto") */
+        model?: ImageGenerationModel;
+        /** Image size/dimensions (default: "auto") */
+        size?: ImageGenerationRequestSize;
+        /** Number of images to generate (default: 1) */
+        count?: number;
+        /** Output format and quality settings */
+        output?: ImageGenerationRequestOutput;
+        /** Public access token configuration */
+        access?: ImageGenerationRequestAccess;
+        /** Webhook notification settings */
+        webhook?: ImageGenerationRequestWebhook;
+        /** Content rating classification settings */
+        content_rating?: ImageGenerationRequestContentRating;
+        /** Custom metadata to attach (returned in results and webhooks). Max 2KB. */
+        metadata?: Record<string, unknown>;
+    };
+    /** @internal Stored prompt format */
+    type ImageGenerationRequestDbPrompt = {
+        positive: string;
+        negative?: string;
+        magic?: boolean;
+    };
+    /** @internal */
+    type ImageGenerationRequestDbWebhook = ImageGenerationRequestWebhook;
+    /** @internal */
+    type ImageGenerationRequestDbContentRating = ImageGenerationRequestContentRating;
+    /** @internal Stored request format */
+    type ImageGenerationRequestDb = {
+        prompt: ImageGenerationRequestDbPrompt;
+        model?: ImageGenerationModel;
+        size?: ImageGenerationRequestSize;
+        count: number;
+        output?: ImageGenerationRequestOutput;
+        webhook?: ImageGenerationRequestDbWebhook;
+        content_rating?: ImageGenerationRequestDbContentRating;
+        metadata?: Record<string, unknown>;
+    };
+    /** Default content rating levels */
+    type ImageResultContentRatingDefaultLevel = "sfw" | "nsfw";
+    /** Content rating result */
+    type ImageResultContentRating = {
+        mode: "default";
+        level: ImageResultContentRatingDefaultLevel;
+    } | {
+        mode: "custom";
+        level: string;
+    };
+    /** Successfully generated image */
+    type ImageResultImageSuccess = {
+        status: "succeeded";
+        /** CDN URL of the generated image */
+        url: string;
+        /** Provider-specific image identifier */
+        provider_id: string;
+        /** Cost for this image in string format */
+        cost: string;
+        /** Content rating if classification was enabled */
+        content_rating?: ImageResultContentRating;
+    };
+    /** Failed image generation */
+    type ImageResultImageFailure = {
+        status: "failed";
+        /** Error message describing the failure */
+        error: string;
+    };
+    /** Individual image result (success or failure) */
+    type ImageResultImage = ImageResultImageSuccess | ImageResultImageFailure;
+    /** Cost breakdown for the generation */
+    type ImageResultCost = {
+        /** Cost of image generation */
+        images: string;
+        /** Total cost including all fees */
+        total: string;
+        /** Platform fee */
+        fee: string;
+    };
+    /** Auto-enhanced parameters (when magic prompt is enabled) */
+    type ImageResultMagic = {
+        /** Model selected by auto mode */
+        model?: ImageGenerationModelId;
+        /** Size selected by auto mode */
+        size?: string;
+        /** Enhanced prompt */
+        prompt?: {
+            positive: string;
+            negative?: string;
+        };
+    };
+    /** Model-specific settings used for generation */
+    type ImageResultModelSettings = {
+        /** Actual resolution used */
+        resolution: {
+            width: number;
+            height: number;
+        };
+        /** Number of inference steps (model-dependent) */
+        steps?: number;
+    };
+    /** Complete generation result */
+    type ImageResult = {
+        /** Array of generated images (may include failures) */
+        images: ImageResultImage[];
+        /** Cost breakdown */
+        cost: ImageResultCost;
+        /** Model information */
+        model: {
+            /** Model that was used */
+            id: ImageGenerationModelId;
+            /** Model-specific settings */
+            settings: ImageResultModelSettings;
+        };
+        /** Auto-enhanced parameters */
+        magic: ImageResultMagic;
+    };
+    /**
+     * Webhook payload for task completion
+     */
+    type WebhookTaskImageCompletedPayload = {
+        task: {
+            id: string;
+        };
+        event: "task.image.completed";
+        result: ImageResult;
+        request: ImageGenerationRequestDb;
+    };
+    /**
+     * Webhook payload for task failure
+     */
+    type WebhookTaskImageFailedPayload = {
+        task: {
+            id: string;
+        };
+        event: "task.image.failed";
+        request: ImageGenerationRequestDb;
+        errors: {
+            code: string;
+            message: string;
+        }[];
+    };
+    /**
+     * Webhook payload union
+     */
+    type WebhookPayload = WebhookTaskImageCompletedPayload | WebhookTaskImageFailedPayload;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@mynthio/sdk",
+  "version": "0.0.1",
+  "description": "Official Mynth SDK for image generation",
+  "keywords": [
+    "ai",
+    "image-generation",
+    "mynth",
+    "sdk"
+  ],
+  "homepage": "https://mynth.io",
+  "license": "MIT",
+  "author": "mynth.io",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mynth-io/sdk"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./convex": {
+      "types": "./dist/convex/index.d.ts",
+      "import": "./dist/convex/index.js",
+      "default": "./dist/convex/index.js"
+    }
+  },
+  "scripts": {
+    "build": "bun run build:clean && bun run build:js && bun run build:types",
+    "build:clean": "rm -rf dist",
+    "build:js": "bun build ./src/index.ts ./src/convex/index.ts --outdir ./dist --format esm --splitting --target bun --minify --packages external",
+    "build:types": "tsc --emitDeclarationOnly",
+    "prepublishOnly": "bun run build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "oxlint -c .oxlintrc.json .",
+    "lint:fix": "oxlint -c .oxlintrc.json --fix .",
+    "format": "oxfmt --write",
+    "format:check": "oxfmt --check",
+    "typecheck": "tsc --noEmit",
+    "changeset": "changeset",
+    "version": "changeset version",
+    "release": "bun run build && npm publish --access public"
+  },
+  "devDependencies": {
+    "@changesets/changelog-github": "^0.5.1",
+    "@changesets/cli": "^2.29.4",
+    "@types/bun": "^1.3.8",
+    "convex": "^1.31.7",
+    "oxfmt": "^0.27.0",
+    "oxlint": "^1.42.0",
+    "tsx": "^4.21.0",
+    "typescript": "5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "peerDependencies": {
+    "convex": "^1.27.3"
+  },
+  "peerDependenciesMeta": {
+    "convex": {
+      "optional": true
+    }
+  }
+}