@acedatacloud/sdk 0.0.1

package/dist/resources/search.d.ts

@@ -0,0 +1,14 @@
+/** Search resources. */
+import { Transport } from '../runtime/transport';
+export declare class Search {
+    private transport;
+    constructor(transport: Transport);
+    google(opts: {
+        query: string;
+        type?: string;
+        country?: string;
+        language?: string;
+        page?: number;
+        [key: string]: unknown;
+    }): Promise<Record<string, unknown>>;
+}

package/dist/resources/search.js

@@ -0,0 +1,22 @@
+"use strict";
+/** Search resources. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Search = void 0;
+class Search {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    async google(opts) {
+        const { query, type = 'search', country, language, page, ...rest } = opts;
+        const body = { query, type, ...rest };
+        if (country !== undefined)
+            body.country = country;
+        if (language !== undefined)
+            body.language = language;
+        if (page !== undefined)
+            body.page = page;
+        return this.transport.request('POST', '/serp/google', { json: body });
+    }
+}
+exports.Search = Search;

package/dist/resources/tasks.d.ts

@@ -0,0 +1,14 @@
+/** Cross-service task retrieval. */
+import { Transport } from '../runtime/transport';
+export declare class Tasks {
+    private transport;
+    constructor(transport: Transport);
+    get(taskId: string, opts?: {
+        service?: string;
+    }): Promise<Record<string, unknown>>;
+    wait(taskId: string, opts?: {
+        service?: string;
+        pollInterval?: number;
+        maxWait?: number;
+    }): Promise<Record<string, unknown>>;
+}

package/dist/resources/tasks.js

@@ -0,0 +1,36 @@
+"use strict";
+/** Cross-service task retrieval. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tasks = void 0;
+const tasks_1 = require("../runtime/tasks");
+const SERVICE_TASK_ENDPOINTS = {
+    suno: '/suno/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',
+};
+class Tasks {
+    transport;
+    constructor(transport) {
+        this.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 tasks_1.TaskHandle(taskId, endpoint, this.transport);
+        return handle.wait({ pollInterval: opts.pollInterval, maxWait: opts.maxWait });
+    }
+}
+exports.Tasks = Tasks;

package/dist/resources/video.d.ts

@@ -0,0 +1,17 @@
+/** Video generation resources. */
+import { Transport } from '../runtime/transport';
+import { TaskHandle } from '../runtime/tasks';
+export declare class Video {
+    private transport;
+    constructor(transport: Transport);
+    generate(opts: {
+        prompt: string;
+        model?: string;
+        imageUrl?: string;
+        callbackUrl?: string;
+        wait?: boolean;
+        pollInterval?: number;
+        maxWait?: number;
+        [key: string]: unknown;
+    }): Promise<Record<string, unknown> | TaskHandle>;
+}

package/dist/resources/video.js

