quantum-ai-sdk 0.2.0 → 0.2.2

package/dist/account.d.ts

@@ -0,0 +1,22 @@
+import type { QuantumClient } from "./client.js";
+import type { BalanceResponse, UsageQuery, UsageResponse, UsageSummaryResponse, AccountPricingResponse } from "./types.js";
+/**
+ * Get account credit balance.
+ * @internal — called by QuantumClient.accountBalance()
+ */
+export declare function accountBalance(client: QuantumClient): Promise<BalanceResponse>;
+/**
+ * Get paginated usage history.
+ * @internal — called by QuantumClient.accountUsage()
+ */
+export declare function accountUsage(client: QuantumClient, query?: UsageQuery): Promise<UsageResponse>;
+/**
+ * Get monthly usage summary.
+ * @internal — called by QuantumClient.accountUsageSummary()
+ */
+export declare function accountUsageSummary(client: QuantumClient, months?: number): Promise<UsageSummaryResponse>;
+/**
+ * Get the full pricing table (model ID → pricing entry map).
+ * @internal — called by QuantumClient.accountPricing()
+ */
+export declare function accountPricing(client: QuantumClient): Promise<AccountPricingResponse>;

package/dist/account.js

@@ -0,0 +1,47 @@
+/**
+ * Get account credit balance.
+ * @internal — called by QuantumClient.accountBalance()
+ */
+export async function accountBalance(client) {
+    const { data } = await client._doJSON("GET", "/qai/v1/account/balance", undefined);
+    return data;
+}
+/**
+ * Get paginated usage history.
+ * @internal — called by QuantumClient.accountUsage()
+ */
+export async function accountUsage(client, query) {
+    let path = "/qai/v1/account/usage";
+    const params = [];
+    if (query?.limit !== undefined) {
+        params.push(`limit=${query.limit}`);
+    }
+    if (query?.start_after !== undefined) {
+        params.push(`start_after=${query.start_after}`);
+    }
+    if (params.length > 0) {
+        path += `?${params.join("&")}`;
+    }
+    const { data } = await client._doJSON("GET", path, undefined);
+    return data;
+}
+/**
+ * Get monthly usage summary.
+ * @internal — called by QuantumClient.accountUsageSummary()
+ */
+export async function accountUsageSummary(client, months) {
+    let path = "/qai/v1/account/usage/summary";
+    if (months !== undefined) {
+        path += `?months=${months}`;
+    }
+    const { data } = await client._doJSON("GET", path, undefined);
+    return data;
+}
+/**
+ * Get the full pricing table (model ID → pricing entry map).
+ * @internal — called by QuantumClient.accountPricing()
+ */
+export async function accountPricing(client) {
+    const { data } = await client._doJSON("GET", "/qai/v1/pricing", undefined);
+    return data;
+}

package/dist/agent.d.ts

@@ -0,0 +1,12 @@
+import type { QuantumClient } from "./client.js";
+import type { AgentEvent, AgentRequest, MissionEvent, MissionRequest } from "./types.js";
+/**
+ * Run a server-side agent orchestration. Streams SSE events.
+ * @internal — called by QuantumClient.agentRun()
+ */
+export declare function agentRun(client: QuantumClient, req: AgentRequest, signal?: AbortSignal): AsyncIterableIterator<AgentEvent>;
+/**
+ * Run a full mission orchestration. Streams SSE events.
+ * @internal — called by QuantumClient.missionRun()
+ */
+export declare function missionRun(client: QuantumClient, req: MissionRequest, signal?: AbortSignal): AsyncIterableIterator<MissionEvent>;

package/dist/agent.js

