@acedatacloud/sdk 2026.322.1 → 2026.418.1

package/dist/index.mjs

@@ -0,0 +1,665 @@
+// src/runtime/errors.ts
+var AceDataCloudError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AceDataCloudError";
+  }
+};
+var TransportError = class extends AceDataCloudError {
+  constructor(message) {
+    super(message);
+    this.name = "TransportError";
+  }
+};
+var APIError = class extends AceDataCloudError {
+  statusCode;
+  code;
+  traceId;
+  body;
+  constructor(opts) {
+    super(opts.message);
+    this.name = "APIError";
+    this.statusCode = opts.statusCode;
+    this.code = opts.code;
+    this.traceId = opts.traceId;
+    this.body = opts.body ?? {};
+  }
+};
+var AuthenticationError = class extends APIError {
+  constructor(opts) {
+    super(opts);
+    this.name = "AuthenticationError";
+  }
+};
+var TokenMismatchError = class extends APIError {
+  constructor(opts) {
+    super(opts);
+    this.name = "TokenMismatchError";
+  }
+};
+var RateLimitError = class extends APIError {
+  constructor(opts) {
+    super(opts);
+    this.name = "RateLimitError";
+  }
+};
+var ValidationError = class extends APIError {
+  constructor(opts) {
+    super(opts);
+    this.name = "ValidationError";
+  }
+};
+var InsufficientBalanceError = class extends APIError {
+  constructor(opts) {
+    super(opts);
+    this.name = "InsufficientBalanceError";
+  }
+};
+var ResourceDisabledError = class extends APIError {
+  constructor(opts) {
+    super(opts);
+    this.name = "ResourceDisabledError";
+  }
+};
+var ModerationError = class extends APIError {
+  constructor(opts) {
+    super(opts);
+    this.name = "ModerationError";
+  }
+};
+var TimeoutError = class extends APIError {
+  constructor(opts) {
+    super(opts);
+    this.name = "TimeoutError";
+  }
+};
+
+// src/runtime/transport.ts
+var ERROR_CODE_MAP = {
+  invalid_token: AuthenticationError,
+  token_expired: AuthenticationError,
+  no_token: AuthenticationError,
+  token_mismatched: TokenMismatchError,
+  used_up: InsufficientBalanceError,
+  disabled: ResourceDisabledError,
+  too_many_requests: RateLimitError,
+  bad_request: ValidationError
+};
+var RETRY_STATUS_CODES = /* @__PURE__ */ new Set([408, 409, 429, 500, 502, 503, 504]);
+function mapError(statusCode, body) {
+  const errorData = body.error ?? {};
+  const code = errorData.code ?? "";
+  const message = errorData.message ?? "";
+  const traceId = body.trace_id;
+  let ErrorClass = ERROR_CODE_MAP[code];
+  if (!ErrorClass) {
+    if (statusCode === 403) ErrorClass = ModerationError;
+    else if (statusCode === 401) ErrorClass = AuthenticationError;
+    else if (statusCode === 429) ErrorClass = RateLimitError;
+    else if (statusCode === 400) ErrorClass = ValidationError;
+    else ErrorClass = APIError;
+  }
+  return new ErrorClass({ message, statusCode, code, traceId, body });
+}
+function backoffDelay(attempt) {
+  const base = Math.min(2 ** attempt, 8);
+  return base + Math.random() * 0.5;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var Transport = class {
+  baseURL;
+  platformBaseURL;
+  timeout;
+  maxRetries;
+  headers;
+  constructor(opts = {}) {
+    const token = opts.apiToken ?? process.env.ACEDATACLOUD_API_TOKEN ?? "";
+    if (!token) {
+      throw new AuthenticationError({
+        message: "apiToken is required. Pass it to the client or set ACEDATACLOUD_API_TOKEN.",
+        statusCode: 0,
+        code: "no_token"
+      });
+    }
+    this.baseURL = (opts.baseURL ?? "https://api.acedata.cloud").replace(/\/+$/, "");
+    this.platformBaseURL = (opts.platformBaseURL ?? "https://platform.acedata.cloud").replace(/\/+$/, "");
+    this.timeout = opts.timeout ?? 3e5;
+    this.maxRetries = opts.maxRetries ?? 2;
+    this.headers = {
+      accept: "application/json",
+      authorization: `Bearer ${token}`,
+      "content-type": "application/json",
+      "user-agent": "acedatacloud-node/0.1.0",
+      ...opts.headers ?? {}
+    };
+  }
+  async request(method, path2, opts = {}) {
+    const base = opts.platform ? this.platformBaseURL : this.baseURL;
+    let url = `${base}${path2}`;
+    if (opts.params) {
+      const qs = new URLSearchParams(opts.params).toString();
+      url += `?${qs}`;
+    }
+    const headers = { ...this.headers, ...opts.headers ?? {} };
+    const timeoutMs = opts.timeout ?? this.timeout;
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeoutMs);
+      try {
+        const resp = await fetch(url, {
+          method,
+          headers,
+          body: opts.json ? JSON.stringify(opts.json) : void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timer);
+        if (resp.status >= 400) {
+          const text = await resp.text();
+          let body;
+          try {
+            body = JSON.parse(text);
+          } catch {
+            body = { error: { code: "unknown", message: text } };
+          }
+          if (RETRY_STATUS_CODES.has(resp.status) && attempt < this.maxRetries) {
+            await sleep(backoffDelay(attempt) * 1e3);
+            continue;
+          }
+          throw mapError(resp.status, body);
+        }
+        return await resp.json();
+      } catch (err) {
+        clearTimeout(timer);
+        if (err instanceof APIError) throw err;
+        lastError = err;
+        if (attempt < this.maxRetries) {
+          await sleep(backoffDelay(attempt) * 1e3);
+          continue;
+        }
+      }
+    }
+    throw lastError ?? new TransportError("Request failed after retries");
+  }
+  async *requestStream(method, path2, opts = {}) {
+    const url = `${this.baseURL}${path2}`;
+    const headers = { ...this.headers, accept: "text/event-stream" };
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), opts.timeout ?? this.timeout);
+    try {
+      const resp = await fetch(url, {
+        method,
+        headers,
+        body: opts.json ? JSON.stringify(opts.json) : void 0,
+        signal: controller.signal
+      });
+      if (resp.status >= 400) {
+        const text = await resp.text();
+        let body;
+        try {
+          body = JSON.parse(text);
+        } catch {
+          body = { error: { code: "unknown", message: text } };
+        }
+        throw mapError(resp.status, body);
+      }
+      if (!resp.body) throw new TransportError("No response body for stream");
+      const reader = resp.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            const data = line.slice(6);
+            if (data === "[DONE]") return;
+            yield data;
+          }
+        }
+      }
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async upload(path2, fileData, filename, opts = {}) {
+    const url = `${this.platformBaseURL}${path2}`;
+    const boundary = `----AceDataCloudBoundary${Date.now()}`;
+    const headers = {
+      ...this.headers,
+      "content-type": `multipart/form-data; boundary=${boundary}`
+    };
+    delete headers["content-type"];
+    const body = new FormData();
+    body.append("file", new Blob([fileData]), filename);
+    const authHeaders = {
+      authorization: this.headers.authorization,
+      "user-agent": this.headers["user-agent"]
+    };
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), opts.timeout ?? this.timeout);
+    try {
+      const resp = await fetch(url, {
+        method: "POST",
+        headers: authHeaders,
+        body,
+        signal: controller.signal
+      });
+      clearTimeout(timer);
+      if (resp.status >= 400) {
+        const text = await resp.text();
+        let respBody;
+        try {
+          respBody = JSON.parse(text);
+        } catch {
+          respBody = { error: { code: "unknown", message: text } };
+        }
+        throw mapError(resp.status, respBody);
+      }
+      return await resp.json();
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+
+// src/resources/chat.ts
+var Messages = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async create(opts) {
+    const { model, messages, maxTokens = 4096, stream, ...rest } = opts;
+    const body = { model, messages, max_tokens: maxTokens, ...rest };
+    if (stream) {
+      body.stream = true;
+      return this.stream(body);
+    }
+    return this.transport.request("POST", "/v1/messages", { json: body });
+  }
+  async *stream(body) {
+    for await (const chunk of this.transport.requestStream("POST", "/v1/messages", { json: body })) {
+      yield JSON.parse(chunk);
+    }
+  }
+  async countTokens(opts) {
+    const { model, messages, ...rest } = opts;
+    return this.transport.request("POST", "/v1/messages/count_tokens", {
+      json: { model, messages, ...rest }
+    });
+  }
+};
+var Chat = class {
+  messages;
+  constructor(transport) {
+    this.messages = new Messages(transport);
+  }
+};
+
+// src/runtime/tasks.ts
+var TaskHandle = class {
+  id;
+  pollEndpoint;
+  transport;
+  _result = null;
+  constructor(taskId, pollEndpoint, transport) {
+    this.id = taskId;
+    this.pollEndpoint = pollEndpoint;
+    this.transport = transport;
+  }
+  async get() {
+    return this.transport.request("POST", this.pollEndpoint, {
+      json: { id: this.id, action: "retrieve" }
+    });
+  }
+  async isCompleted() {
+    const state = await this.get();
+    const response = state.response ?? state;
+    const status = response.status;
+    return status === "succeeded" || status === "failed";
+  }
+  async wait(opts = {}) {
+    const pollInterval = opts.pollInterval ?? 3e3;
+    const maxWait = opts.maxWait ?? 6e5;
+    const start = Date.now();
+    while (Date.now() - start < maxWait) {
+      const state = await this.get();
+      const response = state.response ?? state;
+      const status = response.status;
+      if (status === "succeeded" || status === "failed") {
+        this._result = state;
+        return state;
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new Error(`Task ${this.id} did not complete within ${maxWait}ms`);
+  }
+  get result() {
+    return this._result;
+  }
+};
+
+// src/resources/images.ts
+var Images = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async generate(opts) {
+    const { prompt, provider = "nano-banana", model, negativePrompt, imageUrl, callbackUrl, wait: shouldWait, pollInterval, maxWait, ...rest } = opts;
+    const body = { prompt, ...rest };
+    if (model !== void 0) body.model = model;
+    if (negativePrompt !== void 0) body.negative_prompt = negativePrompt;
+    if (imageUrl !== void 0) body.image_url = imageUrl;
+    if (callbackUrl !== void 0) body.callback_url = callbackUrl;
+    const endpoint = provider === "midjourney" ? "/midjourney/imagine" : `/${provider}/images`;
+    const result = await this.transport.request("POST", endpoint, { json: body });
+    const taskId = result.task_id;
+    if (!taskId || result.data && !shouldWait) return result;
+    const handle = new TaskHandle(taskId, `/${provider}/tasks`, this.transport);
+    if (shouldWait) return handle.wait({ pollInterval, maxWait });
+    return handle;
+  }
+};
+
+// src/resources/audio.ts
+var Audio = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async generate(opts) {
+    const { prompt, provider = "suno", model, tags, callbackUrl, wait: shouldWait, pollInterval, maxWait, ...rest } = opts;
+    const body = { prompt, ...rest };
+    if (model !== void 0) body.model = model;
+    if (tags !== void 0) body.tags = tags;
+    if (callbackUrl !== void 0) body.callback_url = callbackUrl;
+    const result = await this.transport.request("POST", `/${provider}/audios`, { json: body });
+    const taskId = result.task_id;
+    if (!taskId || result.data && !shouldWait) return result;
+    const handle = new TaskHandle(taskId, `/${provider}/tasks`, this.transport);
+    if (shouldWait) return handle.wait({ pollInterval, maxWait });
+    return handle;
+  }
+};
+
+// src/resources/video.ts
+var Video = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async generate(opts) {
+    const { prompt, provider = "sora", model, imageUrl, callbackUrl, wait: shouldWait, pollInterval, maxWait, ...rest } = opts;
+    const body = { prompt, ...rest };
+    if (model !== void 0) body.model = model;
+    if (imageUrl !== void 0) body.image_url = imageUrl;
+    if (callbackUrl !== void 0) body.callback_url = callbackUrl;
+    const result = await this.transport.request("POST", `/${provider}/videos`, { json: body });
+    const taskId = result.task_id;
+    if (!taskId || result.data && !shouldWait) return result;
+    const handle = new TaskHandle(taskId, `/${provider}/tasks`, this.transport);
+    if (shouldWait) return handle.wait({ pollInterval, maxWait });
+    return handle;
+  }
+};
+
+// src/resources/search.ts
+var Search = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async google(opts) {
+    const { query, type = "search", country, language, page, ...rest } = opts;
+    const body = { query, type, ...rest };
+    if (country !== void 0) body.country = country;
+    if (language !== void 0) body.language = language;
+    if (page !== void 0) body.page = page;
+    return this.transport.request("POST", "/serp/google", { json: body });
+  }
+};
+
+// src/resources/tasks.ts
+var SERVICE_TASK_ENDPOINTS = {
+  suno: "/suno/tasks",
+  producer: "/producer/tasks",
+  "nano-banana": "/nano-banana/tasks",
+  seedream: "/seedream/tasks",
+  seedance: "/seedance/tasks",
+  sora: "/sora/tasks",
+  midjourney: "/midjourney/tasks",
+  luma: "/luma/tasks",
+  veo: "/veo/tasks",
+  flux: "/flux/tasks",
+  kling: "/kling/tasks",
+  hailuo: "/hailuo/tasks",
+  wan: "/wan/tasks",
+  pika: "/pika/tasks",
+  pixverse: "/pixverse/tasks"
+};
+var Tasks = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async get(taskId, opts = {}) {
+    const service = opts.service ?? "suno";
+    const endpoint = SERVICE_TASK_ENDPOINTS[service] ?? `/${service}/tasks`;
+    return this.transport.request("POST", endpoint, {
+      json: { id: taskId, action: "retrieve" }
+    });
+  }
+  async wait(taskId, opts = {}) {
+    const service = opts.service ?? "suno";
+    const endpoint = SERVICE_TASK_ENDPOINTS[service] ?? `/${service}/tasks`;
+    const handle = new TaskHandle(taskId, endpoint, this.transport);
+    return handle.wait({ pollInterval: opts.pollInterval, maxWait: opts.maxWait });
+  }
+};
+
+// src/resources/files.ts
+import * as fs from "fs";
+import * as path from "path";
+var Files = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async upload(file, opts = {}) {
+    let data;
+    let filename;
+    if (typeof file === "string") {
+      data = fs.readFileSync(file);
+      filename = opts.filename ?? path.basename(file);
+    } else {
+      data = file;
+      filename = opts.filename ?? "upload";
+    }
+    return this.transport.upload("/api/v1/files/", data, filename);
+  }
+};
+
+// src/resources/platform.ts
+var Applications = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async list(params) {
+    return this.transport.request("GET", "/api/v1/applications/", { params, platform: true });
+  }
+  async create(opts) {
+    const { serviceId, ...rest } = opts;
+    return this.transport.request("POST", "/api/v1/applications/", {
+      json: { service_id: serviceId, ...rest },
+      platform: true
+    });
+  }
+  async get(applicationId) {
+    return this.transport.request("GET", `/api/v1/applications/${applicationId}/`, { platform: true });
+  }
+};
+var Credentials = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async list(params) {
+    return this.transport.request("GET", "/api/v1/credentials/", { params, platform: true });
+  }
+  async create(opts) {
+    const { applicationId, ...rest } = opts;
+    return this.transport.request("POST", "/api/v1/credentials/", {
+      json: { application_id: applicationId, ...rest },
+      platform: true
+    });
+  }
+  async rotate(credentialId) {
+    return this.transport.request("POST", `/api/v1/credentials/${credentialId}/rotate/`, { platform: true });
+  }
+  async delete(credentialId) {
+    return this.transport.request("DELETE", `/api/v1/credentials/${credentialId}/`, { platform: true });
+  }
+};
+var Models = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async list(params) {
+    return this.transport.request("GET", "/api/v1/models/", { params, platform: true });
+  }
+};
+var Config = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async get() {
+    return this.transport.request("GET", "/api/v1/config/", { platform: true });
+  }
+};
+var Platform = class {
+  applications;
+  credentials;
+  models;
+  config;
+  constructor(transport) {
+    this.applications = new Applications(transport);
+    this.credentials = new Credentials(transport);
+    this.models = new Models(transport);
+    this.config = new Config(transport);
+  }
+};
+
+// src/resources/openai.ts
+var Completions = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async create(opts) {
+    const { model, messages, stream, ...rest } = opts;
+    const body = { model, messages, ...rest };
+    if (stream) {
+      body.stream = true;
+      return this.streamResponse(body);
+    }
+    return this.transport.request("POST", "/v1/chat/completions", { json: body });
+  }
+  async *streamResponse(body) {
+    for await (const chunk of this.transport.requestStream("POST", "/v1/chat/completions", { json: body })) {
+      yield JSON.parse(chunk);
+    }
+  }
+};
+var ChatNamespace = class {
+  completions;
+  constructor(transport) {
+    this.completions = new Completions(transport);
+  }
+};
+var Responses = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async create(opts) {
+    const { model, input, stream, ...rest } = opts;
+    const body = { model, input, ...rest };
+    if (stream) {
+      body.stream = true;
+      return this.streamResponse(body);
+    }
+    return this.transport.request("POST", "/openai/responses", { json: body });
+  }
+  async *streamResponse(body) {
+    for await (const chunk of this.transport.requestStream("POST", "/openai/responses", { json: body })) {
+      yield JSON.parse(chunk);
+    }
+  }
+};
+var OpenAI = class {
+  chat;
+  responses;
+  constructor(transport) {
+    this.chat = new ChatNamespace(transport);
+    this.responses = new Responses(transport);
+  }
+};
+
+// src/client.ts
+var AceDataCloud = class {
+  chat;
+  images;
+  audio;
+  video;
+  search;
+  tasks;
+  files;
+  platform;
+  openai;
+  transport;
+  constructor(opts = {}) {
+    this.transport = new Transport({
+      apiToken: opts.apiToken,
+      baseURL: opts.baseURL,
+      platformBaseURL: opts.platformBaseURL,
+      timeout: opts.timeout,
+      maxRetries: opts.maxRetries,
+      headers: opts.headers
+    });
+    this.chat = new Chat(this.transport);
+    this.images = new Images(this.transport);
+    this.audio = new Audio(this.transport);
+    this.video = new Video(this.transport);
+    this.search = new Search(this.transport);
+    this.tasks = new Tasks(this.transport);
+    this.files = new Files(this.transport);
+    this.platform = new Platform(this.transport);
+    this.openai = new OpenAI(this.transport);
+  }
+};
+export {
+  APIError,
+  AceDataCloud,
+  AceDataCloudError,
+  AuthenticationError,
+  InsufficientBalanceError,
+  ModerationError,
+  RateLimitError,
+  ResourceDisabledError,
+  TaskHandle,
+  TimeoutError,
+  TokenMismatchError,
+  TransportError,
+  ValidationError
+};
+//# sourceMappingURL=index.mjs.map