deepseen-sdk 1.0.0

package/README.md

@@ -0,0 +1,54 @@
+# deepseen-sdk
+
+Deepseen Open API 官方 TypeScript SDK。
+
+## 安装
+
+```bash
+pnpm add deepseen-sdk
+# 或安装本地打包：pnpm add ./deepseen-sdk-1.0.0.tgz
+```
+
+## 快速开始
+
+默认连接生产环境 `https://deepseen.ai/v1`，只需提供 API Key：
+
+```typescript
+import { DeepseenClient } from 'deepseen-sdk';
+
+const client = new DeepseenClient({
+  apiKey: process.env.DEEPSEEN_API_KEY!, // sk_xxx
+});
+
+const file = await client.files.upload('./product.jpg');
+const job = await client.smartImage.recreations.create({
+  region: '美国',
+  keywords: 'Men cotton t-shirt',
+  productImages: [file.url],
+});
+
+const result = await job.wait({
+  timeoutMs: 1_800_000,
+  onProgress: (j) => console.log(j.status, j.progress),
+});
+```
+
+## 环境变量
+
+| 变量 | 说明 |
+|------|------|
+| `DEEPSEEN_API_KEY` | 必填，`sk_xxx` |
+| `DEEPSEEN_BASE_URL` | 可选，默认 `https://deepseen.ai/v1` |
+
+```typescript
+import { clientFromEnv } from 'deepseen-sdk';
+const client = clientFromEnv();
+```
+
+## 能力
+
+- `client.files` — 上传产品图 / 参考视频
+- `client.smartImage.recreations` — 图片智创
+- `client.image.recreations` — 图片二创
+- `client.smartVideo.recreations` — 视频智创
+- `client.video.recreations` — 视频二创

package/dist/index.d.ts

