pareta 1.1.0 → 1.2.0

package/dist/index.d.ts

@@ -166,6 +166,27 @@ declare class Embeddings extends BaseModel {
     get promptTokens(): number | null;
     get length(): number;
 }
+/** Speech-to-text result from `audio.transcriptions(...)`. `.durationS` is
+ * the metered input audio length (per minute). */
+declare class Transcription extends BaseModel {
+    get text(): string | null;
+    get language(): string | null;
+    get durationS(): number | null;
+    toString(): string;
+}
+/** Text-to-speech result from `audio.speech(...)`. `.audio` is decoded
+ * bytes; `.durationS` is the metered output audio length (per minute). */
+declare class Speech extends BaseModel {
+    /** The synthesized audio, base64-decoded to raw bytes. */
+    get audio(): Uint8Array;
+    get audioBase64(): string | null;
+    get sampleRate(): number | null;
+    get durationS(): number | null;
+    /** Container/codec of the returned audio (e.g. "wav"). */
+    get format(): string | null;
+    /** Write the decoded audio to `path` (Node only — lazy node:fs). */
+    save(path: string): Promise<this>;
+}
 
 /**
  * `client.chat.completions` — OpenAI-compatible chat completions.
@@ -390,6 +411,47 @@ declare class Auto {
     }): Promise<FrontierComparison>;
 }
 
+/**
+ * `pa.audio` — the Speech capability lanes (ASR + TTS), TS parity with the
+ * Python SDK's `client.audio`.
+ *
+ * Dedicated routes, not `chat.completions`:
+ *   POST /v1/audio/transcriptions {audio_base64, language?} -> {text, language, duration_s}
+ *   POST /v1/audio/speech         {text, voice?}            -> {audio_base64, sample_rate, duration_s, format}
+ *
+ * Both are metered PER MINUTE of audio (input duration for ASR, output
+ * duration for TTS). You never pick a serving model — Pareta resolves the
+ * lane, exactly as `model:"auto"` does for chat.
+ *
+ * Audio input follows the evals FileInput convention: a string is a FILE
+ * PATH (read via lazy node:fs — browser/edge bundles stay clean);
+ * Blob/ArrayBuffer/Uint8Array are raw bytes; `{ base64 }` passes
+ * pre-encoded audio through untouched.
+ */
+
+type AudioInput = string | Blob | ArrayBuffer | Uint8Array | {
+    base64: string;
+};
+interface TranscriptionOptions {
+    /** Optional ISO language hint (omit to auto-detect). */
+    language?: string;
+}
+interface SpeechOptions {
+    /** Optional voice id (omit for the default voice). */
+    voice?: string;
+}
+declare class Audio {
+    private readonly client;
+    constructor(client: Transport);
+    /** Speech-to-text (the `asr` lane). `audio` is a file path, raw bytes, a
+     * Blob, or `{ base64 }`. Metered per minute of input audio. */
+    transcriptions(audio: AudioInput, opts?: TranscriptionOptions): Promise<Transcription>;
+    /** Text-to-speech (the `tts` lane). Returns a `Speech` whose `.audio` is
+     * decoded bytes (`.save(path)` writes a file in Node). Metered per minute
+     * of output audio. */
+    speech(text: string, opts?: SpeechOptions): Promise<Speech>;
+}
+
 /**
  * `pa.rerank(...)` + `pa.embeddings(...)` — the Retrieval capability lanes
  * (the RAG stack: embeddings for recall, reranking for precision).
@@ -472,6 +534,8 @@ declare class Pareta implements Transport {
     readonly tasks: Tasks;
     readonly evals: Evals;
     readonly auto: Auto;
+    /** The Speech lanes — `pa.audio.transcriptions(...)` (ASR) + `pa.audio.speech(...)` (TTS). */
+    readonly audio: Audio;
     /** Document reranking (the Retrieval precision lane) — `pa.rerank(query, docs, {topN})`. */
     readonly rerank: RerankFn;
     /** Text embeddings (the Retrieval recall lane) — `pa.embeddings(input, {inputType})`. */
@@ -499,7 +563,7 @@ declare class Pareta implements Transport {
     stream<T = unknown>(method: string, path: string, opts?: StreamOptions): AsyncGenerator<T>;
 }
 