@@ -0,0 +1,30 @@
+"use strict";
+/** Video generation resources. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Video = void 0;
+const tasks_1 = require("../runtime/tasks");
+class Video {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    async generate(opts) {
+        const { prompt, model, imageUrl, callbackUrl, wait: shouldWait, pollInterval, maxWait, ...rest } = opts;
+        const body = { prompt, ...rest };
+        if (model !== undefined)
+            body.model = model;
+        if (imageUrl !== undefined)
+            body.image_url = imageUrl;
+        if (callbackUrl !== undefined)
+            body.callback_url = callbackUrl;
+        const result = await this.transport.request('POST', '/sora/videos', { json: body });
+        const taskId = result.task_id;
+        if (!taskId || (result.data && !shouldWait))
+            return result;
+        const handle = new tasks_1.TaskHandle(taskId, '/sora/tasks', this.transport);
+        if (shouldWait)
+            return handle.wait({ pollInterval, maxWait });
+        return handle;
+    }
+}
+exports.Video = Video;

package/dist/runtime/errors.d.ts

@@ -0,0 +1,44 @@
+/** AceDataCloud SDK errors. */
+export declare class AceDataCloudError extends Error {
+    constructor(message: string);
+}
+export declare class TransportError extends AceDataCloudError {
+    constructor(message: string);
+}
+export declare class APIError extends AceDataCloudError {
+    statusCode: number;
+    code: string;
+    traceId?: string;
+    body: Record<string, unknown>;
+    constructor(opts: {
+        message: string;
+        statusCode: number;
+        code: string;
+        traceId?: string;
+        body?: Record<string, unknown>;
+    });
+}
+export declare class AuthenticationError extends APIError {
+    constructor(opts: ConstructorParameters<typeof APIError>[0]);
+}
+export declare class TokenMismatchError extends APIError {
+    constructor(opts: ConstructorParameters<typeof APIError>[0]);
+}
+export declare class RateLimitError extends APIError {
+    constructor(opts: ConstructorParameters<typeof APIError>[0]);
+}
+export declare class ValidationError extends APIError {
+    constructor(opts: ConstructorParameters<typeof APIError>[0]);
+}
+export declare class InsufficientBalanceError extends APIError {
+    constructor(opts: ConstructorParameters<typeof APIError>[0]);
+}
+export declare class ResourceDisabledError extends APIError {
+    constructor(opts: ConstructorParameters<typeof APIError>[0]);
+}
+export declare class ModerationError extends APIError {
+    constructor(opts: ConstructorParameters<typeof APIError>[0]);
+}
+export declare class TimeoutError extends APIError {
+    constructor(opts: ConstructorParameters<typeof APIError>[0]);
+}

package/dist/runtime/errors.js