@@ -0,0 +1,114 @@
+/**
+ * Parse a raw SSE JSON event into a typed agent/mission event.
+ */
+function parseSSEEvent(raw) {
+    const event = { ...raw, done: false };
+    if (raw.type === "done") {
+        event.done = true;
+    }
+    // Parse usage if present
+    if (raw.input_tokens !== undefined ||
+        raw.output_tokens !== undefined ||
+        raw.cost_ticks !== undefined) {
+        event.usage = {
+            input_tokens: raw.input_tokens ?? 0,
+            output_tokens: raw.output_tokens ?? 0,
+            cost_ticks: raw.cost_ticks ?? 0,
+        };
+    }
+    return event;
+}
+/**
+ * Run a server-side agent orchestration. Streams SSE events.
+ * @internal — called by QuantumClient.agentRun()
+ */
+export async function* agentRun(client, req, signal) {
+    const response = await client._doStreamRaw("/qai/v1/agent", req, signal);
+    const reader = response.body;
+    if (!reader) {
+        throw new Error("qai: response body is null");
+    }
+    const decoder = new TextDecoder();
+    const streamReader = reader.getReader();
+    let buffer = "";
+    try {
+        while (true) {
+            const { done, value } = await streamReader.read();
+            if (done) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                if (!line.startsWith("data: ")) {
+                    continue;
+                }
+                const payload = line.slice(6);
+                if (payload === "[DONE]") {
+                    yield { type: "done", done: true };
+                    return;
+                }
+                let raw;
+                try {
+                    raw = JSON.parse(payload);
+                }
+                catch {
+                    yield { type: "error", message: "parse SSE: invalid JSON", done: false };
+                    return;
+                }
+                yield parseSSEEvent(raw);
+            }
+        }
+    }
+    finally {
+        streamReader.releaseLock();
+    }
+}
+/**
+ * Run a full mission orchestration. Streams SSE events.
+ * @internal — called by QuantumClient.missionRun()
+ */
+export async function* missionRun(client, req, signal) {
+    const response = await client._doStreamRaw("/qai/v1/missions", req, signal);
+    const reader = response.body;
+    if (!reader) {
+        throw new Error("qai: response body is null");
+    }
+    const decoder = new TextDecoder();
+    const streamReader = reader.getReader();
+    let buffer = "";
+    try {
+        while (true) {
+            const { done, value } = await streamReader.read();
+            if (done) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                if (!line.startsWith("data: ")) {
+                    continue;
+                }
+                const payload = line.slice(6);
+                if (payload === "[DONE]") {
+                    yield { type: "done", done: true };
+                    return;
+                }
+                let raw;
+                try {
+                    raw = JSON.parse(payload);
+                }
+                catch {
+                    yield { type: "error", message: "parse SSE: invalid JSON", done: false };
+                    return;
+                }
+                yield parseSSEEvent(raw);
+            }
+        }
+    }
+    finally {
+        streamReader.releaseLock();
+    }
+}

package/dist/audio.d.ts

