@ai-ecoverse/pi-audio 1.23.0 → 1.25.0

package/dist/node-host.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/node-host.ts"],
+  "sourcesContent": ["import { PassThrough } from 'node:stream';\nimport { VoiceRequestError } from './errors.ts';\nimport { type Mixer, type OpenMixerOptions, openMixer } from './mixer.ts';\n\nexport type NodeAudioEngine = 'node-web-audio-api' | 'web-audio-api';\n\nexport interface NodeAudioModule {\n  AudioContext: new (options?: Record<string, unknown>) => NodeAudioContext;\n  AudioWorkletNode: NonNullable<OpenMixerOptions['workletNode']>;\n}\n\nexport interface NodeAudioContext {\n  readonly state: AudioContextState;\n  resume(): Promise<void>;\n  close(): Promise<void>;\n  readonly sampleRate: number;\n  readonly currentTime: number;\n  readonly destination: AudioDestinationNode;\n  readonly audioWorklet: AudioWorklet;\n  createGain(): GainNode;\n  createBuffer(channels: number, length: number, sampleRate: number): AudioBuffer;\n  createBufferSource(): AudioBufferSourceNode;\n  decodeAudioData(buffer: ArrayBuffer): Promise<AudioBuffer>;\n}\n\nexport interface NodeAudioOptions {\n  engine?: NodeAudioEngine | 'auto';\n  sink?: 'none' | 'default';\n  sampleRate?: number;\n  load?: (engine: NodeAudioEngine) => Promise<NodeAudioModule>;\n}\n\nexport interface NodeAudioSession {\n  readonly engine: NodeAudioEngine;\n  readonly sink: 'none' | 'default';\n  readonly context: BaseAudioContext;\n  readonly out: Mixer;\n  close(): Promise<void>;\n}\n\nconst TAP_NAME = 'pi-audio-tap.js';\n\nconst AUDIO_TAP_CLASSIC = [\n  'class PiAudioTap extends AudioWorkletProcessor {',\n  '  constructor() {',\n  '    super();',\n  '    this.released = false;',\n  '    this.posted = false;',\n  '    var port = this.port;',\n  '    if (port) {',\n  '      port.onmessage = function (event) {',\n  '        if (event.data && event.data.type === \"pi-audio-release\") this.released = true;',\n  '      }.bind(this);',\n  '    }',\n  '  }',\n  '  process(inputs, outputs) {',\n  '    if (this.released) {',\n  '      if (!this.posted) {',\n  '        this.posted = true;',\n  '        if (this.port) this.port.postMessage({ type: \"pi-audio-release\" });',\n  '      }',\n  '      return true;',\n  '    }',\n  '    var input = (inputs && inputs[0]) || [];',\n  '    var output = (outputs && outputs[0]) || [];',\n  '    for (var channel = 0; channel < output.length; channel++) {',\n  '      var dst = output[channel];',\n  '      if (!dst) continue;',\n  '      var src = input[channel] || input[0];',\n  '      if (!src) { dst.fill(0); continue; }',\n  '      if (src.length === dst.length) dst.set(src);',\n  '      else {',\n  '        var count = Math.min(src.length, dst.length);',\n  '        for (var frame = 0; frame < count; frame++) dst[frame] = src[frame];',\n  '      }',\n  '    }',\n  '    var heard = input[0];',\n  '    if (heard && heard.length && this.port) {',\n  '      var copy = new Float32Array(heard.length);',\n  '      copy.set(heard);',\n  '      this.port.postMessage({ samples: copy });',\n  '    }',\n  '    return true;',\n  '  }',\n  '}',\n  \"registerProcessor('pi-audio-tap', PiAudioTap);\",\n  '',\n].join('\\n');\n\nexport async function loadNodeAudioEngine(engine: NodeAudioEngine): Promise<NodeAudioModule> {\n  if (engine === 'node-web-audio-api') {\n    return (await import('node-web-audio-api')) as unknown as NodeAudioModule;\n  }\n  return (await import('web-audio-api')) as unknown as NodeAudioModule;\n}\n\nexport async function openNodeAudio(options: NodeAudioOptions = {}): Promise<NodeAudioSession> {\n  const engine = options.engine ?? 'auto';\n  const sink = options.sink ?? 'none';\n  const load = options.load ?? loadNodeAudioEngine;\n  const names: NodeAudioEngine[] =\n    engine === 'auto' ? ['node-web-audio-api', 'web-audio-api'] : [engine];\n  const tapUrl = await writeTap();\n  let failure: unknown;\n  for (const name of names) {\n    try {\n      return await startEngine(name, sink, options.sampleRate, load, tapUrl);\n    } catch (error) {\n      failure = error;\n      if (engine !== 'auto') break;\n    }\n  }\n  throw new VoiceRequestError('error', failureText(failure));\n}\n\nasync function startEngine(\n  engine: NodeAudioEngine,\n  sink: 'none' | 'default',\n  sampleRate: number | undefined,\n  load: (engine: NodeAudioEngine) => Promise<NodeAudioModule>,\n  tapUrl: string\n): Promise<NodeAudioSession> {\n  const loaded = await load(engine);\n  const built = await nodeContextOptions(engine, sink, sampleRate);\n  const context = new loaded.AudioContext(built.options);\n  try {\n    const out = await openMixer(context as unknown as BaseAudioContext, {\n      playback: 'webaudio',\n      runtime: 'node',\n      tapUrl,\n      workletNode: loaded.AudioWorkletNode,\n    });\n    if (context.state === 'suspended') await context.resume();\n    return {\n      engine,\n      sink,\n      context: context as unknown as BaseAudioContext,\n      out,\n      close: () => closeSession(context, out, built.stream),\n    };\n  } catch (error) {\n    await closeSession(context, undefined, built.stream);\n    throw error;\n  }\n}\n\nasync function nodeContextOptions(\n  engine: NodeAudioEngine,\n  sink: 'none' | 'default',\n  sampleRate: number | undefined\n): Promise<{ options: Record<string, unknown>; stream?: PassThrough }> {\n  const options: Record<string, unknown> = {};\n  if (sampleRate !== undefined) options.sampleRate = sampleRate;\n  if (sink === 'default') return { options };\n  if (engine === 'node-web-audio-api') {\n    options.sinkId = { type: 'none' };\n    return { options };\n  }\n  const stream = new PassThrough();\n  stream.resume();\n  options.sinkId = stream;\n  return { options, stream };\n}\n\nasync function closeSession(\n  context: NodeAudioContext,\n  out: Mixer | undefined,\n  stream: PassThrough | undefined\n): Promise<void> {\n  if (out) out.close();\n  if (stream) stream.destroy();\n  await context.close();\n}\n\nfunction failureText(error: unknown): string {\n  if (error instanceof Error) return error.message;\n  return 'Node audio engine is unavailable';\n}\n\nasync function writeTap(): Promise<string> {\n  const { writeFileSync } = await import('node:fs');\n  const { tmpdir } = await import('node:os');\n  const { join } = await import('node:path');\n  const file = join(tmpdir(), TAP_NAME);\n  writeFileSync(file, AUDIO_TAP_CLASSIC);\n  return file;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/types/index.d.ts

@@ -7,8 +7,12 @@ export { convertAudio, convertAudioSource, decodeAudioBase64, encodeAudioBase64,
 export type { EchoCanceller, EchoControl, EchoMode, EchoReport, MicOpen } from './echo.ts';
 export { assertNodeEcho, calibrateEcho, chooseCapture, echoRuntime, measureEcho, micOpen, openEchoMic, } from './echo.ts';
 export { VoiceRequestError } from './errors.ts';
+export type { Mixer, OpenMixerOptions } from './mixer.ts';
+export { openMixer } from './mixer.ts';
 export type { Delivery, DeliverySupport, KnownRealtimeApi, KnownSpeechApi, KnownTranscriptionApi, RealtimeApi, RealtimeModel, SpeechApi, SpeechModel, TranscriptionApi, TranscriptionModel, VoiceInfo, VoiceModel, VoiceModelType, } from './models.ts';
 export { getVoiceModel, listVoiceModels, registerVoiceModel, } from './models.ts';
+export type { NodeAudioEngine, NodeAudioModule, NodeAudioOptions, NodeAudioSession, } from './node-host.ts';
+export { openNodeAudio } from './node-host.ts';
 export type { DeliveryPlan, RealtimeApiProvider, RealtimeContext, RealtimeEvent, RealtimeOptions, RealtimeSession, RealtimeSocket, RealtimeToken, TruncationPlan, } from './realtime.ts';
 export { planDelivery, planTruncation, RealtimeLedger, realtimeSocket } from './realtime.ts';
 export { connectRealtime, listen, registerRealtimeApiProvider, registerSpeechApiProvider, registerTranscriptionApiProvider, speak, transcribe, } from './registry.ts';
@@ -29,3 +33,5 @@ export type { AudioCost, AudioCounters, AudioUsage, RealtimeAudioCost, SpeechAud
 export { addAudioCounters, priceAudio } from './usage.ts';
 export type { VadHook, VadUpdate } from './vad.ts';
 export { energyVad } from './vad.ts';
+export { bindWorkletNode, WORKLET_RELEASE } from './worklet/release.ts';
+export { AUDIO_TAP_PROCESSOR, audioTapWorkletUrl } from './worklet/tap.ts';

package/dist/types/mixer.d.ts

@@ -0,0 +1,15 @@
+import type { AudioOut } from './soundscape.ts';
+import { type WorkletNodeLike } from './worklet/release.ts';
+export interface Mixer extends AudioOut {
+    close(): void;
+}
+export interface MixerWorkletNode extends WorkletNodeLike {
+    connect(destination: AudioNode): AudioNode;
+}
+export interface OpenMixerOptions {
+    playback?: 'webaudio' | 'rtc-loopback';
+    runtime?: 'node' | 'browser';
+    tapUrl?: string;
+    workletNode?: new (context: BaseAudioContext, name: string, options?: AudioWorkletNodeOptions) => MixerWorkletNode;
+}
+export declare function openMixer(context: BaseAudioContext, options?: OpenMixerOptions): Promise<Mixer>;

package/dist/types/models.d.ts

@@ -1,7 +1,7 @@
 import type { BaseModel } from '@earendil-works/pi-ai';
 import type { AudioFormat } from './audio.ts';
 import type { RealtimeAudioCost, SpeechAudioCost, TranscriptionAudioCost } from './usage.ts';
-export type KnownTranscriptionApi = 'openai-transcriptions' | 'openai-realtime-transcription' | 'xai-stt' | 'elevenlabs-scribe' | 'mistral-transcriptions' | 'fish-asr' | 'cloudflare-ai-run';
+export type KnownTranscriptionApi = 'openai-transcriptions' | 'openai-realtime-transcription' | 'xai-stt' | 'elevenlabs-scribe' | 'mistral-transcriptions' | 'fish-asr' | 'cloudflare-ai-run' | 'wavespeed';
 export type TranscriptionApi = KnownTranscriptionApi | (string & {});
 export type KnownSpeechApi = 'openai-speech' | 'xai-tts' | 'elevenlabs-tts' | 'mistral-speech' | 'fish-tts' | 'google-tts' | 'cloudflare-ai-run' | 'wavespeed';
 export type SpeechApi = KnownSpeechApi | (string & {});

package/dist/types/node-host.d.ts

@@ -0,0 +1,34 @@
+import { type Mixer, type OpenMixerOptions } from './mixer.ts';
+export type NodeAudioEngine = 'node-web-audio-api' | 'web-audio-api';
+export interface NodeAudioModule {
+    AudioContext: new (options?: Record<string, unknown>) => NodeAudioContext;
+    AudioWorkletNode: NonNullable<OpenMixerOptions['workletNode']>;
+}
+export interface NodeAudioContext {
+    readonly state: AudioContextState;
+    resume(): Promise<void>;
+    close(): Promise<void>;
+    readonly sampleRate: number;
+    readonly currentTime: number;
+    readonly destination: AudioDestinationNode;
+    readonly audioWorklet: AudioWorklet;
+    createGain(): GainNode;
+    createBuffer(channels: number, length: number, sampleRate: number): AudioBuffer;
+    createBufferSource(): AudioBufferSourceNode;
+    decodeAudioData(buffer: ArrayBuffer): Promise<AudioBuffer>;
+}
+export interface NodeAudioOptions {
+    engine?: NodeAudioEngine | 'auto';
+    sink?: 'none' | 'default';
+    sampleRate?: number;
+    load?: (engine: NodeAudioEngine) => Promise<NodeAudioModule>;
+}
+export interface NodeAudioSession {
+    readonly engine: NodeAudioEngine;
+    readonly sink: 'none' | 'default';
+    readonly context: BaseAudioContext;
+    readonly out: Mixer;
+    close(): Promise<void>;
+}
+export declare function loadNodeAudioEngine(engine: NodeAudioEngine): Promise<NodeAudioModule>;
+export declare function openNodeAudio(options?: NodeAudioOptions): Promise<NodeAudioSession>;

package/dist/types/wavespeed/catalog.d.ts

@@ -0,0 +1 @@
+export declare function registerWaveSpeed(): () => void;

package/dist/types/wavespeed/index.d.ts

@@ -0,0 +1 @@
+export { registerWaveSpeed } from './catalog.ts';

package/dist/types/wavespeed/speak.d.ts

@@ -0,0 +1,4 @@
+import type { ProviderRequestOptions } from '@earendil-works/pi-ai';
+import type { SpeechModel } from '../models.ts';
+import { SpeechEventStream, type SpeechInput } from '../speech.ts';
+export declare function speakWaveSpeed(model: SpeechModel<string>, input: SpeechInput, options?: ProviderRequestOptions): SpeechEventStream;

package/dist/types/wavespeed/transcribe.d.ts

@@ -0,0 +1,4 @@
+import type { ProviderRequestOptions } from '@earendil-works/pi-ai';
+import type { TranscriptionModel } from '../models.ts';
+import type { AudioInput, Transcript } from '../transcription.ts';
+export declare function transcribeWaveSpeed(model: TranscriptionModel<string>, input: AudioInput, options?: ProviderRequestOptions): Promise<Transcript>;

package/dist/types/wavespeed/wire.d.ts

@@ -0,0 +1,25 @@
+import type { ProviderRequestOptions } from '@earendil-works/pi-ai';
+export declare function taskRecord(body: unknown): Record<string, unknown>;
+export declare function errorText(text: string, status: number): string;
+export declare function isHttpUrl(value: string): boolean;
+export declare function outputText(output: unknown): string | undefined;
+export declare function outputUrl(output: unknown): string | undefined;
+export declare function downloadUrl(body: unknown): string;
+export declare function durationSeconds(record: Record<string, unknown>): number;
+declare function waveFetch(model: {
+    provider: string;
+    headers?: Record<string, string>;
+    id: string;
+}, options: ProviderRequestOptions | undefined, url: string, body: BodyInit | undefined, contentType: string | undefined): Promise<unknown>;
+export declare function finishTask(model: {
+    provider: string;
+    baseUrl: string;
+    headers?: Record<string, string>;
+    id: string;
+}, options: ProviderRequestOptions | undefined, payload: unknown, rejected: string): Promise<Record<string, unknown>>;
+export declare function readHttp(model: {
+    provider: string;
+    headers?: Record<string, string>;
+    id: string;
+}, options: ProviderRequestOptions | undefined, url: string): Promise<Response>;
+export { waveFetch };

package/dist/types/worklet/convert.d.ts

@@ -6,22 +6,25 @@ export interface AudioConvertProcessorOptions {
         sampleRate?: number;
     };
 }
+interface WorkletPort {
+    postMessage(message: unknown): void;
+    onmessage: ((event: {
+        data?: unknown;
+    }) => void) | null;
+}
 interface WorkletScope {
     AudioWorkletProcessor?: new (options?: AudioConvertProcessorOptions) => {
-        port?: {
-            postMessage(message: unknown): void;
-        };
+        port?: WorkletPort;
     };
     registerProcessor?: (name: string, processor: new (options?: AudioConvertProcessorOptions) => object) => void;
 }
 declare const WorkletBase: new (options?: AudioConvertProcessorOptions) => {
-    port?: {
-        postMessage(message: unknown): void;
-    };
+    port?: WorkletPort;
 };
 export declare class AudioConvertProcessor extends WorkletBase {
     #private;
     constructor(options?: AudioConvertProcessorOptions);
+    release(): void;
     process(inputs: Array<ArrayLike<Float32Array | undefined> | undefined>): boolean;
     take(): Uint8Array[];
 }

package/dist/types/worklet/release.d.ts

@@ -0,0 +1,13 @@
+export declare const WORKLET_RELEASE = "pi-audio-release";
+export interface WorkletPort {
+    postMessage(message: unknown): void;
+    onmessage: ((event: {
+        data?: unknown;
+    }) => void) | null;
+}
+export interface WorkletNodeLike {
+    disconnect(): void;
+    port: WorkletPort;
+}
+export declare function isWorkletRelease(data: unknown): boolean;
+export declare function bindWorkletNode(node: WorkletNodeLike): () => void;

package/dist/types/worklet/tap.d.ts

@@ -0,0 +1,25 @@
+export declare const AUDIO_TAP_PROCESSOR = "pi-audio-tap";
+interface TapPort {
+    postMessage(message: unknown): void;
+    onmessage: ((event: {
+        data?: unknown;
+    }) => void) | null;
+}
+interface WorkletScope {
+    AudioWorkletProcessor?: new () => {
+        port?: TapPort;
+    };
+    registerProcessor?: (name: string, processor: new () => object) => void;
+}
+interface TapInputs {
+    inputs: Array<ArrayLike<Float32Array | undefined> | undefined>;
+    outputs: Array<ArrayLike<Float32Array | undefined> | undefined>;
+}
+export declare function copyTap(inputs: TapInputs['inputs'], outputs: TapInputs['outputs']): void;
+export declare function tapSamples(inputs: TapInputs['inputs']): Float32Array | undefined;
+export declare function registerAudioTapWorklet(target?: WorkletScope): void;
+export declare function audioTapWorkletUrl(): string;
+export declare function loadAudioTap(worklet: {
+    addModule(module: unknown): Promise<void>;
+}, url?: string): Promise<void>;
+export {};

package/dist/wavespeed/catalog.js

@@ -0,0 +1,60 @@
+import { registerVoiceModel } from "../models.js";
+import { registerSpeechApiProvider, registerTranscriptionApiProvider } from "../registry.js";
+import { speakWaveSpeed } from "./speak.js";
+import { transcribeWaveSpeed } from "./transcribe.js";
+const tokenCost = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+const wavespeed = "https://api.wavespeed.ai/api/v3";
+const format = (encoding, sampleRate) => ({
+  encoding,
+  sampleRate,
+  channels: 1
+});
+function registerWaveSpeed() {
+  const whisper = {
+    id: "wavespeed-ai/openai-whisper",
+    name: "wavespeed-ai/openai-whisper",
+    api: "wavespeed",
+    provider: "wavespeed",
+    baseUrl: wavespeed,
+    type: "transcription",
+    streaming: false,
+    turnDetection: "none",
+    inputFormats: [format("wav", 16e3), format("mp3", 16e3), format("flac", 16e3)],
+    cost: tokenCost,
+    audioCost: { perInputMinute: 0.06 }
+  };
+  const speech = {
+    id: "minimax/speech-2.6-turbo",
+    name: "minimax/speech-2.6-turbo",
+    api: "wavespeed",
+    provider: "wavespeed",
+    baseUrl: wavespeed,
+    type: "speech",
+    textStreaming: false,
+    outputFormats: [format("mp3", 24e3)],
+    cloning: true,
+    cost: tokenCost,
+    audioCost: { perThousandChars: 0.06 }
+  };
+  const unregisterModels = [registerVoiceModel(whisper), registerVoiceModel(speech)];
+  const unregisterTranscription = registerTranscriptionApiProvider({
+    api: "wavespeed",
+    transcribe: transcribeWaveSpeed
+  });
+  const unregisterSpeech = registerSpeechApiProvider({
+    api: "wavespeed",
+    speak: speakWaveSpeed
+  });
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    for (const unregister of unregisterModels) unregister();
+    unregisterTranscription();
+    unregisterSpeech();
+  };
+}
+export {
+  registerWaveSpeed
+};
+//# sourceMappingURL=catalog.js.map

package/dist/wavespeed/catalog.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/wavespeed/catalog.ts"],
+  "sourcesContent": ["import type { AudioFormat } from '../audio.ts';\nimport { registerVoiceModel, type SpeechModel, type TranscriptionModel } from '../models.ts';\nimport { registerSpeechApiProvider, registerTranscriptionApiProvider } from '../registry.ts';\nimport { speakWaveSpeed } from './speak.ts';\nimport { transcribeWaveSpeed } from './transcribe.ts';\n\nconst tokenCost = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };\nconst wavespeed = 'https://api.wavespeed.ai/api/v3';\n\nconst format = (encoding: 'wav' | 'mp3' | 'flac', sampleRate: number): AudioFormat => ({\n  encoding,\n  sampleRate,\n  channels: 1,\n});\n\nexport function registerWaveSpeed(): () => void {\n  const whisper: TranscriptionModel<string> = {\n    id: 'wavespeed-ai/openai-whisper',\n    name: 'wavespeed-ai/openai-whisper',\n    api: 'wavespeed',\n    provider: 'wavespeed',\n    baseUrl: wavespeed,\n    type: 'transcription',\n    streaming: false,\n    turnDetection: 'none',\n    inputFormats: [format('wav', 16000), format('mp3', 16000), format('flac', 16000)],\n    cost: tokenCost,\n    audioCost: { perInputMinute: 0.06 },\n  };\n  const speech: SpeechModel<string> = {\n    id: 'minimax/speech-2.6-turbo',\n    name: 'minimax/speech-2.6-turbo',\n    api: 'wavespeed',\n    provider: 'wavespeed',\n    baseUrl: wavespeed,\n    type: 'speech',\n    textStreaming: false,\n    outputFormats: [format('mp3', 24000)],\n    cloning: true,\n    cost: tokenCost,\n    audioCost: { perThousandChars: 0.06 },\n  };\n  const unregisterModels = [registerVoiceModel(whisper), registerVoiceModel(speech)];\n  const unregisterTranscription = registerTranscriptionApiProvider({\n    api: 'wavespeed',\n    transcribe: transcribeWaveSpeed,\n  });\n  const unregisterSpeech = registerSpeechApiProvider({\n    api: 'wavespeed',\n    speak: speakWaveSpeed,\n  });\n  let released = false;\n  return () => {\n    if (released) return;\n    released = true;\n    for (const unregister of unregisterModels) unregister();\n    unregisterTranscription();\n    unregisterSpeech();\n  };\n}\n"],
+  "mappings": "AACA,SAAS,0BAAqE;AAC9E,SAAS,2BAA2B,wCAAwC;AAC5E,SAAS,sBAAsB;AAC/B,SAAS,2BAA2B;AAEpC,MAAM,YAAY,EAAE,OAAO,GAAG,QAAQ,GAAG,WAAW,GAAG,YAAY,EAAE;AACrE,MAAM,YAAY;AAElB,MAAM,SAAS,CAAC,UAAkC,gBAAqC;AAAA,EACrF;AAAA,EACA;AAAA,EACA,UAAU;AACZ;AAEO,SAAS,oBAAgC;AAC9C,QAAM,UAAsC;AAAA,IAC1C,IAAI;AAAA,IACJ,MAAM;AAAA,IACN,KAAK;AAAA,IACL,UAAU;AAAA,IACV,SAAS;AAAA,IACT,MAAM;AAAA,IACN,WAAW;AAAA,IACX,eAAe;AAAA,IACf,cAAc,CAAC,OAAO,OAAO,IAAK,GAAG,OAAO,OAAO,IAAK,GAAG,OAAO,QAAQ,IAAK,CAAC;AAAA,IAChF,MAAM;AAAA,IACN,WAAW,EAAE,gBAAgB,KAAK;AAAA,EACpC;AACA,QAAM,SAA8B;AAAA,IAClC,IAAI;AAAA,IACJ,MAAM;AAAA,IACN,KAAK;AAAA,IACL,UAAU;AAAA,IACV,SAAS;AAAA,IACT,MAAM;AAAA,IACN,eAAe;AAAA,IACf,eAAe,CAAC,OAAO,OAAO,IAAK,CAAC;AAAA,IACpC,SAAS;AAAA,IACT,MAAM;AAAA,IACN,WAAW,EAAE,kBAAkB,KAAK;AAAA,EACtC;AACA,QAAM,mBAAmB,CAAC,mBAAmB,OAAO,GAAG,mBAAmB,MAAM,CAAC;AACjF,QAAM,0BAA0B,iCAAiC;AAAA,IAC/D,KAAK;AAAA,IACL,YAAY;AAAA,EACd,CAAC;AACD,QAAM,mBAAmB,0BAA0B;AAAA,IACjD,KAAK;AAAA,IACL,OAAO;AAAA,EACT,CAAC;AACD,MAAI,WAAW;AACf,SAAO,MAAM;AACX,QAAI,SAAU;AACd,eAAW;AACX,eAAW,cAAc,iBAAkB,YAAW;AACtD,4BAAwB;AACxB,qBAAiB;AAAA,EACnB;AACF;",
+  "names": []
+}

