@acedatacloud/sdk 0.0.1

package/README.md

@@ -0,0 +1,97 @@
+# AceDataCloud TypeScript SDK
+
+Official TypeScript/Node.js client for the [AceDataCloud API](https://platform.acedata.cloud).
+
+Requires Node.js 18+ (uses native `fetch`).
+
+## Installation
+
+```bash
+npm install @acedatacloud/sdk
+```
+
+## Quick Start
+
+```typescript
+import { AceDataCloud } from '@acedatacloud/sdk';
+
+const client = new AceDataCloud({ apiToken: 'your-token' });
+
+// OpenAI-compatible chat completions
+const response = await client.openai.chat.completions.create({
+  model: 'gpt-4o',
+  messages: [{ role: 'user', content: 'Hello!' }],
+});
+console.log(response.choices[0].message.content);
+```
+
+## Streaming
+
+```typescript
+const stream = await client.openai.chat.completions.create({
+  model: 'gpt-4o',
+  messages: [{ role: 'user', content: 'Tell me a story' }],
+  stream: true,
+});
+
+for await (const chunk of stream) {
+  process.stdout.write(chunk.choices?.[0]?.delta?.content ?? '');
+}
+```
+
+## Resources
+
+| Resource | Description |
+|----------|-------------|
+| `client.openai` | OpenAI-compatible chat completions and responses |
+| `client.chat` | Native chat messages |
+| `client.images` | Image generation (Midjourney, Flux, etc.) |
+| `client.audio` | Music generation (Suno) |
+| `client.video` | Video generation (Luma, Sora, Veo, etc.) |
+| `client.search` | Web search (Google SERP) |
+| `client.tasks` | Cross-service async task polling |
+| `client.files` | File uploads |
+| `client.platform` | Applications, credentials, models management |
+
+## Image Generation (with Task Polling)
+
+```typescript
+const task = await client.images.generate({ prompt: 'A sunset over mountains' });
+const result = await task.wait();
+console.log(result.image_url);
+```
+
+## Error Handling
+
+```typescript
+import { AceDataCloud, AuthenticationError, RateLimitError } from '@acedatacloud/sdk';
+
+const client = new AceDataCloud({ apiToken: 'your-token' });
+try {
+  await client.search.google({ q: 'test' });
+} catch (err) {
+  if (err instanceof AuthenticationError) {
+    console.error('Invalid or expired token');
+  } else if (err instanceof RateLimitError) {
+    console.error('Too many requests');
+  }
+}
+```
+
+## Configuration
+
+```typescript
+const client = new AceDataCloud({
+  apiToken: 'your-token',
+  baseUrl: 'https://api.acedata.cloud',
+  platformBaseUrl: 'https://platform.acedata.cloud',
+  timeout: 300000,    // ms
+  maxRetries: 2,
+});
+```
+
+The token can also be set via the `ACEDATACLOUD_API_TOKEN` environment variable.
+
+## License
+
+MIT

package/dist/client.d.ts

@@ -0,0 +1,31 @@
+/** Top-level AceDataCloud client for TypeScript. */
+import { Chat } from './resources/chat';
+import { Images } from './resources/images';
+import { Audio } from './resources/audio';
+import { Video } from './resources/video';
+import { Search } from './resources/search';
+import { Tasks } from './resources/tasks';
+import { Files } from './resources/files';
+import { Platform } from './resources/platform';
+import { OpenAI } from './resources/openai';
+export interface AceDataCloudOptions {
+    apiToken?: string;
+    baseURL?: string;
+    platformBaseURL?: string;
+    timeout?: number;
+    maxRetries?: number;
+    headers?: Record<string, string>;
+}
+export declare class AceDataCloud {
+    readonly chat: Chat;
+    readonly images: Images;
+    readonly audio: Audio;
+    readonly video: Video;
+    readonly search: Search;
+    readonly tasks: Tasks;
+    readonly files: Files;
+    readonly platform: Platform;
+    readonly openai: OpenAI;
+    private transport;
+    constructor(opts?: AceDataCloudOptions);
+}

package/dist/client.js

@@ -0,0 +1,46 @@
+"use strict";
+/** Top-level AceDataCloud client for TypeScript. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AceDataCloud = void 0;
+const transport_1 = require("./runtime/transport");
+const chat_1 = require("./resources/chat");
+const images_1 = require("./resources/images");
+const audio_1 = require("./resources/audio");
+const video_1 = require("./resources/video");
+const search_1 = require("./resources/search");
+const tasks_1 = require("./resources/tasks");
+const files_1 = require("./resources/files");
+const platform_1 = require("./resources/platform");
+const openai_1 = require("./resources/openai");
+class AceDataCloud {
+    chat;
+    images;
+    audio;
+    video;
+    search;
+    tasks;
+    files;
+    platform;
+    openai;
+    transport;
+    constructor(opts = {}) {
+        this.transport = new transport_1.Transport({
+            apiToken: opts.apiToken,
+            baseURL: opts.baseURL,
+            platformBaseURL: opts.platformBaseURL,
+            timeout: opts.timeout,
+            maxRetries: opts.maxRetries,
+            headers: opts.headers,
+        });
+        this.chat = new chat_1.Chat(this.transport);
+        this.images = new images_1.Images(this.transport);
+        this.audio = new audio_1.Audio(this.transport);
+        this.video = new video_1.Video(this.transport);
+        this.search = new search_1.Search(this.transport);
+        this.tasks = new tasks_1.Tasks(this.transport);
+        this.files = new files_1.Files(this.transport);
+        this.platform = new platform_1.Platform(this.transport);
+        this.openai = new openai_1.OpenAI(this.transport);
+    }
+}
+exports.AceDataCloud = AceDataCloud;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+/** @acedatacloud/sdk — Official TypeScript SDK for AceDataCloud. */
+export { AceDataCloud, AceDataCloudOptions } from './client';
+export { AceDataCloudError, APIError, AuthenticationError, InsufficientBalanceError, ModerationError, RateLimitError, ResourceDisabledError, TimeoutError, TokenMismatchError, TransportError, ValidationError, } from './runtime/errors';
+export { TaskHandle, TaskHandleOptions } from './runtime/tasks';

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+/** @acedatacloud/sdk — Official TypeScript SDK for AceDataCloud. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskHandle = exports.ValidationError = exports.TransportError = exports.TokenMismatchError = exports.TimeoutError = exports.ResourceDisabledError = exports.RateLimitError = exports.ModerationError = exports.InsufficientBalanceError = exports.AuthenticationError = exports.APIError = exports.AceDataCloudError = exports.AceDataCloud = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "AceDataCloud", { enumerable: true, get: function () { return client_1.AceDataCloud; } });
+var errors_1 = require("./runtime/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; } });
+var tasks_1 = require("./runtime/tasks");
+Object.defineProperty(exports, "TaskHandle", { enumerable: true, get: function () { return tasks_1.TaskHandle; } });

package/dist/resources/audio.d.ts

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

package/dist/resources/audio.js

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

package/dist/resources/chat.d.ts

@@ -0,0 +1,30 @@
+/** Chat resources — native provider APIs (Claude Messages). */
+import { Transport } from '../runtime/transport';
+export declare class Messages {
+    private transport;
+    constructor(transport: Transport);
+    create(opts: {
+        model: string;
+        messages: Array<Record<string, unknown>>;
+        maxTokens?: number;
+        stream?: false;
+        [key: string]: unknown;
+    }): Promise<Record<string, unknown>>;
+    create(opts: {
+        model: string;
+        messages: Array<Record<string, unknown>>;
+        maxTokens?: number;
+        stream: true;
+        [key: string]: unknown;
+    }): Promise<AsyncGenerator<Record<string, unknown>>>;
+    private stream;
+    countTokens(opts: {
+        model: string;
+        messages: Array<Record<string, unknown>>;
+        [key: string]: unknown;
+    }): Promise<Record<string, unknown>>;
+}
+export declare class Chat {
+    readonly messages: Messages;
+    constructor(transport: Transport);
+}

package/dist/resources/chat.js

@@ -0,0 +1,38 @@
+"use strict";
+/** Chat resources — native provider APIs (Claude Messages). */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Chat = exports.Messages = void 0;
+class Messages {
+    transport;
+    constructor(transport) {
+        this.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 },
+        });
+    }
+}
+exports.Messages = Messages;
+class Chat {
+    messages;
+    constructor(transport) {
+        this.messages = new Messages(transport);
+    }
+}
+exports.Chat = Chat;

