@aviaryhq/cloudglue-js 0.0.13 → 0.0.14

package/dist/src/client.d.ts

@@ -1,5 +1,5 @@
-import { FilesApi, CollectionsApi, ChatApi, TranscribeApi, ExtractApi } from '../generated';
-import type { File } from './types';
+import { FilesApi, CollectionsApi, ChatApi, TranscribeApi, ExtractApi } from "../generated";
+import type { File } from "./types";
 export declare class CloudGlueError extends Error {
     readonly statusCode?: number | undefined;
     readonly data?: string | undefined;
@@ -12,13 +12,14 @@ export declare class CloudGlueError extends Error {
 export interface CloudGlueConfig {
     apiKey?: string;
     baseUrl?: string;
+    timeout?: number;
 }
 interface ListFilesParams {
-    status?: 'pending' | 'processing' | 'ready' | 'completed' | 'failed' | 'not_applicable';
+    status?: "pending" | "processing" | "ready" | "completed" | "failed" | "not_applicable";
     limit?: number;
     offset?: number;
-    order?: 'created_at' | 'filename';
-    sort?: 'asc' | 'desc';
+    order?: "created_at" | "filename";
+    sort?: "asc" | "desc";
     created_before?: string;
     created_after?: string;
 }
@@ -29,12 +30,12 @@ interface UploadFileParams {
 interface ListCollectionParams {
     limit?: number;
     offset?: number;
-    order?: 'name' | 'created_at';
-    sort?: 'asc' | 'desc';
-    collection_type?: 'entities' | 'rich-transcripts';
+    order?: "name" | "created_at";
+    sort?: "asc" | "desc";
+    collection_type?: "entities" | "rich-transcripts";
 }
 interface CreateCollectionParams {
-    collection_type: 'entities' | 'rich-transcripts';
+    collection_type: "entities" | "rich-transcripts";
     name: string;
     description?: string;
     extract_config?: {
@@ -51,16 +52,16 @@ interface CreateCollectionParams {
 interface ListCollectionVideosParams {
     limit?: number;
     offset?: number;
-    status?: 'pending' | 'processing' | 'ready' | 'completed' | 'failed' | 'not_applicable';
-    order?: 'added_at' | 'filename';
-    sort?: 'asc' | 'desc';
+    status?: "pending" | "processing" | "ready" | "completed" | "failed" | "not_applicable";
+    order?: "added_at" | "filename";
+    sort?: "asc" | "desc";
     added_before?: string;
     added_after?: string;
 }
 interface ChatCompletionParams {
     model?: string;
     messages: Array<{
-        role: 'system' | 'user' | 'assistant';
+        role: "system" | "user" | "assistant";
         content: string;
         name?: string;
     }>;
@@ -68,7 +69,7 @@ interface ChatCompletionParams {
     filter?: {
         metadata?: Array<{
             path: string;
-            operator: 'NotEqual' | 'Equal' | 'LessThan' | 'GreaterThan' | 'In' | 'ContainsAny' | 'ContainsAll';
+            operator: "NotEqual" | "Equal" | "LessThan" | "GreaterThan" | "In" | "ContainsAny" | "ContainsAll";
             valueText?: string;
             valueTextArray?: string[];
         }>;
@@ -79,6 +80,12 @@ interface ChatCompletionParams {
     top_p?: number;
     max_tokens?: number;
 }
+interface WaitForReadyOptions {
+    /** Interval in milliseconds between polling attempts. Defaults to 5000ms (5 seconds). */
+    pollingInterval?: number;
+    /** Maximum number of polling attempts before giving up. Defaults to 36 (3 minutes total with default interval). */
+    maxAttempts?: number;
+}
 declare class EnhancedFilesApi {
     private readonly api;
     constructor(api: typeof FilesApi);
@@ -122,6 +129,43 @@ declare class EnhancedFilesApi {
         id: import("zod").ZodString;
         object: import("zod").ZodLiteral<"file">;
     }, import("zod").ZodTypeAny, "passthrough">>;
+    /**
+     * Waits for a file to finish processing by polling the getFile endpoint until the file
+     * reaches a terminal state (completed, failed, or not_applicable) or until maxAttempts is reached.
+     *
+     * @param fileId - The ID of the file to wait for
+     * @param options - Optional configuration for polling behavior
+     * @returns The final file object
+     * @throws {CloudGlueError} If the file fails to process or maxAttempts is reached
+     */
+    waitForReady(fileId: string, options?: WaitForReadyOptions): Promise<import("zod").objectOutputType<{
+        id: import("zod").ZodString;
+        status: import("zod").ZodEnum<["pending", "processing", "completed", "failed", "not_applicable"]>;
+        bytes: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNull]>>;
+        created_at: import("zod").ZodOptional<import("zod").ZodNumber>;
+        filename: import("zod").ZodOptional<import("zod").ZodString>;
+        uri: import("zod").ZodString;
+        metadata: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodNull]>>;
+        video_info: import("zod").ZodOptional<import("zod").ZodObject<{
+            duration_seconds: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNull]>>;
+            height: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNull]>>;
+            width: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNull]>>;
+            format: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNull]>>;
+            has_audio: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodBoolean, import("zod").ZodNull]>>;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            duration_seconds: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNull]>>;
+            height: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNull]>>;
+            width: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNull]>>;
+            format: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNull]>>;
+            has_audio: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodBoolean, import("zod").ZodNull]>>;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            duration_seconds: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNull]>>;
+            height: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNull]>>;
+            width: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodNumber, import("zod").ZodNull]>>;
+            format: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNull]>>;
+            has_audio: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodBoolean, import("zod").ZodNull]>>;
+        }, import("zod").ZodTypeAny, "passthrough">>>;
+    }, import("zod").ZodTypeAny, "passthrough">>;
 }
 declare class EnhancedCollectionsApi {
     private readonly api;
@@ -258,7 +302,7 @@ declare class EnhancedCollectionsApi {
         limit: import("zod").ZodNumber;
         offset: import("zod").ZodNumber;
     }, import("zod").ZodTypeAny, "passthrough">>;
-    getTranscripts(collectionId: string, fileId: string, limit?: number, offset?: number, response_format?: 'markdown' | 'json'): Promise<import("zod").objectOutputType<{
+    getTranscripts(collectionId: string, fileId: string, limit?: number, offset?: number, response_format?: "markdown" | "json"): Promise<import("zod").objectOutputType<{
         collection_id: import("zod").ZodString;
         file_id: import("zod").ZodString;
         content: import("zod").ZodOptional<import("zod").ZodString>;
@@ -314,6 +358,26 @@ declare class EnhancedCollectionsApi {
         searchable_status?: ("pending" | "processing" | "completed" | "failed" | "not_applicable") | undefined;
         file?: File | undefined;
     }>;
+    /**
+     * Waits for a video in a collection to be ready by polling the getVideo endpoint until
+     * the video reaches a terminal state (completed, failed, or not_applicable) or until maxAttempts is reached.
+     *
+     * @param collectionId - The ID of the collection containing the video
+     * @param fileId - The ID of the video file to wait for
+     * @param options - Optional configuration for polling behavior
+     * @returns The final collection file object
+     * @throws {CloudGlueError} If the video fails to process or maxAttempts is reached
+     */
+    waitForReady(collectionId: string, fileId: string, options?: WaitForReadyOptions): Promise<{
+        collection_id: string;
+        file_id: string;
+        object: "collection_file";
+        added_at: number;
+        status: "pending" | "processing" | "completed" | "failed" | "not_applicable";
+        extract_status?: ("pending" | "processing" | "completed" | "failed" | "not_applicable") | undefined;
+        searchable_status?: ("pending" | "processing" | "completed" | "failed" | "not_applicable") | undefined;
+        file?: File | undefined;
+    }>;
 }
 declare class EnhancedChatApi {
     private readonly api;
@@ -408,7 +472,7 @@ declare class EnhancedTranscribeApi {
         error?: string | undefined;
     }>;
     getTranscribe(jobId: string, options?: {
-        response_format?: 'json' | 'markdown';
+        response_format?: "json" | "markdown";
     }): Promise<{
         job_id: string;
         status: "pending" | "processing" | "completed" | "failed" | "not_applicable";
@@ -445,11 +509,11 @@ declare class EnhancedTranscribeApi {
     listTranscribes(params?: {
         limit?: number;
         offset?: number;
-        status?: 'pending' | 'processing' | 'completed' | 'failed' | 'not_applicable';
+        status?: "pending" | "processing" | "completed" | "failed" | "not_applicable";
         created_before?: string;
         created_after?: string;
         url?: string;
-        response_format?: 'json' | 'markdown';
+        response_format?: "json" | "markdown";
     }): Promise<{
         object: "list";
         data: Array<{
@@ -488,6 +552,50 @@ declare class EnhancedTranscribeApi {
         total: number;
         limit: number;
     }>;
+    /**
+     * Waits for a transcription job to be ready by polling the getTranscribe endpoint until
+     * the job reaches a terminal state (completed, failed, or not_applicable) or until maxAttempts is reached.
+     *
+     * @param jobId - The ID of the transcription job to wait for
+     * @param options - Optional configuration for polling behavior and response format
+     * @returns The final transcription job object
+     * @throws {CloudGlueError} If the job fails to process or maxAttempts is reached
+     */
+    waitForReady(jobId: string, options?: WaitForReadyOptions & {
+        response_format?: "json" | "markdown";
+    }): Promise<{
+        job_id: string;
+        status: "pending" | "processing" | "completed" | "failed" | "not_applicable";
+        url?: string | undefined;
+        created_at?: number | undefined;
+        transcribe_config?: Partial<{
+            "enable_summary ": boolean;
+            enable_speech: boolean;
+            enable_visual_scene_description: boolean;
+            enable_scene_text: boolean;
+        }> | undefined;
+        data?: Partial<{
+            content: string;
+            title: string;
+            summary: string;
+            speech: Array<Partial<{
+                text: string;
+                start_time: number;
+                end_time: number;
+            }>>;
+            visual_scene_description: Array<Partial<{
+                text: string;
+                start_time: number;
+                end_time: number;
+            }>>;
+            scene_text: Array<Partial<{
+                text: string;
+                start_time: number;
+                end_time: number;
+            }>>;
+        }> | undefined;
+        error?: string | undefined;
+    }>;
 }
 declare class EnhancedExtractApi {
     private readonly api;
@@ -538,7 +646,7 @@ declare class EnhancedExtractApi {
     listExtracts(params?: {
         limit?: number;
         offset?: number;
-        status?: 'pending' | 'processing' | 'completed' | 'failed' | 'not_applicable';
+        status?: "pending" | "processing" | "completed" | "failed" | "not_applicable";
         created_before?: string;
         created_after?: string;
         url?: string;
@@ -568,6 +676,35 @@ declare class EnhancedExtractApi {
         limit: number;
         offset: number;
     }>;
+    /**
+     * Waits for an extraction job to be ready by polling the getExtract endpoint until
+     * the job reaches a terminal state (completed, failed, or not_applicable) or until maxAttempts is reached.
+     *
+     * @param jobId - The ID of the extraction job to wait for
+     * @param options - Optional configuration for polling behavior
+     * @returns The final extraction job object
+     * @throws {CloudGlueError} If the job fails to process or maxAttempts is reached
+     */
+    waitForReady(jobId: string, options?: WaitForReadyOptions): Promise<{
+        job_id: string;
+        status: "pending" | "processing" | "completed" | "failed" | "not_applicable";
+        url?: string | undefined;
+        created_at?: number | undefined;
+        extract_config?: Partial<{
+            prompt: string;
+            schema: {};
+        }> | undefined;
+        data?: Partial<{
+            entities: {};
+            segment_entities: Array<Partial<{
+                segment_id: string | number;
+                start_time: number;
+                end_time: number;
+                entities: {};
+            }>>;
+        }> | undefined;
+        error?: string | undefined;
+    }>;
 }
 /**
  * Main CloudGlue client class that provides access to all API functionality
@@ -576,6 +713,7 @@ declare class EnhancedExtractApi {
 export declare class CloudGlue {
     private readonly baseUrl;
     private readonly apiKey;
+    private readonly timeout;
     /**
      * Files API for managing video files
      * Provides methods for uploading, listing, and managing video files

package/dist/src/client.js

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CloudGlue = exports.CloudGlueError = void 0;
-const generated_1 = require("../generated");
+const Files_1 = require("../generated/Files");
+const Collections_1 = require("../generated/Collections");
+const Chat_1 = require("../generated/Chat");
+const Transcribe_1 = require("../generated/Transcribe");
+const Extract_1 = require("../generated/Extract");
 class CloudGlueError extends Error {
     constructor(message, statusCode, data, headers) {
         super(message);
@@ -27,26 +31,55 @@ class EnhancedFilesApi {
         // 3. Set the correct Content-Type header
         // This is why we use axios directly instead of the generated client method.
         const formData = new FormData();
-        formData.append('file', params.file);
+        formData.append("file", params.file);
         // Add metadata if provided
         if (params.metadata) {
-            formData.append('metadata', JSON.stringify(params.metadata));
+            formData.append("metadata", JSON.stringify(params.metadata));
         }
         // Use axios directly to bypass Zodios validation
         return this.api.axios({
-            method: 'post',
-            url: '/files',
+            method: "post",
+            url: "/files",
             data: formData,
             headers: {
-                'Content-Type': 'multipart/form-data'
-            }
+                "Content-Type": "multipart/form-data",
+            },
         });
     }
     async getFile(fileId) {
         return this.api.getFile({ params: { file_id: fileId } });
     }
     async deleteFile(fileId) {
-        return this.api.deleteFile({ params: { file_id: fileId } }, { params: { file_id: fileId } });
+        return this.api.deleteFile({ params: { file_id: fileId } }, {
+            params: { file_id: fileId },
+        });
+    }
+    /**
+     * Waits for a file to finish processing by polling the getFile endpoint until the file
+     * reaches a terminal state (completed, failed, or not_applicable) or until maxAttempts is reached.
+     *
+     * @param fileId - The ID of the file to wait for
+     * @param options - Optional configuration for polling behavior
+     * @returns The final file object
+     * @throws {CloudGlueError} If the file fails to process or maxAttempts is reached
+     */
+    async waitForReady(fileId, options = {}) {
+        const { pollingInterval = 5000, maxAttempts = 36 } = options;
+        let attempts = 0;
+        while (attempts < maxAttempts) {
+            const file = await this.getFile(fileId);
+            // If we've reached a terminal state, return the file
+            if (["completed", "failed", "not_applicable"].includes(file.status)) {
+                if (file.status === "failed") {
+                    throw new CloudGlueError(`File processing failed: ${fileId}`);
+                }
+                return file;
+            }
+            // Wait for the polling interval before trying again
+            await new Promise((resolve) => setTimeout(resolve, pollingInterval));
+            attempts++;
+        }
+        throw new CloudGlueError(`Timeout waiting for file ${fileId} to process after ${maxAttempts} attempts`);
     }
 }
 class EnhancedCollectionsApi {
@@ -60,7 +93,9 @@ class EnhancedCollectionsApi {
         return this.api.createCollection(params);
     }
     async getCollection(collectionId) {
-        return this.api.getCollection({ params: { collection_id: collectionId } });
+        return this.api.getCollection({
+            params: { collection_id: collectionId },
+        });
     }
     async deleteCollection(collectionId) {
         return this.api.deleteCollection({ params: { collection_id: collectionId } }, { params: { collection_id: collectionId } });
@@ -71,34 +106,62 @@ class EnhancedCollectionsApi {
     async listVideos(collectionId, params = {}) {
         return this.api.listVideos({
             params: { collection_id: collectionId },
-            queries: params
+            queries: params,
         });
     }
     async getVideo(collectionId, fileId) {
         return this.api.getVideo({
-            params: { collection_id: collectionId, file_id: fileId }
+            params: { collection_id: collectionId, file_id: fileId },
         });
     }
     async deleteVideo(collectionId, fileId) {
         return this.api.deleteVideo({
-            params: { collection_id: collectionId, file_id: fileId }
+            params: { collection_id: collectionId, file_id: fileId },
         }, { params: { collection_id: collectionId, file_id: fileId } });
     }
     async getEntities(collectionId, fileId, limit, offset) {
         return this.api.getEntities({
             params: { collection_id: collectionId, file_id: fileId },
-            queries: { limit, offset }
+            queries: { limit, offset },
         });
     }
     async getTranscripts(collectionId, fileId, limit, offset, response_format) {
         return this.api.getTranscripts({
             params: { collection_id: collectionId, file_id: fileId },
-            queries: { limit, offset, response_format }
+            queries: { limit, offset, response_format },
         });
     }
     async addYouTubeVideo(collectionId, url, metadata) {
         return this.api.addYouTubeVideo({ url, metadata }, { params: { collection_id: collectionId } });
     }
+    /**
+     * Waits for a video in a collection to be ready by polling the getVideo endpoint until
+     * the video reaches a terminal state (completed, failed, or not_applicable) or until maxAttempts is reached.
+     *
+     * @param collectionId - The ID of the collection containing the video
+     * @param fileId - The ID of the video file to wait for
+     * @param options - Optional configuration for polling behavior
+     * @returns The final collection file object
+     * @throws {CloudGlueError} If the video fails to process or maxAttempts is reached
+     */
+    async waitForReady(collectionId, fileId, options = {}) {
+        const { pollingInterval = 5000, maxAttempts = 36 } = options;
+        let attempts = 0;
+        while (attempts < maxAttempts) {
+            const video = await this.getVideo(collectionId, fileId);
+            // If we've reached a terminal state, return the video
+            if (["completed", "failed", "not_applicable"].includes(video.status)) {
+                if (video.status === "failed") {
+                    throw new CloudGlueError(`Video processing failed: ${fileId} in collection ${collectionId}`);
+                }
+                return video;
+            }
+            // Wait for the polling interval before trying again
+            await new Promise((resolve) => setTimeout(resolve, pollingInterval));
+            attempts++;
+        }
+        throw new CloudGlueError(`Timeout waiting for video ${fileId} in collection ${collectionId} to process after ${maxAttempts} attempts`);
+    }
 }
 class EnhancedChatApi {
     constructor(api) {
@@ -106,8 +169,8 @@ class EnhancedChatApi {
     }
     async createCompletion(params) {
         return this.api.createCompletion({
-            model: params.model || 'nimbus-001',
-            ...params
+            model: params.model || "nimbus-001",
+            ...params,
         });
     }
 }
@@ -118,18 +181,45 @@ class EnhancedTranscribeApi {
     async createTranscribe(url, options = {}) {
         return this.api.createTranscribe({
             url,
-            ...options
+            ...options,
         });
     }
     async getTranscribe(jobId, options = {}) {
         return this.api.getTranscribe({
             params: { job_id: jobId },
-            queries: { response_format: options.response_format }
+            queries: { response_format: options.response_format },
         });
     }
     async listTranscribes(params = {}) {
         return this.api.listTranscribes({ queries: params });
     }
+    /**
+     * Waits for a transcription job to be ready by polling the getTranscribe endpoint until
+     * the job reaches a terminal state (completed, failed, or not_applicable) or until maxAttempts is reached.
+     *
+     * @param jobId - The ID of the transcription job to wait for
+     * @param options - Optional configuration for polling behavior and response format
+     * @returns The final transcription job object
+     * @throws {CloudGlueError} If the job fails to process or maxAttempts is reached
+     */
+    async waitForReady(jobId, options = {}) {
+        const { pollingInterval = 5000, maxAttempts = 36, response_format, } = options;
+        let attempts = 0;
+        while (attempts < maxAttempts) {
+            const job = await this.getTranscribe(jobId, { response_format });
+            // If we've reached a terminal state, return the job
+            if (["completed", "failed", "not_applicable"].includes(job.status)) {
+                if (job.status === "failed") {
+                    throw new CloudGlueError(`Transcription job failed: ${jobId}`);
+                }
+                return job;
+            }
+            // Wait for the polling interval before trying again
+            await new Promise((resolve) => setTimeout(resolve, pollingInterval));
+            attempts++;
+        }
+        throw new CloudGlueError(`Timeout waiting for transcription job ${jobId} to process after ${maxAttempts} attempts`);
+    }
 }
 class EnhancedExtractApi {
     constructor(api) {
@@ -138,7 +228,7 @@ class EnhancedExtractApi {
     async createExtract(url, options) {
         return this.api.createExtract({
             url,
-            ...options
+            ...options,
         });
     }
     async getExtract(jobId) {
@@ -147,6 +237,33 @@ class EnhancedExtractApi {
     async listExtracts(params = {}) {
         return this.api.listExtracts({ queries: params });
     }
+    /**
+     * Waits for an extraction job to be ready by polling the getExtract endpoint until
+     * the job reaches a terminal state (completed, failed, or not_applicable) or until maxAttempts is reached.
+     *
+     * @param jobId - The ID of the extraction job to wait for
+     * @param options - Optional configuration for polling behavior
+     * @returns The final extraction job object
+     * @throws {CloudGlueError} If the job fails to process or maxAttempts is reached
+     */
+    async waitForReady(jobId, options = {}) {
+        const { pollingInterval = 5000, maxAttempts = 36 } = options;
+        let attempts = 0;
+        while (attempts < maxAttempts) {
+            const job = await this.getExtract(jobId);
+            // If we've reached a terminal state, return the job
+            if (["completed", "failed", "not_applicable"].includes(job.status)) {
+                if (job.status === "failed") {
+                    throw new CloudGlueError(`Extraction job failed: ${jobId}`);
+                }
+                return job;
+            }
+            // Wait for the polling interval before trying again
+            await new Promise((resolve) => setTimeout(resolve, pollingInterval));
+            attempts++;
+        }
+        throw new CloudGlueError(`Timeout waiting for extraction job ${jobId} to process after ${maxAttempts} attempts`);
+    }
 }
 /**
  * Main CloudGlue client class that provides access to all API functionality
@@ -154,25 +271,28 @@ class EnhancedExtractApi {
  */
 class CloudGlue {
     constructor(config = {}) {
-        this.apiKey = config.apiKey || process.env.CLOUDGLUE_API_KEY || '';
-        this.baseUrl = config.baseUrl || 'https://api.cloudglue.dev/v1';
+        this.apiKey = config.apiKey || process.env.CLOUDGLUE_API_KEY || "";
+        this.baseUrl = config.baseUrl || "https://api.cloudglue.dev/v1";
+        this.timeout = config.timeout || 10000;
         if (!this.apiKey) {
-            throw new Error('API key is required. Please provide an API key via constructor or CLOUDGLUE_API_KEY environment variable.');
+            throw new Error("API key is required. Please provide an API key via constructor or CLOUDGLUE_API_KEY environment variable.");
         }
         const axiosConfig = {
             headers: {
-                Authorization: `Bearer ${this.apiKey}`
-            }
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+            baseURL: this.baseUrl,
+            timeout: this.timeout,
         };
         // Initialize all API clients with the configured base URL and auth
-        const filesApi = generated_1.FilesApi;
-        const collectionsApi = generated_1.CollectionsApi;
-        const chatApi = generated_1.ChatApi;
-        const transcribeApi = generated_1.TranscribeApi;
-        const extractApi = generated_1.ExtractApi;
+        const filesApi = (0, Files_1.createApiClient)(this.baseUrl);
+        const collectionsApi = (0, Collections_1.createApiClient)(this.baseUrl);
+        const chatApi = (0, Chat_1.createApiClient)(this.baseUrl);
+        const transcribeApi = (0, Transcribe_1.createApiClient)(this.baseUrl);
+        const extractApi = (0, Extract_1.createApiClient)(this.baseUrl);
         // Configure base URL and axios config for all clients
-        [filesApi, collectionsApi, chatApi, transcribeApi, extractApi].forEach(client => {
-            client.axios.defaults.baseURL = this.baseUrl;
+        [filesApi, collectionsApi, chatApi, transcribeApi, extractApi].forEach((client) => {
+            Object.assign(client.axios.defaults, axiosConfig);
             client.axios.interceptors.response.use((response) => {
                 return response;
             }, (error) => {
@@ -185,7 +305,6 @@ class CloudGlue {
                 // Something happened in setting up the request that triggered an Error
                 return Promise.reject(new CloudGlueError(error.message, error.statusCode ?? 500, error.data, error.headers));
             });
-            Object.assign(client.axios.defaults, axiosConfig);
         });
         // Create enhanced API clients
         this.files = new EnhancedFilesApi(filesApi);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aviaryhq/cloudglue-js",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "description": "CloudGlue API client for Node.js",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",