package/dist/wavespeed/index.js

@@ -0,0 +1,5 @@
+import { registerWaveSpeed } from "./catalog.js";
+export {
+  registerWaveSpeed
+};
+//# sourceMappingURL=index.js.map

package/dist/wavespeed/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/wavespeed/index.ts"],
+  "sourcesContent": ["export { registerWaveSpeed } from './catalog.ts';\n"],
+  "mappings": "AAAA,SAAS,yBAAyB;",
+  "names": []
+}

package/dist/wavespeed/speak.js

@@ -0,0 +1,66 @@
+import { asVoiceError } from "../openai/wire.js";
+import { SpeechEventStream } from "../speech.js";
+import { priceAudio } from "../usage.js";
+import { finishTask, outputUrl, readHttp } from "./wire.js";
+function resolveFormat(model, requested) {
+  const fallback = model.outputFormats[0];
+  if (!fallback) throw new Error("No output format");
+  if (!requested) return fallback;
+  const match = model.outputFormats.find(
+    (format) => format.encoding === requested.encoding && format.sampleRate === requested.sampleRate && format.channels === requested.channels
+  );
+  if (!match) throw new Error(`Unsupported speech format ${requested.encoding}`);
+  return match;
+}
+async function readText(text, signal) {
+  if (typeof text === "string") return text;
+  let combined = "";
+  for await (const part of text) {
+    if (signal?.aborted) throw new DOMException("aborted", "AbortError");
+    combined += part;
+  }
+  return combined;
+}
+async function audioOf(model, options, output) {
+  const url = outputUrl(output);
+  if (url === void 0) throw new Error("Speech response had no audio");
+  const response = await readHttp(model, options, url);
+  const data = new Uint8Array(await response.arrayBuffer());
+  if (data.byteLength === 0) throw new Error("Speech response had no audio");
+  return data;
+}
+function speakWaveSpeed(model, input, options) {
+  const stream = new SpeechEventStream();
+  void pumpSpeech(model, input, options, stream);
+  return stream;
+}
+async function pumpSpeech(model, input, options, stream) {
+  try {
+    if (options?.signal?.aborted) throw new DOMException("aborted", "AbortError");
+    const format = resolveFormat(model, input.format);
+    const text = await readText(input.text, options?.signal);
+    const payload = { text, voice_id: input.voice, format: "mp3" };
+    if (input.language !== void 0) payload.language_boost = input.language;
+    const record = await finishTask(model, options, payload, "Speech payload was not JSON");
+    const outputs = record.outputs;
+    const first = Array.isArray(outputs) ? outputs[0] : void 0;
+    const data = await audioOf(model, options, first);
+    stream.push({ type: "start", format });
+    stream.push({
+      type: "audio",
+      chunk: { data, format, timestamp: 0 },
+      span: { itemId: model.id, start: 0, end: text.length }
+    });
+    stream.push({
+      type: "done",
+      usage: priceAudio(model.audioCost, { characters: text.length })
+    });
+  } catch (error) {
+    const voice = asVoiceError(error);
+    stream.push({ type: "error", reason: voice.reason, error: voice.error });
+  }
+}
+export {
+  speakWaveSpeed
+};
+//# sourceMappingURL=speak.js.map

