@absolutejs/ai 0.0.50 → 0.0.52

package/dist/src/ai/providers/openrouterClient.d.ts

@@ -1,10 +1,96 @@
 export type OpenRouterClientConfig = {
     allowedModels?: readonly string[];
     apiKey?: string;
+    batchBaseUrl?: string;
     baseUrl?: string;
     fetch?: typeof globalThis.fetch;
     headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
     tokenSource?: () => Promise<string> | string;
+    /** Default workspace for APIs that accept explicit workspace selection. */
+    workspaceId?: string;
+};
+export type OpenRouterPKCE = {
+    codeChallenge: string;
+    codeChallengeMethod: "S256";
+    codeVerifier: string;
+};
+export type OpenRouterAuthorizationUrlOptions = {
+    baseUrl?: string;
+    callbackUrl?: string;
+    codeChallenge?: string;
+    codeChallengeMethod?: "S256" | "plain";
+    keyLabel?: string;
+};
+export type OpenRouterAuthCodeExchangeRequest = {
+    code: string;
+    code_challenge_method?: "S256" | "plain";
+    code_verifier?: string;
+};
+export type OpenRouterAuthCodeExchangeResponse = {
+    key: string;
+    user_id: string | null;
+};
+export type OpenRouterCreateAuthCodeRequest = {
+    callback_url: string;
+    code_challenge?: string;
+    code_challenge_method?: "S256" | "plain";
+    expires_at?: string;
+    key_label?: string;
+    limit?: number;
+    usage_limit_type?: string;
+    workspace_id?: string;
+};
+export type OpenRouterCreateAuthCodeResponse = {
+    data: {
+        app_id: number;
+        created_at: string;
+        id: string;
+    };
+};
+export type OpenRouterBatchEndpoint = "/v1/chat/completions" | "/v1/responses" | "/v1/messages" | "/v1/embeddings";
+export type OpenRouterBatchStatus = "validating" | "in_progress" | "finalizing" | "completed" | "failed" | "expired" | "cancelling" | "cancelled";
+export type OpenRouterBatchRequest = {
+    custom_id: string;
+    body: Record<string, unknown>;
+};
+export type OpenRouterBatchResult = {
+    custom_id: string;
+    id: string;
+    response?: {
+        body: Record<string, unknown>;
+        request_id: string;
+        status_code: number;
+    };
+    error?: Record<string, unknown>;
+};
+export type OpenRouterBatch = {
+    id: string;
+    endpoint: OpenRouterBatchEndpoint;
+    model: string;
+    status: OpenRouterBatchStatus;
+    completion_window?: "24h";
+    created_at?: string;
+    completed_at?: string | null;
+    request_counts?: {
+        completed: number;
+        failed: number;
+        total: number;
+    };
+    results?: OpenRouterBatchResult[];
+    usage?: {
+        completion_tokens: number;
+        cost: number;
+        is_byok: boolean;
+        prompt_tokens: number;
+        total_tokens: number;
+    };
+    [field: string]: unknown;
+};
+export type OpenRouterCreateBatchRequest = {
+    endpoint: OpenRouterBatchEndpoint;
+    model: string;
+    requests: [OpenRouterBatchRequest, ...OpenRouterBatchRequest[]];
+    completion_window?: "24h";
 };
 export type OpenRouterModel = {
     id: string;
@@ -12,13 +98,39 @@ export type OpenRouterModel = {
     description?: string;
     context_length?: number;
     architecture?: Record<string, unknown>;
-    pricing?: Record<string, string>;
+    pricing?: OpenRouterPricing;
     supported_parameters?: string[] | Record<string, unknown>;
     [field: string]: unknown;
 };
+export type OpenRouterPricingKey = "prompt" | "completion" | "request" | "image" | "web_search" | "internal_reasoning" | "input_cache_read" | "input_cache_write";
+export type OpenRouterPricing = Partial<Record<OpenRouterPricingKey, string>> & Record<string, string | undefined>;
+export type OpenRouterCostUnits = Partial<Record<OpenRouterPricingKey, number>>;
+export type OpenRouterCostEstimate = {
+    components: Partial<Record<OpenRouterPricingKey, number>>;
+    total: number;
+};
+/** Estimate USD cost using OpenRouter's per-unit model pricing fields. */
+export declare const estimateOpenRouterCost: (pricing: OpenRouterPricing, units: OpenRouterCostUnits) => OpenRouterCostEstimate;
+export declare const estimateOpenRouterModelCost: (model: Pick<OpenRouterModel, "pricing">, units: OpenRouterCostUnits) => OpenRouterCostEstimate;
 export type OpenRouterModelList = {
     data: OpenRouterModel[];
 };
+export type OpenRouterModelQuery = {
+    arch?: string;
+    context?: number;
+    distillable?: "false" | "true";
+    input_modalities?: string;
+    max_price?: number;
+    min_price?: number;
+    model_authors?: string;
+    output_modalities?: string;
+    providers?: string;
+    q?: string;
+    region?: "eu";
+    supported_parameters?: string;
+    sort?: "pricing-low-to-high" | "pricing-high-to-low" | "context-high-to-low" | "throughput-high-to-low" | "latency-low-to-high" | "most-popular" | "top-weekly" | "newest" | "intelligence-high-to-low" | "design-arena-elo-high-to-low";
+    zdr?: "true";
+};
 export type OpenRouterEmbeddingRequest = {
     model: string;
     input: string | string[] | number[] | number[][];
@@ -76,6 +188,7 @@ export type OpenRouterImageRequest = {
     seed?: number;
     input_references?: Array<Record<string, unknown>>;
     provider?: Record<string, unknown>;
+    stream?: boolean;
 };
 export type OpenRouterImageResponse = {
     created: number;
@@ -85,6 +198,24 @@ export type OpenRouterImageResponse = {
     }>;
     usage?: Record<string, number>;
 };
+export type OpenRouterImageModelEndpoint = {
+    allowed_passthrough_parameters: string[];
+    pricing: Array<{
+        billable: string;
+        cost_usd: number;
+        unit: "image" | "megapixel" | "token" | string;
+        variant?: string;
+    }>;
+    provider_name: string;
+    provider_slug: string;
+    provider_tag: string | null;
+    supported_parameters: Record<string, unknown>;
+    supports_streaming: boolean;
+};
+export type OpenRouterImageModelEndpoints = {
+    endpoints: OpenRouterImageModelEndpoint[];
+    id: string;
+};
 export type OpenRouterResponsesRequest = Record<string, unknown> & {
     input: unknown;
     model: string;
@@ -96,12 +227,263 @@ export type OpenRouterSpeechRequest = Record<string, unknown> & {
     voice: string;
 };
 export type OpenRouterTranscriptionRequest = Record<string, unknown> & {
+    input_audio: {
+        data: string;
+        format: string;
+    };
+    language?: string;
     model: string;
+    provider?: Record<string, unknown>;
+    temperature?: number;
+};
+export type OpenRouterTranscriptionResponse = {
+    text: string;
+    usage: {
+        cost: number;
+        input_tokens: number;
+        output_tokens: number;
+        seconds: number;
+        total_tokens: number;
+    };
 };
 export type OpenRouterVideoRequest = Record<string, unknown> & {
     model: string;
     prompt: string;
 };
+export type OpenRouterImageStreamEvent = Record<string, unknown> & {
+    type: string;
+    b64_json?: string;
+    media_type?: string;
+    partial_image_index?: number;
+    usage?: Record<string, number>;
+};
+export type OpenRouterFile = {
+    created_at: string;
+    downloadable: boolean;
+    filename: string;
+    id: string;
+    mime_type: string;
+    size_bytes: number;
+    type: "file";
+};
+export type OpenRouterFileList = {
+    cursor: string | null;
+    data: OpenRouterFile[];
+    first_id: string | null;
+    has_more: boolean;
+    last_id: string | null;
+};
+export type OpenRouterVideoJob = {
+    error?: string;
+    generation_id?: string | null;
+    id: string;
+    polling_url?: string;
+    status: "pending" | "in_progress" | "completed" | "failed" | "cancelled" | "expired";
+    unsigned_urls?: string[];
+    usage?: {
+        cost?: number;
+        is_byok?: boolean;
+    };
+};
+export type OpenRouterVideoWebhookEvent = {
+    created_at: string;
+    data: OpenRouterVideoJob & {
+        model?: string | null;
+    };
+    type: "video.generation.completed" | "video.generation.failed" | "video.generation.cancelled" | "video.generation.expired";
+};
+export type OpenRouterZdrEndpoint = Record<string, unknown> & {
+    context_length: number;
+    model_id: string;
+    model_name: string;
+    name: string;
+    pricing: Record<string, string>;
+    provider_name: string;
+    supported_parameters: string[];
+    tag: string;
+};
+export type OpenRouterPresetVersion = {
+    config: Record<string, unknown>;
+    created_at: string;
+    creator_id: string;
+    id: string;
+    preset_id: string;
+    system_prompt: string | null;
+    updated_at: string | null;
+    version: number;
+};
+export type OpenRouterPreset = {
+    created_at: string;
+    creator_user_id: string;
+    designated_version: OpenRouterPresetVersion;
+    designated_version_id: string;
+    description: string | null;
+    id: string;
+    name: string;
+    slug: string;
+    status: string;
+    status_updated_at: string | null;
+    updated_at: string | null;
+    workspace_id: string;
+};
+export type OpenRouterPresetResponse = {
+    data: OpenRouterPreset;
+};
+export type OpenRouterPresetVersionResponse = {
+    data: OpenRouterPresetVersion;
+};
+export type OpenRouterPresetInferenceRequest = Record<string, unknown> & {
+    model?: string;
+    models?: string[];
+};
+export type OpenRouterActivityQuery = {
+    api_key_hash?: string;
+    date?: string;
+    user_id?: string;
+    workspace_id?: string;
+};
+export type OpenRouterActivityItem = {
+    byok_usage_inference: number;
+    completion_tokens: number;
+    date: string;
+    endpoint_id: string;
+    model: string;
+    model_permaslug: string;
+    prompt_tokens: number;
+    provider_name: string;
+    reasoning_tokens: number;
+    requests: number;
+    usage: number;
+    workspace_id?: string;
+};
+export type OpenRouterAnalyticsQuery = {
+    metrics: [string, ...string[]];
+    dimensions?: string[];
+    filters?: Array<{
+        field: string;
+        operator: string;
+        value: unknown;
+    }>;
+    granularity?: string;
+    group_limit?: number;
+    limit?: number;
+    order_by?: {
+        direction: "asc" | "desc";
+        field: string;
+    };
+    time_range?: {
+        end: string;
+        start: string;
+    };
+};
+export type OpenRouterAnalyticsResponse = {
+    data: {
+        data: Record<string, unknown>[];
+        metadata: {
+            query_time_ms: number;
+            row_count: number;
+            truncated: boolean;
+        };
+    };
+};
+export type OpenRouterAnalyticsMeta = {
+    data: {
+        dimensions: Array<{
+            display_label: string;
+            name: string;
+        }>;
+        granularities: Array<{
+            display_label: string;
+            name: string;
+        }>;
+        metrics: Array<{
+            display_format: string;
+            display_label: string;
+            is_rate: boolean;
+            name: string;
+        }>;
+        operators: Array<{
+            name: string;
+            value_type: string;
+        }>;
+    };
+};
+export type OpenRouterTaskClassifications = {
+    data: {
+        as_of: string;
+        classifications: Array<{
+            category_token_share: number;
+            category_usage_share: number;
+            display_name: string;
+            macro_category: string;
+            models: Array<{
+                id: string;
+                tag_token_share: number;
+                tag_usage_share: number;
+            }>;
+            tag: string;
+            token_share: number;
+            usage_share: number;
+        }>;
+        macro_categories: Array<{
+            key: string;
+            label: string;
+            token_share: number;
+            usage_share: number;
+        }>;
+        window_days: 7;
+    };
+};
+export type OpenRouterWorkspace = {
+    created_at: string;
+    created_by: string;
+    default_image_model: string | null;
+    default_provider_sort: "price" | "throughput" | "latency" | "exacto" | null;
+    default_text_model: string | null;
+    description: string | null;
+    id: string;
+    io_logging_api_key_ids: number[] | null;
+    io_logging_sampling_rate: number;
+    is_data_discount_logging_enabled: boolean;
+    is_observability_broadcast_enabled: boolean;
+    is_observability_io_logging_enabled: boolean;
+    name: string;
+    slug: string;
+    updated_at: string | null;
+};
+export type OpenRouterWorkspaceOptions = {
+    default_image_model?: string | null;
+    default_provider_sort?: OpenRouterWorkspace["default_provider_sort"];
+    default_text_model?: string | null;
+    description?: string | null;
+    io_logging_api_key_ids?: number[] | null;
+    io_logging_sampling_rate?: number;
+    is_data_discount_logging_enabled?: boolean;
+    is_observability_broadcast_enabled?: boolean;
+    is_observability_io_logging_enabled?: boolean;
+    name?: string;
+    slug?: string;
+};
+export type OpenRouterCreateWorkspaceRequest = OpenRouterWorkspaceOptions & {
+    name: string;
+    slug: string;
+};
+export type OpenRouterWorkspaceBudgetInterval = "daily" | "weekly" | "monthly" | "lifetime";
+export type OpenRouterWorkspaceBudget = {
+    created_at: string;
+    id: string;
+    limit_usd: number;
+    reset_interval: OpenRouterWorkspaceBudgetInterval;
+    updated_at: string | null;
+    workspace_id: string;
+};
+export type OpenRouterWorkspaceMember = {
+    created_at: string;
+    id: string;
+    role: string;
+    user_id: string;
+    workspace_id: string;
+};
 export type OpenRouterHttpRequestOptions = Omit<RequestInit, "body" | "headers"> & {
     body?: unknown;
     headers?: HeadersInit;
@@ -109,28 +491,104 @@ export type OpenRouterHttpRequestOptions = Omit<RequestInit, "body" | "headers">
 };
 export type OpenRouterClient = ReturnType<typeof createOpenRouterClient>;
 export declare const openRouterModelMatchesRule: (model: string, rule: string) => boolean;
+export declare const generateOpenRouterPKCE: () => Promise<OpenRouterPKCE>;
+export declare const createOpenRouterAuthorizationUrl: (options?: OpenRouterAuthorizationUrlOptions) => string;
+/** Exchange a single-use OAuth code. This endpoint intentionally has no API-key authentication. */
+export declare const exchangeOpenRouterAuthCode: (body: OpenRouterAuthCodeExchangeRequest, options?: {
+    baseUrl?: string;
+    fetch?: typeof globalThis.fetch;
+}) => Promise<OpenRouterAuthCodeExchangeResponse>;
+export declare const createOpenRouterKeyLinks: (key: string, siteUrl?: string) => Promise<{
+    hash: string;
+    logsUrl: string;
+    settingsUrl: string;
+}>;
+/** Verify `X-OpenRouter-Signature` against the exact raw webhook bytes. */
+export declare const verifyOpenRouterWebhookSignature: (options: {
+    body: string | Uint8Array;
+    header: string;
+    secret: string;
+    nowSeconds?: number;
+    toleranceSeconds?: number;
+}) => Promise<boolean>;
 export declare const createOpenRouterClient: (config: OpenRouterClientConfig) => {
-    cancelBatch: (id: string) => Promise<Record<string, unknown>>;
-    createBatch: (body: Record<string, unknown>) => Promise<Record<string, unknown>>;
+    addWorkspaceMembers: (id: string, userIds: readonly string[]) => Promise<{
+        added_count: number;
+        data: OpenRouterWorkspaceMember[];
+    }>;
+    createAuthCode: (body: OpenRouterCreateAuthCodeRequest) => Promise<OpenRouterCreateAuthCodeResponse>;
+    createPresetFromChatCompletions: (slug: string, body: OpenRouterPresetInferenceRequest) => Promise<OpenRouterPresetResponse>;
+    createPresetFromMessages: (slug: string, body: OpenRouterPresetInferenceRequest) => Promise<OpenRouterPresetResponse>;
+    createPresetFromResponses: (slug: string, body: OpenRouterPresetInferenceRequest) => Promise<OpenRouterPresetResponse>;
+    createWorkspace: (body: OpenRouterCreateWorkspaceRequest) => Promise<{
+        data: OpenRouterWorkspace;
+    }>;
+    createBatch: (body: OpenRouterCreateBatchRequest) => Promise<OpenRouterBatch>;
     createEmbedding: (body: OpenRouterEmbeddingRequest) => Promise<OpenRouterEmbeddingResponse>;
     generateImage: (body: OpenRouterImageRequest) => Promise<OpenRouterImageResponse>;
-    generateVideo: (body: OpenRouterVideoRequest) => Promise<Record<string, unknown>>;
-    getBatch: (id: string) => Promise<Record<string, unknown>>;
+    deleteFile: (id: string, workspaceId?: string | undefined) => Promise<{
+        id: string;
+        type: "file_deleted";
+    }>;
+    deleteWorkspace: (id: string) => Promise<{
+        deleted: true;
+    }>;
+    deleteWorkspaceBudget: (id: string, interval: OpenRouterWorkspaceBudgetInterval) => Promise<{
+        deleted: true;
+    }>;
+    downloadFile: (id: string, workspaceId?: string | undefined) => Promise<Response>;
+    downloadVideo: (id: string, index?: number) => Promise<Response>;
+    generateVideo: (body: OpenRouterVideoRequest) => Promise<OpenRouterVideoJob>;
+    getBatch: (id: string) => Promise<OpenRouterBatch>;
+    getActivity: (query?: OpenRouterActivityQuery) => Promise<{
+        data: OpenRouterActivityItem[];
+    }>;
+    getAnalyticsMeta: () => Promise<OpenRouterAnalyticsMeta>;
     getCredits: () => Promise<{
         data: Record<string, number>;
     }>;
     getCurrentKey: () => Promise<{
         data: Record<string, unknown>;
     }>;
+    getFile: (id: string, workspaceId?: string | undefined) => Promise<OpenRouterFile>;
     getGeneration: (id: string) => Promise<{
         data: Record<string, unknown>;
     }>;
+    getGenerationContent: (id: string) => Promise<Record<string, unknown>>;
     getModelEndpoints: (model: string) => Promise<Record<string, unknown>>;
-    getVideo: (id: string) => Promise<Record<string, unknown>>;
+    getModel: (model: string) => Promise<{
+        data: OpenRouterModel;
+    }>;
+    getImageModelEndpoints: (model: string) => Promise<OpenRouterImageModelEndpoints>;
+    getPreset: (slug: string) => Promise<OpenRouterPresetResponse>;
+    getPresetVersion: (slug: string, version: number | string) => Promise<OpenRouterPresetVersionResponse>;
+    getTaskClassifications: (window?: "7d") => Promise<OpenRouterTaskClassifications>;
+    getVideo: (id: string) => Promise<OpenRouterVideoJob>;
+    getWorkspace: (id: string) => Promise<{
+        data: OpenRouterWorkspace;
+    }>;
     listImageModels: () => Promise<OpenRouterModelList>;
-    listModels: (query?: OpenRouterHttpRequestOptions["query"]) => Promise<OpenRouterModelList>;
+    listFiles: (query?: {
+        cursor?: string;
+        limit?: number;
+        workspace_id?: string;
+    }) => Promise<OpenRouterFileList>;
+    listModels: (query?: OpenRouterModelQuery) => Promise<OpenRouterModelList>;
+    listUserModels: () => Promise<OpenRouterModelList>;
+    listZdrEndpoints: () => Promise<{
+        data: OpenRouterZdrEndpoint[];
+    }>;
+    countModels: (outputModalities?: string) => Promise<{
+        data: {
+            count: number;
+        };
+    }>;
     listPresets: (offset?: number, limit?: number) => Promise<{
-        data: Record<string, unknown>[];
+        data: OpenRouterPreset[];
+        total_count: number;
+    }>;
+    listPresetVersions: (slug: string, offset?: number, limit?: number) => Promise<{
+        data: OpenRouterPresetVersion[];
         total_count: number;
     }>;
     listProviders: () => Promise<{
@@ -138,10 +596,38 @@ export declare const createOpenRouterClient: (config: OpenRouterClientConfig) =>
     }>;
     listRerankModels: () => Promise<OpenRouterModelList>;
     listVideoModels: () => Promise<OpenRouterModelList>;
+    listWorkspaceBudgets: (id: string) => Promise<{
+        data: OpenRouterWorkspaceBudget[];
+    }>;
+    listWorkspaces: (offset?: number, limit?: number) => Promise<{
+        data: OpenRouterWorkspace[];
+        total_count: number;
+    }>;
+    queryAnalytics: (body: OpenRouterAnalyticsQuery) => Promise<OpenRouterAnalyticsResponse>;
+    removeWorkspaceMembers: (id: string, userIds: readonly string[]) => Promise<{
+        data: OpenRouterWorkspaceMember[];
+        removed_count: number;
+    }>;
     request: <T>(path: string, options?: OpenRouterHttpRequestOptions) => Promise<T>;
     requestRaw: (path: string, options?: OpenRouterHttpRequestOptions) => Promise<Response>;
+    streamImage: (body: Omit<OpenRouterImageRequest, "stream">, options?: Omit<OpenRouterHttpRequestOptions, "body" | "method">) => AsyncGenerator<OpenRouterImageStreamEvent, void, any>;
     respond: (body: OpenRouterResponsesRequest) => Promise<Response> | Promise<Record<string, unknown>>;
     rerank: (body: OpenRouterRerankRequest) => Promise<OpenRouterRerankResponse>;
     speak: (body: OpenRouterSpeechRequest) => Promise<Response>;
-    transcribe: (body: OpenRouterTranscriptionRequest | FormData) => Promise<Record<string, unknown>>;
+    transcribe: (body: OpenRouterTranscriptionRequest | FormData) => Promise<OpenRouterTranscriptionResponse>;
+    uploadFile: (file: Blob, options?: {
+        filename?: string;
+        workspaceId?: string;
+    }) => Promise<OpenRouterFile>;
+    updateWorkspace: (id: string, body: OpenRouterWorkspaceOptions) => Promise<{
+        data: OpenRouterWorkspace;
+    }>;
+    upsertWorkspaceBudget: (id: string, interval: OpenRouterWorkspaceBudgetInterval, limitUsd: number) => Promise<{
+        data: OpenRouterWorkspaceBudget;
+    }>;
+    waitForBatch: (id: string, options?: {
+        intervalMs?: number;
+        signal?: AbortSignal;
+        timeoutMs?: number;
+    }) => Promise<OpenRouterBatch>;
 };

package/dist/src/ai/streamAIWithTools.d.ts

@@ -23,6 +23,12 @@ export type StreamAIWithToolsEvent = {
 } | {
     type: "text";
     content: string;
+} | {
+    type: "audio";
+    data: string;
+    format: string;
+    transcript?: string;
+    audioId?: string;
 }
 /** A model turn finished streaming — carries that turn's own usage, so
  *  metering can bill per-turn instead of waiting for the summed total. */

package/dist/svelte/ai/index.js

@@ -106,6 +106,16 @@ var serverMessageToAction = (message) => {
         revisedPrompt: message.revisedPrompt,
         type: "image"
       };
+    case "audio":
+      return {
+        audioId: message.audioId,
+        conversationId: message.conversationId,
+        data: message.data,
+        format: message.format,
+        messageId: message.messageId,
+        transcript: message.transcript,
+        type: "audio"
+      };
     case "complete":
       return {
         conversationId: message.conversationId,
@@ -181,6 +191,8 @@ var isValidAIServerMessage = (data) => {
       return "name" in data && "status" in data && "messageId" in data && "conversationId" in data;
     case "image":
       return "data" in data && typeof data.data === "string" && "format" in data && typeof data.format === "string" && "isPartial" in data && typeof data.isPartial === "boolean" && "messageId" in data && "conversationId" in data;
+    case "audio":
+      return "data" in data && typeof data.data === "string" && "format" in data && typeof data.format === "string" && "messageId" in data && "conversationId" in data;
     case "complete":
       return "messageId" in data && "conversationId" in data;
     case "turn_queued":
@@ -543,6 +555,20 @@ var handleImage = (state, action) => {
   });
   conversation.messages = [...conversation.messages];
 };
+var handleAudio = (state, action) => {
+  const conversation = getOrCreate(state, action.conversationId);
+  const message = getOrCreateAssistantMessage(conversation, action.messageId, action.conversationId);
+  message.audio = [
+    ...message.audio ?? [],
+    {
+      audioId: action.audioId,
+      data: action.data,
+      format: action.format,
+      transcript: action.transcript
+    }
+  ];
+  conversation.messages = [...conversation.messages];
+};
 var handleComplete = (state, action) => {
   const conversation = state.conversations.get(action.conversationId);
   if (conversation) {
@@ -613,6 +639,9 @@ var applyAction = (state, action) => {
     case "image":
       handleImage(state, action);
       break;
+    case "audio":
+      handleAudio(state, action);
+      break;
     case "complete":
       handleComplete(state, action);
       break;
@@ -772,5 +801,5 @@ export {
   createAIStream
 };
 
-//# debugId=1D557221A7953C4F64756E2164756E21
+//# debugId=D75F7C4E06A093F864756E2164756E21
 //# sourceMappingURL=index.js.map