WebInfer

API Reference

Complete reference for the WebInfer Client SDK

WebInfer Client API

Complete reference documentation for the WebInfer Client SDK.

generateText()

Generate text from a prompt using the best available model.

Parameters

types.ts
interface GenerateTextOptions {  prompt?: string              // Use prompt OR messages, not both  messages?: Array<{           // OpenAI-style message array    role: 'system' | 'user' | 'assistant'    content: string | ContentPart[]  // String or multimodal array  }>  mock?: boolean               // Return mock response instantly (no provider needed)  provider?: string            // Specific provider to use  model?: string               // Specific model to use}// For multimodal messages (images, audio, files):type ContentPart =  | { type: 'text'; text: string }  | { type: 'image'; image: string; mimeType?: string }  | { type: 'file'; data: string; mimeType: string; filename?: string }

Returns

response.ts
interface GenerateTextResponse {  text: string  model: string  provider: string  usage: {    inputTokens: number    outputTokens: number    totalTokens: number  }  metadata: {    latency: number    cost?: number  }}

streamText()

Stream text generation in real-time.

Parameters

Same as generateText()

Returns

An async iterable that yields text chunks as they are generated.

generateObject()

Generate a structured object from a prompt using JSON Schema validation.

Parameters

types.ts
interface GenerateObjectOptions {  prompt: string  schema: JSONSchema           // JSON Schema for the output structure  mock?: boolean               // Return mock object matching schema (no provider needed)  output?: 'object' | 'array'  // Output type (default: 'object')  provider?: string            // Specific provider to use  model?: string               // Specific model to use}

Returns

response.ts
interface GenerateObjectResponse<T> {  object: T                 // The generated object matching the schema  model: string  provider: string  usage: {    inputTokens: number    outputTokens: number    totalTokens: number  }  metadata: {    latency: number    cost?: number  }}

streamObject()

Stream structured object generation with partial updates as the model generates.

Parameters

types.ts
interface StreamObjectOptions<T> {  prompt: string  schema: JSONSchema           // JSON Schema for the output structure  mock?: boolean               // Return mock object matching schema (no provider needed)  output?: 'object' | 'array'  // Output type (default: 'object')  onPartialObject?: (partial: Partial<T>) => void  // Callback for partial results  provider?: string            // Specific provider to use  model?: string               // Specific model to use}

Returns

response.ts
interface StreamObjectResult<T> {  object: Promise<T>        // Resolves to the final complete object  partialObjectStream: AsyncIterable<Partial<T>>  // Stream of partial objects}

generateImage()

Generate images from a text prompt using AI image generation models.

Parameters

types.ts
interface GenerateImageOptions {  prompt: string              // Text description of the image to generate  mock?: boolean              // Return placeholder image instantly (no provider needed)  model?: string              // Model to use (e.g., 'gpt-image-1', 'gpt-image-1-mini')  provider?: string           // Provider to use (e.g., 'openai')  size?: string               // Image size (e.g., '1024x1024', '1792x1024')  aspectRatio?: string        // Aspect ratio (e.g., '16:9', '1:1')  n?: number                  // Number of images to generate (default: 1)  seed?: number               // Random seed for reproducibility  providerOptions?: Record<string, any>  // Provider-specific options  headers?: Record<string, string>       // Custom headers}

Returns

response.ts
interface GenerateImageResult {  image: GeneratedImage       // The first generated image  images: GeneratedImage[]    // All generated images  warnings?: Array<{ type: string; message: string }>  model?: string  provider?: string}interface GeneratedImage {  base64: string              // Base64-encoded image data  uint8Array: Uint8Array      // Raw image bytes  mimeType?: string           // Image MIME type (e.g., 'image/png')}

embed()

Generate an embedding vector for a single text value. Useful for semantic search, similarity comparison, and clustering.

Parameters

types.ts
interface EmbedOptions {  value: string               // Text to embed  mock?: boolean              // Return mock embedding instantly (no provider needed)  model?: string              // Model to use (e.g., 'text-embedding-3-small')  provider?: string           // Provider to use (e.g., 'openai')  maxRetries?: number         // Max retries (default: 2)  headers?: Record<string, string>           // Custom headers  providerOptions?: Record<string, any>      // Provider-specific options}

Returns

response.ts
interface EmbedResult {  embedding: number[]         // The embedding vector  value: string               // The embedded text  usage: { tokens: number }   // Token usage  model?: string  provider?: string}

embedMany()

Generate embeddings for multiple text values in batch. Optimized for RAG data preparation and bulk processing.

Parameters

types.ts
interface EmbedManyOptions {  values: string[]            // Array of texts to embed  mock?: boolean              // Return mock embeddings instantly (no provider needed)  model?: string              // Model to use  provider?: string           // Provider to use  maxParallelCalls?: number   // Max parallel requests (default: Infinity)  maxRetries?: number         // Max retries per call (default: 2)  headers?: Record<string, string>  providerOptions?: Record<string, any>}

Returns

response.ts
interface EmbedManyResult {  embeddings: number[][]      // Array of embedding vectors  values: string[]            // The embedded texts (same order)  usage: { tokens: number }   // Total token usage  model?: string  provider?: string}

WebInferClient

Advanced client for fine-grained control over requests.

Constructor

client.ts
interface WebInferClientOptions {  preferences?: {    speed?: number      // 0-1, higher = prefer faster models    quality?: number    // 0-1, higher = prefer better models    cost?: number       // 0-1, higher = prefer cheaper models    privacy?: number    // 0-1, higher = prefer local/private models  }  gatewayToken?: string  preferredTransport?: 'extension' | 'gateway' | 'daemon'}const client = new WebInferClient(options)

Mock Mode

All WebInfer methods support a mock parameter for instant responses without requiring any provider, extension, or daemon connection. This is useful for testing, UI development, and offline scenarios.

How It Works

