@apicity/fireworks 0.6.6 → 0.7.0

package/dist/src/fireworks.js

@@ -2,268 +2,164 @@ import { FireworksError, } from "./types.js";
 import { sseToIterable } from "./sse.js";
 import { FireworksChatRequestSchema, FireworksCompletionRequestSchema, FireworksEmbeddingRequestSchema, FireworksRerankRequestSchema, AnthropicMessagesRequestSchema, FireworksTextToImageRequestSchema, FireworksKontextRequestSchema, FireworksGetResultRequestSchema, FireworksTranscriptionRequestSchema, FireworksTranslationRequestSchema, FireworksStreamingTranscriptionOptionsSchema, FireworksAudioBatchTranscriptionRequestSchema, FireworksAudioBatchTranslationRequestSchema, FireworksCreateModelRequestSchema, FireworksPrepareModelRequestSchema, FireworksGetUploadEndpointRequestSchema, FireworksUpdateModelRequestSchema, FireworksValidateUploadRequestSchema, FireworksBatchJobCreateRequestSchema, FireworksSFTCreateRequestSchema, FireworksCreateDeploymentRequestSchema, FireworksUpdateDeploymentRequestSchema, FireworksScaleDeploymentRequestSchema, FireworksDpoJobCreateRequestSchema, FireworksCreateDeployedModelRequestSchema, FireworksUpdateDeployedModelRequestSchema, FireworksCreateUserRequestSchema, FireworksUpdateUserRequestSchema, FireworksCreateApiKeyRequestSchema, FireworksDeleteApiKeyRequestSchema, FireworksCreateSecretRequestSchema, FireworksUpdateSecretRequestSchema, FireworksCreateDatasetRequestSchema, FireworksUpdateDatasetRequestSchema, FireworksDatasetGetUploadEndpointRequestSchema, FireworksDatasetValidateUploadRequestSchema, FireworksCreateEvaluatorRequestSchema, FireworksUpdateEvaluatorRequestSchema, FireworksGetUploadEndpointEvaluatorRequestSchema, FireworksCreateEvaluationJobRequestSchema, FireworksRFTCreateRequestSchema, FireworksRlorTrainerJobCreateRequestSchema, FireworksRlorTrainerJobExecuteStepRequestSchema, FireworksEmptySchema, } 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 });