-declare const VERSION = "1.1.0";
+declare const VERSION = "1.2.0";
 
 /**
  * Typed error hierarchy for the Pareta SDK — a faithful port of the Python
@@ -591,4 +655,4 @@ declare class EndpointNotReadyError extends APIStatusError {
     constructor(message: string, init: APIStatusErrorInit);
 }
 
-export { APIConnectionError, APIStatusError, APITimeoutError, AuthenticationError, BadRequestError, BaseModel, ChatCompletion, ChatCompletionChunk, type ChatCompletionCreateParams, type ChatMessage, Choice, ConflictError, Embeddings, type EmbeddingsFn, type EmbeddingsOptions, EndpointNotReadyError, type ErrorDetail, EvalItemResult, EvalResult, EvalRun, type EvalRunCreateParams, EvalRuns, EvalSet, EvalSets, type FileInput, type FilePart, FrontierModel, type FrontierSpec, InsufficientCreditsError, Message, Model, ModelList, NotFoundError, Pareta, ParetaError, type ParetaOptions, PermissionDeniedError, RateLimitError, Rerank, type RerankFn, type RerankOptions, RerankResult, type SSEEvent, Task, TaskMatch, TaskMatchCandidate, type Transport, Usage, VERSION, type ValidationErrorItem };
+export { APIConnectionError, APIStatusError, APITimeoutError, Audio, type AudioInput, AuthenticationError, BadRequestError, BaseModel, ChatCompletion, ChatCompletionChunk, type ChatCompletionCreateParams, type ChatMessage, Choice, ConflictError, Embeddings, type EmbeddingsFn, type EmbeddingsOptions, EndpointNotReadyError, type ErrorDetail, EvalItemResult, EvalResult, EvalRun, type EvalRunCreateParams, EvalRuns, EvalSet, EvalSets, type FileInput, type FilePart, FrontierModel, type FrontierSpec, InsufficientCreditsError, Message, Model, ModelList, NotFoundError, Pareta, ParetaError, type ParetaOptions, PermissionDeniedError, RateLimitError, Rerank, type RerankFn, type RerankOptions, RerankResult, type SSEEvent, Speech, type SpeechOptions, Task, TaskMatch, TaskMatchCandidate, Transcription, type TranscriptionOptions, type Transport, Usage, VERSION, type ValidationErrorItem };

package/dist/index.mjs

@@ -172,7 +172,7 @@ function parseSSE(reader, opts) {
 }
 
 // src/version.ts
-var VERSION = "1.1.0";
+var VERSION = "1.2.0";
 
 // src/money.ts
 var MICRO_PER_CENT = 10000n;
@@ -484,6 +484,53 @@ var Embeddings = class extends BaseModel {
     return (this.raw.data ?? []).length;
   }
 };
+function base64ToBytes(b64) {
+  if (typeof Buffer !== "undefined") return new Uint8Array(Buffer.from(b64, "base64"));
+  const bin = atob(b64);
+  const bytes = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
+  return bytes;
+}
+var Transcription = class extends BaseModel {
+  get text() {
+    return this.raw.text ?? null;
+  }
+  get language() {
+    return this.raw.language ?? null;
+  }
+  get durationS() {
+    return this.raw.duration_s ?? null;
+  }
+  toString() {
+    return this.text ?? "";
+  }
+};
+var Speech = class extends BaseModel {
+  /** The synthesized audio, base64-decoded to raw bytes. */
+  get audio() {
+    const b64 = this.raw.audio_base64 || "";
+    return b64 ? base64ToBytes(b64) : new Uint8Array(0);
+  }
+  get audioBase64() {
+    return this.raw.audio_base64 ?? null;
+  }
+  get sampleRate() {
+    return this.raw.sample_rate ?? null;
+  }
+  get durationS() {
+    return this.raw.duration_s ?? null;
+  }
+  /** Container/codec of the returned audio (e.g. "wav"). */
+  get format() {
+    return this.raw.format ?? null;
+  }
+  /** Write the decoded audio to `path` (Node only — lazy node:fs). */
+  async save(path) {
+    const { writeFile } = await import('fs/promises');
+    await writeFile(path, this.audio);
+    return this;
+  }
+};
 
 // src/resources/chat.ts
 var PATH = "/v1/chat/completions";
@@ -786,6 +833,60 @@ var Auto = class {
   }
 };
 