@@ -0,0 +1,89 @@
+"use strict";
+/** AceDataCloud SDK errors. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeoutError = exports.ModerationError = exports.ResourceDisabledError = exports.InsufficientBalanceError = exports.ValidationError = exports.RateLimitError = exports.TokenMismatchError = exports.AuthenticationError = exports.APIError = exports.TransportError = exports.AceDataCloudError = void 0;
+class AceDataCloudError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'AceDataCloudError';
+    }
+}
+exports.AceDataCloudError = AceDataCloudError;
+class TransportError extends AceDataCloudError {
+    constructor(message) {
+        super(message);
+        this.name = 'TransportError';
+    }
+}
+exports.TransportError = TransportError;
+class APIError 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 ?? {};
+    }
+}
+exports.APIError = APIError;
+class AuthenticationError extends APIError {
+    constructor(opts) {
+        super(opts);
+        this.name = 'AuthenticationError';
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+class TokenMismatchError extends APIError {
+    constructor(opts) {
+        super(opts);
+        this.name = 'TokenMismatchError';
+    }
+}
+exports.TokenMismatchError = TokenMismatchError;
+class RateLimitError extends APIError {
+    constructor(opts) {
+        super(opts);
+        this.name = 'RateLimitError';
+    }
+}
+exports.RateLimitError = RateLimitError;
+class ValidationError extends APIError {
+    constructor(opts) {
+        super(opts);
+        this.name = 'ValidationError';
+    }
+}
+exports.ValidationError = ValidationError;
+class InsufficientBalanceError extends APIError {
+    constructor(opts) {
+        super(opts);
+        this.name = 'InsufficientBalanceError';
+    }
+}
+exports.InsufficientBalanceError = InsufficientBalanceError;
+class ResourceDisabledError extends APIError {
+    constructor(opts) {
+        super(opts);
+        this.name = 'ResourceDisabledError';
+    }
+}
+exports.ResourceDisabledError = ResourceDisabledError;
+class ModerationError extends APIError {
+    constructor(opts) {
+        super(opts);
+        this.name = 'ModerationError';
+    }
+}
+exports.ModerationError = ModerationError;
+class TimeoutError extends APIError {
+    constructor(opts) {
+        super(opts);
+        this.name = 'TimeoutError';
+    }
+}
+exports.TimeoutError = TimeoutError;

package/dist/runtime/index.d.ts

@@ -0,0 +1,3 @@
+export { Transport, TransportOptions } from './transport';
+export { TaskHandle, TaskHandleOptions } from './tasks';
+export { AceDataCloudError, APIError, AuthenticationError, InsufficientBalanceError, ModerationError, RateLimitError, ResourceDisabledError, TimeoutError, TokenMismatchError, TransportError, ValidationError, } from './errors';

package/dist/runtime/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationError = exports.TransportError = exports.TokenMismatchError = exports.TimeoutError = exports.ResourceDisabledError = exports.RateLimitError = exports.ModerationError = exports.InsufficientBalanceError = exports.AuthenticationError = exports.APIError = exports.AceDataCloudError = exports.TaskHandle = exports.Transport = void 0;
+var transport_1 = require("./transport");
+Object.defineProperty(exports, "Transport", { enumerable: true, get: function () { return transport_1.Transport; } });
+var tasks_1 = require("./tasks");
+Object.defineProperty(exports, "TaskHandle", { enumerable: true, get: function () { return tasks_1.TaskHandle; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "AceDataCloudError", { enumerable: true, get: function () { return errors_1.AceDataCloudError; } });
+Object.defineProperty(exports, "APIError", { enumerable: true, get: function () { return errors_1.APIError; } });
+Object.defineProperty(exports, "AuthenticationError", { enumerable: true, get: function () { return errors_1.AuthenticationError; } });
+Object.defineProperty(exports, "InsufficientBalanceError", { enumerable: true, get: function () { return errors_1.InsufficientBalanceError; } });
+Object.defineProperty(exports, "ModerationError", { enumerable: true, get: function () { return errors_1.ModerationError; } });
+Object.defineProperty(exports, "RateLimitError", { enumerable: true, get: function () { return errors_1.RateLimitError; } });
+Object.defineProperty(exports, "ResourceDisabledError", { enumerable: true, get: function () { return errors_1.ResourceDisabledError; } });
+Object.defineProperty(exports, "TimeoutError", { enumerable: true, get: function () { return errors_1.TimeoutError; } });
+Object.defineProperty(exports, "TokenMismatchError", { enumerable: true, get: function () { return errors_1.TokenMismatchError; } });
+Object.defineProperty(exports, "TransportError", { enumerable: true, get: function () { return errors_1.TransportError; } });
+Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return errors_1.ValidationError; } });

package/dist/runtime/tasks.d.ts

@@ -0,0 +1,17 @@
+/** Task polling abstraction. */
+import { Transport } from './transport';
+export interface TaskHandleOptions {
+    pollInterval?: number;
+    maxWait?: number;
+}
+export declare class TaskHandle {
+    readonly id: string;
+    private pollEndpoint;
+    private transport;
+    private _result;
+    constructor(taskId: string, pollEndpoint: string, transport: Transport);
+    get(): Promise<Record<string, unknown>>;
+    isCompleted(): Promise<boolean>;
+    wait(opts?: TaskHandleOptions): Promise<Record<string, unknown>>;
+    get result(): Record<string, unknown> | null;
+}

package/dist/runtime/tasks.js

@@ -0,0 +1,46 @@
+"use strict";
+/** Task polling abstraction. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskHandle = void 0;
+class TaskHandle {
+    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 ?? 3000;
+        const maxWait = opts.maxWait ?? 600_000;
+        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;
+    }
+}
+exports.TaskHandle = TaskHandle;

package/dist/runtime/transport.d.ts

@@ -0,0 +1,31 @@
+/** HTTP transport for AceDataCloud SDK. Uses native fetch (Node 18+). */
+export interface TransportOptions {
+    apiToken?: string;
+    baseURL?: string;
+    platformBaseURL?: string;
+    timeout?: number;
+    maxRetries?: number;
+    headers?: Record<string, string>;
+}
+export declare class Transport {
+    private baseURL;
+    private platformBaseURL;
+    private timeout;
+    private maxRetries;
+    private headers;
+    constructor(opts?: TransportOptions);
+    request(method: string, path: string, opts?: {
+        json?: Record<string, unknown>;
+        params?: Record<string, string>;
+        platform?: boolean;
+        timeout?: number;
+        headers?: Record<string, string>;
+    }): Promise<Record<string, unknown>>;
+    requestStream(method: string, path: string, opts?: {
+        json?: Record<string, unknown>;
+        timeout?: number;
+    }): AsyncGenerator<string, void, unknown>;
+    upload(path: string, fileData: Buffer | Uint8Array, filename: string, opts?: {
+        timeout?: number;
+    }): Promise<Record<string, unknown>>;
+}