+import { createTransport } from "./transport.js";
+function parseFireworksErrorBody(status, body) {
+    if (typeof body === "object" && body !== null && "error" in body) {
+        const err = body.error;
+        if (err?.message) {
+            return { message: `Fireworks API error ${status}: ${err.message}` };
+        }
     }
-    else if (signal.aborted) {
-        // Already aborted, abort our controller too
-        controller.abort();
+    return { message: `Fireworks API error: ${status}` };
+}
+function parseFireworksWorkflowErrorBody(status, body) {
+    if (typeof body === "object" && body !== null && "error_message" in body) {
+        return {
+            message: `Fireworks API error ${status}: ${body.error_message}`,
+        };
     }
+    return parseFireworksErrorBody(status, body);
+}
+async function wrapFireworksTransportFailure(fn) {
+    try {
+        return await fn();
+    }
+    catch (error) {
+        if (error instanceof FireworksError)
+            throw error;
+        throw new FireworksError(`Fireworks request failed: ${error}`, 500);
+    }
+}
+async function readJsonResponse(res) {
+    return await wrapFireworksTransportFailure(async () => (await res.json()));
+}
+function withQuery(path, query) {
+    if (!query) {
+        return path;
+    }
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+        if (value !== undefined) {
+            params.append(key, String(value));
+        }
+    }
+    const qs = params.toString();
+    return qs ? `${path}?${qs}` : path;
+}
+async function jsonRequest(transport, method, path, body, query, signal) {
+    const hasBody = body !== undefined && method !== "GET" && method !== "DELETE";
+    const res = await transport.raw(withQuery(path, query), {
+        method,
+        headers: hasBody ? { "Content-Type": "application/json" } : undefined,
+        body: hasBody ? JSON.stringify(body) : undefined,
+        signal,
+    });
+    return await readJsonResponse(res);
 }
 export function createFireworks(opts) {
     const baseURL = opts.baseURL ?? "https://api.fireworks.ai/inference/v1";
     const modelsBaseURL = "https://api.fireworks.ai";
     const audioBaseURL = opts.audioBaseURL ?? "https://audio-prod.api.fireworks.ai/v1";
     const audioStreamingBaseURL = opts.audioStreamingBaseURL ?? "wss://audio-streaming.api.fireworks.ai";
-    const doFetch = opts.fetch ?? fetch;
     const WS = opts.WebSocket ?? globalThis.WebSocket;
     const timeout = opts.timeout ?? 30000;
+    const transport = createTransport({
+        baseUrl: baseURL,
+        timeoutMs: timeout,
+        fetchImpl: opts.fetch,
+        defaultHeaders: () => ({ Authorization: `Bearer ${opts.apiKey}` }),
+        parseErrorBody: parseFireworksErrorBody,
+        errorClass: FireworksError,
+        requestFailedPrefix: "Fireworks request failed",
+    });
+    const workflowTransport = createTransport({
+        baseUrl: baseURL,
+        timeoutMs: timeout,
+        fetchImpl: opts.fetch,
+        defaultHeaders: () => ({ Authorization: `Bearer ${opts.apiKey}` }),
+        parseErrorBody: parseFireworksWorkflowErrorBody,
+        errorClass: FireworksError,
+        requestFailedPrefix: "Fireworks request failed",
+    });
+    const audioTransport = createTransport({
+        baseUrl: audioBaseURL,
+        timeoutMs: timeout,
+        fetchImpl: opts.fetch,
+        defaultHeaders: () => ({ Authorization: opts.apiKey }),
+        parseErrorBody: parseFireworksErrorBody,
+        errorClass: FireworksError,
+        requestFailedPrefix: "Fireworks request failed",
+    });
+    const audioBatchBaseURL = "https://audio-batch.api.fireworks.ai/v1";
+    const audioBatchTransport = createTransport({
+        baseUrl: audioBatchBaseURL,
+        timeoutMs: timeout,
+        fetchImpl: opts.fetch,
+        defaultHeaders: () => ({ Authorization: opts.apiKey }),
+        parseErrorBody: parseFireworksErrorBody,
+        errorClass: FireworksError,
+        requestFailedPrefix: "Fireworks request failed",
+    });
+    const modelsTransport = createTransport({
+        baseUrl: modelsBaseURL,
+        timeoutMs: timeout,
+        fetchImpl: opts.fetch,
+        defaultHeaders: () => ({ Authorization: `Bearer ${opts.apiKey}` }),
+        parseErrorBody: parseFireworksErrorBody,
+        errorClass: FireworksError,
+        requestFailedPrefix: "Fireworks request failed",
+    });
     async function makeRequest(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 = `Fireworks API error: ${res.status}`;
-                let resBody = null;
-                try {
-                    resBody = await res.json();
-                    if (typeof resBody === "object" &&
-                        resBody !== null &&
-                        "error" in resBody) {
-                        const err = resBody.error;
-                        if (err?.message) {
-                            message = `Fireworks API error ${res.status}: ${err.message}`;
-                        }
-                    }
-                }
-                catch {
-                    // ignore parse errors
-                }
-                throw new FireworksError(message, res.status, resBody);
-            }
-            return (await res.json());
-        }
-        catch (error) {
-            clearTimeout(timeoutId);
-            if (error instanceof FireworksError)
-                throw error;
-            throw new FireworksError(`Fireworks request failed: ${error}`, 500);
-        }
+        return await transport.postJson(path, body, { signal });
     }
     async function* makeStreamRequest(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 = `Fireworks API error: ${res.status}`;
-                let resBody = null;
-                try {
-                    resBody = await res.json();
-                    if (typeof resBody === "object" &&
-                        resBody !== null &&
-                        "error" in resBody) {
-                        const err = resBody.error;
-                        if (err?.message) {
-                            message = `Fireworks API error ${res.status}: ${err.message}`;
-                        }
-                    }
-                }
-                catch {
-                    // ignore parse errors
-                }
-                throw new FireworksError(message, res.status, resBody);
+        const res = await transport.raw(path, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+            signal,
+        });
+        for await (const { data } of sseToIterable(res)) {
+            if (data === "[DONE]") {
+                break;
             }
-            for await (const { data } of sseToIterable(res)) {
-                if (data === "[DONE]") {
-                    break;
-                }
-                try {
-                    yield JSON.parse(data);
-                }
-                catch {
-                    // ignore non-JSON lines
-                }
+            try {
+                yield JSON.parse(data);
+            }
+            catch {
+                // ignore non-JSON lines
             }
-        }
-        finally {
-            clearTimeout(timeoutId);
         }
     }
     // POST https://api.fireworks.ai/inference/v1/messages
     // Docs: https://docs.fireworks.ai/api-reference
     async function* messagesStreamImpl(req, signal) {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        try {
-            const res = await doFetch(`${baseURL}/messages`, {
-                method: "POST",
-                headers: {
-                    Authorization: `Bearer ${opts.apiKey}`,
-                    "Content-Type": "application/json",
-                },
-                body: JSON.stringify(req),
-                signal: signal || controller.signal,
-            });
-            clearTimeout(timeoutId);
-            if (!res.ok) {
-                let message = `Fireworks API error: ${res.status}`;
-                let resBody = null;
-                try {
-                    resBody = await res.json();
-                    if (typeof resBody === "object" &&
-                        resBody !== null &&
-                        "error" in resBody) {
-                        const err = resBody.error;
-                        if (err?.message) {
-                            message = `Fireworks API error ${res.status}: ${err.message}`;
-                        }
-                    }
-                }
-                catch {
-                    // ignore parse errors
-                }
-                throw new FireworksError(message, res.status, resBody);
+        const res = await transport.raw("/messages", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(req),
+            signal,
+        });
+        for await (const { event, data } of sseToIterable(res)) {
+            if (event === "message_stop") {
+                break;
             }
-            for await (const { event, data } of sseToIterable(res)) {
-                if (event === "message_stop") {
-                    break;
-                }
-                try {
-                    const parsed = JSON.parse(data);
-                    yield parsed;
-                }
-                catch {
-                    // ignore non-JSON lines
-                }
+            try {
+                const parsed = JSON.parse(data);
+                yield parsed;
+            }
+            catch {
+                // ignore non-JSON lines
             }
-        }
-        finally {
-            clearTimeout(timeoutId);
         }
     }
     // POST https://api.fireworks.ai/inference/v1/messages
     // Docs: https://docs.fireworks.ai/api-reference
     async function messagesImpl(req, signal) {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        try {
-            const res = await doFetch(`${baseURL}/messages`, {
-                method: "POST",
-                headers: {
-                    Authorization: `Bearer ${opts.apiKey}`,
-                    "Content-Type": "application/json",
-                },
-                body: JSON.stringify(req),
-                signal: signal || controller.signal,
-            });
-            clearTimeout(timeoutId);
-            if (!res.ok) {
-                let message = `Fireworks API error: ${res.status}`;
-                let resBody = null;
-                try {
-                    resBody = await res.json();
-                    if (typeof resBody === "object" &&
-                        resBody !== null &&
-                        "error" in resBody) {
-                        const err = resBody.error;
-                        if (err?.message) {
-                            message = `Fireworks API error ${res.status}: ${err.message}`;
-                        }
-                    }
-                }
-                catch {
-                    // ignore parse errors
-                }
-                throw new FireworksError(message, res.status, resBody);
-            }
-            return (await res.json());
-        }
-        finally {
-            clearTimeout(timeoutId);
-        }
+        return await transport.postJson("/messages", req, { signal });
     }
     async function makeWorkflowRequest(model, suffix, body, signal) {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        if (signal) {
-            attachAbortHandler(signal, controller);
-        }
-        try {
-            const url = `${baseURL}/workflows/accounts/fireworks/models/${model}${suffix}`;
-            const res = await doFetch(url, {
-                method: "POST",
-                headers: {
-                    Authorization: `Bearer ${opts.apiKey}`,
-                    "Content-Type": "application/json",
-                    Accept: "application/json",
-                },
-                body: JSON.stringify(body),
-                signal: controller.signal,
-            });
-            clearTimeout(timeoutId);
-            if (!res.ok) {
-                let message = `Fireworks API error: ${res.status}`;
-                let resBody = null;
-                try {
-                    resBody = await res.json();
-                    if (typeof resBody === "object" &&
-                        resBody !== null &&
-                        "error" in resBody) {
-                        const err = resBody.error;
-                        if (err?.message) {
-                            message = `Fireworks API error ${res.status}: ${err.message}`;
-                        }
-                    }
-                    if (typeof resBody === "object" &&
-                        resBody !== null &&
-                        "error_message" in resBody) {
-                        message = `Fireworks API error ${res.status}: ${resBody.error_message}`;
-                    }
-                }
-                catch {
-                    // ignore parse errors
-                }
-                throw new FireworksError(message, res.status, resBody);
-            }
-            return (await res.json());
-        }
-        catch (error) {
-            clearTimeout(timeoutId);
-            if (error instanceof FireworksError)
-                throw error;
-            throw new FireworksError(`Fireworks request failed: ${error}`, 500);
-        }
+        return await workflowTransport.postJson(`/workflows/accounts/fireworks/models/${model}${suffix}`, body, { headers: { Accept: "application/json" }, signal });
     }
     function getAudioBaseURL(model) {
         if (model === "whisper-v3-turbo") {
@@ -272,157 +168,16 @@ export function createFireworks(opts) {
         return audioBaseURL;
     }
     async function makeAudioRequest(path, form, model, signal) {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        if (signal) {
-            attachAbortHandler(signal, controller);
-        }
-        try {
-            const url = `${getAudioBaseURL(model)}${path}`;
-            const res = await doFetch(url, {
-                method: "POST",
-                headers: {
-                    Authorization: opts.apiKey,
-                },
-                body: form,
-                signal: controller.signal,
-            });
-            clearTimeout(timeoutId);
-            if (!res.ok) {
-                let message = `Fireworks API error: ${res.status}`;
-                let resBody = null;
-                try {
-                    resBody = await res.json();
-                    if (typeof resBody === "object" &&
-                        resBody !== null &&
-                        "error" in resBody) {
-                        const err = resBody.error;
-                        if (err?.message) {
-                            message = `Fireworks API error ${res.status}: ${err.message}`;
-                        }
-                    }
-                }
-                catch {
-                    // ignore parse errors
-                }
-                throw new FireworksError(message, res.status, resBody);
-            }
-            return (await res.json());
-        }
-        catch (error) {
-            clearTimeout(timeoutId);
-            if (error instanceof FireworksError)
-                throw error;
-            throw new FireworksError(`Fireworks request failed: ${error}`, 500);
-        }
+        return await audioTransport.postForm(path, form, {
+            baseUrl: getAudioBaseURL(model),
+            signal,
+        });
     }
-    const audioBatchBaseURL = "https://audio-batch.api.fireworks.ai/v1";
     async function makeAudioBatchRequest(path, form, endpointId, signal) {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        if (signal) {
-            attachAbortHandler(signal, controller);
-        }
-        try {
-            const url = `${audioBatchBaseURL}${path}?endpoint_id=${encodeURIComponent(endpointId)}`;
-            const res = await doFetch(url, {
-                method: "POST",
-                headers: {
-                    Authorization: opts.apiKey,
-                },
-                body: form,
-                signal: controller.signal,
-            });
-            clearTimeout(timeoutId);
-            if (!res.ok) {
-                let message = `Fireworks API error: ${res.status}`;
-                let resBody = null;
-                try {
-                    resBody = await res.json();
-                    if (typeof resBody === "object" &&
-                        resBody !== null &&
-                        "error" in resBody) {
-                        const err = resBody.error;
-                        if (err?.message) {
-                            message = `Fireworks API error ${res.status}: ${err.message}`;
-                        }
-                    }
-                }
-                catch {
-                    // ignore parse errors
-                }
-                throw new FireworksError(message, res.status, resBody);
-            }
-            return (await res.json());
-        }
-        catch (error) {
-            clearTimeout(timeoutId);
-            if (error instanceof FireworksError)
-                throw error;
-            throw new FireworksError(`Fireworks request failed: ${error}`, 500);
-        }
+        return await audioBatchTransport.postForm(`${path}?endpoint_id=${encodeURIComponent(endpointId)}`, form, { signal });
     }
     async function makeModelsRequest(method, path, body, query, signal) {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        if (signal) {
-            attachAbortHandler(signal, controller);
-        }
-        try {
-            let url = `${modelsBaseURL}${path}`;
-            if (query) {
-                const params = new URLSearchParams();
-                for (const [k, v] of Object.entries(query)) {
-                    if (v !== undefined)
-                        params.append(k, String(v));
-                }
-                const qs = params.toString();
-                if (qs)
-                    url += `?${qs}`;
-            }
-            const headers = {
-                Authorization: `Bearer ${opts.apiKey}`,
-            };
-            if (method !== "GET" && method !== "DELETE") {
-                headers["Content-Type"] = "application/json";
-            }
-            const init = {
-                method,
-                headers,
-                signal: controller.signal,
-            };
-            if (body !== undefined && method !== "GET" && method !== "DELETE") {
-                init.body = JSON.stringify(body);
-            }
-            const res = await doFetch(url, init);
-            clearTimeout(timeoutId);
-            if (!res.ok) {
-                let message = `Fireworks API error: ${res.status}`;
-                let resBody = null;
-                try {
-                    resBody = await res.json();
-                    if (typeof resBody === "object" &&
-                        resBody !== null &&
-                        "error" in resBody) {
-                        const err = resBody.error;
-                        if (err?.message) {
-                            message = `Fireworks API error ${res.status}: ${err.message}`;
-                        }
-                    }
-                }
-                catch {
-                    // ignore parse errors
-                }
-                throw new FireworksError(message, res.status, resBody);
-            }
-            return (await res.json());
-        }
-        catch (error) {
-            clearTimeout(timeoutId);
-            if (error instanceof FireworksError)
-                throw error;
-            throw new FireworksError(`Fireworks request failed: ${error}`, 500);
-        }
+        return await jsonRequest(modelsTransport, method, path, body, query, signal);
     }
     // ============================================================
     // Verb-Prefixed API Surface Implementation