+// src/resources/audio.ts
+var BASE3 = "/v1/audio";
+function bytesToBase64(bytes) {
+  if (typeof Buffer !== "undefined") return Buffer.from(bytes).toString("base64");
+  let bin = "";
+  const CHUNK = 32768;
+  for (let i = 0; i < bytes.length; i += CHUNK) {
+    bin += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
+  }
+  return btoa(bin);
+}
+async function toBase64(audio) {
+  if (typeof audio === "string") {
+    const { readFile } = await import('fs/promises');
+    return bytesToBase64(new Uint8Array(await readFile(audio)));
+  }
+  if (typeof audio === "object" && audio !== null && "base64" in audio) {
+    if (!audio.base64 || !audio.base64.trim()) throw new ParetaError("audio.base64 is empty");
+    return audio.base64;
+  }
+  if (audio instanceof Blob) return bytesToBase64(new Uint8Array(await audio.arrayBuffer()));
+  const bytes = audio instanceof Uint8Array ? audio : new Uint8Array(audio);
+  if (bytes.byteLength === 0) throw new ParetaError("audio is empty");
+  return bytesToBase64(bytes);
+}
+var Audio = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Speech-to-text (the `asr` lane). `audio` is a file path, raw bytes, a
+   * Blob, or `{ base64 }`. Metered per minute of input audio. */
+  async transcriptions(audio, opts = {}) {
+    const body = { audio_base64: await toBase64(audio) };
+    if (opts.language) body.language = opts.language;
+    return this.client.request("POST", `${BASE3}/transcriptions`, {
+      body,
+      cast: (raw) => new Transcription(raw)
+    });
+  }
+  /** Text-to-speech (the `tts` lane). Returns a `Speech` whose `.audio` is
+   * decoded bytes (`.save(path)` writes a file in Node). Metered per minute
+   * of output audio. */
+  speech(text, opts = {}) {
+    if (!text || !text.trim()) throw new ParetaError("text is required");
+    const body = { text };
+    if (opts.voice) body.voice = opts.voice;
+    return this.client.request("POST", `${BASE3}/speech`, {
+      body,
+      cast: (raw) => new Speech(raw)
+    });
+  }
+};
+
 // src/resources/retrieval.ts
 function makeRerank(client) {
   return (query, documents, opts = {}) => {
@@ -846,6 +947,8 @@ var Pareta = class _Pareta {
   tasks;
   evals;
   auto;
+  /** The Speech lanes — `pa.audio.transcriptions(...)` (ASR) + `pa.audio.speech(...)` (TTS). */
+  audio;
   /** Document reranking (the Retrieval precision lane) — `pa.rerank(query, docs, {topN})`. */
   rerank;
   /** Text embeddings (the Retrieval recall lane) — `pa.embeddings(input, {inputType})`. */
@@ -870,6 +973,7 @@ var Pareta = class _Pareta {
     this.tasks = new Tasks(this);
     this.evals = new Evals(this);
     this.auto = new Auto(this);
+    this.audio = new Audio(this);
     this.rerank = makeRerank(this);
     this.embeddings = makeEmbeddings(this);
   }
@@ -1052,6 +1156,6 @@ var Pareta = class _Pareta {
   }
 };
 
-export { APIConnectionError, APIStatusError, APITimeoutError, AuthenticationError, BadRequestError, BaseModel, ChatCompletion, ChatCompletionChunk, Choice, ConflictError, Embeddings, EndpointNotReadyError, EvalItemResult, EvalResult, EvalRun, EvalRuns, EvalSet, EvalSets, FrontierModel, InsufficientCreditsError, Message, Model, ModelList, NotFoundError, Pareta, ParetaError, PermissionDeniedError, RateLimitError, Rerank, RerankResult, Task, TaskMatch, TaskMatchCandidate, Usage, VERSION };
+export { APIConnectionError, APIStatusError, APITimeoutError, Audio, AuthenticationError, BadRequestError, BaseModel, ChatCompletion, ChatCompletionChunk, Choice, ConflictError, Embeddings, EndpointNotReadyError, EvalItemResult, EvalResult, EvalRun, EvalRuns, EvalSet, EvalSets, FrontierModel, InsufficientCreditsError, Message, Model, ModelList, NotFoundError, Pareta, ParetaError, PermissionDeniedError, RateLimitError, Rerank, RerankResult, Speech, Task, TaskMatch, TaskMatchCandidate, Transcription, Usage, VERSION };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map