package/dist/resources/files.d.ts

@@ -0,0 +1,9 @@
+/** File upload resources. */
+import { Transport } from '../runtime/transport';
+export declare class Files {
+    private transport;
+    constructor(transport: Transport);
+    upload(file: string | Buffer | Uint8Array, opts?: {
+        filename?: string;
+    }): Promise<Record<string, unknown>>;
+}

package/dist/resources/files.js

@@ -0,0 +1,59 @@
+"use strict";
+/** File upload resources. */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Files = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class Files {
+    transport;
+    constructor(transport) {
+        this.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);
+    }
+}
+exports.Files = Files;

package/dist/resources/images.d.ts

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

package/dist/resources/images.js

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

package/dist/resources/openai.d.ts

@@ -0,0 +1,46 @@
+/** OpenAI-compatible facade resources. */
+import { Transport } from '../runtime/transport';
+declare class Completions {
+    private transport;
+    constructor(transport: Transport);
+    create(opts: {
+        model: string;
+        messages: Array<Record<string, unknown>>;
+        stream?: false;
+        [key: string]: unknown;
+    }): Promise<Record<string, unknown>>;
+    create(opts: {
+        model: string;
+        messages: Array<Record<string, unknown>>;
+        stream: true;
+        [key: string]: unknown;
+    }): Promise<AsyncGenerator<Record<string, unknown>>>;
+    private streamResponse;
+}
+declare class ChatNamespace {
+    readonly completions: Completions;
+    constructor(transport: Transport);
+}
+declare class Responses {
+    private transport;
+    constructor(transport: Transport);
+    create(opts: {
+        model: string;
+        input: string | Array<Record<string, unknown>>;
+        stream?: false;
+        [key: string]: unknown;
+    }): Promise<Record<string, unknown>>;
+    create(opts: {
+        model: string;
+        input: string | Array<Record<string, unknown>>;
+        stream: true;
+        [key: string]: unknown;
+    }): Promise<AsyncGenerator<Record<string, unknown>>>;
+    private streamResponse;
+}
+export declare class OpenAI {
+    readonly chat: ChatNamespace;
+    readonly responses: Responses;
+    constructor(transport: Transport);
+}
+export {};