package/dist/runtime/transport.js

@@ -0,0 +1,210 @@
+"use strict";
+/** HTTP transport for AceDataCloud SDK. Uses native fetch (Node 18+). */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transport = void 0;
+const errors_1 = require("./errors");
+const ERROR_CODE_MAP = {
+    invalid_token: errors_1.AuthenticationError,
+    token_expired: errors_1.AuthenticationError,
+    no_token: errors_1.AuthenticationError,
+    token_mismatched: errors_1.TokenMismatchError,
+    used_up: errors_1.InsufficientBalanceError,
+    disabled: errors_1.ResourceDisabledError,
+    too_many_requests: errors_1.RateLimitError,
+    bad_request: errors_1.ValidationError,
+};
+const RETRY_STATUS_CODES = 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 = errors_1.ModerationError;
+        else if (statusCode === 401)
+            ErrorClass = errors_1.AuthenticationError;
+        else if (statusCode === 429)
+            ErrorClass = errors_1.RateLimitError;
+        else if (statusCode === 400)
+            ErrorClass = errors_1.ValidationError;
+        else
+            ErrorClass = errors_1.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));
+}
+class Transport {
+    baseURL;
+    platformBaseURL;
+    timeout;
+    maxRetries;
+    headers;
+    constructor(opts = {}) {
+        const token = opts.apiToken ?? process.env.ACEDATACLOUD_API_TOKEN ?? '';
+        if (!token) {
+            throw new errors_1.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 ?? 300_000;
+        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, path, opts = {}) {
+        const base = opts.platform ? this.platformBaseURL : this.baseURL;
+        let url = `${base}${path}`;
+        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) : undefined,
+                    signal: controller.signal,
+                });
+                clearTimeout(timer);
+                if (resp.status >= 400) {
+                    let body;
+                    try {
+                        body = (await resp.json());
+                    }
+                    catch {
+                        body = { error: { code: 'unknown', message: await resp.text() } };
+                    }
+                    if (RETRY_STATUS_CODES.has(resp.status) && attempt < this.maxRetries) {
+                        await sleep(backoffDelay(attempt) * 1000);
+                        continue;
+                    }
+                    throw mapError(resp.status, body);
+                }
+                return (await resp.json());
+            }
+            catch (err) {
+                clearTimeout(timer);
+                if (err instanceof errors_1.APIError)
+                    throw err;
+                lastError = err;
+                if (attempt < this.maxRetries) {
+                    await sleep(backoffDelay(attempt) * 1000);
+                    continue;
+                }
+            }
+        }
+        throw lastError ?? new errors_1.TransportError('Request failed after retries');
+    }
+    async *requestStream(method, path, opts = {}) {
+        const url = `${this.baseURL}${path}`;
+        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) : undefined,
+                signal: controller.signal,
+            });
+            if (resp.status >= 400) {
+                let body;
+                try {
+                    body = (await resp.json());
+                }
+                catch {
+                    body = { error: { code: 'unknown', message: '' } };
+                }
+                throw mapError(resp.status, body);
+            }
+            if (!resp.body)
+                throw new errors_1.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(path, fileData, filename, opts = {}) {
+        const url = `${this.platformBaseURL}${path}`;
+        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) {
+                let respBody;
+                try {
+                    respBody = (await resp.json());
+                }
+                catch {
+                    respBody = { error: { code: 'unknown', message: await resp.text() } };
+                }
+                throw mapError(resp.status, respBody);
+            }
+            return (await resp.json());
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}
+exports.Transport = Transport;

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@acedatacloud/sdk",
+  "version": "0.0.1",
+  "description": "Official TypeScript SDK for AceDataCloud — AI-powered data services",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest --forceExit",
+    "lint": "tsc --noEmit"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@types/node": "^20.0.0",
+    "jest": "^29.0.0",
+    "ts-jest": "^29.0.0",
+    "@types/jest": "^29.0.0"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "engines": {
+    "node": ">=18"
+  }
+}