package/dist/wavespeed/speak.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/wavespeed/speak.ts"],
+  "sourcesContent": ["import type { ProviderRequestOptions } from '@earendil-works/pi-ai';\nimport type { AudioFormat } from '../audio.ts';\nimport type { SpeechModel } from '../models.ts';\nimport { asVoiceError } from '../openai/wire.ts';\nimport { SpeechEventStream, type SpeechInput } from '../speech.ts';\nimport { priceAudio } from '../usage.ts';\nimport { finishTask, outputUrl, readHttp } from './wire.ts';\n\nfunction resolveFormat(\n  model: SpeechModel<string>,\n  requested: AudioFormat | undefined\n): AudioFormat {\n  const fallback = model.outputFormats[0];\n  if (!fallback) throw new Error('No output format');\n  if (!requested) return fallback;\n  const match = model.outputFormats.find(\n    (format) =>\n      format.encoding === requested.encoding &&\n      format.sampleRate === requested.sampleRate &&\n      format.channels === requested.channels\n  );\n  if (!match) throw new Error(`Unsupported speech format ${requested.encoding}`);\n  return match;\n}\n\nasync function readText(\n  text: string | AsyncIterable<string>,\n  signal: AbortSignal | undefined\n): Promise<string> {\n  if (typeof text === 'string') return text;\n  let combined = '';\n  for await (const part of text) {\n    if (signal?.aborted) throw new DOMException('aborted', 'AbortError');\n    combined += part;\n  }\n  return combined;\n}\n\nasync function audioOf(\n  model: SpeechModel<string>,\n  options: ProviderRequestOptions | undefined,\n  output: unknown\n): Promise<Uint8Array> {\n  const url = outputUrl(output);\n  if (url === undefined) throw new Error('Speech response had no audio');\n  const response = await readHttp(model, options, url);\n  const data = new Uint8Array(await response.arrayBuffer());\n  if (data.byteLength === 0) throw new Error('Speech response had no audio');\n  return data;\n}\n\nexport function speakWaveSpeed(\n  model: SpeechModel<string>,\n  input: SpeechInput,\n  options?: ProviderRequestOptions\n): SpeechEventStream {\n  const stream = new SpeechEventStream();\n  void pumpSpeech(model, input, options, stream);\n  return stream;\n}\n\nasync function pumpSpeech(\n  model: SpeechModel<string>,\n  input: SpeechInput,\n  options: ProviderRequestOptions | undefined,\n  stream: SpeechEventStream\n) {\n  try {\n    if (options?.signal?.aborted) throw new DOMException('aborted', 'AbortError');\n    const format = resolveFormat(model, input.format);\n    const text = await readText(input.text, options?.signal);\n    const payload: Record<string, unknown> = { text, voice_id: input.voice, format: 'mp3' };\n    if (input.language !== undefined) payload.language_boost = input.language;\n    const record = await finishTask(model, options, payload, 'Speech payload was not JSON');\n    const outputs = record.outputs;\n    const first = Array.isArray(outputs) ? outputs[0] : undefined;\n    const data = await audioOf(model, options, first);\n    stream.push({ type: 'start', format });\n    stream.push({\n      type: 'audio',\n      chunk: { data, format, timestamp: 0 },\n      span: { itemId: model.id, start: 0, end: text.length },\n    });\n    stream.push({\n      type: 'done',\n      usage: priceAudio(model.audioCost, { characters: text.length }),\n    });\n  } catch (error) {\n    const voice = asVoiceError(error);\n    stream.push({ type: 'error', reason: voice.reason, error: voice.error });\n  }\n}\n"],
+  "mappings": "AAGA,SAAS,oBAAoB;AAC7B,SAAS,yBAA2C;AACpD,SAAS,kBAAkB;AAC3B,SAAS,YAAY,WAAW,gBAAgB;AAEhD,SAAS,cACP,OACA,WACa;AACb,QAAM,WAAW,MAAM,cAAc,CAAC;AACtC,MAAI,CAAC,SAAU,OAAM,IAAI,MAAM,kBAAkB;AACjD,MAAI,CAAC,UAAW,QAAO;AACvB,QAAM,QAAQ,MAAM,cAAc;AAAA,IAChC,CAAC,WACC,OAAO,aAAa,UAAU,YAC9B,OAAO,eAAe,UAAU,cAChC,OAAO,aAAa,UAAU;AAAA,EAClC;AACA,MAAI,CAAC,MAAO,OAAM,IAAI,MAAM,6BAA6B,UAAU,QAAQ,EAAE;AAC7E,SAAO;AACT;AAEA,eAAe,SACb,MACA,QACiB;AACjB,MAAI,OAAO,SAAS,SAAU,QAAO;AACrC,MAAI,WAAW;AACf,mBAAiB,QAAQ,MAAM;AAC7B,QAAI,QAAQ,QAAS,OAAM,IAAI,aAAa,WAAW,YAAY;AACnE,gBAAY;AAAA,EACd;AACA,SAAO;AACT;AAEA,eAAe,QACb,OACA,SACA,QACqB;AACrB,QAAM,MAAM,UAAU,MAAM;AAC5B,MAAI,QAAQ,OAAW,OAAM,IAAI,MAAM,8BAA8B;AACrE,QAAM,WAAW,MAAM,SAAS,OAAO,SAAS,GAAG;AACnD,QAAM,OAAO,IAAI,WAAW,MAAM,SAAS,YAAY,CAAC;AACxD,MAAI,KAAK,eAAe,EAAG,OAAM,IAAI,MAAM,8BAA8B;AACzE,SAAO;AACT;AAEO,SAAS,eACd,OACA,OACA,SACmB;AACnB,QAAM,SAAS,IAAI,kBAAkB;AACrC,OAAK,WAAW,OAAO,OAAO,SAAS,MAAM;AAC7C,SAAO;AACT;AAEA,eAAe,WACb,OACA,OACA,SACA,QACA;AACA,MAAI;AACF,QAAI,SAAS,QAAQ,QAAS,OAAM,IAAI,aAAa,WAAW,YAAY;AAC5E,UAAM,SAAS,cAAc,OAAO,MAAM,MAAM;AAChD,UAAM,OAAO,MAAM,SAAS,MAAM,MAAM,SAAS,MAAM;AACvD,UAAM,UAAmC,EAAE,MAAM,UAAU,MAAM,OAAO,QAAQ,MAAM;AACtF,QAAI,MAAM,aAAa,OAAW,SAAQ,iBAAiB,MAAM;AACjE,UAAM,SAAS,MAAM,WAAW,OAAO,SAAS,SAAS,6BAA6B;AACtF,UAAM,UAAU,OAAO;AACvB,UAAM,QAAQ,MAAM,QAAQ,OAAO,IAAI,QAAQ,CAAC,IAAI;AACpD,UAAM,OAAO,MAAM,QAAQ,OAAO,SAAS,KAAK;AAChD,WAAO,KAAK,EAAE,MAAM,SAAS,OAAO,CAAC;AACrC,WAAO,KAAK;AAAA,MACV,MAAM;AAAA,MACN,OAAO,EAAE,MAAM,QAAQ,WAAW,EAAE;AAAA,MACpC,MAAM,EAAE,QAAQ,MAAM,IAAI,OAAO,GAAG,KAAK,KAAK,OAAO;AAAA,IACvD,CAAC;AACD,WAAO,KAAK;AAAA,MACV,MAAM;AAAA,MACN,OAAO,WAAW,MAAM,WAAW,EAAE,YAAY,KAAK,OAAO,CAAC;AAAA,IAChE,CAAC;AAAA,EACH,SAAS,OAAO;AACd,UAAM,QAAQ,aAAa,KAAK;AAChC,WAAO,KAAK,EAAE,MAAM,SAAS,QAAQ,MAAM,QAAQ,OAAO,MAAM,MAAM,CAAC;AAAA,EACzE;AACF;",
+  "names": []
+}