  • generateText / streamText: Returns lorem ipsum text
  • generateObject / streamObject: Returns an object matching the provided schema
  • generateImage: Returns a placeholder image
  • embed / embedMany: Returns mock embedding vectors

Use Cases

  • UI Development: Build and test UI components without API costs
  • Unit Testing: Write tests without mocking the entire client
  • Offline Development: Work without network connectivity
  • Quick Prototyping: Rapidly iterate on integrations

Quick Start

The simplest way to use WebInfer in the browser:

speak()

Instant text-to-speech using browser TTS (Web Speech API) with fallback to cloud TTS. Works without the extension for browser voices, enhanced with cloud providers when extension is available.

Key Features

  • Works without extension - Browser TTS is available in all modern browsers
  • Fallback voice chain - Like CSS font-family, tries voices in order until one is available
  • Cloud fallback - Higher quality voices via extension when browser TTS isn't enough
  • Playback controls - Pause, resume, cancel, and wait for completion
  • User preferences - Extension stores user's preferred voice across all websites

Parameters

types.ts
interface SpeakOptions {  text: string                    // Text to speak  voice?: string | string[]       // Voice or fallback chain (like CSS font-family)  lang?: string                   // BCP-47 language tag (e.g., 'en-US')  rate?: number                   // Speaking rate: 0.1 to 10, default 1.0  pitch?: number                  // Speaking pitch: 0 to 2, default 1.0  volume?: number                 // Volume: 0 to 1, default 1.0  prefer?: 'instant' | 'quality' | 'offline'  // Voice source preference}// Special voice keywords for fallback chain:// 'default'        - User's preferred voice (from extension settings)// 'browser-default'- System's default browser voice// 'cloud-default'  - First available cloud voice// 'any'            - Any available voice

Preference Modes

  • 'instant' (default) - Browser TTS first, cloud fallback. Fast, free, works offline.
  • 'quality' - Cloud TTS first, browser fallback. Better quality voices.
  • 'offline' - Browser TTS only, error if unavailable.

Returns

response.ts
interface SpeakResult {  method: 'browser' | 'cloud'     // Which TTS was used  voice: string                   // Actual voice name used  voiceIndex: number              // Position in fallback chain (0 = first choice)  provider?: string               // Provider name if cloud was used  pause: () => void               // Pause playback  resume: () => void              // Resume playback  cancel: () => void              // Stop playback  finished: Promise<void>         // Resolves when speech ends}

getVoices()

Get all available voices from browser and cloud providers.

Returns

response.ts
interface VoiceInfo {  name: string                    // Voice name  source: 'browser' | 'cloud'     // Voice source  provider?: string               // Provider if cloud (e.g., 'openai')  lang?: string                   // Language code (e.g., 'en-US')  offlineCapable: boolean         // Works without internet  isDefault?: boolean             // Default for its source}

generateSpeech()

Generate speech audio from text using cloud TTS providers. Unlike speak(), this returns audio data that you can save, manipulate, or play later.

Parameters

types.ts
interface GenerateSpeechOptions {  text: string                    // Text to convert to speech  mock?: boolean                  // Return mock audio instantly (no provider needed)  voice?: string                  // Voice ID (e.g., 'nova', 'alloy', 'shimmer')  model?: string                  // Model (e.g., 'tts-1', 'tts-1-hd', 'gpt-4o-mini-tts')  provider?: string               // Provider (e.g., 'openai', 'elevenlabs')  language?: string               // Language code  speed?: number                  // Speed: 0.25 to 4.0, default 1.0  instructions?: string           // Voice style instructions (gpt-4o-mini-tts only)  outputFormat?: 'mp3' | 'wav' | 'ogg' | 'flac' | 'aac' | 'opus' | 'pcm'}

Returns

response.ts
interface GenerateSpeechResult {  audio: {    audioData: Uint8Array         // Raw audio bytes    base64: string                // Base64-encoded audio    mimeType: string              // MIME type (e.g., 'audio/mpeg')    duration?: number             // Duration in seconds    sampleRate?: number           // Sample rate in Hz  }  model?: string  provider?: string  // Convenience methods  play?: () => Promise<void>      // Play the audio  toBlob?: () => Blob             // Get as Blob  toObjectURL?: () => string      // Get as object URL}

speak() vs generateSpeech()

Featurespeak()generateSpeech()
Works without extension✅ Yes (browser TTS)❌ Requires extension/provider
Returns audio data❌ No (plays directly)✅ Yes (Blob, base64, etc.)
Offline support✅ Yes (browser voices)❌ Requires network
Voice qualityVaries (browser/cloud)High (cloud only)
Use caseInstant playbackSave, process, or custom playback