@@ -0,0 +1,263 @@
+interface HttpClientOptions {
+    apiKey: string;
+    baseURL: string;
+    timeoutMs: number;
+}
+declare class HttpClient {
+    private readonly options;
+    constructor(options: HttpClientOptions);
+    get baseURL(): string;
+    request<T>(method: string, path: string, init?: {
+        body?: unknown;
+        formData?: FormData;
+        idempotencyKey?: string;
+    }): Promise<T>;
+    get<T>(path: string): Promise<T>;
+    post<T>(path: string, body?: unknown, idempotencyKey?: string): Promise<T>;
+    postForm<T>(path: string, formData: FormData): Promise<T>;
+}
+
+type MediaJobStatus = 'queued' | 'analyzing' | 'awaiting_confirmation' | 'generating' | 'completed' | 'failed' | 'cancelled';
+/** @deprecated 使用 MediaJobStatus */
+type ImageJobStatus = MediaJobStatus;
+type MediaJobType = 'image.recreation' | 'smart_image.recreation' | 'video.recreation' | 'smart_video.recreation';
+type SmartVideoModel = 'Veo8s' | 'Veo8s_official' | 'Veo8s*2' | 'Grok10s' | 'SeeDance15s';
+interface MediaOutput {
+    index: number;
+    url: string;
+    variant_id: string;
+    kind?: 'image' | 'video';
+    revised_prompt?: string;
+}
+/** @deprecated 使用 MediaOutput */
+type ImageOutput = MediaOutput;
+interface MediaJobAnalysis {
+    variants: Array<{
+        variant_id: string;
+        strategy?: string;
+        prompt?: string;
+    }>;
+    reference_images?: string[];
+}
+interface MediaJob {
+    id: string;
+    object: 'image.job' | 'video.job';
+    type: MediaJobType;
+    status: MediaJobStatus;
+    progress: number;
+    created_at: number;
+    completed_at?: number;
+    metadata?: Record<string, string>;
+    error?: {
+        code: string;
+        message: string;
+    };
+    analysis?: MediaJobAnalysis;
+    outputs?: MediaOutput[];
+}
+/** @deprecated 使用 MediaJob */
+type ImageJob = MediaJob;
+interface ApiFile {
+    id: string;
+    object: 'file';
+    purpose: string;
+    filename: string;
+    bytes: number;
+    content_type: string;
+    url: string;
+    created_at: number;
+}
+interface DeepseenClientOptions {
+    apiKey: string;
+    baseURL?: string;
+    timeoutMs?: number;
+}
+interface SmartImageCreateParams {
+    region?: string;
+    keywords: string;
+    productImages?: string[];
+    productFileIds?: string[];
+    productDetails?: string;
+    includePrompts?: boolean;
+    metadata?: Record<string, string>;
+    webhookUrl?: string;
+    idempotencyKey?: string;
+}
+interface SmartVideoCreateParams {
+    region?: string;
+    productTitle: string;
+    productImages?: string[];
+    productFileIds?: string[];
+    count?: number;
+    model?: SmartVideoModel;
+    includePrompts?: boolean;
+    metadata?: Record<string, string>;
+    webhookUrl?: string;
+    idempotencyKey?: string;
+}
+interface ImageRecreationCreateParams {
+    competitorProductUrl: string;
+    productImages?: string[];
+    productFileIds?: string[];
+    model?: string;
+    aspectRatio?: string;
+    autoGenerate?: boolean;
+    includePrompts?: boolean;
+    metadata?: Record<string, string>;
+    webhookUrl?: string;
+    idempotencyKey?: string;
+}
+interface VideoRecreationCreateParams {
+    competitorVideoUrl: string;
+    productImages?: string[];
+    productFileIds?: string[];
+    model?: string;
+    groupCount?: number;
+    autoGenerate?: boolean;
+    includePrompts?: boolean;
+    metadata?: Record<string, string>;
+    webhookUrl?: string;
+    idempotencyKey?: string;
+}
+interface RecreationConfirmParams {
+    model?: string;
+    variants?: Array<{
+        variant_id: string;
+        prompt?: string;
+    }>;
+}
+/** @deprecated 使用 RecreationConfirmParams */
+type ImageRecreationConfirmParams = RecreationConfirmParams;
+interface WaitOptions {
+    pollIntervalMs?: number;
+    timeoutMs?: number;
+    onProgress?: (job: MediaJob) => void;
+}
+
+declare class FilesAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    /** 上传本地文件（图片或视频），返回可填入 product_images / competitor_video_url 的 url */
+    upload(filePath: string, purpose?: string): Promise<ApiFile>;
+    /** 上传 Buffer / Blob（浏览器或 Node 均可用） */
+    uploadBlob(blob: Blob, filename: string, purpose?: string): Promise<ApiFile>;
+    retrieve(fileId: string): Promise<ApiFile>;
+}
+
+type JobResource = 'smart-image' | 'image' | 'smart-video' | 'video';
+declare class MediaJobHandle {
+    private readonly http;
+    private readonly resource;
+    data: MediaJob;
+    constructor(http: HttpClient, resource: JobResource, data: MediaJob);
+    get id(): string;
+    get status(): MediaJobStatus;
+    refresh(): Promise<MediaJobHandle>;
+    wait(options?: WaitOptions): Promise<MediaJob>;
+    cancel(): Promise<MediaJob>;
+    confirm(body?: RecreationConfirmParams): Promise<MediaJobHandle>;
+}
+/** @deprecated 使用 MediaJobHandle */
+type ImageJobHandle = MediaJobHandle;
+
+declare class SmartImageRecreationsAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    create(params: SmartImageCreateParams): Promise<MediaJobHandle>;
+    retrieve(jobId: string): Promise<MediaJobHandle>;
+}
+declare class SmartImageAPI {
+    readonly recreations: SmartImageRecreationsAPI;
+    constructor(http: HttpClient);
+}
+
+declare class ImageRecreationsAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    create(params: ImageRecreationCreateParams): Promise<MediaJobHandle>;
+    retrieve(jobId: string): Promise<MediaJobHandle>;
+    confirm(jobId: string, params?: ImageRecreationConfirmParams): Promise<MediaJobHandle>;
+}
+declare class ImageAPI {
+    readonly recreations: ImageRecreationsAPI;
+    constructor(http: HttpClient);
+}
+
+declare class SmartVideoRecreationsAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    create(params: SmartVideoCreateParams): Promise<MediaJobHandle>;
+    retrieve(jobId: string): Promise<MediaJobHandle>;
+}
+declare class SmartVideoAPI {
+    readonly recreations: SmartVideoRecreationsAPI;
+    constructor(http: HttpClient);
+}
+
+declare class VideoRecreationsAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    create(params: VideoRecreationCreateParams): Promise<MediaJobHandle>;
+    retrieve(jobId: string): Promise<MediaJobHandle>;
+    confirm(jobId: string, params?: RecreationConfirmParams): Promise<MediaJobHandle>;
+}
+declare class VideoAPI {
+    readonly recreations: VideoRecreationsAPI;
+    constructor(http: HttpClient);
+}
+
+/**
+ * Deepseen Open API 客户端
+ *
+ * @example
+ * ```ts
+ * const client = new DeepseenClient({
+ *   apiKey: 'sk_xxx',
+ *   // baseURL 可选，默认 https://deepseen.ai/v1
+ * });
+ *
+ * const file = await client.files.upload('./product.jpg');
+ * const job = await client.smartImage.recreations.create({
+ *   keywords: 'Men cotton t-shirt',
+ *   productImages: [file.url],
+ * });
+ * const result = await job.wait({ timeoutMs: 600_000 });
+ * console.log(result.outputs);
+ * ```
+ */
+declare class DeepseenClient {
+    readonly files: FilesAPI;
+    readonly smartImage: SmartImageAPI;
+    readonly image: ImageAPI;
+    readonly smartVideo: SmartVideoAPI;
+    readonly video: VideoAPI;
+    private readonly http;
+    constructor(options: DeepseenClientOptions);
+    /** 健康检查 / 列出可用端点 */
+    ping(): Promise<{
+        object: string;
+        openapi_enabled?: boolean;
+    }>;
+}
+declare function createClient(options: DeepseenClientOptions): DeepseenClient;
+/** 从环境变量 DEEPSEEN_API_KEY + DEEPSEEN_BASE_URL 创建客户端 */
+declare function clientFromEnv(): DeepseenClient;
+
+/** Deepseen Open API 生产环境默认地址 */
+declare const DEFAULT_BASE_URL = "https://deepseen.ai/v1";
+
+declare class DeepseenError extends Error {
+    readonly code: string;
+    readonly status?: number;
+    readonly param?: string | null;
+    constructor(message: string, code?: string, status?: number, param?: string | null);
+}
+declare class DeepseenTimeoutError extends DeepseenError {
+    constructor(message?: string);
+}
+declare class DeepseenJobFailedError extends DeepseenError {
+    readonly jobId: string;
+    constructor(jobId: string, message: string, code?: string);
+}
+
+export { type ApiFile, DEFAULT_BASE_URL, DeepseenClient, type DeepseenClientOptions, DeepseenError, DeepseenJobFailedError, DeepseenTimeoutError, type ImageJob, type ImageJobHandle, type ImageJobStatus, type ImageOutput, type ImageRecreationConfirmParams, type ImageRecreationCreateParams, type MediaJob, MediaJobHandle, type MediaJobStatus, type MediaOutput, type RecreationConfirmParams, type SmartImageCreateParams, type SmartVideoCreateParams, type SmartVideoModel, type VideoRecreationCreateParams, type WaitOptions, clientFromEnv, createClient };