package/dist/wavespeed/transcribe.js

@@ -0,0 +1,85 @@
+import { VoiceRequestError } from "../errors.js";
+import {
+  asVoiceError,
+  audioFile,
+  encodeMultipart,
+  endpoint,
+  multipartType
+} from "../openai/wire.js";
+import { priceAudio } from "../usage.js";
+import {
+  downloadUrl,
+  durationSeconds,
+  finishTask,
+  isHttpUrl,
+  outputText,
+  readHttp,
+  waveFetch
+} from "./wire.js";
+async function sourceUrl(model, input, options) {
+  if ("url" in input) return input.url;
+  const named = audioFile(input.mimeType);
+  const encoded = encodeMultipart(
+    { data: input.data, mimeType: input.mimeType, filename: named.filename, format: named.format },
+    {}
+  );
+  const copy = new Uint8Array(encoded.byteLength);
+  copy.set(encoded);
+  const parsed = await waveFetch(
+    model,
+    options,
+    endpoint(model.baseUrl, "media/upload/binary"),
+    copy.buffer,
+    multipartType()
+  );
+  return downloadUrl(parsed);
+}
+async function textOf(model, options, output) {
+  if (typeof output === "string" && isHttpUrl(output)) {
+    const response = await readHttp(model, options, output);
+    const text2 = await response.text();
+    if (text2 === "") throw new Error("Transcription response had no text");
+    return text2;
+  }
+  const text = outputText(output);
+  if (text === void 0 || text === "" || isHttpUrl(text)) {
+    throw new Error("Transcription response had no text");
+  }
+  return text;
+}
+function languageOf(options) {
+  const record = options;
+  if (record === void 0) return void 0;
+  if (typeof record.language !== "string") return void 0;
+  return record.language;
+}
+async function transcribeWaveSpeed(model, input, options) {
+  try {
+    if (options?.signal?.aborted) throw new DOMException("aborted", "AbortError");
+    const audio = await sourceUrl(model, input, options);
+    const payload = {
+      audio,
+      task: "transcribe",
+      enable_timestamps: false
+    };
+    const language = languageOf(options);
+    if (language !== void 0) payload.language = language;
+    const record = await finishTask(model, options, payload, "Transcription payload was not JSON");
+    const outputs = record.outputs;
+    const first = Array.isArray(outputs) ? outputs[0] : void 0;
+    const text = await textOf(model, options, first);
+    const meters = {};
+    const seconds = durationSeconds(record);
+    if (seconds > 0) meters.inputSeconds = seconds;
+    const transcript = { text, usage: priceAudio(model.audioCost, meters) };
+    if (language !== void 0) transcript.language = language;
+    return transcript;
+  } catch (error) {
+    const voice = asVoiceError(error);
+    throw new VoiceRequestError(voice.reason, voice.error);
+  }
+}
+export {
+  transcribeWaveSpeed
+};
+//# sourceMappingURL=transcribe.js.map