@@ -0,0 +1,82 @@
+import type { QuantumClient } from "./client.js";
+import type { AlignRequest, AlignResponse, DialogueRequest, DialogueResponse, DubRequest, DubResponse, IsolateVoiceRequest, IsolateVoiceResponse, MusicAdvancedRequest, MusicAdvancedResponse, MusicFinetuneCreateRequest, MusicFinetuneInfo, MusicFinetuneListResponse, MusicRequest, MusicResponse, RemixVoiceRequest, RemixVoiceResponse, SoundEffectRequest, SoundEffectResponse, SpeechToSpeechRequest, SpeechToSpeechResponse, StarfishTTSRequest, StarfishTTSResponse, StatusResponse, STTRequest, STTResponse, TTSRequest, TTSResponse, VoiceDesignRequest, VoiceDesignResponse } from "./types.js";
+/**
+ * Generate speech from text.
+ * @internal
+ */
+export declare function speak(client: QuantumClient, req: TTSRequest): Promise<TTSResponse>;
+/**
+ * Convert speech to text.
+ * @internal
+ */
+export declare function transcribe(client: QuantumClient, req: STTRequest): Promise<STTResponse>;
+/**
+ * Generate sound effects from a text prompt (ElevenLabs).
+ * @internal
+ */
+export declare function soundEffects(client: QuantumClient, req: SoundEffectRequest): Promise<SoundEffectResponse>;
+/**
+ * Generate music from a text prompt.
+ * @internal
+ */
+export declare function generateMusic(client: QuantumClient, req: MusicRequest): Promise<MusicResponse>;
+/**
+ * Generate multi-speaker dialogue audio (ElevenLabs).
+ * @internal
+ */
+export declare function dialogue(client: QuantumClient, req: DialogueRequest): Promise<DialogueResponse>;
+/**
+ * Convert speech audio to a different voice (ElevenLabs).
+ * @internal
+ */
+export declare function speechToSpeech(client: QuantumClient, req: SpeechToSpeechRequest): Promise<SpeechToSpeechResponse>;
+/**
+ * Remove background noise and isolate speech (ElevenLabs).
+ * @internal
+ */
+export declare function isolateVoice(client: QuantumClient, req: IsolateVoiceRequest): Promise<IsolateVoiceResponse>;
+/**
+ * Transform a voice by modifying attributes (ElevenLabs).
+ * @internal
+ */
+export declare function remixVoice(client: QuantumClient, req: RemixVoiceRequest): Promise<RemixVoiceResponse>;
+/**
+ * Dub audio/video into a target language (ElevenLabs).
+ * @internal
+ */
+export declare function dub(client: QuantumClient, req: DubRequest): Promise<DubResponse>;
+/**
+ * Get word-level timestamps for audio+text alignment (ElevenLabs).
+ * @internal
+ */
+export declare function align(client: QuantumClient, req: AlignRequest): Promise<AlignResponse>;
+/**
+ * Generate voice previews from a text description (ElevenLabs).
+ * @internal
+ */
+export declare function voiceDesign(client: QuantumClient, req: VoiceDesignRequest): Promise<VoiceDesignResponse>;
+/**
+ * Generate speech using HeyGen's Starfish TTS model.
+ * @internal
+ */
+export declare function starfishTTS(client: QuantumClient, req: StarfishTTSRequest): Promise<StarfishTTSResponse>;
+/**
+ * Generate music via ElevenLabs Eleven Music (advanced: finetunes, etc).
+ * @internal
+ */
+export declare function generateMusicAdvanced(client: QuantumClient, req: MusicAdvancedRequest): Promise<MusicAdvancedResponse>;
+/**
+ * List all music finetunes for the authenticated user.
+ * @internal
+ */
+export declare function listFinetunes(client: QuantumClient): Promise<MusicFinetuneListResponse>;
+/**
+ * Create a new music finetune from audio samples (base64-encoded).
+ * @internal
+ */
+export declare function createFinetune(client: QuantumClient, req: MusicFinetuneCreateRequest): Promise<MusicFinetuneInfo>;
+/**
+ * Delete a music finetune by ID.
+ * @internal
+ */
+export declare function deleteFinetune(client: QuantumClient, id: string): Promise<StatusResponse>;

package/dist/audio.js

