@d-ai/pi 0.2.0

package/dist/index.js

@@ -0,0 +1,1859 @@
+// src/index.ts
+import { Type } from "typebox";
+
+// ../typescript/dist/index.js
+var SdkError = class extends Error {
+  name = "SdkError";
+};
+var RequestAbortedError = class extends SdkError {
+  name = "RequestAbortedError";
+  constructor() {
+    super("D.AI media request was aborted");
+  }
+};
+var RequestTimeoutError = class extends SdkError {
+  constructor(timeoutMs) {
+    super(`D.AI media request timed out after ${timeoutMs}ms`);
+    this.timeoutMs = timeoutMs;
+  }
+  timeoutMs;
+  name = "RequestTimeoutError";
+};
+var ApiError = class extends SdkError {
+  constructor(status, message, errorType, code, requestId, bodyPreview = "", raw) {
+    super(`${message} (HTTP ${status})`);
+    this.status = status;
+    this.errorType = errorType;
+    this.code = code;
+    this.requestId = requestId;
+    this.bodyPreview = bodyPreview;
+    this.raw = raw;
+  }
+  status;
+  errorType;
+  code;
+  requestId;
+  bodyPreview;
+  raw;
+  name = "ApiError";
+};
+var WaitTimeoutError = class extends SdkError {
+  constructor(jobId, lastResult, maxWaitMs) {
+    super(`Job ${jobId} did not finish within ${maxWaitMs}ms`);
+    this.jobId = jobId;
+    this.lastResult = lastResult;
+    this.maxWaitMs = maxWaitMs;
+  }
+  jobId;
+  lastResult;
+  maxWaitMs;
+  name = "WaitTimeoutError";
+};
+var DEFAULT_BASE_URL = "https://dai.itbug.shop";
+var MAX_BODY_PREVIEW = 2e3;
+var RESERVED_HEADERS = {
+  authorization: true,
+  "content-type": true
+};
+var Transport = class {
+  baseUrl;
+  timeoutMs;
+  #apiKey;
+  #headers;
+  #fetch;
+  constructor(configuration) {
+    if (!configuration.apiKey.trim()) {
+      throw new SdkError("apiKey is required");
+    }
+    this.#apiKey = configuration.apiKey;
+    this.baseUrl = normalizeBaseUrl(configuration.baseUrl ?? DEFAULT_BASE_URL);
+    this.timeoutMs = configuration.timeoutMs ?? 6e4;
+    if (!Number.isFinite(this.timeoutMs) || this.timeoutMs <= 0) {
+      throw new SdkError("timeoutMs must be greater than zero");
+    }
+    this.#headers = safeHeaders(configuration.headers);
+    const fetchImplementation = configuration.fetch ?? globalThis.fetch;
+    if (typeof fetchImplementation !== "function") {
+      throw new SdkError("A Fetch API implementation is required");
+    }
+    this.#fetch = fetchImplementation.bind(globalThis);
+  }
+  async request(method, path, options = {}) {
+    const url = endpointUrl(this.baseUrl, path, options.query);
+    const headers = new Headers(this.#headers);
+    mergeSafeHeaders(headers, options.headers);
+    headers.set("Authorization", `Bearer ${this.#apiKey}`);
+    if (options.body !== void 0) {
+      headers.set("Content-Type", "application/json");
+    }
+    const controller = new AbortController();
+    let timedOut = false;
+    const abortFromCaller = () => controller.abort(options.signal?.reason);
+    if (options.signal?.aborted) {
+      throw new RequestAbortedError();
+    }
+    options.signal?.addEventListener("abort", abortFromCaller, { once: true });
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, this.timeoutMs);
+    try {
+      const init = {
+        method,
+        headers,
+        signal: controller.signal
+      };
+      if (options.body !== void 0) {
+        init.body = JSON.stringify(options.body);
+      }
+      const response = await this.#fetch(url, init);
+      return await parseResponse(response);
+    } catch (error) {
+      if (timedOut) {
+        throw new RequestTimeoutError(this.timeoutMs);
+      }
+      if (options.signal?.aborted || isAbortError(error)) {
+        throw new RequestAbortedError();
+      }
+      if (error instanceof SdkError) {
+        throw error;
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      throw new SdkError(`D.AI media network request failed: ${message}`);
+    } finally {
+      clearTimeout(timeout);
+      options.signal?.removeEventListener("abort", abortFromCaller);
+    }
+  }
+  toString() {
+    return `Transport(baseUrl=${JSON.stringify(this.baseUrl)}, apiKey="[REDACTED]")`;
+  }
+};
+function normalizeBaseUrl(value) {
+  let url;
+  try {
+    url = new URL(value.trim());
+  } catch {
+    throw new SdkError("baseUrl must be an absolute http or https URL");
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:" || !url.hostname) {
+    throw new SdkError("baseUrl must be an absolute http or https URL");
+  }
+  if (url.username || url.password || url.search || url.hash) {
+    throw new SdkError("baseUrl cannot contain user info, query, or fragment");
+  }
+  url.pathname = `${url.pathname.replace(/\/+$/, "")}/`;
+  return url.toString();
+}
+function endpointUrl(baseUrl, path, query) {
+  if (!path.startsWith("/") || path.includes("?") || path.includes("#")) {
+    throw new SdkError(`Invalid endpoint path: ${path}`);
+  }
+  const url = new URL(`${baseUrl.replace(/\/+$/, "")}${path}`);
+  for (const [key, value] of Object.entries(query ?? {})) {
+    url.searchParams.set(key, value);
+  }
+  return url;
+}
+async function parseResponse(response) {
+  const requestId = response.headers.get("x-request-id") ?? void 0;
+  const bodyText = await response.text();
+  let parsed;
+  try {
+    parsed = JSON.parse(bodyText);
+  } catch {
+    if (response.ok) {
+      throw new SdkError("D.AI response was not valid JSON");
+    }
+    throw new ApiError(
+      response.status,
+      "D.AI media request failed",
+      void 0,
+      void 0,
+      requestId,
+      bodyText.slice(0, MAX_BODY_PREVIEW)
+    );
+  }
+  if (!isJsonObject(parsed)) {
+    throw new SdkError("D.AI response must be a JSON object");
+  }
+  if (!response.ok) {
+    const error = isJsonObject(parsed.error) ? parsed.error : void 0;
+    const message = stringValue(error?.message) ?? stringValue(parsed.message) ?? "D.AI media request failed";
+    throw new ApiError(
+      response.status,
+      message,
+      stringValue(error?.type),
+      stringValue(error?.code),
+      requestId,
+      bodyText.slice(0, MAX_BODY_PREVIEW),
+      parsed
+    );
+  }
+  return requestId === void 0 ? { body: parsed } : { body: parsed, requestId };
+}
+function safeHeaders(value) {
+  const headers = new Headers();
+  mergeSafeHeaders(headers, value, true);
+  return headers;
+}
+function mergeSafeHeaders(target, value, rejectReserved = false) {
+  if (value === void 0) {
+    return;
+  }
+  for (const [name, headerValue] of new Headers(value)) {
+    if (RESERVED_HEADERS[name.toLowerCase()] === true) {
+      if (rejectReserved) {
+        throw new SdkError(`Header is reserved and managed by the SDK: ${name}`);
+      }
+      continue;
+    }
+    target.set(name, headerValue);
+  }
+}
+function isAbortError(error) {
+  return error instanceof DOMException ? error.name === "AbortError" : error instanceof Error && error.name === "AbortError";
+}
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringValue(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function mergePayload(extra, typed) {
+  const result = { ...extra ?? {} };
+  for (const [key, value] of Object.entries(typed)) {
+    if (value !== void 0) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function imageResult(response) {
+  const images = [];
+  const data = response.body.data;
+  if (Array.isArray(data)) {
+    for (const item of data) {
+      if (!isJsonObject(item)) {
+        continue;
+      }
+      const url = stringValue(item.url);
+      const b64Json = stringValue(item.b64_json);
+      if (url !== void 0 || b64Json !== void 0) {
+        images.push({
+          ...url === void 0 ? {} : { url },
+          ...b64Json === void 0 ? {} : { b64Json }
+        });
+      }
+    }
+  } else if (isJsonObject(data)) {
+    const url = stringValue(data.image_url);
+    if (url !== void 0) {
+      images.push({ url });
+    }
+  }
+  return {
+    images,
+    ...response.requestId === void 0 ? {} : { requestId: response.requestId },
+    raw: response.body
+  };
+}
+function jobHandle(response, operation, fetchPath) {
+  const jobId = extractJobId(response.body);
+  const serverFetchUrl = stringValue(response.body.fetchUrl);
+  return {
+    jobId,
+    operation,
+    fetchPath,
+    ...serverFetchUrl === void 0 ? {} : { serverFetchUrl },
+    ...response.requestId === void 0 ? {} : { requestId: response.requestId },
+    raw: response.body
+  };
+}
+function jobResult(handle, response) {
+  const raw = response.body;
+  const data = isJsonObject(raw.data) ? raw.data : void 0;
+  const output = isJsonObject(raw.output) ? raw.output : void 0;
+  const error = isJsonObject(raw.error) ? raw.error : void 0;
+  const rawStatus = stringValue(raw.status) ?? stringValue(data?.status) ?? stringValue(output?.task_status);
+  const assets = /* @__PURE__ */ new Set();
+  collectAssets(raw, assets);
+  const errorMessage = stringValue(raw.message) ?? stringValue(error?.message);
+  return {
+    jobId: handle.jobId,
+    state: normalizeJobState(rawStatus),
+    assets: [...assets],
+    ...errorMessage === void 0 ? {} : { errorMessage },
+    ...response.requestId === void 0 ? {} : { requestId: response.requestId },
+    raw
+  };
+}
+function normalizeJobState(value) {
+  switch (value?.trim().toLowerCase()) {
+    case "queued":
+    case "pending":
+    case "submitted":
+      return "queued";
+    case "running":
+    case "processing":
+    case "in_progress":
+      return "running";
+    case "success":
+    case "succeeded":
+    case "completed":
+    case "finished":
+      return "succeeded";
+    case "failed":
+    case "error":
+    case "cancelled":
+    case "canceled":
+      return "failed";
+    default:
+      return "unknown";
+  }
+}
+function isTerminalState(state) {
+  return state === "succeeded" || state === "failed";
+}
+function extractJobId(body) {
+  const data = isJsonObject(body.data) ? body.data : void 0;
+  const values = [body.jobId, body.job_id, data?.jobId, data?.job_id];
+  for (const value of values) {
+    const jobId = stringValue(value)?.trim();
+    if (jobId) {
+      return jobId;
+    }
+  }
+  throw new SdkError(
+    `Asynchronous response did not include jobId; body: ${JSON.stringify(body).slice(0, 2e3)}`
+  );
+}
+function collectAssets(value, assets) {
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectAssets(item, assets);
+    }
+    return;
+  }
+  if (!isJsonObject(value)) {
+    return;
+  }
+  for (const key of ["url", "image_url", "video_url", "audio_url"]) {
+    const candidate = stringValue(value[key]);
+    if (candidate !== void 0) {
+      assets.add(candidate);
+    }
+  }
+  for (const child of Object.values(value)) {
+    collectAssets(child, assets);
+  }
+}
+var AudioApi = class {
+  suno;
+  constructor(transport) {
+    this.suno = new SunoAudioApi(transport);
+  }
+};
+var SunoAudioApi = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async music(request, options = {}) {
+    const body = mergePayload(request.extra, {
+      custom: request.custom,
+      instrumental: request.instrumental,
+      mv: request.mv,
+      ...request.gptDescriptionPrompt === void 0 ? {} : { gpt_description_prompt: request.gptDescriptionPrompt },
+      ...request.prompt === void 0 ? {} : { prompt: request.prompt },
+      ...request.title === void 0 ? {} : { title: request.title },
+      ...request.tags === void 0 ? {} : { tags: request.tags },
+      ...request.negativeTags === void 0 ? {} : { negative_tags: request.negativeTags },
+      ...request.styleWeight === void 0 ? {} : { style_weight: request.styleWeight },
+      ...request.weirdnessConstraint === void 0 ? {} : { weirdness_constraint: request.weirdnessConstraint },
+      ...request.audioWeight === void 0 ? {} : { audio_weight: request.audioWeight },
+      ...request.autoLyrics === void 0 ? {} : { auto_lyrics: request.autoLyrics },
+      ...request.vocalGender === void 0 ? {} : { vocal_gender: request.vocalGender },
+      ...request.personaId === void 0 ? {} : { persona_id: request.personaId },
+      ...request.isStorage === void 0 ? {} : { is_storage: request.isStorage }
+    });
+    const response = await this.transport.request("POST", "/api/audio/suno/v1/music", {
+      ...options,
+      body
+    });
+    return jobHandle(response, "suno_music", "/api/audio/suno/v2/fetch");
+  }
+};
+var ImagesApi = class {
+  openai;
+  gemini;
+  novel;
+  midjourney;
+  flux;
+  constructor(transport) {
+    this.openai = new OpenAiImagesApi(transport);
+    this.gemini = new GeminiImagesApi(transport);
+    this.novel = new NovelImagesApi(transport);
+    this.midjourney = new MidjourneyImagesApi(transport);
+    this.flux = new FluxImagesApi(transport);
+  }
+};
+var OpenAiImagesApi = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async generate(request, options = {}) {
+    const body = mergePayload(request.extra, {
+      prompt: request.prompt,
+      ...request.model === void 0 ? {} : { model: request.model },
+      ...request.size === void 0 ? {} : { size: request.size },
+      ...request.quality === void 0 ? {} : { quality: request.quality },
+      ...request.n === void 0 ? {} : { n: request.n },
+      ...request.responseFormat === void 0 ? {} : { response_format: request.responseFormat },
+      ...request.background === void 0 ? {} : { background: request.background },
+      ...request.outputFormat === void 0 ? {} : { output_format: request.outputFormat }
+    });
+    const response = await this.transport.request(
+      "POST",
+      "/api/image/openai/v1/images/generations",
+      { ...options, body }
+    );
+    return imageResult(response);
+  }
+  async gptGenerate(request, options = {}) {
+    const body = mergePayload(request.extra, {
+      prompt: request.prompt,
+      ...request.model === void 0 ? {} : { model: request.model },
+      ...request.size === void 0 ? {} : { size: request.size },
+      ...request.quality === void 0 ? {} : { quality: request.quality },
+      ...request.n === void 0 ? {} : { n: request.n },
+      ...request.responseFormat === void 0 ? {} : { response_format: request.responseFormat },
+      ...request.background === void 0 ? {} : { background: request.background },
+      ...request.outputFormat === void 0 ? {} : { output_format: request.outputFormat }
+    });
+    const response = await this.transport.request(
+      "POST",
+      "/api/image/openai/gpt/generations",
+      { ...options, body }
+    );
+    return jobHandle(response, "openai_gpt_image", "/api/image/openai/gpt/fetch");
+  }
+};
+var FluxImagesApi = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async generate(request, options = {}) {
+    const body = mergePayload(request.extra, {
+      prompt: request.prompt,
+      ...request.model === void 0 ? {} : { model: request.model },
+      ...request.size === void 0 ? {} : { size: request.size }
+    });
+    const response = await this.transport.request("POST", "/api/image/flux/v1/generate", {
+      ...options,
+      body
+    });
+    return jobHandle(response, "flux_image", "/api/image/flux/v1/fetch");
+  }
+  async edits(request, options = {}) {
+    const body = mergePayload(request.extra, {
+      prompt: request.prompt,
+      image: request.image,
+      ...request.model === void 0 ? {} : { model: request.model },
+      ...request.size === void 0 ? {} : { size: request.size }
+    });
+    const response = await this.transport.request("POST", "/api/image/flux/v1/edits", {
+      ...options,
+      body
+    });
+    return jobHandle(response, "flux_image", "/api/image/flux/v1/fetch");
+  }
+};
+var GeminiImagesApi = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async generate(request, options = {}) {
+    const body = mergePayload(request.extra, {
+      model: request.model,
+      prompt: request.prompt,
+      ...request.aspectRatio === void 0 ? {} : { aspect_ratio: request.aspectRatio },
+      reference_images: request.referenceImages ?? []
+    });
+    const response = await this.transport.request("POST", "/api/image/gemini/generate", {
+      ...options,
+      body
+    });
+    return imageResult(response);
+  }
+};
+var NovelImagesApi = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async textToImage(request, options = {}) {
+    const response = await this.transport.request(
+      "POST",
+      "/api/image/novel/v1/text-to-image",
+      { ...options, body: novelPayload(request) }
+    );
+    return jobHandle(response, "novel_text_to_image", "/api/image/novel/v1/fetch");
+  }
+  async imageToImage(request, options = {}) {
+    const body = mergePayload(novelPayload(request), {
+      image: request.image,
+      ...request.strength === void 0 ? {} : { strength: request.strength },
+      ...request.noise === void 0 ? {} : { noise: request.noise }
+    });
+    const response = await this.transport.request(
+      "POST",
+      "/api/image/novel/v1/image-to-image",
+      { ...options, body }
+    );
+    return jobHandle(response, "novel_image_to_image", "/api/image/novel/v1/fetch");
+  }
+};
+var MidjourneyImagesApi = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async imagine(request, options = {}) {
+    return await this.submit(
+      "/api/image/midjourney/v1/imagine",
+      "midjourney_imagine",
+      mergePayload(request.extra, {
+        prompt: request.prompt,
+        ...request.mode === void 0 ? {} : { mode: request.mode }
+      }),
+      options
+    );
+  }
+  async action(request, options = {}) {
+    return await this.submit(
+      "/api/image/midjourney/v1/action",
+      "midjourney_action",
+      mergePayload(request.extra, { jobId: request.jobId, action: request.action }),
+      options
+    );
+  }
+  async blend(request, options = {}) {
+    return await this.submit(
+      "/api/image/midjourney/v1/blend",
+      "midjourney_blend",
+      mergePayload(request.extra, {
+        imageUrls: request.imageUrls,
+        ...request.mode === void 0 ? {} : { mode: request.mode }
+      }),
+      options
+    );
+  }
+  async describe(request, options = {}) {
+    return await this.submit(
+      "/api/image/midjourney/v1/describe",
+      "midjourney_describe",
+      mergePayload(request.extra, { imageUrl: request.imageUrl }),
+      options
+    );
+  }
+  async seed(request, options = {}) {
+    return await this.submit(
+      "/api/image/midjourney/v1/seed",
+      "midjourney_seed",
+      mergePayload(request.extra, { jobId: request.jobId }),
+      options
+    );
+  }
+  async inpaint(request, options = {}) {
+    return await this.submit(
+      "/api/image/midjourney/v1/inpaint",
+      "midjourney_inpaint",
+      mergePayload(request.extra, {
+        jobId: request.jobId,
+        prompt: request.prompt,
+        mask: request.mask
+      }),
+      options
+    );
+  }
+  async submit(path, operation, body, options) {
+    const response = await this.transport.request("POST", path, { ...options, body });
+    return jobHandle(response, operation, "/api/image/midjourney/v1/fetch");
+  }
+};
+function novelPayload(request) {
+  return mergePayload(request.extra, {
+    prompt: request.prompt,
+    ...request.model === void 0 ? {} : { model: request.model },
+    ...request.n === void 0 ? {} : { n: request.n },
+    ...request.width === void 0 ? {} : { width: request.width },
+    ...request.height === void 0 ? {} : { height: request.height },
+    ...request.seed === void 0 ? {} : { seed: request.seed },
+    ...request.negativePrompt === void 0 ? {} : { negative_prompt: request.negativePrompt },
+    ...request.steps === void 0 ? {} : { steps: request.steps },
+    ...request.scale === void 0 ? {} : { scale: request.scale },
+    ...request.sampler === void 0 ? {} : { sampler: request.sampler },
+    ...request.noiseSchedule === void 0 ? {} : { noise_schedule: request.noiseSchedule }
+  });
+}
+var DEFAULT_POLL_INTERVAL_MS = 2e3;
+var DEFAULT_MAX_WAIT_MS = 20 * 6e4;
+var JobsApi = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async fetch(handle, options = {}) {
+    const response = await this.transport.request("GET", handle.fetchPath, {
+      ...options,
+      query: { jobId: handle.jobId }
+    });
+    return jobResult(handle, response);
+  }
+  async wait(handle, options = {}) {
+    const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    const maxWaitMs = options.maxWaitMs ?? DEFAULT_MAX_WAIT_MS;
+    if (!Number.isFinite(pollIntervalMs) || pollIntervalMs <= 0) {
+      throw new SdkError("pollIntervalMs must be greater than zero");
+    }
+    if (!Number.isFinite(maxWaitMs) || maxWaitMs <= 0) {
+      throw new SdkError("maxWaitMs must be greater than zero");
+    }
+    const startedAt = Date.now();
+    while (true) {
+      const result = await this.fetch(handle, options);
+      if (isTerminalState(result.state)) {
+        return result;
+      }
+      const elapsed = Date.now() - startedAt;
+      if (elapsed >= maxWaitMs) {
+        throw new WaitTimeoutError(handle.jobId, result, maxWaitMs);
+      }
+      await abortableDelay(Math.min(pollIntervalMs, maxWaitMs - elapsed), options.signal);
+    }
+  }
+};
+async function abortableDelay(milliseconds, signal) {
+  if (signal?.aborted) {
+    throw new RequestAbortedError();
+  }
+  await new Promise((resolve, reject) => {
+    const complete = () => {
+      signal?.removeEventListener("abort", abort);
+      resolve();
+    };
+    const timer = setTimeout(complete, milliseconds);
+    const abort = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", abort);
+      reject(new RequestAbortedError());
+    };
+    signal?.addEventListener("abort", abort, { once: true });
+  });
+}
+var VideosApi = class {
+  gemini;
+  midjourney;
+  happyhorse;
+  flux;
+  constructor(transport) {
+    this.gemini = new GeminiVideosApi(transport);
+    this.midjourney = new MidjourneyVideosApi(transport);
+    this.happyhorse = new HappyHorseVideosApi(transport);
+    this.flux = new FluxVideosApi(transport);
+  }
+};
+var GeminiVideosApi = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async generate(request, options = {}) {
+    const body = mergePayload(request.extra, {
+      prompt: request.prompt,
+      model: request.model,
+      aspect_ratio: request.aspectRatio,
+      ...request.resolution === void 0 ? {} : { resolution: request.resolution },
+      ...request.duration === void 0 ? {} : { duration: request.duration },
+      ...request.generationType === void 0 ? {} : { generation_type: request.generationType },
+      reference_images: request.referenceImages ?? [],
+      reference_videos: request.referenceVideos ?? []
+    });
+    const response = await this.transport.request("POST", "/api/video/gemini/generate", {
+      ...options,
+      body
+    });
+    return jobHandle(response, "gemini_video", "/api/video/gemini/fetch");
+  }
+};
+var FluxVideosApi = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async generate(request, options = {}) {
+    const body = mergePayload(request.extra, {
+      prompt: request.prompt,
+      ...request.model === void 0 ? {} : { model: request.model },
+      ...request.mode === void 0 ? {} : { mode: request.mode },
+      ...request.aspectRatio === void 0 ? {} : { aspect_ratio: request.aspectRatio },
+      ...request.duration === void 0 ? {} : { duration: request.duration },
+      ...request.resolution === void 0 ? {} : { resolution: request.resolution },
+      ...request.generateAudio === void 0 ? {} : { generate_audio: request.generateAudio },
+      ...request.keyframes === void 0 ? {} : { keyframes: request.keyframes },
+      ...request.startVideo === void 0 ? {} : { start_video: request.startVideo },
+      ...request.draft === void 0 ? {} : { draft: request.draft }
+    });
+    const response = await this.transport.request("POST", "/api/video/flux/v1/generate", {
+      ...options,
+      body
+    });
+    return jobHandle(response, "flux_video", "/api/video/flux/v1/fetch");
+  }
+};
+var MidjourneyVideosApi = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async submit(request, options = {}) {
+    const body = mergePayload(request.extra, {
+      prompt: request.prompt,
+      ...request.imageUrl === void 0 ? {} : { imageUrl: request.imageUrl },
+      ...request.model === void 0 ? {} : { model: request.model },
+      ...request.manual === void 0 ? {} : { manual: request.manual },
+      ...request.resolution === void 0 ? {} : { resolution: request.resolution },
+      ...request.bs === void 0 ? {} : { bs: request.bs }
+    });
+    const response = await this.transport.request(
+      "POST",
+      "/api/video/midjourney/v1/submit",
+      { ...options, body }
+    );
+    return jobHandle(response, "midjourney_video", "/api/video/midjourney/v1/fetch");
+  }
+  async extend(request, options = {}) {
+    const body = mergePayload(request.extra, {
+      jobId: request.jobId,
+      index: request.index,
+      ...request.animateMode === void 0 ? {} : { animateMode: request.animateMode },
+      ...request.manual === void 0 ? {} : { manual: request.manual },
+      ...request.bs === void 0 ? {} : { bs: request.bs }
+    });
+    const response = await this.transport.request(
+      "POST",
+      "/api/video/midjourney/v1/extend",
+      { ...options, body }
+    );
+    return jobHandle(
+      response,
+      "midjourney_video_extend",
+      "/api/video/midjourney/v1/fetch"
+    );
+  }
+};
+var HappyHorseVideosApi = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async textToVideo(request, options = {}) {
+    return await this.submit(
+      "/api/video/happyhorse/text-to-video",
+      "happyhorse_text_to_video",
+      request,
+      options
+    );
+  }
+  async imageToVideo(request, options = {}) {
+    return await this.submit(
+      "/api/video/happyhorse/image-to-video",
+      "happyhorse_image_to_video",
+      request,
+      options
+    );
+  }
+  async referenceToVideo(request, options = {}) {
+    return await this.submit(
+      "/api/video/happyhorse/reference-to-video",
+      "happyhorse_reference_to_video",
+      request,
+      options
+    );
+  }
+  async videoEdit(request, options = {}) {
+    return await this.submit(
+      "/api/video/happyhorse/video-edit",
+      "happyhorse_video_edit",
+      request,
+      options
+    );
+  }
+  async submit(path, operation, request, options) {
+    const body = mergePayload(request.extra, {
+      model: request.model,
+      input: {
+        ...request.input.prompt === void 0 ? {} : { prompt: request.input.prompt },
+        media: (request.input.media ?? []).map((item) => ({ type: item.type, url: item.url }))
+      },
+      parameters: request.parameters ?? {}
+    });
+    const response = await this.transport.request("POST", path, { ...options, body });
+    return jobHandle(response, operation, "/api/video/happyhorse/fetch");
+  }
+};
+var DaiMediaClient = class {
+  images;
+  videos;
+  audio;
+  jobs;
+  baseUrl;
+  timeoutMs;
+  #transport;
+  constructor(configuration) {
+    this.#transport = new Transport(configuration);
+    this.images = new ImagesApi(this.#transport);
+    this.videos = new VideosApi(this.#transport);
+    this.audio = new AudioApi(this.#transport);
+    this.jobs = new JobsApi(this.#transport);
+    this.baseUrl = this.#transport.baseUrl;
+    this.timeoutMs = this.#transport.timeoutMs;
+  }
+  toString() {
+    return `DaiMediaClient(baseUrl=${JSON.stringify(this.baseUrl)}, apiKey="[REDACTED]")`;
+  }
+};
+
+// src/client.ts
+function createMediaClient(config, options = {}) {
+  return new DaiMediaClient({
+    apiKey: config.apiKey,
+    ...config.baseUrl === void 0 ? {} : { baseUrl: config.baseUrl },
+    ...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs },
+    ...options.fetch === void 0 ? {} : { fetch: options.fetch }
+  });
+}
+
+// src/catalog.ts
+var PROVIDER_ID = "dai";
+var DEFAULT_IMAGE_MODEL = "gpt-image-2.5-flare";
+var DEFAULT_VIDEO_MODEL = "veo-3.1-quality";
+var DEFAULT_MUSIC_MODEL = "chirp-v5-5";
+var IMAGE_MODELS = [
+  { id: "gpt-image-2.5-flare", family: "openai", generate: true, edit: false },
+  { id: "gpt-image-2.5-sunburst", family: "openai", generate: true, edit: false },
+  { id: "gpt-image-2-plus", family: "openai", generate: true, edit: false },
+  { id: "gpt-image-2", family: "openai", generate: true, edit: false },
+  { id: "gpt-image-1.5", family: "openai", generate: true, edit: false },
+  { id: "gemini-3-pro-image-preview", family: "gemini", generate: true, edit: true },
+  { id: "gemini-3.1-flash-image-preview", family: "gemini", generate: true, edit: true },
+  { id: "gemini-3.1-flash-image", family: "gemini", generate: true, edit: true },
+  { id: "gemini-3.1-flash-lite-image", family: "gemini", generate: true, edit: true },
+  { id: "flux-2-max", family: "flux", generate: true, edit: true },
+  { id: "flux-2-pro", family: "flux", generate: true, edit: true },
+  { id: "flux-2-flex", family: "flux", generate: true, edit: true },
+  { id: "flux-2-klein-9b", family: "flux", generate: true, edit: true },
+  { id: "flux-2-klein-4b", family: "flux", generate: true, edit: true },
+  { id: "flux-kontext-max", family: "flux", generate: true, edit: true },
+  { id: "flux-kontext-pro", family: "flux", generate: true, edit: true },
+  { id: "flux1-pro", family: "flux", generate: true, edit: true },
+  { id: "flux1-dev", family: "flux", generate: true, edit: true },
+  { id: "flux1-schnell", family: "flux", generate: false, edit: true }
+];
+var VIDEO_MODELS = [
+  {
+    id: "veo-3.1-quality",
+    family: "gemini",
+    generate: true,
+    imageToVideo: true,
+    videoToVideo: false
+  },
+  {
+    id: "veo-3.1-fast",
+    family: "gemini",
+    generate: true,
+    imageToVideo: true,
+    videoToVideo: false
+  },
+  {
+    id: "veo-3.1-lite",
+    family: "gemini",
+    generate: true,
+    imageToVideo: true,
+    videoToVideo: false
+  },
+  {
+    id: "omni-flash",
+    family: "gemini",
+    generate: true,
+    imageToVideo: true,
+    videoToVideo: true
+  },
+  {
+    id: "flux-3-video",
+    family: "flux",
+    generate: true,
+    imageToVideo: true,
+    videoToVideo: true
+  }
+];
+var MUSIC_MODELS = [
+  "chirp-v5-5",
+  "chirp-v5",
+  "chirp-v4-5+",
+  "chirp-v4-5",
+  "chirp-v4-5-all",
+  "chirp-v4",
+  "chirp-v3-5",
+  "chirp-v3-0"
+];
+var liveImages;
+var liveVideos;
+var liveMusic;
+var imageById = new Map(IMAGE_MODELS.map((model) => [model.id, model]));
+var videoById = new Map(VIDEO_MODELS.map((model) => [model.id, model]));
+var musicIds = new Set(MUSIC_MODELS);
+function currentImageModels() {
+  return liveImages ?? IMAGE_MODELS;
+}
+function currentVideoModels() {
+  return liveVideos ?? VIDEO_MODELS;
+}
+function currentMusicModels() {
+  return liveMusic ?? MUSIC_MODELS;
+}
+function applyDiscoveredMedia(input) {
+  liveImages = input.images.length > 0 ? input.images : void 0;
+  liveVideos = input.videos.length > 0 ? input.videos : void 0;
+  liveMusic = input.music.length > 0 ? input.music : void 0;
+  rebuildLookups();
+}
+function rebuildLookups() {
+  imageById = new Map(currentImageModels().map((model) => [model.id, model]));
+  videoById = new Map(currentVideoModels().map((model) => [model.id, model]));
+  musicIds = new Set(currentMusicModels());
+}
+function stripProviderPrefix(model) {
+  const trimmed = model?.trim() ?? "";
+  if (trimmed.startsWith(`${PROVIDER_ID}/`)) {
+    return trimmed.slice(PROVIDER_ID.length + 1);
+  }
+  return trimmed;
+}
+function resolveImageModel(model) {
+  const id = stripProviderPrefix(model) || DEFAULT_IMAGE_MODEL;
+  const spec = imageById.get(id);
+  if (!spec) {
+    throw new Error(`Unknown D.AI image model: ${id}`);
+  }
+  return spec;
+}
+function resolveVideoModel(model) {
+  const id = stripProviderPrefix(model) || DEFAULT_VIDEO_MODEL;
+  const spec = videoById.get(id);
+  if (!spec) {
+    throw new Error(`Unknown D.AI video model: ${id}`);
+  }
+  return spec;
+}
+function resolveMusicModel(model) {
+  const id = stripProviderPrefix(model) || DEFAULT_MUSIC_MODEL;
+  if (!musicIds.has(id)) {
+    throw new Error(`Unknown D.AI music model: ${id}`);
+  }
+  return id;
+}
+function assertImageMode(spec, edit) {
+  if (edit && !spec.edit) {
+    throw new Error(`${spec.id} does not support image edits.`);
+  }
+  if (!edit && !spec.generate) {
+    throw new Error(
+      spec.id === "flux1-schnell" ? "flux1-schnell is edits-only. Use a reference image, or generate with flux1-dev." : `${spec.id} does not support text-to-image generation.`
+    );
+  }
+}
+function imageModelIds() {
+  return currentImageModels().map((model) => `${PROVIDER_ID}/${model.id}`);
+}
+function videoModelIds() {
+  return currentVideoModels().map((model) => `${PROVIDER_ID}/${model.id}`);
+}
+function musicModelIds() {
+  return currentMusicModels().map((model) => `${PROVIDER_ID}/${model}`);
+}
+
+// src/config.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join } from "path";
+
+// src/errors.ts
+var PROVIDER_LEAK = /provider_code|ttapi|upstream job|route_id/iu;
+var DaiPluginError = class extends Error {
+  name = "DaiPluginError";
+};
+function missingApiKeyError() {
+  return new DaiPluginError(
+    "Set DAI_API_KEY, write ~/.pi/agent/dai.json, or run /dai key."
+  );
+}
+function toUserError(error) {
+  if (error instanceof DaiPluginError) {
+    return error;
+  }
+  if (error instanceof RequestAbortedError || error instanceof RequestTimeoutError) {
+    return new DaiPluginError("Generation cancelled or timed out.");
+  }
+  if (error instanceof WaitTimeoutError) {
+    return new DaiPluginError("Generation cancelled or timed out.");
+  }
+  if (error instanceof ApiError) {
+    if (error.status === 401 || error.status === 403) {
+      return new DaiPluginError("Invalid D.AI API key.");
+    }
+    if (error.status === 402 || /余额不足|insufficient_quota/iu.test(error.message)) {
+      return new DaiPluginError("D.AI \u4F59\u989D\u4E0D\u8DB3\u3002");
+    }
+    if (error.status >= 400 && error.status < 500) {
+      return new DaiPluginError(sanitize(publicMessage(error)));
+    }
+    return new DaiPluginError("Generation failed.");
+  }
+  if (error instanceof Error) {
+    return new DaiPluginError(sanitize(error.message));
+  }
+  return new DaiPluginError("Generation failed.");
+}
+function publicMessage(error) {
+  const rawMessage = typeof error.raw?.message === "string" ? error.raw.message : error.message.replace(/ \(HTTP \d+\)$/u, "");
+  return rawMessage.trim() || "Generation failed.";
+}
+function sanitize(message) {
+  const cleaned = message.replace(PROVIDER_LEAK, "").replace(/\s+/gu, " ").trim();
+  return cleaned.length > 0 ? cleaned : "Generation failed.";
+}
+
+// src/config.ts
+function configPath() {
+  return join(homedir(), ".pi", "agent", "dai.json");
+}
+async function loadFileConfig(path = configPath()) {
+  try {
+    const raw = JSON.parse(await readFile(path, "utf8"));
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+      return {};
+    }
+    const record = raw;
+    return {
+      ...typeof record.apiKey === "string" ? { apiKey: record.apiKey } : {},
+      ...typeof record.baseUrl === "string" ? { baseUrl: record.baseUrl } : {}
+    };
+  } catch (error) {
+    if (isMissingFile(error)) {
+      return {};
+    }
+    throw error;
+  }
+}
+async function saveFileConfig(config, path = configPath()) {
+  await mkdir(dirname(path), { recursive: true });
+  const current = await loadFileConfig(path);
+  const next = {
+    ...current,
+    ...config.apiKey === void 0 ? {} : { apiKey: config.apiKey.trim() },
+    ...config.baseUrl === void 0 ? {} : { baseUrl: config.baseUrl.trim() }
+  };
+  await writeFile(`${path}`, `${JSON.stringify(next, null, 2)}
+`, { mode: 384 });
+}
+async function resolveConfig(env = process.env, path = configPath()) {
+  const file = await loadFileConfig(path);
+  const apiKey = firstNonEmpty(file.apiKey, env.DAI_API_KEY);
+  if (!apiKey) {
+    throw missingApiKeyError();
+  }
+  const baseUrl = firstNonEmpty(file.baseUrl, env.DAI_BASE_URL);
+  return baseUrl === void 0 ? { apiKey } : { apiKey, baseUrl };
+}
+function hasApiKey(config, env = process.env) {
+  return Boolean(firstNonEmpty(config.apiKey, env.DAI_API_KEY));
+}
+function firstNonEmpty(...values) {
+  for (const value of values) {
+    const trimmed = value?.trim();
+    if (trimmed) {
+      return trimmed;
+    }
+  }
+  return void 0;
+}
+function isMissingFile(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+
+// src/origin.ts
+var DEFAULT_BASE_URL2 = "https://dai.itbug.shop";
+function normalizeOrigin(baseUrl) {
+  return baseUrl.replace(/\/+$/u, "").replace(/\/v1$/u, "");
+}
+
+// src/discover.ts
+async function discoverDaiCatalog(options = {}) {
+  const origin = normalizeOrigin(options.origin ?? DEFAULT_BASE_URL2);
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const docs = await fetchJson(
+    fetchImpl,
+    `${origin}/api/system/public/capability-docs`,
+    options.signal
+  );
+  const catalog = parseCapabilityDocs(docs);
+  if (options.apiKey) {
+    const listed = await fetchJson(
+      fetchImpl,
+      `${origin}/v1/models`,
+      options.signal,
+      options.apiKey
+    );
+    const allowed = new Set(
+      (listed.data ?? []).map((model) => model.id?.trim()).filter((id) => Boolean(id))
+    );
+    if (allowed.size > 0) {
+      catalog.chat = catalog.chat.filter((model) => allowed.has(model.id));
+    }
+  }
+  applyDiscoveredMedia({
+    images: catalog.images,
+    videos: catalog.videos,
+    music: catalog.music
+  });
+  return catalog;
+}
+function parseCapabilityDocs(docs) {
+  const chat = [];
+  const images = [];
+  const videos = [];
+  const music = [];
+  const seenChat = /* @__PURE__ */ new Set();
+  const seenImage = /* @__PURE__ */ new Set();
+  const seenVideo = /* @__PURE__ */ new Set();
+  const seenMusic = /* @__PURE__ */ new Set();
+  for (const capability of docs.data ?? []) {
+    const code = capability.capability_code?.trim() ?? "";
+    for (const model of capability.models ?? []) {
+      const id = model.model_code?.trim();
+      if (!id) {
+        continue;
+      }
+      if (code === "openai_chat_completions" && model.token_rate) {
+        if (seenChat.has(id)) {
+          continue;
+        }
+        seenChat.add(id);
+        chat.push(toChatModel(id, model));
+        continue;
+      }
+      if (code === "openai_image" || code === "gemini_image" || code === "flux_image") {
+        if (seenImage.has(id)) {
+          continue;
+        }
+        seenImage.add(id);
+        images.push(toImageSpec(code, id));
+        continue;
+      }
+      if (code === "gemini_video" || code === "flux_video") {
+        if (seenVideo.has(id)) {
+          continue;
+        }
+        seenVideo.add(id);
+        videos.push(toVideoSpec(code, id));
+        continue;
+      }
+      if (code === "suno_music") {
+        if (seenMusic.has(id)) {
+          continue;
+        }
+        seenMusic.add(id);
+        music.push(id);
+      }
+    }
+  }
+  return { chat, images, videos, music };
+}
+function toChatModel(id, model) {
+  const path = model.integration_docs?.path ?? "";
+  const responses = path.includes("/responses");
+  const rate = model.token_rate;
+  return {
+    id,
+    name: model.display_name?.trim() || id,
+    api: responses ? "openai-responses" : "openai-completions",
+    reasoning: /gpt-5|o1|o3|o4|reason/iu.test(id),
+    input: ["text"],
+    cost: {
+      input: rate?.input_usd_per_1m_tokens ?? 0,
+      output: rate?.output_usd_per_1m_tokens ?? 0,
+      cacheRead: 0,
+      cacheWrite: 0
+    },
+    contextWindow: Math.max(1, rate?.context_window_tokens ?? 128e3),
+    maxTokens: Math.max(1, rate?.prepay_completion_token_limit ?? 16384)
+  };
+}
+function toImageSpec(capability, id) {
+  if (capability === "openai_image") {
+    return { id, family: "openai", generate: true, edit: false };
+  }
+  if (capability === "gemini_image") {
+    return { id, family: "gemini", generate: true, edit: true };
+  }
+  return {
+    id,
+    family: "flux",
+    generate: id !== "flux1-schnell",
+    edit: true
+  };
+}
+function toVideoSpec(capability, id) {
+  if (capability === "flux_video") {
+    return { id, family: "flux", generate: true, imageToVideo: true, videoToVideo: true };
+  }
+  return {
+    id,
+    family: "gemini",
+    generate: true,
+    imageToVideo: true,
+    videoToVideo: id === "omni-flash"
+  };
+}
+async function fetchJson(fetchImpl, url, signal, apiKey) {
+  const headers = new Headers();
+  if (apiKey) {
+    headers.set("Authorization", `Bearer ${apiKey}`);
+  }
+  const response = await fetchImpl(url, {
+    headers,
+    ...signal === void 0 ? {} : { signal }
+  });
+  if (!response.ok) {
+    throw new Error(`D.AI catalog request failed (HTTP ${response.status}).`);
+  }
+  return await response.json();
+}
+
+// src/assets.ts
+import { readFile as readFile2 } from "fs/promises";
+import { basename, extname } from "path";
+var HTTP_URL = /^https?:\/\//iu;
+var DATA_URL = /^data:/iu;
+var FILE_URL = /^file:/iu;
+function collectReferences(request) {
+  const images = [
+    ...request.image ? [request.image] : [],
+    ...request.images ?? []
+  ].filter((value) => value.trim().length > 0);
+  const videos = [
+    ...request.video ? [request.video] : [],
+    ...request.videos ?? []
+  ].filter((value) => value.trim().length > 0);
+  return { images, videos };
+}
+function optionalSignal(signal) {
+  return signal === void 0 ? {} : { signal };
+}
+async function toRemoteMedia(value, options = {}) {
+  const trimmed = value.trim();
+  if (HTTP_URL.test(trimmed) || DATA_URL.test(trimmed)) {
+    return trimmed;
+  }
+  if (FILE_URL.test(trimmed)) {
+    return dataUrlFromFile(fileURLToPathSafe(trimmed), options);
+  }
+  return dataUrlFromFile(trimmed, options);
+}
+function absoluteAssetUrl(baseUrl, asset) {
+  const trimmed = asset.trim();
+  if (HTTP_URL.test(trimmed) || DATA_URL.test(trimmed)) {
+    return trimmed;
+  }
+  if (trimmed.startsWith("/")) {
+    return new URL(trimmed, ensureTrailingSlash(baseUrl)).toString();
+  }
+  return trimmed;
+}
+async function fetchMediaBuffer(url, options = {}) {
+  const response = await fetch(url, optionalSignal(options.signal));
+  if (!response.ok) {
+    throw new Error("Generated media could not be downloaded.");
+  }
+  const mimeType = response.headers.get("content-type")?.split(";")[0]?.trim() || guessMime(url);
+  const buffer = Buffer.from(await response.arrayBuffer());
+  if (buffer.byteLength === 0) {
+    throw new Error("Generated media was empty.");
+  }
+  return {
+    buffer,
+    mimeType,
+    fileName: options.fileName ?? filenameFromUrl(url, mimeType)
+  };
+}
+async function dataUrlFromFile(filePath, options) {
+  if (options.signal?.aborted) {
+    throw options.signal.reason instanceof Error ? options.signal.reason : new Error("Generation cancelled or timed out.");
+  }
+  const bytes = await readFile2(filePath);
+  const mime = guessMime(filePath);
+  return `data:${mime};base64,${bytes.toString("base64")}`;
+}
+function fileURLToPathSafe(value) {
+  return new URL(value).pathname;
+}
+function ensureTrailingSlash(baseUrl) {
+  return baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+}
+function guessMime(path) {
+  switch (extname(path).toLowerCase()) {
+    case ".png":
+      return "image/png";
+    case ".jpg":
+    case ".jpeg":
+      return "image/jpeg";
+    case ".webp":
+      return "image/webp";
+    case ".gif":
+      return "image/gif";
+    case ".mp4":
+      return "video/mp4";
+    case ".webm":
+      return "video/webm";
+    case ".mp3":
+      return "audio/mpeg";
+    case ".wav":
+      return "audio/wav";
+    default:
+      return "application/octet-stream";
+  }
+}
+function filenameFromUrl(url, mimeType) {
+  try {
+    const name = basename(new URL(url).pathname);
+    if (name) {
+      return name;
+    }
+  } catch {
+  }
+  const ext = mimeType.split("/")[1] ?? "bin";
+  return `dai-media.${ext}`;
+}
+
+// src/image.ts
+var FLUX_WAIT_MS = 3 * 6e4;
+async function generateDaiImage(client, request) {
+  try {
+    const spec = resolveImageModel(request.model);
+    const refs = collectReferences(request);
+    const edit = refs.images.length > 0;
+    assertImageMode(spec, edit);
+    const remoteImages = await Promise.all(
+      refs.images.map((image) => toRemoteMedia(image, optionalSignal(request.signal)))
+    );
+    if (spec.family === "openai") {
+      const result = await client.images.openai.generate(
+        {
+          prompt: request.prompt,
+          model: spec.id,
+          ...request.size === void 0 ? {} : { size: request.size },
+          ...request.quality === void 0 ? {} : { quality: request.quality },
+          ...request.outputFormat === void 0 ? {} : { outputFormat: request.outputFormat },
+          ...request.background === void 0 ? {} : { background: request.background },
+          ...request.count === void 0 ? {} : { n: request.count }
+        },
+        optionalSignal(request.signal)
+      );
+      return { images: await buffersFromImageResult(client, result, request) };
+    }
+    if (spec.family === "gemini") {
+      const result = await client.images.gemini.generate(
+        {
+          model: spec.id,
+          prompt: request.prompt,
+          ...request.aspectRatio === void 0 ? {} : { aspectRatio: request.aspectRatio },
+          referenceImages: remoteImages
+        },
+        optionalSignal(request.signal)
+      );
+      return { images: await buffersFromImageResult(client, result, request) };
+    }
+    const job = edit ? await client.images.flux.edits(
+      {
+        prompt: request.prompt,
+        model: spec.id,
+        image: remoteImages.length === 1 ? remoteImages[0] : remoteImages,
+        ...request.size === void 0 ? {} : { size: request.size }
+      },
+      optionalSignal(request.signal)
+    ) : await client.images.flux.generate(
+      {
+        prompt: request.prompt,
+        model: spec.id,
+        ...request.size === void 0 ? {} : { size: request.size }
+      },
+      optionalSignal(request.signal)
+    );
+    const waited = await client.jobs.wait(job, {
+      pollIntervalMs: 2e3,
+      maxWaitMs: FLUX_WAIT_MS,
+      ...optionalSignal(request.signal)
+    });
+    return { images: await buffersFromJob(client, waited, request, "image/png") };
+  } catch (error) {
+    throw toUserError(error);
+  }
+}
+async function buffersFromImageResult(client, result, request) {
+  const images = [];
+  for (const [index, image] of result.images.entries()) {
+    if (image.b64Json) {
+      images.push({
+        buffer: Buffer.from(image.b64Json, "base64"),
+        mimeType: mimeFromFormat(request.outputFormat),
+        fileName: request.filename ?? `dai-image-${index + 1}.png`
+      });
+      continue;
+    }
+    if (!image.url) {
+      continue;
+    }
+    images.push(
+      await fetchMediaBuffer(absoluteAssetUrl(client.baseUrl, image.url), {
+        ...optionalSignal(request.signal),
+        ...request.filename === void 0 ? {} : { fileName: request.filename }
+      })
+    );
+  }
+  if (images.length === 0) {
+    throw new Error("D.AI did not return an image.");
+  }
+  return images;
+}
+async function buffersFromJob(client, result, request, fallbackMime) {
+  if (result.state === "failed") {
+    throw new Error(result.errorMessage ?? "Generation failed.");
+  }
+  const images = [];
+  for (const [index, asset] of result.assets.entries()) {
+    images.push(
+      await fetchMediaBuffer(absoluteAssetUrl(client.baseUrl, asset), {
+        ...optionalSignal(request.signal),
+        fileName: request.filename ?? `dai-image-${index + 1}.${extensionFor(fallbackMime)}`
+      })
+    );
+  }
+  if (images.length === 0) {
+    throw new Error("D.AI did not return an image.");
+  }
+  return images;
+}
+function mimeFromFormat(format) {
+  switch (format) {
+    case "jpeg":
+      return "image/jpeg";
+    case "webp":
+      return "image/webp";
+    default:
+      return "image/png";
+  }
+}
+function extensionFor(mimeType) {
+  return mimeType.split("/")[1] ?? "bin";
+}
+
+// src/music.ts
+var MUSIC_WAIT_MS = 5 * 6e4;
+async function generateDaiMusic(client, request) {
+  try {
+    const mv = resolveMusicModel(request.model);
+    const lyrics = request.lyrics?.trim();
+    const custom = Boolean(lyrics);
+    const job = await client.audio.suno.music(
+      {
+        custom,
+        instrumental: request.instrumental ?? !custom,
+        mv,
+        ...custom && lyrics !== void 0 ? { prompt: lyrics } : { gptDescriptionPrompt: request.prompt }
+      },
+      optionalSignal(request.signal)
+    );
+    const waited = await client.jobs.wait(job, {
+      pollIntervalMs: 2e3,
+      maxWaitMs: MUSIC_WAIT_MS,
+      ...optionalSignal(request.signal)
+    });
+    return { tracks: remoteMediaFromJob(client, waited, request, "audio/mpeg") };
+  } catch (error) {
+    throw toUserError(error);
+  }
+}
+function remoteMediaFromJob(client, result, request, mimeType) {
+  if (result.state === "failed") {
+    throw new Error(result.errorMessage ?? "Generation failed.");
+  }
+  const tracks = result.assets.map((asset) => ({
+    url: absoluteAssetUrl(client.baseUrl, asset),
+    mimeType,
+    ...request.filename === void 0 ? {} : { fileName: request.filename }
+  }));
+  if (tracks.length === 0) {
+    throw new Error("D.AI did not return audio.");
+  }
+  return tracks;
+}
+
+// src/provider.ts
+import { createProvider } from "@earendil-works/pi-ai";
+import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completions.lazy";
+import { openAIResponsesApi } from "@earendil-works/pi-ai/api/openai-responses.lazy";
+function registerDaiProvider(pi) {
+  pi.registerProvider(
+    createProvider({
+      id: "dai",
+      name: "D.AI",
+      baseUrl: `${DEFAULT_BASE_URL2}/v1`,
+      auth: {
+        apiKey: {
+          name: "D.AI API key",
+          async login(interaction) {
+            const key = await interaction.prompt({
+              type: "secret",
+              message: "D.AI API key (ddsk_...)",
+              placeholder: "ddsk_..."
+            });
+            const trimmed = key.trim();
+            await saveFileConfig({ apiKey: trimmed });
+            process.env.DAI_API_KEY = trimmed;
+            return { type: "api_key", key: trimmed };
+          },
+          async resolve({
+            credential,
+            ctx
+          }) {
+            const file = await loadFileConfig();
+            const key = credential?.key?.trim() || await ctx.env("DAI_API_KEY") || file.apiKey?.trim();
+            if (!key) {
+              return void 0;
+            }
+            const origin = normalizeOrigin(file.baseUrl ?? DEFAULT_BASE_URL2);
+            return {
+              auth: { apiKey: key, baseUrl: `${origin}/v1` },
+              source: credential?.key ? "stored D.AI API key" : "DAI_API_KEY"
+            };
+          }
+        }
+      },
+      models: [],
+      async fetchModels(context) {
+        if (!context.allowNetwork) {
+          return context.stored?.models ?? [];
+        }
+        const file = await loadFileConfig();
+        const key = (context.credential && "key" in context.credential ? context.credential.key : void 0) || file.apiKey;
+        const origin = normalizeOrigin(file.baseUrl ?? DEFAULT_BASE_URL2);
+        const catalog = await discoverDaiCatalog({
+          origin,
+          ...key === void 0 ? {} : { apiKey: key },
+          signal: context.signal
+        });
+        return toPiModels(catalog.chat, `${origin}/v1`);
+      },
+      api: {
+        "openai-completions": openAICompletionsApi(),
+        "openai-responses": openAIResponsesApi()
+      }
+    })
+  );
+}
+function toPiModels(models, baseUrl) {
+  return models.map((model) => ({
+    id: model.id,
+    name: model.name,
+    api: model.api,
+    provider: "dai",
+    baseUrl,
+    reasoning: model.reasoning,
+    input: model.input,
+    cost: model.cost,
+    contextWindow: model.contextWindow,
+    maxTokens: model.maxTokens
+  }));
+}
+
+// src/video.ts
+var VIDEO_WAIT_MS = 12 * 6e4;
+async function generateDaiVideo(client, request) {
+  try {
+    const spec = resolveVideoModel(request.model);
+    const refs = collectReferences(request);
+    if (refs.images.length > 0 && refs.videos.length > 0) {
+      throw new Error("Use either reference images or a reference video, not both.");
+    }
+    if (refs.videos.length > 0 && !spec.videoToVideo) {
+      throw new Error(`${spec.id} does not support video-to-video.`);
+    }
+    if (refs.images.length > 0 && !spec.imageToVideo) {
+      throw new Error(`${spec.id} does not support image-to-video.`);
+    }
+    const remoteImages = await Promise.all(
+      refs.images.map((image) => toRemoteMedia(image, optionalSignal(request.signal)))
+    );
+    const remoteVideos = await Promise.all(
+      refs.videos.map((video) => toRemoteMedia(video, optionalSignal(request.signal)))
+    );
+    const job = spec.family === "gemini" ? await client.videos.gemini.generate(
+      {
+        prompt: request.prompt,
+        model: spec.id,
+        aspectRatio: request.aspectRatio === "9:16" ? "9:16" : "16:9",
+        ...request.resolution === void 0 ? {} : { resolution: mapGeminiResolution(request.resolution) },
+        ...request.durationSeconds === void 0 ? {} : { duration: request.durationSeconds },
+        ...remoteImages.length > 0 ? { generationType: "frame", referenceImages: remoteImages } : {},
+        ...remoteVideos.length > 0 ? { referenceVideos: remoteVideos } : {}
+      },
+      optionalSignal(request.signal)
+    ) : await client.videos.flux.generate(
+      {
+        prompt: request.prompt,
+        model: spec.id,
+        mode: fluxMode(remoteImages, remoteVideos),
+        ...request.aspectRatio === void 0 ? {} : { aspectRatio: request.aspectRatio },
+        ...request.durationSeconds === void 0 ? {} : { duration: clampFluxDuration(request.durationSeconds) },
+        ...request.resolution === void 0 ? {} : { resolution: mapFluxResolution(request.resolution) },
+        ...request.audio === void 0 ? {} : { generateAudio: request.audio },
+        ...remoteImages.length > 0 ? { keyframes: remoteImages } : {},
+        ...remoteVideos[0] === void 0 ? {} : { startVideo: remoteVideos[0] }
+      },
+      optionalSignal(request.signal)
+    );
+    const waited = await client.jobs.wait(job, {
+      pollIntervalMs: 3e3,
+      maxWaitMs: VIDEO_WAIT_MS,
+      ...optionalSignal(request.signal)
+    });
+    return { videos: remoteMediaFromJob2(client, waited, request, "video/mp4") };
+  } catch (error) {
+    throw toUserError(error);
+  }
+}
+function fluxMode(images, videos) {
+  if (videos.length > 0) {
+    return "v2v";
+  }
+  if (images.length > 0) {
+    return "i2v";
+  }
+  return "t2v";
+}
+function clampFluxDuration(seconds) {
+  return Math.min(20, Math.max(5, Math.round(seconds)));
+}
+function mapGeminiResolution(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "1080p" || normalized === "1080" || normalized === "fhd") {
+    return "1080p";
+  }
+  return "720p";
+}
+function mapFluxResolution(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "1080p" || normalized === "1080" || normalized === "fhd" || normalized === "4k") {
+    return "fhd";
+  }
+  return "hd";
+}
+function remoteMediaFromJob2(client, result, request, mimeType) {
+  if (result.state === "failed") {
+    throw new Error(result.errorMessage ?? "Generation failed.");
+  }
+  const videos = result.assets.map((asset) => ({
+    url: absoluteAssetUrl(client.baseUrl, asset),
+    mimeType,
+    ...request.filename === void 0 ? {} : { fileName: request.filename }
+  }));
+  if (videos.length === 0) {
+    throw new Error("D.AI did not return a video.");
+  }
+  return videos;
+}
+
+// src/index.ts
+var optionalString = Type.Optional(Type.String());
+var optionalStringArray = Type.Optional(Type.Array(Type.String()));
+async function index_default(pi) {
+  registerDaiProvider(pi);
+  try {
+    const config = await resolveConfig();
+    await discoverDaiCatalog({
+      ...config.baseUrl === void 0 ? {} : { origin: config.baseUrl },
+      apiKey: config.apiKey
+    });
+  } catch {
+    try {
+      await discoverDaiCatalog();
+    } catch {
+    }
+  }
+  pi.registerTool({
+    name: "dai_generate_image",
+    label: "D.AI Image",
+    description: "Generate or edit an image through D.AI. Default model is dai/gpt-image-2.5-flare. GPT Image models are text-to-image only. Use Gemini Image or Flux for edits with a reference image. flux1-schnell is edits-only.",
+    promptSnippet: "Generate or edit images via D.AI (GPT Image 2.5, Gemini, Flux)",
+    promptGuidelines: [
+      "Use dai_generate_image when the user asks to generate or edit an image with D.AI.",
+      "Pass model as a public id such as gpt-image-2.5-flare or dai/flux-2-max."
+    ],
+    parameters: Type.Object({
+      prompt: Type.String({ description: "Image prompt or edit instruction." }),
+      model: optionalString,
+      image: optionalString,
+      images: optionalStringArray,
+      size: optionalString,
+      aspectRatio: optionalString,
+      quality: optionalString,
+      count: Type.Optional(Type.Number())
+    }),
+    async execute(_id, params, signal, onUpdate) {
+      try {
+        onUpdate?.({ content: [{ type: "text", text: "Generating image with D.AI..." }] });
+        const client = createMediaClient(await resolveConfig());
+        const result = await generateDaiImage(client, { ...params, ...optionalSignal(signal) });
+        const first = result.images[0];
+        if (!first) {
+          throw new Error("D.AI did not return an image.");
+        }
+        const model = params.model?.trim() || DEFAULT_IMAGE_MODEL;
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Generated with ${model}. ${result.images.length} image(s).`
+            },
+            {
+              type: "image",
+              source: {
+                type: "base64",
+                mediaType: first.mimeType,
+                data: first.buffer.toString("base64")
+              }
+            }
+          ],
+          details: { model, count: result.images.length, fileName: first.fileName }
+        };
+      } catch (error) {
+        const message = toUserError(error).message;
+        return { content: [{ type: "text", text: message }], isError: true, details: { error: message } };
+      }
+    }
+  });
+  pi.registerTool({
+    name: "dai_generate_video",
+    label: "D.AI Video",
+    description: "Generate video through D.AI. Default model is dai/veo-3.1-quality. Optional reference images become image-to-video; a reference video is video-to-video when the model supports it.",
+    promptSnippet: "Generate video via D.AI (Veo 3.1, omni-flash, Flux 3)",
+    promptGuidelines: [
+      "Use dai_generate_video when the user asks D.AI to generate a video."
+    ],
+    parameters: Type.Object({
+      prompt: Type.String({ description: "Video prompt." }),
+      model: optionalString,
+      image: optionalString,
+      images: optionalStringArray,
+      video: optionalString,
+      videos: optionalStringArray,
+      aspectRatio: optionalString,
+      resolution: optionalString,
+      durationSeconds: Type.Optional(Type.Number()),
+      audio: Type.Optional(Type.Boolean())
+    }),
+    async execute(_id, params, signal, onUpdate) {
+      try {
+        onUpdate?.({ content: [{ type: "text", text: "Submitting D.AI video job..." }] });
+        const client = createMediaClient(await resolveConfig());
+        const result = await generateDaiVideo(client, { ...params, ...optionalSignal(signal) });
+        const urls = result.videos.map((item) => item.url).join("\n");
+        return {
+          content: [{ type: "text", text: `Video ready:
+${urls}` }],
+          details: { model: params.model?.trim() || DEFAULT_VIDEO_MODEL, urls: result.videos.map((item) => item.url) }
+        };
+      } catch (error) {
+        const message = toUserError(error).message;
+        return { content: [{ type: "text", text: message }], isError: true, details: { error: message } };
+      }
+    }
+  });
+  pi.registerTool({
+    name: "dai_generate_music",
+    label: "D.AI Music",
+    description: "Generate music through D.AI Suno. Default model is dai/chirp-v5-5. Use lyrics for custom mode; otherwise the prompt is a style description.",
+    promptSnippet: "Generate music via D.AI Suno",
+    promptGuidelines: [
+      "Use dai_generate_music when the user asks D.AI to generate a song or instrumental."
+    ],
+    parameters: Type.Object({
+      prompt: Type.String({ description: "Style description, or ignored when lyrics are set." }),
+      model: optionalString,
+      lyrics: optionalString,
+      instrumental: Type.Optional(Type.Boolean())
+    }),
+    async execute(_id, params, signal, onUpdate) {
+      try {
+        onUpdate?.({ content: [{ type: "text", text: "Submitting D.AI music job..." }] });
+        const client = createMediaClient(await resolveConfig());
+        const result = await generateDaiMusic(client, { ...params, ...optionalSignal(signal) });
+        const urls = result.tracks.map((item) => item.url).join("\n");
+        return {
+          content: [{ type: "text", text: `Track ready:
+${urls}` }],
+          details: { model: params.model?.trim() || DEFAULT_MUSIC_MODEL, urls: result.tracks.map((item) => item.url) }
+        };
+      } catch (error) {
+        const message = toUserError(error).message;
+        return { content: [{ type: "text", text: message }], isError: true, details: { error: message } };
+      }
+    }
+  });
+  pi.registerCommand("dai", {
+    description: "D.AI media status, or `/dai key` to save an API key",
+    handler: async (args, ctx) => {
+      const trimmed = args.trim();
+      if (trimmed === "key" || trimmed.startsWith("key ")) {
+        const inline = trimmed.slice(3).trim();
+        const apiKey = inline || (ctx.hasUI ? await ctx.ui.input("D.AI API key", "ddsk_...") : void 0);
+        if (!apiKey?.trim()) {
+          ctx.ui.notify("No API key provided.", "warning");
+          return;
+        }
+        await saveFileConfig({ apiKey: apiKey.trim() });
+        ctx.ui.notify("Saved D.AI API key to ~/.pi/agent/dai.json", "info");
+        return;
+      }
+      const file = await loadFileConfig();
+      const ready = hasApiKey(file);
+      const models = [
+        `image ${DEFAULT_IMAGE_MODEL}`,
+        `video ${DEFAULT_VIDEO_MODEL}`,
+        `music ${DEFAULT_MUSIC_MODEL}`
+      ].join(" \xB7 ");
+      ctx.ui.notify(
+        ready ? `D.AI ready. Defaults: ${models}. Catalog ${imageModelIds().length} images, ${videoModelIds().length} videos, ${musicModelIds().length} music.` : "D.AI key missing. Run /login and choose D.AI, or /dai key / DAI_API_KEY.",
+        ready ? "info" : "warning"
+      );
+    }
+  });
+}
+export {
+  index_default as default
+};