package/dist/wavespeed/transcribe.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/wavespeed/transcribe.ts"],
+  "sourcesContent": ["import type { ProviderRequestOptions } from '@earendil-works/pi-ai';\nimport { VoiceRequestError } from '../errors.ts';\nimport type { TranscriptionModel } from '../models.ts';\nimport {\n  asVoiceError,\n  audioFile,\n  encodeMultipart,\n  endpoint,\n  multipartType,\n} from '../openai/wire.ts';\nimport type { AudioInput, Transcript } from '../transcription.ts';\nimport { type AudioCounters, priceAudio } from '../usage.ts';\nimport {\n  downloadUrl,\n  durationSeconds,\n  finishTask,\n  isHttpUrl,\n  outputText,\n  readHttp,\n  waveFetch,\n} from './wire.ts';\n\nasync function sourceUrl(\n  model: TranscriptionModel<string>,\n  input: AudioInput,\n  options: ProviderRequestOptions | undefined\n): Promise<string> {\n  if ('url' in input) return input.url;\n  const named = audioFile(input.mimeType);\n  const encoded = encodeMultipart(\n    { data: input.data, mimeType: input.mimeType, filename: named.filename, format: named.format },\n    {}\n  );\n  const copy = new Uint8Array(encoded.byteLength);\n  copy.set(encoded);\n  const parsed = await waveFetch(\n    model,\n    options,\n    endpoint(model.baseUrl, 'media/upload/binary'),\n    copy.buffer,\n    multipartType()\n  );\n  return downloadUrl(parsed);\n}\n\nasync function textOf(\n  model: TranscriptionModel<string>,\n  options: ProviderRequestOptions | undefined,\n  output: unknown\n): Promise<string> {\n  if (typeof output === 'string' && isHttpUrl(output)) {\n    const response = await readHttp(model, options, output);\n    const text = await response.text();\n    if (text === '') throw new Error('Transcription response had no text');\n    return text;\n  }\n  const text = outputText(output);\n  if (text === undefined || text === '' || isHttpUrl(text)) {\n    throw new Error('Transcription response had no text');\n  }\n  return text;\n}\n\nfunction languageOf(options: ProviderRequestOptions | undefined): string | undefined {\n  const record = options as { language?: unknown } | undefined;\n  if (record === undefined) return undefined;\n  if (typeof record.language !== 'string') return undefined;\n  return record.language;\n}\n\nexport async function transcribeWaveSpeed(\n  model: TranscriptionModel<string>,\n  input: AudioInput,\n  options?: ProviderRequestOptions\n): Promise<Transcript> {\n  try {\n    if (options?.signal?.aborted) throw new DOMException('aborted', 'AbortError');\n    const audio = await sourceUrl(model, input, options);\n    const payload: Record<string, unknown> = {\n      audio,\n      task: 'transcribe',\n      enable_timestamps: false,\n    };\n    const language = languageOf(options);\n    if (language !== undefined) payload.language = language;\n    const record = await finishTask(model, options, payload, 'Transcription payload was not JSON');\n    const outputs = record.outputs;\n    const first = Array.isArray(outputs) ? outputs[0] : undefined;\n    const text = await textOf(model, options, first);\n    const meters: AudioCounters = {};\n    const seconds = durationSeconds(record);\n    if (seconds > 0) meters.inputSeconds = seconds;\n    const transcript: Transcript = { text, usage: priceAudio(model.audioCost, meters) };\n    if (language !== undefined) transcript.language = language;\n    return transcript;\n  } catch (error) {\n    const voice = asVoiceError(error);\n    throw new VoiceRequestError(voice.reason, voice.error);\n  }\n}\n"],
+  "mappings": "AACA,SAAS,yBAAyB;AAElC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAA6B,kBAAkB;AAC/C;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,eAAe,UACb,OACA,OACA,SACiB;AACjB,MAAI,SAAS,MAAO,QAAO,MAAM;AACjC,QAAM,QAAQ,UAAU,MAAM,QAAQ;AACtC,QAAM,UAAU;AAAA,IACd,EAAE,MAAM,MAAM,MAAM,UAAU,MAAM,UAAU,UAAU,MAAM,UAAU,QAAQ,MAAM,OAAO;AAAA,IAC7F,CAAC;AAAA,EACH;AACA,QAAM,OAAO,IAAI,WAAW,QAAQ,UAAU;AAC9C,OAAK,IAAI,OAAO;AAChB,QAAM,SAAS,MAAM;AAAA,IACnB;AAAA,IACA;AAAA,IACA,SAAS,MAAM,SAAS,qBAAqB;AAAA,IAC7C,KAAK;AAAA,IACL,cAAc;AAAA,EAChB;AACA,SAAO,YAAY,MAAM;AAC3B;AAEA,eAAe,OACb,OACA,SACA,QACiB;AACjB,MAAI,OAAO,WAAW,YAAY,UAAU,MAAM,GAAG;AACnD,UAAM,WAAW,MAAM,SAAS,OAAO,SAAS,MAAM;AACtD,UAAMA,QAAO,MAAM,SAAS,KAAK;AACjC,QAAIA,UAAS,GAAI,OAAM,IAAI,MAAM,oCAAoC;AACrE,WAAOA;AAAA,EACT;AACA,QAAM,OAAO,WAAW,MAAM;AAC9B,MAAI,SAAS,UAAa,SAAS,MAAM,UAAU,IAAI,GAAG;AACxD,UAAM,IAAI,MAAM,oCAAoC;AAAA,EACtD;AACA,SAAO;AACT;AAEA,SAAS,WAAW,SAAiE;AACnF,QAAM,SAAS;AACf,MAAI,WAAW,OAAW,QAAO;AACjC,MAAI,OAAO,OAAO,aAAa,SAAU,QAAO;AAChD,SAAO,OAAO;AAChB;AAEA,eAAsB,oBACpB,OACA,OACA,SACqB;AACrB,MAAI;AACF,QAAI,SAAS,QAAQ,QAAS,OAAM,IAAI,aAAa,WAAW,YAAY;AAC5E,UAAM,QAAQ,MAAM,UAAU,OAAO,OAAO,OAAO;AACnD,UAAM,UAAmC;AAAA,MACvC;AAAA,MACA,MAAM;AAAA,MACN,mBAAmB;AAAA,IACrB;AACA,UAAM,WAAW,WAAW,OAAO;AACnC,QAAI,aAAa,OAAW,SAAQ,WAAW;AAC/C,UAAM,SAAS,MAAM,WAAW,OAAO,SAAS,SAAS,oCAAoC;AAC7F,UAAM,UAAU,OAAO;AACvB,UAAM,QAAQ,MAAM,QAAQ,OAAO,IAAI,QAAQ,CAAC,IAAI;AACpD,UAAM,OAAO,MAAM,OAAO,OAAO,SAAS,KAAK;AAC/C,UAAM,SAAwB,CAAC;AAC/B,UAAM,UAAU,gBAAgB,MAAM;AACtC,QAAI,UAAU,EAAG,QAAO,eAAe;AACvC,UAAM,aAAyB,EAAE,MAAM,OAAO,WAAW,MAAM,WAAW,MAAM,EAAE;AAClF,QAAI,aAAa,OAAW,YAAW,WAAW;AAClD,WAAO;AAAA,EACT,SAAS,OAAO;AACd,UAAM,QAAQ,aAAa,KAAK;AAChC,UAAM,IAAI,kBAAkB,MAAM,QAAQ,MAAM,KAAK;AAAA,EACvD;AACF;",
+  "names": ["text"]
+}