@@ -0,0 +1,140 @@
+/**
+ * Helper to backfill cost/request metadata from response headers.
+ */
+function backfillMeta(data, meta) {
+    if (!data.cost_ticks) {
+        data.cost_ticks = meta.costTicks;
+    }
+    if (!data.request_id) {
+        data.request_id = meta.requestId;
+    }
+    return data;
+}
+/**
+ * Generate speech from text.
+ * @internal
+ */
+export async function speak(client, req) {
+    const { data, meta } = await client._doJSON("POST", "/qai/v1/audio/tts", req);
+    return backfillMeta(data, meta);
+}
+/**
+ * Convert speech to text.
+ * @internal
+ */
+export async function transcribe(client, req) {
+    const { data, meta } = await client._doJSON("POST", "/qai/v1/audio/stt", req);
+    return backfillMeta(data, meta);
+}
+/**
+ * Generate sound effects from a text prompt (ElevenLabs).
+ * @internal
+ */
+export async function soundEffects(client, req) {
+    const { data, meta } = await client._doJSON("POST", "/qai/v1/audio/sound-effects", req);
+    return backfillMeta(data, meta);
+}
+/**
+ * Generate music from a text prompt.
+ * @internal
+ */
+export async function generateMusic(client, req) {
+    const { data, meta } = await client._doJSON("POST", "/qai/v1/audio/music", req);
+    return backfillMeta(data, meta);
+}
+/**
+ * Generate multi-speaker dialogue audio (ElevenLabs).
+ * @internal
+ */
+export async function dialogue(client, req) {
+    const { data, meta } = await client._doJSON("POST", "/qai/v1/audio/dialogue", req);
+    return backfillMeta(data, meta);
+}
+/**
+ * Convert speech audio to a different voice (ElevenLabs).
+ * @internal
+ */
+export async function speechToSpeech(client, req) {
+    const { data, meta } = await client._doJSON("POST", "/qai/v1/audio/speech-to-speech", req);
+    return backfillMeta(data, meta);
+}
+/**
+ * Remove background noise and isolate speech (ElevenLabs).
+ * @internal
+ */
+export async function isolateVoice(client, req) {
+    const { data, meta } = await client._doJSON("POST", "/qai/v1/audio/isolate", req);
+    return backfillMeta(data, meta);
+}
+/**
+ * Transform a voice by modifying attributes (ElevenLabs).
+ * @internal
+ */
+export async function remixVoice(client, req) {
+    const { data, meta } = await client._doJSON("POST", "/qai/v1/audio/remix", req);
+    return backfillMeta(data, meta);
+}
+/**
+ * Dub audio/video into a target language (ElevenLabs).
+ * @internal
+ */
+export async function dub(client, req) {
+    const { data, meta } = await client._doJSON("POST", "/qai/v1/audio/dub", req);
+    return backfillMeta(data, meta);
+}
+/**
+ * Get word-level timestamps for audio+text alignment (ElevenLabs).
+ * @internal
+ */
+export async function align(client, req) {
+    const { data, meta } = await client._doJSON("POST", "/qai/v1/audio/align", req);
+    return backfillMeta(data, meta);
+}
+/**
+ * Generate voice previews from a text description (ElevenLabs).
+ * @internal
+ */
+export async function voiceDesign(client, req) {
+    const { data, meta } = await client._doJSON("POST", "/qai/v1/audio/voice-design", req);
+    return backfillMeta(data, meta);
+}
+/**
+ * Generate speech using HeyGen's Starfish TTS model.
+ * @internal
+ */
+export async function starfishTTS(client, req) {
+    const { data, meta } = await client._doJSON("POST", "/qai/v1/audio/starfish-tts", req);
+    return backfillMeta(data, meta);
+}
+/**
+ * Generate music via ElevenLabs Eleven Music (advanced: finetunes, etc).
+ * @internal
+ */
+export async function generateMusicAdvanced(client, req) {
+    const { data, meta } = await client._doJSON("POST", "/qai/v1/audio/music/advanced", req);
+    return backfillMeta(data, meta);
+}
+/**
+ * List all music finetunes for the authenticated user.
+ * @internal
+ */
+export async function listFinetunes(client) {
+    const { data } = await client._doJSON("GET", "/qai/v1/audio/finetunes", undefined);
+    return data;
+}
+/**
+ * Create a new music finetune from audio samples (base64-encoded).
+ * @internal
+ */
+export async function createFinetune(client, req) {
+    const { data } = await client._doJSON("POST", "/qai/v1/audio/finetunes", req);
+    return data;
+}
+/**
+ * Delete a music finetune by ID.
+ * @internal
+ */
+export async function deleteFinetune(client, id) {
+    const { data } = await client._doJSON("DELETE", `/qai/v1/audio/finetunes/${id}`, undefined);
+    return data;
+}

package/dist/auth.d.ts