package/dist/index.js

@@ -0,0 +1,410 @@
+// src/errors.ts
+var DeepseenError = class extends Error {
+  code;
+  status;
+  param;
+  constructor(message, code = "deepseen_error", status, param) {
+    super(message);
+    this.name = "DeepseenError";
+    this.code = code;
+    this.status = status;
+    this.param = param;
+  }
+};
+var DeepseenTimeoutError = class extends DeepseenError {
+  constructor(message = "Job wait timeout") {
+    super(message, "timeout");
+    this.name = "DeepseenTimeoutError";
+  }
+};
+var DeepseenJobFailedError = class extends DeepseenError {
+  jobId;
+  constructor(jobId, message, code = "job_failed") {
+    super(message, code);
+    this.name = "DeepseenJobFailedError";
+    this.jobId = jobId;
+  }
+};
+
+// src/http.ts
+var HttpClient = class {
+  constructor(options) {
+    this.options = options;
+  }
+  get baseURL() {
+    return this.options.baseURL;
+  }
+  async request(method, path2, init) {
+    const url = `${this.options.baseURL}${path2.startsWith("/") ? path2 : `/${path2}`}`;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.options.timeoutMs);
+    try {
+      const headers = {
+        Authorization: `Bearer ${this.options.apiKey}`
+      };
+      if (init?.idempotencyKey) {
+        headers["Idempotency-Key"] = init.idempotencyKey;
+      }
+      if (!init?.formData) {
+        headers["Content-Type"] = "application/json";
+      }
+      const res = await fetch(url, {
+        method,
+        headers,
+        body: init?.formData ?? (init?.body != null ? JSON.stringify(init.body) : void 0),
+        signal: controller.signal
+      });
+      const text = await res.text();
+      let data = null;
+      if (text) {
+        try {
+          data = JSON.parse(text);
+        } catch {
+          data = text;
+        }
+      }
+      if (!res.ok) {
+        const err = data ?? {};
+        throw new DeepseenError(
+          err.error?.message || `HTTP ${res.status}`,
+          err.error?.code || err.error?.type || "http_error",
+          res.status,
+          err.error?.param ?? null
+        );
+      }
+      return data;
+    } catch (err) {
+      if (err instanceof DeepseenError) throw err;
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new DeepseenError("Request timeout", "timeout");
+      }
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  get(path2) {
+    return this.request("GET", path2);
+  }
+  post(path2, body, idempotencyKey) {
+    return this.request("POST", path2, { body, idempotencyKey });
+  }
+  postForm(path2, formData) {
+    return this.request("POST", path2, { formData });
+  }
+};
+
+// src/resources/files.ts
+import fs from "fs";
+import path from "path";
+var FilesAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** 上传本地文件（图片或视频），返回可填入 product_images / competitor_video_url 的 url */
+  async upload(filePath, purpose = "product_image") {
+    const buffer = fs.readFileSync(filePath);
+    const filename = path.basename(filePath);
+    const ext = path.extname(filename).toLowerCase();
+    const mime = ext === ".png" ? "image/png" : ext === ".webp" ? "image/webp" : ext === ".mp4" ? "video/mp4" : ext === ".webm" ? "video/webm" : ext === ".mov" ? "video/quicktime" : "image/jpeg";
+    const form = new FormData();
+    form.append("purpose", purpose);
+    form.append("file", new Blob([buffer], { type: mime }), filename);
+    return this.http.postForm("/files", form);
+  }
+  /** 上传 Buffer / Blob（浏览器或 Node 均可用） */
+  async uploadBlob(blob, filename, purpose = "product_image") {
+    const form = new FormData();
+    form.append("purpose", purpose);
+    form.append("file", blob, filename);
+    return this.http.postForm("/files", form);
+  }
+  async retrieve(fileId) {
+    return this.http.get(`/files/${fileId}`);
+  }
+};
+
+// src/imageJob.ts
+var TERMINAL = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
+function jobPath(resource, jobId, action) {
+  const baseMap = {
+    "smart-image": `/smart-image/recreations/${jobId}`,
+    image: `/image/recreations/${jobId}`,
+    "smart-video": `/smart-video/recreations/${jobId}`,
+    video: `/video/recreations/${jobId}`
+  };
+  const base = baseMap[resource];
+  if (action === "cancel") return `${base}/cancel`;
+  if (action === "confirm") return `${base}/confirm`;
+  return base;
+}
+var MediaJobHandle = class {
+  constructor(http, resource, data) {
+    this.http = http;
+    this.resource = resource;
+    this.data = data;
+  }
+  get id() {
+    return this.data.id;
+  }
+  get status() {
+    return this.data.status;
+  }
+  async refresh() {
+    this.data = await this.http.get(jobPath(this.resource, this.data.id));
+    return this;
+  }
+  async wait(options = {}) {
+    const pollIntervalMs = options.pollIntervalMs ?? 8e3;
+    const timeoutMs = options.timeoutMs ?? 6e5;
+    const start = Date.now();
+    while (true) {
+      await this.refresh();
+      options.onProgress?.(this.data);
+      if (TERMINAL.has(this.data.status)) {
+        if (this.data.status === "failed") {
+          throw new DeepseenJobFailedError(
+            this.data.id,
+            this.data.error?.message ?? "Job failed",
+            this.data.error?.code ?? "job_failed"
+          );
+        }
+        return this.data;
+      }
+      if (Date.now() - start > timeoutMs) {
+        throw new DeepseenTimeoutError();
+      }
+      await new Promise((r) => setTimeout(r, pollIntervalMs));
+    }
+  }
+  async cancel() {
+    this.data = await this.http.post(jobPath(this.resource, this.data.id, "cancel"));
+    return this.data;
+  }
+  async confirm(body) {
+    if (this.resource !== "image" && this.resource !== "video") {
+      throw new Error("confirm() \u4EC5\u9002\u7528\u4E8E\u56FE\u7247/\u89C6\u9891\u4E8C\u521B Job");
+    }
+    this.data = await this.http.post(
+      jobPath(this.resource, this.data.id, "confirm"),
+      body
+    );
+    return this;
+  }
+};
+function wrapJob(http, resource, data) {
+  return new MediaJobHandle(http, resource, data);
+}
+
+// src/resources/smartImage.ts
+var SmartImageRecreationsAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async create(params) {
+    const body = {
+      region: params.region,
+      keywords: params.keywords,
+      product_images: params.productImages,
+      product_file_ids: params.productFileIds,
+      product_details: params.productDetails,
+      include_prompts: params.includePrompts,
+      metadata: params.metadata,
+      webhook_url: params.webhookUrl
+    };
+    const job = await this.http.post(
+      "/smart-image/recreations",
+      body,
+      params.idempotencyKey
+    );
+    return wrapJob(this.http, "smart-image", job);
+  }
+  async retrieve(jobId) {
+    const job = await this.http.get(`/smart-image/recreations/${jobId}`);
+    return wrapJob(this.http, "smart-image", job);
+  }
+};
+var SmartImageAPI = class {
+  recreations;
+  constructor(http) {
+    this.recreations = new SmartImageRecreationsAPI(http);
+  }
+};
+
+// src/resources/imageRecreation.ts
+var ImageRecreationsAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async create(params) {
+    const body = {
+      competitor_product_url: params.competitorProductUrl,
+      product_images: params.productImages,
+      product_file_ids: params.productFileIds,
+      model: params.model,
+      aspect_ratio: params.aspectRatio,
+      auto_generate: params.autoGenerate,
+      include_prompts: params.includePrompts,
+      metadata: params.metadata,
+      webhook_url: params.webhookUrl
+    };
+    const job = await this.http.post(
+      "/image/recreations",
+      body,
+      params.idempotencyKey
+    );
+    return wrapJob(this.http, "image", job);
+  }
+  async retrieve(jobId) {
+    const job = await this.http.get(`/image/recreations/${jobId}`);
+    return wrapJob(this.http, "image", job);
+  }
+  async confirm(jobId, params = {}) {
+    const job = await this.http.post(`/image/recreations/${jobId}/confirm`, {
+      model: params.model,
+      variants: params.variants
+    });
+    return wrapJob(this.http, "image", job);
+  }
+};
+var ImageAPI = class {
+  recreations;
+  constructor(http) {
+    this.recreations = new ImageRecreationsAPI(http);
+  }
+};
+
+// src/resources/smartVideo.ts
+var SmartVideoRecreationsAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async create(params) {
+    const body = {
+      region: params.region,
+      product_title: params.productTitle,
+      product_images: params.productImages,
+      product_file_ids: params.productFileIds,
+      count: params.count,
+      model: params.model,
+      include_prompts: params.includePrompts,
+      metadata: params.metadata,
+      webhook_url: params.webhookUrl
+    };
+    const job = await this.http.post(
+      "/smart-video/recreations",
+      body,
+      params.idempotencyKey
+    );
+    return wrapJob(this.http, "smart-video", job);
+  }
+  async retrieve(jobId) {
+    const job = await this.http.get(`/smart-video/recreations/${jobId}`);
+    return wrapJob(this.http, "smart-video", job);
+  }
+};
+var SmartVideoAPI = class {
+  recreations;
+  constructor(http) {
+    this.recreations = new SmartVideoRecreationsAPI(http);
+  }
+};
+
+// src/resources/videoRecreation.ts
+var VideoRecreationsAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async create(params) {
+    const body = {
+      competitor_video_url: params.competitorVideoUrl,
+      product_images: params.productImages,
+      product_file_ids: params.productFileIds,
+      model: params.model,
+      group_count: params.groupCount,
+      auto_generate: params.autoGenerate,
+      include_prompts: params.includePrompts,
+      metadata: params.metadata,
+      webhook_url: params.webhookUrl
+    };
+    const job = await this.http.post(
+      "/video/recreations",
+      body,
+      params.idempotencyKey
+    );
+    return wrapJob(this.http, "video", job);
+  }
+  async retrieve(jobId) {
+    const job = await this.http.get(`/video/recreations/${jobId}`);
+    return wrapJob(this.http, "video", job);
+  }
+  async confirm(jobId, params = {}) {
+    const job = await this.http.post(`/video/recreations/${jobId}/confirm`, {
+      model: params.model,
+      variants: params.variants
+    });
+    return wrapJob(this.http, "video", job);
+  }
+};
+var VideoAPI = class {
+  recreations;
+  constructor(http) {
+    this.recreations = new VideoRecreationsAPI(http);
+  }
+};
+
+// src/constants.ts
+var DEFAULT_BASE_URL = "https://deepseen.ai/v1";
+
+// src/client.ts
+var DeepseenClient = class {
+  files;
+  smartImage;
+  image;
+  smartVideo;
+  video;
+  http;
+  constructor(options) {
+    if (!options.apiKey?.trim()) {
+      throw new Error("apiKey \u5FC5\u586B");
+    }
+    const baseURL = (options.baseURL ?? process.env.DEEPSEEN_BASE_URL ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+    this.http = new HttpClient({
+      apiKey: options.apiKey.trim(),
+      baseURL,
+      timeoutMs: options.timeoutMs ?? 12e4
+    });
+    this.files = new FilesAPI(this.http);
+    this.smartImage = new SmartImageAPI(this.http);
+    this.image = new ImageAPI(this.http);
+    this.smartVideo = new SmartVideoAPI(this.http);
+    this.video = new VideoAPI(this.http);
+  }
+  /** 健康检查 / 列出可用端点 */
+  async ping() {
+    return this.http.get("/");
+  }
+};
+function createClient(options) {
+  return new DeepseenClient(options);
+}
+function clientFromEnv() {
+  const apiKey = process.env.DEEPSEEN_API_KEY;
+  if (!apiKey) {
+    throw new Error("\u8BF7\u8BBE\u7F6E\u73AF\u5883\u53D8\u91CF DEEPSEEN_API_KEY");
+  }
+  return new DeepseenClient({
+    apiKey,
+    baseURL: process.env.DEEPSEEN_BASE_URL
+  });
+}
+export {
+  DEFAULT_BASE_URL,
+  DeepseenClient,
+  DeepseenError,
+  DeepseenJobFailedError,
+  DeepseenTimeoutError,
+  MediaJobHandle,
+  clientFromEnv,
+  createClient
+};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "deepseen-sdk",
+  "version": "1.0.0",
+  "description": "Deepseen Open API SDK — 图片/视频智创与二创",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts",
+    "dev": "tsup src/index.ts --format esm --dts --watch",
+    "test": "vitest run",
+    "prepack": "pnpm run build",
+    "publish:npm": "powershell -ExecutionPolicy Bypass -File ./scripts/publish.ps1"
+  },
+  "keywords": [
+    "deepseen",
+    "openapi",
+    "tiktok",
+    "ai",
+    "image-generation",
+    "video-generation"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kanehuang168/deepseen.git",
+    "directory": "packages/sdk"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@types/node": "^25.1.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  }
+}