package/dist/resources/openai.js

@@ -0,0 +1,59 @@
+"use strict";
+/** OpenAI-compatible facade resources. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAI = void 0;
+class Completions {
+    transport;
+    constructor(transport) {
+        this.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);
+        }
+    }
+}
+class ChatNamespace {
+    completions;
+    constructor(transport) {
+        this.completions = new Completions(transport);
+    }
+}
+class Responses {
+    transport;
+    constructor(transport) {
+        this.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);
+        }
+    }
+}
+class OpenAI {
+    chat;
+    responses;
+    constructor(transport) {
+        this.chat = new ChatNamespace(transport);
+        this.responses = new Responses(transport);
+    }
+}
+exports.OpenAI = OpenAI;

package/dist/resources/platform.d.ts

@@ -0,0 +1,41 @@
+/** Management-plane resources. */
+import { Transport } from '../runtime/transport';
+declare class Applications {
+    private transport;
+    constructor(transport: Transport);
+    list(params?: Record<string, string>): Promise<Record<string, unknown>>;
+    create(opts: {
+        serviceId: string;
+        [key: string]: unknown;
+    }): Promise<Record<string, unknown>>;
+    get(applicationId: string): Promise<Record<string, unknown>>;
+}
+declare class Credentials {
+    private transport;
+    constructor(transport: Transport);
+    list(params?: Record<string, string>): Promise<Record<string, unknown>>;
+    create(opts: {
+        applicationId: string;
+        [key: string]: unknown;
+    }): Promise<Record<string, unknown>>;
+    rotate(credentialId: string): Promise<Record<string, unknown>>;
+    delete(credentialId: string): Promise<Record<string, unknown>>;
+}
+declare class Models {
+    private transport;
+    constructor(transport: Transport);
+    list(params?: Record<string, string>): Promise<Record<string, unknown>>;
+}
+declare class Config {
+    private transport;
+    constructor(transport: Transport);
+    get(): Promise<Record<string, unknown>>;
+}
+export declare class Platform {
+    readonly applications: Applications;
+    readonly credentials: Credentials;
+    readonly models: Models;
+    readonly config: Config;
+    constructor(transport: Transport);
+}
+export {};

package/dist/resources/platform.js

@@ -0,0 +1,76 @@
+"use strict";
+/** Management-plane resources. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Platform = void 0;
+class Applications {
+    transport;
+    constructor(transport) {
+        this.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 });
+    }
+}
+class Credentials {
+    transport;
+    constructor(transport) {
+        this.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 });
+    }
+}
+class Models {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    async list(params) {
+        return this.transport.request('GET', '/api/v1/models/', { params, platform: true });
+    }
+}
+class Config {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    async get() {
+        return this.transport.request('GET', '/api/v1/config/', { platform: true });
+    }
+}
+class Platform {
+    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);
+    }
+}
+exports.Platform = Platform;