@@ -0,0 +1,7 @@
+import type { QuantumClient } from "./client.js";
+import type { AuthAppleRequest, AuthResponse } from "./types.js";
+/**
+ * Authenticate with Apple Sign-In.
+ * @internal — called by QuantumClient.authApple()
+ */
+export declare function authApple(client: QuantumClient, req: AuthAppleRequest): Promise<AuthResponse>;

package/dist/auth.js

@@ -0,0 +1,8 @@
+/**
+ * Authenticate with Apple Sign-In.
+ * @internal — called by QuantumClient.authApple()
+ */
+export async function authApple(client, req) {
+    const { data } = await client._doJSON("POST", "/qai/v1/auth/apple", req);
+    return data;
+}

package/dist/batch.d.ts

@@ -0,0 +1,22 @@
+import type { QuantumClient } from "./client.js";
+import type { BatchSubmitRequest, BatchSubmitResponse, BatchJsonlResponse, BatchJobsResponse, BatchJobInfo } from "./types.js";
+/**
+ * Submit a batch of jobs for processing.
+ * @internal — called by QuantumClient.batchSubmit()
+ */
+export declare function batchSubmit(client: QuantumClient, req: BatchSubmitRequest): Promise<BatchSubmitResponse>;
+/**
+ * Submit a batch of jobs using JSONL format.
+ * @internal — called by QuantumClient.batchSubmitJsonl()
+ */
+export declare function batchSubmitJsonl(client: QuantumClient, jsonl: string): Promise<BatchJsonlResponse>;
+/**
+ * List all batch jobs for the account.
+ * @internal — called by QuantumClient.batchJobs()
+ */
+export declare function batchJobs(client: QuantumClient): Promise<BatchJobsResponse>;
+/**
+ * Get the status and result of a single batch job.
+ * @internal — called by QuantumClient.batchJob()
+ */
+export declare function batchJob(client: QuantumClient, id: string): Promise<BatchJobInfo>;

package/dist/batch.js

@@ -0,0 +1,32 @@
+/**
+ * Submit a batch of jobs for processing.
+ * @internal — called by QuantumClient.batchSubmit()
+ */
+export async function batchSubmit(client, req) {
+    const { data } = await client._doJSON("POST", "/qai/v1/batch", req);
+    return data;
+}
+/**
+ * Submit a batch of jobs using JSONL format.
+ * @internal — called by QuantumClient.batchSubmitJsonl()
+ */
+export async function batchSubmitJsonl(client, jsonl) {
+    const { data } = await client._doJSON("POST", "/qai/v1/batch/jsonl", { jsonl });
+    return data;
+}
+/**
+ * List all batch jobs for the account.
+ * @internal — called by QuantumClient.batchJobs()
+ */
+export async function batchJobs(client) {
+    const { data } = await client._doJSON("GET", "/qai/v1/batch/jobs", undefined);
+    return { ...data, jobs: data.jobs ?? [] };
+}
+/**
+ * Get the status and result of a single batch job.
+ * @internal — called by QuantumClient.batchJob()
+ */
+export async function batchJob(client, id) {
+    const { data } = await client._doJSON("GET", `/qai/v1/batch/jobs/${id}`, undefined);
+    return data;
+}

package/dist/chat.d.ts

@@ -0,0 +1,27 @@
+import type { QuantumClient } from "./client.js";
+import type { ChatRequest, ChatResponse, ContentBlock, StreamEvent } from "./types.js";
+/**
+ * Returns concatenated text content from a ChatResponse, ignoring thinking and tool_use blocks.
+ */
+export declare function responseText(response: ChatResponse): string;
+/**
+ * Returns concatenated thinking content from a ChatResponse.
+ */
+export declare function responseThinking(response: ChatResponse): string;
+/**
+ * Returns all tool_use blocks from a ChatResponse.
+ */
+export declare function responseToolCalls(response: ChatResponse): ContentBlock[];
+/**
+ * Send a non-streaming chat request.
+ * @internal — called by QuantumClient.chat()
+ */
+export declare function chat(client: QuantumClient, req: ChatRequest): Promise<ChatResponse>;
+/**
+ * Send a streaming chat request. Returns an AsyncIterableIterator of StreamEvents.
+ *
+ * The last event will have done=true. Cancel the AbortSignal to abort early.
+ *
+ * @internal — called by QuantumClient.chatStream()
+ */
+export declare function chatStream(client: QuantumClient, req: ChatRequest, signal?: AbortSignal): AsyncIterableIterator<StreamEvent>;