package/dist/wavespeed/wire.js

@@ -0,0 +1,138 @@
+import {
+  applyPayload,
+  endpoint,
+  isRecord,
+  numberField,
+  requestHeaders,
+  requestSignal,
+  stringField
+} from "../openai/wire.js";
+const terminal = /* @__PURE__ */ new Set(["failed", "cancelled", "timeout", "deleted"]);
+function taskRecord(body) {
+  if (!isRecord(body) || Array.isArray(body)) throw new Error("WaveSpeed response was not JSON");
+  const data = body.data;
+  if (isRecord(data) && !Array.isArray(data)) return data;
+  return body;
+}
+function errorText(text, status) {
+  if (text === "") return `HTTP ${status}`;
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return text;
+  }
+  if (!isRecord(parsed) || Array.isArray(parsed)) return text;
+  const message = stringField(parsed, "message");
+  if (message !== void 0 && message !== "") return message;
+  return text;
+}
+function isHttpUrl(value) {
+  if (value.startsWith("https://")) return true;
+  if (value.startsWith("http://")) return true;
+  return false;
+}
+function outputText(output) {
+  if (typeof output === "string") return output;
+  if (!isRecord(output) || Array.isArray(output)) return void 0;
+  return stringField(output, "text") ?? stringField(output, "transcript");
+}
+function outputUrl(output) {
+  if (typeof output === "string" && isHttpUrl(output)) return output;
+  if (!isRecord(output) || Array.isArray(output)) return void 0;
+  const url = stringField(output, "url") ?? stringField(output, "audio");
+  if (url === void 0 || !isHttpUrl(url)) return void 0;
+  return url;
+}
+function downloadUrl(body) {
+  const record = taskRecord(body);
+  const url = stringField(record, "download_url") ?? stringField(record, "url");
+  if (url === void 0 || url === "") throw new Error("WaveSpeed upload had no url");
+  return url;
+}
+function durationSeconds(record) {
+  const direct = numberField(record, "duration");
+  if (direct !== void 0) return direct;
+  return 0;
+}
+async function waveFetch(model, options, url, body, contentType) {
+  const headers = requestHeaders(model, options);
+  if (contentType !== void 0) headers["Content-Type"] = contentType;
+  const fetchImpl = options?.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(url, {
+    method: body === void 0 ? "GET" : "POST",
+    headers,
+    body,
+    signal: requestSignal(options)
+  });
+  if (options?.onResponse !== void 0) {
+    await options.onResponse({ status: response.status, headers: {} }, model);
+  }
+  if (!response.ok) {
+    const text2 = await response.text();
+    throw new Error(errorText(text2, response.status));
+  }
+  const text = await response.text();
+  if (text === "") throw new Error("WaveSpeed response was not JSON");
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error("WaveSpeed response was not JSON");
+  }
+}
+function failure(record, status) {
+  const error = stringField(record, "error");
+  if (error === void 0 || error === "") return new Error(`WaveSpeed ${status}`);
+  return new Error(error);
+}
+async function finishTask(model, options, payload, rejected) {
+  const body = await applyPayload(payload, model, options);
+  if (!isRecord(body) || Array.isArray(body)) throw new Error(rejected);
+  let record = taskRecord(
+    await waveFetch(
+      model,
+      options,
+      endpoint(model.baseUrl, model.id),
+      JSON.stringify(body),
+      "application/json"
+    )
+  );
+  for (let attempt = 0; attempt < 9; attempt += 1) {
+    const status = stringField(record, "status") ?? "";
+    if (status === "completed") return record;
+    if (terminal.has(status)) throw failure(record, status);
+    if (attempt === 8) break;
+    const id = stringField(record, "id");
+    if (id === void 0 || id === "") throw new Error("WaveSpeed prediction had no id");
+    record = taskRecord(
+      await waveFetch(
+        model,
+        options,
+        endpoint(model.baseUrl, `predictions/${id}/result`),
+        void 0,
+        void 0
+      )
+    );
+  }
+  throw new Error("WaveSpeed prediction timed out");
+}
+async function readHttp(model, options, url) {
+  const headers = requestHeaders(model, options);
+  const fetchImpl = options?.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(url, { headers, signal: requestSignal(options) });
+  if (!response.ok) throw new Error(errorText("", response.status));
+  return response;
+}
+export {
+  downloadUrl,
+  durationSeconds,
+  errorText,
+  finishTask,
+  isHttpUrl,
+  outputText,
+  outputUrl,
+  readHttp,
+  taskRecord,
+  waveFetch
+};
+//# sourceMappingURL=wire.js.map