@apicity/xai 0.1.0-alpha.0

package/dist/src/xai.js

@@ -0,0 +1,759 @@
+import { XaiError, } from "./types.js";
+import { XaiChatRequestSchema, XaiImageGenerateRequestSchema, XaiImageEditRequestSchema, XaiVideoGenerateRequestSchema, XaiVideoEditRequestSchema, XaiVideoExtendRequestSchema, XaiBatchCreateRequestSchema, XaiCollectionCreateRequestSchema, XaiCollectionUpdateRequestSchema, XaiDocumentSearchRequestSchema, XaiResponseRequestSchema, XaiTokenizeTextRequestSchema, XaiRealtimeClientSecretRequestSchema, XaiTtsRequestSchema, XaiSttRequestSchema, XaiCustomVoiceCreateRequestSchema, } from "./zod.js";
+import { attachExamples } from "./example.js";
+// Helper function to safely handle AbortSignal across different environments
+function attachAbortHandler(signal, controller) {
+    if (!signal)
+        return;
+    // Handle both standard AbortSignal and node-fetch's AbortSignal
+    if (typeof signal.addEventListener === "function") {
+        signal.addEventListener("abort", () => controller.abort(), { once: true });
+    }
+    else if (signal.aborted) {
+        // Already aborted, abort our controller too
+        controller.abort();
+    }
+}
+export function xai(opts) {
+    const baseURL = opts.baseURL ?? "https://api.x.ai/v1";
+    const managementBaseURL = opts.managementBaseURL ?? "https://management-api.x.ai/v1";
+    const managementApiKey = opts.managementApiKey ?? opts.apiKey;
+    const doFetch = opts.fetch ?? fetch;
+    const timeout = opts.timeout ?? 30000;
+    async function makeRequest(method, path, body, signal) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        if (signal) {
+            attachAbortHandler(signal, controller);
+        }
+        try {
+            const headers = {
+                Authorization: `Bearer ${opts.apiKey}`,
+            };
+            const init = {
+                method,
+                headers,
+                signal: controller.signal,
+            };
+            if (body !== undefined) {
+                headers["Content-Type"] = "application/json";
+                init.body = JSON.stringify(body);
+            }
+            const res = await doFetch(`${baseURL}${path}`, init);
+            clearTimeout(timeoutId);
+            if (!res.ok) {
+                let message = `XAI API error: ${res.status}`;
+                let body = null;
+                try {
+                    body = await res.json();
+                    if (typeof body === "object" && body !== null && "error" in body) {
+                        const err = body.error;
+                        if (err?.message) {
+                            message = `XAI API error ${res.status}: ${err.message}`;
+                        }
+                    }
+                }
+                catch {
+                    // ignore parse errors
+                }
+                throw new XaiError(message, res.status, body);
+            }
+            return (await res.json());
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof XaiError)
+                throw error;
+            throw new XaiError(`XAI request failed: ${error}`, 500);
+        }
+    }
+    function buildQuery(params) {
+        const parts = [];
+        for (const [key, value] of Object.entries(params)) {
+            if (value !== undefined && value !== null) {
+                parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+            }
+        }
+        return parts.length > 0 ? `?${parts.join("&")}` : "";
+    }
+    async function makeManagementRequest(method, path, body, signal) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        if (signal) {
+            attachAbortHandler(signal, controller);
+        }
+        try {
+            const headers = {
+                Authorization: `Bearer ${managementApiKey}`,
+            };
+            const init = {
+                method,
+                headers,
+                signal: controller.signal,
+            };
+            if (body !== undefined) {
+                headers["Content-Type"] = "application/json";
+                init.body = JSON.stringify(body);
+            }
+            const res = await doFetch(`${managementBaseURL}${path}`, init);
+            clearTimeout(timeoutId);
+            if (!res.ok) {
+                let message = `XAI API error: ${res.status}`;
+                let errBody = null;
+                try {
+                    errBody = await res.json();
+                    if (typeof errBody === "object" &&
+                        errBody !== null &&
+                        "error" in errBody) {
+                        const err = errBody.error;
+                        if (err?.message) {
+                            message = `XAI API error ${res.status}: ${err.message}`;
+                        }
+                    }
+                }
+                catch {
+                    // ignore parse errors
+                }
+                throw new XaiError(message, res.status, errBody);
+            }
+            return (await res.json());
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof XaiError)
+                throw error;
+            throw new XaiError(`XAI request failed: ${error}`, 500);
+        }
+    }
+    function buildManagementQuery(params) {
+        const parts = [];
+        for (const [key, value] of Object.entries(params)) {
+            if (value !== undefined && value !== null) {
+                if (Array.isArray(value)) {
+                    for (const item of value) {
+                        parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(item))}`);
+                    }
+                }
+                else {
+                    parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+                }
+            }
+        }
+        return parts.length > 0 ? `?${parts.join("&")}` : "";
+    }
+    async function makeBinaryRequest(path, body, signal) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        if (signal) {
+            attachAbortHandler(signal, controller);
+        }
+        try {
+            const res = await doFetch(`${baseURL}${path}`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${opts.apiKey}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!res.ok) {
+                let message = `XAI API error: ${res.status}`;
+                let errBody = null;
+                try {
+                    errBody = await res.json();
+                    if (typeof errBody === "object" &&
+                        errBody !== null &&
+                        "error" in errBody) {
+                        const err = errBody.error;
+                        if (err?.message) {
+                            message = `XAI API error ${res.status}: ${err.message}`;
+                        }
+                    }
+                }
+                catch {
+                    // ignore parse errors
+                }
+                throw new XaiError(message, res.status, errBody);
+            }
+            return await res.arrayBuffer();
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof XaiError)
+                throw error;
+            throw new XaiError(`XAI request failed: ${error}`, 500);
+        }
+    }
+    async function makeMultipartRequest(path, form, signal) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        if (signal) {
+            attachAbortHandler(signal, controller);
+        }
+        try {
+            const res = await doFetch(`${baseURL}${path}`, {
+                method: "POST",
+                headers: { Authorization: `Bearer ${opts.apiKey}` },
+                body: form,
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!res.ok) {
+                let message = `XAI API error: ${res.status}`;
+                let errBody = null;
+                try {
+                    errBody = await res.json();
+                    if (typeof errBody === "object" &&
+                        errBody !== null &&
+                        "error" in errBody) {
+                        const err = errBody.error;
+                        if (err?.message) {
+                            message = `XAI API error ${res.status}: ${err.message}`;
+                        }
+                    }
+                }
+                catch {
+                    // ignore parse errors
+                }
+                throw new XaiError(message, res.status, errBody);
+            }
+            return (await res.json());
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof XaiError)
+                throw error;
+            throw new XaiError(`XAI request failed: ${error}`, 500);
+        }
+    }
+    // POST https://api.x.ai/v1/batches
+    // Docs: https://docs.x.ai/docs/api-reference
+    const postBatches = Object.assign(async function createBatch(req, signal) {
+        return await makeRequest("POST", "/batches", req, signal);
+    }, {
+        schema: XaiBatchCreateRequestSchema,
+        // POST https://api.x.ai/v1/batches/{batchId}:cancel
+        // Docs: https://docs.x.ai/docs/api-reference
+        cancel: async function cancelBatch(batchId, signal) {
+            return await makeRequest("POST", `/batches/${batchId}:cancel`, {}, signal);
+        },
+        // POST https://api.x.ai/v1/batches/{batchId}/requests
+        // Docs: https://docs.x.ai/docs/api-reference
+        requests: async function addRequests(batchId, req, signal) {
+            await makeRequest("POST", `/batches/${batchId}/requests`, req, signal);
+        },
+    });
+    // POST https://api.x.ai/v1/collections
+    // Docs: https://docs.x.ai/docs/api-reference
+    const postCollections = Object.assign(async function createCollection(req, signal) {
+        return await makeManagementRequest("POST", "/collections", req, signal);
+    }, {
+        schema: XaiCollectionCreateRequestSchema,
+        // POST https://api.x.ai/v1/collections/{collectionId}/documents/{fileId}
+        // Docs: https://docs.x.ai/docs/api-reference
+        documents: async function addDocument(collectionId, fileId, req, signal) {
+            await makeManagementRequest("POST", `/collections/${collectionId}/documents/${fileId}`, req ?? {}, signal);
+        },
+    });
+    // GET https://api.x.ai/v1/files/{fileIdOrSignal}
+    // Docs: https://docs.x.ai/docs/api-reference
+    async function getFiles(fileIdOrSignal, signal) {
+        if (typeof fileIdOrSignal === "string") {
+            return makeRequest("GET", `/files/${fileIdOrSignal}`, undefined, signal);
+        }
+        return makeRequest("GET", "/files", undefined, fileIdOrSignal);
+    }
+    // GET https://api.x.ai/v1/models/{modelIdOrSignal}
+    // Docs: https://docs.x.ai/docs/api-reference
+    async function getModels(modelIdOrSignal, signal) {
+        if (typeof modelIdOrSignal === "string") {
+            return makeRequest("GET", `/models/${modelIdOrSignal}`, undefined, signal);
+        }
+        return makeRequest("GET", "/models", undefined, modelIdOrSignal);
+    }
+    // GET https://api.x.ai/v1/language-models/{modelIdOrSignal}
+    // Docs: https://docs.x.ai/docs/api-reference
+    async function getLanguageModels(modelIdOrSignal, signal) {
+        if (typeof modelIdOrSignal === "string") {
+            return makeRequest("GET", `/language-models/${modelIdOrSignal}`, undefined, signal);
+        }
+        return makeRequest("GET", "/language-models", undefined, modelIdOrSignal);
+    }
+    // GET https://api.x.ai/v1/image-generation-models/{modelIdOrSignal}
+    // Docs: https://docs.x.ai/docs/api-reference
+    async function getImageGenerationModels(modelIdOrSignal, signal) {
+        if (typeof modelIdOrSignal === "string") {
+            return makeRequest("GET", `/image-generation-models/${modelIdOrSignal}`, undefined, signal);
+        }
+        return makeRequest("GET", "/image-generation-models", undefined, modelIdOrSignal);
+    }
+    // GET https://api.x.ai/v1/video-generation-models/{modelIdOrSignal}
+    // Docs: https://docs.x.ai/docs/api-reference
+    async function getVideoGenerationModels(modelIdOrSignal, signal) {
+        if (typeof modelIdOrSignal === "string") {
+            return makeRequest("GET", `/video-generation-models/${modelIdOrSignal}`, undefined, signal);
+        }
+        return makeRequest("GET", "/video-generation-models", undefined, modelIdOrSignal);
+    }
+    // GET https://api.x.ai/v1/batches/{paramsOrIdOrSignal}
+    // Docs: https://docs.x.ai/docs/api-reference
+    async function getBatches(paramsOrIdOrSignal, signal) {
+        if (typeof paramsOrIdOrSignal === "string") {
+            return makeRequest("GET", `/batches/${paramsOrIdOrSignal}`, undefined, signal);
+        }
+        const query = buildQuery(paramsOrIdOrSignal ?? {});
+        return makeRequest("GET", `/batches${query}`, undefined, signal);
+    }
+    const getBatchesNamespace = Object.assign(getBatches, {
+        // GET https://api.x.ai/v1/batches/{batchId}/requests{query}
+        // Docs: https://docs.x.ai/docs/api-reference
+        requests: async function listRequests(batchId, params, signal) {
+            const query = buildQuery(params ?? {});
+            return await makeRequest("GET", `/batches/${batchId}/requests${query}`, undefined, signal);
+        },
+        // GET https://api.x.ai/v1/batches/{batchId}/results{query}
+        // Docs: https://docs.x.ai/docs/api-reference
+        results: async function listResults(batchId, params, signal) {
+            const query = buildQuery(params ?? {});
+            return await makeRequest("GET", `/batches/${batchId}/results${query}`, undefined, signal);
+        },
+    });
+    // GET https://api.x.ai/v1/collections/{paramsOrIdOrSignal}
+    // Docs: https://docs.x.ai/docs/api-reference
+    async function getCollections(paramsOrIdOrSignal, signal) {
+        if (typeof paramsOrIdOrSignal === "string") {
+            return makeManagementRequest("GET", `/collections/${paramsOrIdOrSignal}`, undefined, signal);
+        }
+        const query = buildManagementQuery(paramsOrIdOrSignal ?? {});
+        return makeManagementRequest("GET", `/collections${query}`, undefined, signal);
+    }
+    // GET https://api.x.ai/v1/collections/{collectionId}/documents/{paramsOrFileId}
+    // Docs: https://docs.x.ai/docs/api-reference
+    const getCollectionsDocuments = Object.assign(async function listDocuments(collectionId, paramsOrFileId, signal) {
+        if (typeof paramsOrFileId === "string") {
+            return makeManagementRequest("GET", `/collections/${collectionId}/documents/${paramsOrFileId}`, undefined, signal);
+        }
+        const query = buildManagementQuery(paramsOrFileId ?? {});
+        return makeManagementRequest("GET", `/collections/${collectionId}/documents${query}`, undefined, signal);
+    }, {
+        // GET https://api.x.ai/v1/collections/{collectionId}/documents:batchGet{query}
+        // Docs: https://docs.x.ai/docs/api-reference
+        batchGet: async function batchGetDocuments(collectionId, fileIds, signal) {
+            const params = fileIds
+                .map((id) => `file_ids=${encodeURIComponent(id)}`)
+                .join("&");
+            const query = params ? `?${params}` : "";
+            return await makeManagementRequest("GET", `/collections/${collectionId}/documents:batchGet${query}`, undefined, signal);
+        },
+    });
+    const getCollectionsNamespace = Object.assign(getCollections, {
+        documents: getCollectionsDocuments,
+    });
+    // DELETE https://api.x.ai/v1/collections/{collectionId}
+    // Docs: https://docs.x.ai/docs/api-reference
+    const deleteCollections = Object.assign(async function deleteCollection(collectionId, signal) {
+        await makeManagementRequest("DELETE", `/collections/${collectionId}`, undefined, signal);
+    }, {
+        // DELETE https://api.x.ai/v1/collections/{collectionId}/documents/{fileId}
+        // Docs: https://docs.x.ai/docs/api-reference
+        documents: async function deleteDocument(collectionId, fileId, signal) {
+            await makeManagementRequest("DELETE", `/collections/${collectionId}/documents/${fileId}`, undefined, signal);
+        },
+    });
+    // PUT https://api.x.ai/v1/collections/{collectionId}
+    // Docs: https://docs.x.ai/docs/api-reference
+    const putCollections = Object.assign(async function updateCollection(collectionId, req, signal) {
+        return await makeManagementRequest("PUT", `/collections/${collectionId}`, req, signal);
+    }, {
+        schema: XaiCollectionUpdateRequestSchema,
+    });
+    return attachExamples({
+        post: {
+            v1: {
+                // POST https://api.x.ai/v1/responses
+                // Docs: https://docs.x.ai/docs/api-reference
+                responses: Object.assign(async function postResponses(req, signal) {
+                    return await makeRequest("POST", "/responses", req, signal);
+                }, {
+                    schema: XaiResponseRequestSchema,
+                }),
+                chat: {
+                    // POST https://api.x.ai/v1/chat/completions
+                    // Docs: https://docs.x.ai/docs/api-reference
+                    completions: Object.assign(async function completions(req, signal) {
+                        return await makeRequest("POST", "/chat/completions", req, signal);
+                    }, {
+                        schema: XaiChatRequestSchema,
+                    }),
+                },
+                images: {
+                    // POST https://api.x.ai/v1/images/generations
+                    // Docs: https://docs.x.ai/docs/api-reference
+                    generations: Object.assign(async function generations(req, signal) {
+                        return await makeRequest("POST", "/images/generations", req, signal);
+                    }, {
+                        schema: XaiImageGenerateRequestSchema,
+                    }),
+                    // POST https://api.x.ai/v1/images/edits
+                    // Docs: https://docs.x.ai/docs/api-reference
+                    edits: Object.assign(async function edits(req, signal) {
+                        return await makeRequest("POST", "/images/edits", req, signal);
+                    }, {
+                        schema: XaiImageEditRequestSchema,
+                    }),
+                },
+                videos: {
+                    // POST https://api.x.ai/v1/videos/generations
+                    // Docs: https://docs.x.ai/docs/api-reference
+                    generations: Object.assign(async function generations(req, signal) {
+                        return await makeRequest("POST", "/videos/generations", req, signal);
+                    }, {
+                        schema: XaiVideoGenerateRequestSchema,
+                    }),
+                    // POST https://api.x.ai/v1/videos/edits
+                    // Docs: https://docs.x.ai/docs/api-reference
+                    edits: Object.assign(async function edits(req, signal) {
+                        return await makeRequest("POST", "/videos/edits", req, signal);
+                    }, {
+                        schema: XaiVideoEditRequestSchema,
+                    }),
+                    // POST https://api.x.ai/v1/videos/extensions
+                    // Docs: https://docs.x.ai/docs/api-reference
+                    extensions: Object.assign(async function extensions(req, signal) {
+                        return await makeRequest("POST", "/videos/extensions", req, signal);
+                    }, {
+                        schema: XaiVideoExtendRequestSchema,
+                    }),
+                },
+                // POST https://api.x.ai/v1/files
+                // Docs: https://docs.x.ai/docs/api-reference
+                files: Object.assign(async function postFiles(file, filename, purpose, signal) {
+                    const controller = new AbortController();
+                    const timeoutId = setTimeout(() => controller.abort(), timeout);
+                    if (signal) {
+                        attachAbortHandler(signal, controller);
+                    }
+                    try {
+                        const formData = new FormData();
+                        formData.append("file", file, filename);
+                        if (purpose !== undefined)
+                            formData.append("purpose", purpose);
+                        const res = await doFetch(`${baseURL}/files`, {
+                            method: "POST",
+                            headers: { Authorization: `Bearer ${opts.apiKey}` },
+                            body: formData,
+                            signal: controller.signal,
+                        });
+                        clearTimeout(timeoutId);
+                        if (!res.ok) {
+                            let message = `XAI API error: ${res.status}`;
+                            let body = null;
+                            try {
+                                body = await res.json();
+                                if (typeof body === "object" &&
+                                    body !== null &&
+                                    "error" in body) {
+                                    const err = body.error;
+                                    if (err?.message) {
+                                        message = `XAI API error ${res.status}: ${err.message}`;
+                                    }
+                                }
+                            }
+                            catch {
+                                // ignore parse errors
+                            }
+                            throw new XaiError(message, res.status, body);
+                        }
+                        return (await res.json());
+                    }
+                    catch (error) {
+                        clearTimeout(timeoutId);
+                        if (error instanceof XaiError)
+                            throw error;
+                        throw new XaiError(`XAI request failed: ${error}`, 500);
+                    }
+                }, {}),
+                batches: postBatches,
+                collections: postCollections,
+                documents: {
+                    // POST https://api.x.ai/v1/documents/search
+                    // Docs: https://docs.x.ai/docs/api-reference
+                    search: Object.assign(async function search(req, signal) {
+                        return await makeRequest("POST", "/documents/search", req, signal);
+                    }, {
+                        schema: XaiDocumentSearchRequestSchema,
+                    }),
+                },
+                // POST https://api.x.ai/v1/tokenize-text
+                // Docs: https://docs.x.ai/docs/api-reference
+                tokenizeText: Object.assign(async function tokenizeText(req, signal) {
+                    return await makeRequest("POST", "/tokenize-text", req, signal);
+                }, {
+                    schema: XaiTokenizeTextRequestSchema,
+                }),
+                realtime: {
+                    // POST https://api.x.ai/v1/realtime/client_secrets
+                    // Docs: https://docs.x.ai/docs/api-reference
+                    clientSecrets: Object.assign(async function clientSecrets(req, signal) {
+                        return await makeRequest("POST", "/realtime/client_secrets", req, signal);
+                    }, {
+                        schema: XaiRealtimeClientSecretRequestSchema,
+                    }),
+                },
+                // POST https://api.x.ai/v1/tts
+                // Docs: https://docs.x.ai/docs/api-reference
+                tts: Object.assign(async function tts(req, signal) {
+                    return await makeBinaryRequest("/tts", req, signal);
+                }, {
+                    schema: XaiTtsRequestSchema,
+                }),
+                // POST https://api.x.ai/v1/stt
+                // Docs: https://docs.x.ai/docs/api-reference
+                stt: Object.assign(async function stt(req, signal) {
+                    const form = new FormData();
+                    form.append("file", req.file, req.filename ?? "audio");
+                    if (req.language !== undefined) {
+                        form.append("language", req.language);
+                    }
+                    return await makeMultipartRequest("/stt", form, signal);
+                }, {
+                    schema: XaiSttRequestSchema,
+                }),
+                // POST https://api.x.ai/v1/custom-voices
+                // Docs: https://docs.x.ai/docs/api-reference
+                customVoices: Object.assign(async function customVoices(req, signal) {
+                    const form = new FormData();
+                    form.append("file", req.file, req.filename ?? "reference");
+                    form.append("name", req.name);
+                    form.append("language", req.language);
+                    return await makeMultipartRequest("/custom-voices", form, signal);
+                }, {
+                    schema: XaiCustomVoiceCreateRequestSchema,
+                }),
+            },
+        },
+        get: {
+            v1: {
+                // GET https://api.x.ai/v1/responses/{id}
+                // Docs: https://docs.x.ai/docs/api-reference
+                responses: async function getResponses(id, signal) {
+                    return await makeRequest("GET", `/responses/${encodeURIComponent(id)}`, undefined, signal);
+                },
+                chat: {
+                    // GET https://api.x.ai/v1/chat/deferred-completion/{requestId}
+                    // Docs: https://docs.x.ai/docs/api-reference
+                    deferredCompletion: async function deferredCompletion(requestId, signal) {
+                        const controller = new AbortController();
+                        const timeoutId = setTimeout(() => controller.abort(), timeout);
+                        if (signal) {
+                            attachAbortHandler(signal, controller);
+                        }
+                        try {
+                            const res = await doFetch(`${baseURL}/chat/deferred-completion/${encodeURIComponent(requestId)}`, {
+                                method: "GET",
+                                headers: { Authorization: `Bearer ${opts.apiKey}` },
+                                signal: controller.signal,
+                            });
+                            clearTimeout(timeoutId);
+                            if (res.status === 202) {
+                                return { ready: false, data: null };
+                            }
+                            if (!res.ok) {
+                                let message = `XAI API error: ${res.status}`;
+                                let body = null;
+                                try {
+                                    body = await res.json();
+                                    if (typeof body === "object" &&
+                                        body !== null &&
+                                        "error" in body) {
+                                        const err = body.error;
+                                        if (err?.message) {
+                                            message = `XAI API error ${res.status}: ${err.message}`;
+                                        }
+                                    }
+                                }
+                                catch {
+                                    // ignore parse errors
+                                }
+                                throw new XaiError(message, res.status, body);
+                            }
+                            const data = (await res.json());
+                            return { ready: true, data };
+                        }
+                        catch (error) {
+                            clearTimeout(timeoutId);
+                            if (error instanceof XaiError)
+                                throw error;
+                            throw new XaiError(`XAI request failed: ${error}`, 500);
+                        }
+                    },
+                },
+                // GET https://api.x.ai/v1/videos/{requestId}
+                // Docs: https://docs.x.ai/docs/api-reference
+                videos: async function getVideos(requestId, signal) {
+                    return await makeRequest("GET", `/videos/${requestId}`, undefined, signal);
+                },
+                files: getFiles,
+                models: getModels,
+                languageModels: getLanguageModels,
+                imageGenerationModels: getImageGenerationModels,
+                videoGenerationModels: getVideoGenerationModels,
+                batches: getBatchesNamespace,
+                collections: getCollectionsNamespace,
+            },
+        },
+        delete: {
+            v1: {
+                // DELETE https://api.x.ai/v1/responses/{id}
+                // Docs: https://docs.x.ai/docs/api-reference
+                responses: async function deleteResponses(id, signal) {
+                    return await makeRequest("DELETE", `/responses/${encodeURIComponent(id)}`, undefined, signal);
+                },
+                // DELETE https://api.x.ai/v1/files/{fileId}
+                // Docs: https://docs.x.ai/docs/api-reference
+                files: async function deleteFiles(fileId, signal) {
+                    const controller = new AbortController();
+                    const timeoutId = setTimeout(() => controller.abort(), timeout);
+                    if (signal) {
+                        attachAbortHandler(signal, controller);
+                    }
+                    try {
+                        const res = await doFetch(`${baseURL}/files/${fileId}`, {
+                            method: "DELETE",
+                            headers: { Authorization: `Bearer ${opts.apiKey}` },
+                            signal: controller.signal,
+                        });
+                        clearTimeout(timeoutId);
+                        if (!res.ok) {
+                            let deleteBody = null;
+                            try {
+                                deleteBody = await res.json();
+                            }
+                            catch {
+                                // ignore parse errors
+                            }
+                            throw new XaiError(`XAI API error: ${res.status}`, res.status, deleteBody);
+                        }
+                        return (await res.json());
+                    }
+                    catch (error) {
+                        clearTimeout(timeoutId);
+                        if (error instanceof XaiError)
+                            throw error;
+                        throw new XaiError(`XAI request failed: ${error}`, 500);
+                    }
+                },
+                collections: deleteCollections,
+            },
+        },
+        put: {
+            v1: {
+                collections: putCollections,
+            },
+        },
+        patch: {
+            v1: {
+                collections: {
+                    // PATCH https://api.x.ai/v1/collections/{collectionId}/documents/{fileId}
+                    // Docs: https://docs.x.ai/docs/api-reference
+                    documents: async function regenerateDocument(collectionId, fileId, signal) {
+                        await makeManagementRequest("PATCH", `/collections/${collectionId}/documents/${fileId}`, undefined, signal);
+                    },
+                },
+            },
+        },
+        ws: {
+            v1: {
+                realtime: function connectRealtime(connectOpts) {
+                    const wsBaseURL = baseURL.replace(/^http/, "ws");
+                    const token = connectOpts?.token ?? opts.apiKey;
+                    const model = connectOpts?.model;
+                    // Voice-agent connection: ?model= query string + Authorization
+                    // header (no subprotocols). Otherwise, OpenAI-compat subprotocol auth.
+                    let ws;
+                    if (model) {
+                        const url = `${wsBaseURL}/realtime?model=${encodeURIComponent(model)}`;
+                        // Node `ws` accepts a third-arg options object with `headers`;
+                        // browsers ignore it. Cast keeps TS happy across DOM/Node lib defs.
+                        ws = new WebSocket(url, undefined, {
+                            headers: { Authorization: `Bearer ${token}` },
+                        });
+                    }
+                    else {
+                        ws = new WebSocket(`${wsBaseURL}/realtime`, [
+                            "realtime",
+                            `openai-insecure-api-key.${token}`,
+                            "openai-beta.realtime-v1",
+                        ]);
+                    }
+                    let resolveNext = null;
+                    const eventQueue = [];
+                    let closed = false;
+                    ws.onmessage = (ev) => {
+                        const event = JSON.parse(typeof ev.data === "string" ? ev.data : String(ev.data));
+                        if (resolveNext) {
+                            const resolve = resolveNext;
+                            resolveNext = null;
+                            resolve({ value: event, done: false });
+                        }
+                        else {
+                            eventQueue.push(event);
+                        }
+                    };
+                    ws.onclose = () => {
+                        closed = true;
+                        if (resolveNext) {
+                            const resolve = resolveNext;
+                            resolveNext = null;
+                            resolve({ value: undefined, done: true });
+                        }
+                    };
+                    ws.onerror = () => {
+                        closed = true;
+                        if (resolveNext) {
+                            const resolve = resolveNext;
+                            resolveNext = null;
+                            resolve({ value: undefined, done: true });
+                        }
+                    };
+                    return {
+                        send(event) {
+                            ws.send(JSON.stringify(event));
+                        },
+                        close() {
+                            closed = true;
+                            ws.close();
+                        },
+                        [Symbol.asyncIterator]() {
+                            return {
+                                next() {
+                                    if (eventQueue.length > 0) {
+                                        return Promise.resolve({
+                                            value: eventQueue.shift(),
+                                            done: false,
+                                        });
+                                    }
+                                    if (closed) {
+                                        return Promise.resolve({
+                                            value: undefined,
+                                            done: true,
+                                        });
+                                    }
+                                    return new Promise((resolve) => {
+                                        resolveNext = resolve;
+                                    });
+                                },
+                                [Symbol.asyncIterator]() {
+                                    return this;
+                                },
+                            };
+                        },
+                    };
+                },
+            },
+        },
+    });
+}
+//# sourceMappingURL=xai.js.map