package/dist/chat.js

@@ -0,0 +1,122 @@
+/**
+ * Returns concatenated text content from a ChatResponse, ignoring thinking and tool_use blocks.
+ */
+export function responseText(response) {
+    return response.content
+        .filter((b) => b.type === "text")
+        .map((b) => b.text ?? "")
+        .join("");
+}
+/**
+ * Returns concatenated thinking content from a ChatResponse.
+ */
+export function responseThinking(response) {
+    return response.content
+        .filter((b) => b.type === "thinking")
+        .map((b) => b.text ?? "")
+        .join("");
+}
+/**
+ * Returns all tool_use blocks from a ChatResponse.
+ */
+export function responseToolCalls(response) {
+    return response.content.filter((b) => b.type === "tool_use");
+}
+/**
+ * Send a non-streaming chat request.
+ * @internal — called by QuantumClient.chat()
+ */
+export async function chat(client, req) {
+    const body = { ...req, stream: false };
+    const { data, meta } = await client._doJSON("POST", "/qai/v1/chat", body);
+    data.cost_ticks = data.cost_ticks || meta.costTicks;
+    data.request_id = data.request_id || meta.requestId;
+    if (!data.model) {
+        data.model = meta.model;
+    }
+    return data;
+}
+/**
+ * Send a streaming chat request. Returns an AsyncIterableIterator of StreamEvents.
+ *
+ * The last event will have done=true. Cancel the AbortSignal to abort early.
+ *
+ * @internal — called by QuantumClient.chatStream()
+ */
+export async function* chatStream(client, req, signal) {
+    const body = { ...req, stream: true };
+    const response = await client._doStreamRaw("/qai/v1/chat", body, signal);
+    const reader = response.body;
+    if (!reader) {
+        throw new Error("qai: response body is null");
+    }
+    const decoder = new TextDecoder();
+    const streamReader = reader.getReader();
+    let buffer = "";
+    try {
+        while (true) {
+            const { done, value } = await streamReader.read();
+            if (done) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            // Process complete lines from the buffer.
+            const lines = buffer.split("\n");
+            // Keep the last (possibly incomplete) line in the buffer.
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                if (!line.startsWith("data: ")) {
+                    continue;
+                }
+                const payload = line.slice(6); // "data: ".length
+                if (payload === "[DONE]") {
+                    yield { type: "done", done: true };
+                    return;
+                }
+                let raw;
+                try {
+                    raw = JSON.parse(payload);
+                }
+                catch {
+                    yield {
+                        type: "error",
+                        error: `parse SSE: invalid JSON`,
+                        done: false,
+                    };
+                    return;
+                }
+                const event = { type: raw.type || "unknown", done: false };
+                switch (raw.type) {
+                    case "content_delta":
+                    case "thinking_delta":
+                        event.delta = raw.delta;
+                        break;
+                    case "tool_use":
+                        event.tool_use = {
+                            id: String(raw.id ?? ""),
+                            name: String(raw.name ?? ""),
+                            input: raw.input ?? {},
+                        };
+                        break;
+                    case "usage":
+                        event.usage = {
+                            input_tokens: raw.input_tokens ?? 0,
+                            output_tokens: raw.output_tokens ?? 0,
+                            cost_ticks: raw.cost_ticks ?? 0,
+                        };
+                        break;
+                    case "error":
+                        event.error = raw.message;
+                        break;
+                    case "heartbeat":
+                        // pass through
+                        break;
+                }
+                yield event;
+            }
+        }
+    }
+    finally {
+        streamReader.releaseLock();
+    }
+}