@firebase/ai 2.1.0 → 2.2.0-canary.095c098de

package/dist/src/api.d.ts

@@ -18,14 +18,16 @@ import { FirebaseApp } from '@firebase/app';
 import { AI_TYPE } from './constants';
 import { AIService } from './service';
 import { AI, AIOptions } from './public-types';
-import { ImagenModelParams, HybridParams, ModelParams, RequestOptions } from './types';
+import { ImagenModelParams, HybridParams, ModelParams, RequestOptions, LiveModelParams } from './types';
 import { AIError } from './errors';
-import { AIModel, GenerativeModel, ImagenModel } from './models';
+import { AIModel, GenerativeModel, LiveGenerativeModel, ImagenModel } from './models';
 export { ChatSession } from './methods/chat-session';
+export { LiveSession } from './methods/live-session';
 export * from './requests/schema-builder';
 export { ImagenImageFormat } from './requests/imagen-image-format';
-export { AIModel, GenerativeModel, ImagenModel, AIError };
+export { AIModel, GenerativeModel, LiveGenerativeModel, ImagenModel, AIError };
 export { Backend, VertexAIBackend, GoogleAIBackend } from './backend';
+export { startAudioConversation, AudioConversationController, StartAudioConversationOptions } from './methods/live-session-helpers';
 declare module '@firebase/component' {
     interface NameServiceMapping {
         [AI_TYPE]: AIService;
@@ -82,3 +84,16 @@ export declare function getGenerativeModel(ai: AI, modelParams: ModelParams | Hy
  * @beta
  */
 export declare function getImagenModel(ai: AI, modelParams: ImagenModelParams, requestOptions?: RequestOptions): ImagenModel;
+/**
+ * Returns a {@link LiveGenerativeModel} class for real-time, bidirectional communication.
+ *
+ * The Live API is only supported in modern browser windows and Node >= 22.
+ *
+ * @param ai - An {@link AI} instance.
+ * @param modelParams - Parameters to use when setting up a {@link LiveSession}.
+ * @throws If the `apiKey` or `projectId` fields are missing in your
+ * Firebase config.
+ *
+ * @beta
+ */
+export declare function getLiveGenerativeModel(ai: AI, modelParams: LiveModelParams): LiveGenerativeModel;

package/dist/src/constants.d.ts

@@ -16,7 +16,7 @@
  */
 export declare const AI_TYPE = "AI";
 export declare const DEFAULT_LOCATION = "us-central1";
-export declare const DEFAULT_BASE_URL = "https://firebasevertexai.googleapis.com";
+export declare const DEFAULT_DOMAIN = "firebasevertexai.googleapis.com";
 export declare const DEFAULT_API_VERSION = "v1beta";
 export declare const PACKAGE_VERSION: string;
 export declare const LANGUAGE_TAG = "gl-js";

package/dist/src/index.d.ts

@@ -3,9 +3,10 @@
  *
  * @packageDocumentation
  */
+import { LanguageModel } from './types/language-model';
 declare global {
     interface Window {
-        [key: string]: unknown;
+        LanguageModel: LanguageModel;
     }
 }
 export * from './api';

package/dist/src/methods/chrome-adapter.d.ts

@@ -23,9 +23,9 @@ import { LanguageModel } from '../types/language-model';
  * possible.
  */
 export declare class ChromeAdapterImpl implements ChromeAdapter {
-    private languageModelProvider;
-    private mode;
-    private onDeviceParams;
+    languageModelProvider: LanguageModel;
+    mode: InferenceMode;
+    onDeviceParams: OnDeviceParams;
     static SUPPORTED_MIME_TYPES: string[];
     private isDownloading;
     private downloadPromise;
@@ -34,24 +34,25 @@ export declare class ChromeAdapterImpl implements ChromeAdapter {
     /**
      * Checks if a given request can be made on-device.
      *
-     * <ol>Encapsulates a few concerns:
-     *   <li>the mode</li>
-     *   <li>API existence</li>
-     *   <li>prompt formatting</li>
-     *   <li>model availability, including triggering download if necessary</li>
-     * </ol>
+     * Encapsulates a few concerns:
+     *   the mode
+     *   API existence
+     *   prompt formatting
+     *   model availability, including triggering download if necessary
      *
-     * <p>Pros: callers needn't be concerned with details of on-device availability.</p>
-     * <p>Cons: this method spans a few concerns and splits request validation from usage.
+     *
+     * Pros: callers needn't be concerned with details of on-device availability.</p>
+     * Cons: this method spans a few concerns and splits request validation from usage.
      * If instance variables weren't already part of the API, we could consider a better
-     * separation of concerns.</p>
+     * separation of concerns.
      */
     isAvailable(request: GenerateContentRequest): Promise<boolean>;
     /**
      * Generates content on device.
      *
-     * <p>This is comparable to {@link GenerativeModel.generateContent} for generating content in
-     * Cloud.</p>
+     * @remarks
+     * This is comparable to {@link GenerativeModel.generateContent} for generating content in
+     * Cloud.
      * @param request - a standard Firebase AI {@link GenerateContentRequest}
      * @returns {@link Response}, so we can reuse common response formatting.
      */
@@ -59,8 +60,9 @@ export declare class ChromeAdapterImpl implements ChromeAdapter {
     /**
      * Generates content stream on device.
      *
-     * <p>This is comparable to {@link GenerativeModel.generateContentStream} for generating content in
-     * Cloud.</p>
+     * @remarks
+     * This is comparable to {@link GenerativeModel.generateContentStream} for generating content in
+     * Cloud.
      * @param request - a standard Firebase AI {@link GenerateContentRequest}
      * @returns {@link Response}, so we can reuse common response formatting.
      */
@@ -77,11 +79,11 @@ export declare class ChromeAdapterImpl implements ChromeAdapter {
     /**
      * Triggers out-of-band download of an on-device model.
      *
-     * <p>Chrome only downloads models as needed. Chrome knows a model is needed when code calls
-     * LanguageModel.create.</p>
+     * Chrome only downloads models as needed. Chrome knows a model is needed when code calls
+     * LanguageModel.create.
      *
-     * <p>Since Chrome manages the download, the SDK can only avoid redundant download requests by
-     * tracking if a download has previously been requested.</p>
+     * Since Chrome manages the download, the SDK can only avoid redundant download requests by
+     * tracking if a download has previously been requested.
      */
     private download;
     /**
@@ -99,12 +101,12 @@ export declare class ChromeAdapterImpl implements ChromeAdapter {
     /**
      * Abstracts Chrome session creation.
      *
-     * <p>Chrome uses a multi-turn session for all inference. Firebase AI uses single-turn for all
+     * Chrome uses a multi-turn session for all inference. Firebase AI uses single-turn for all
      * inference. To map the Firebase AI API to Chrome's API, the SDK creates a new session for all
-     * inference.</p>
+     * inference.
      *
-     * <p>Chrome will remove a model from memory if it's no longer in use, so this method ensures a
-     * new session is created before an old session is destroyed.</p>
+     * Chrome will remove a model from memory if it's no longer in use, so this method ensures a
+     * new session is created before an old session is destroyed.
      */
     private createSession;
     /**
@@ -116,3 +118,7 @@ export declare class ChromeAdapterImpl implements ChromeAdapter {
      */
     private static toStreamResponse;
 }
+/**
+ * Creates a ChromeAdapterImpl on demand.
+ */
+export declare function chromeAdapterFactory(mode: InferenceMode, window?: Window, params?: OnDeviceParams): ChromeAdapterImpl | undefined;

package/dist/src/methods/live-session-helpers.d.ts

@@ -0,0 +1,154 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { LiveServerToolCall, Part } from '../types';
+import { LiveSession } from './live-session';
+/**
+ * A controller for managing an active audio conversation.
+ *
+ * @beta
+ */
+export interface AudioConversationController {
+    /**
+     * Stops the audio conversation, closes the microphone connection, and
+     * cleans up resources. Returns a promise that resolves when cleanup is complete.
+     */
+    stop: () => Promise<void>;
+}
+/**
+ * Options for {@link startAudioConversation}.
+ *
+ * @beta
+ */
+export interface StartAudioConversationOptions {
+    /**
+     * An async handler that is called when the model requests a function to be executed.
+     * The handler should perform the function call and return the result as a `Part`,
+     * which will then be sent back to the model.
+     */
+    functionCallingHandler?: (functionCalls: LiveServerToolCall['functionCalls']) => Promise<Part>;
+}
+/**
+ * Dependencies needed by the {@link AudioConversationRunner}.
+ *
+ * @internal
+ */
+interface RunnerDependencies {
+    audioContext: AudioContext;
+    mediaStream: MediaStream;
+    sourceNode: MediaStreamAudioSourceNode;
+    workletNode: AudioWorkletNode;
+}
+/**
+ * Encapsulates the core logic of an audio conversation.
+ *
+ * @internal
+ */
+export declare class AudioConversationRunner {
+    private readonly liveSession;
+    private readonly options;
+    private readonly deps;
+    /** A flag to indicate if the conversation has been stopped. */
+    private isStopped;
+    /** A deferred that contains a promise that is resolved when stop() is called, to unblock the receive loop. */
+    private readonly stopDeferred;
+    /** A promise that tracks the lifecycle of the main `runReceiveLoop`. */
+    private readonly receiveLoopPromise;
+    /** A FIFO queue of 24kHz, 16-bit PCM audio chunks received from the server. */
+    private readonly playbackQueue;
+    /** Tracks scheduled audio sources. Used to cancel scheduled audio when the model is interrupted. */
+    private scheduledSources;
+    /** A high-precision timeline pointer for scheduling gapless audio playback. */
+    private nextStartTime;
+    /** A mutex to prevent the playback processing loop from running multiple times concurrently. */
+    private isPlaybackLoopRunning;
+    constructor(liveSession: LiveSession, options: StartAudioConversationOptions, deps: RunnerDependencies);
+    /**
+     * Stops the conversation and unblocks the main receive loop.
+     */
+    stop(): Promise<void>;
+    /**
+     * Cleans up all audio resources (nodes, stream tracks, context) and marks the
+     * session as no longer in a conversation.
+     */
+    private cleanup;
+    /**
+     * Adds audio data to the queue and ensures the playback loop is running.
+     */
+    private enqueueAndPlay;
+    /**
+     * Stops all current and pending audio playback and clears the queue. This is
+     * called when the server indicates the model's speech was interrupted with
+     * `LiveServerContent.modelTurn.interrupted`.
+     */
+    private interruptPlayback;
+    /**
+     * Processes the playback queue in a loop, scheduling each chunk in a gapless sequence.
+     */
+    private processPlaybackQueue;
+    /**
+     * The main loop that listens for and processes messages from the server.
+     */
+    private runReceiveLoop;
+}
+/**
+ * Starts a real-time, bidirectional audio conversation with the model. This helper function manages
+ * the complexities of microphone access, audio recording, playback, and interruptions.
+ *
+ * @remarks Important: This function must be called in response to a user gesture
+ * (for example, a button click) to comply with {@link https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API/Best_practices#autoplay_policy | browser autoplay policies}.
+ *
+ * @example
+ * ```javascript
+ * const liveSession = await model.connect();
+ * let conversationController;
+ *
+ * // This function must be called from within a click handler.
+ * async function startConversation() {
+ *   try {
+ *     conversationController = await startAudioConversation(liveSession);
+ *   } catch (e) {
+ *     // Handle AI-specific errors
+ *     if (e instanceof AIError) {
+ *       console.error("AI Error:", e.message);
+ *     }
+ *     // Handle microphone permission and hardware errors
+ *     else if (e instanceof DOMException) {
+ *       console.error("Microphone Error:", e.message);
+ *     }
+ *     // Handle other unexpected errors
+ *     else {
+ *       console.error("An unexpected error occurred:", e);
+ *     }
+ *   }
+ * }
+ *
+ * // Later, to stop the conversation:
+ * // if (conversationController) {
+ * //   await conversationController.stop();
+ * // }
+ * ```
+ *
+ * @param liveSession - An active {@link LiveSession} instance.
+ * @param options - Configuration options for the audio conversation.
+ * @returns A `Promise` that resolves with an {@link AudioConversationController}.
+ * @throws `AIError` if the environment does not support required Web APIs (`UNSUPPORTED`), if a conversation is already active (`REQUEST_ERROR`), the session is closed (`SESSION_CLOSED`), or if an unexpected initialization error occurs (`ERROR`).
+ * @throws `DOMException` Thrown by `navigator.mediaDevices.getUserMedia()` if issues occur with microphone access, such as permissions being denied (`NotAllowedError`) or no compatible hardware being found (`NotFoundError`). See the {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia#exceptions | MDN documentation} for a full list of exceptions.
+ *
+ * @beta
+ */
+export declare function startAudioConversation(liveSession: LiveSession, options?: StartAudioConversationOptions): Promise<AudioConversationController>;
+export {};

package/dist/src/methods/live-session.d.ts

@@ -0,0 +1,90 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { GenerativeContentBlob, LiveServerContent, LiveServerToolCall, LiveServerToolCallCancellation, Part } from '../public-types';
+import { WebSocketHandler } from '../websocket';
+/**
+ * Represents an active, real-time, bidirectional conversation with the model.
+ *
+ * This class should only be instantiated by calling {@link LiveGenerativeModel.connect}.
+ *
+ * @beta
+ */
+export declare class LiveSession {
+    private webSocketHandler;
+    private serverMessages;
+    /**
+     * Indicates whether this Live session is closed.
+     *
+     * @beta
+     */
+    isClosed: boolean;
+    /**
+     * Indicates whether this Live session is being controlled by an `AudioConversationController`.
+     *
+     * @beta
+     */
+    inConversation: boolean;
+    /**
+     * @internal
+     */
+    constructor(webSocketHandler: WebSocketHandler, serverMessages: AsyncGenerator<unknown>);
+    /**
+     * Sends content to the server.
+     *
+     * @param request - The message to send to the model.
+     * @param turnComplete - Indicates if the turn is complete. Defaults to false.
+     * @throws If this session has been closed.
+     *
+     * @beta
+     */
+    send(request: string | Array<string | Part>, turnComplete?: boolean): Promise<void>;
+    /**
+     * Sends realtime input to the server.
+     *
+     * @param mediaChunks - The media chunks to send.
+     * @throws If this session has been closed.
+     *
+     * @beta
+     */
+    sendMediaChunks(mediaChunks: GenerativeContentBlob[]): Promise<void>;
+    /**
+     * Sends a stream of {@link GenerativeContentBlob}.
+     *
+     * @param mediaChunkStream - The stream of {@link GenerativeContentBlob} to send.
+     * @throws If this session has been closed.
+     *
+     * @beta
+     */
+    sendMediaStream(mediaChunkStream: ReadableStream<GenerativeContentBlob>): Promise<void>;
+    /**
+     * Yields messages received from the server.
+     * This can only be used by one consumer at a time.
+     *
+     * @returns An `AsyncGenerator` that yields server messages as they arrive.
+     * @throws If the session is already closed, or if we receive a response that we don't support.
+     *
+     * @beta
+     */
+    receive(): AsyncGenerator<LiveServerContent | LiveServerToolCall | LiveServerToolCallCancellation>;
+    /**
+     * Closes this session.
+     * All methods on this session will throw an error once this resolves.
+     *
+     * @beta
+     */
+    close(): Promise<void>;
+}

package/dist/src/models/ai-model.d.ts

@@ -33,7 +33,7 @@ export declare abstract class AIModel {
     /**
      * @internal
      */
-    protected _apiSettings: ApiSettings;
+    _apiSettings: ApiSettings;
     /**
      * Constructs a new instance of the {@link AIModel} class.
      *

package/dist/src/models/index.d.ts

@@ -16,4 +16,5 @@
  */
 export * from './ai-model';
 export * from './generative-model';
+export * from './live-generative-model';
 export * from './imagen-model';

package/dist/src/models/live-generative-model.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { AIModel } from './ai-model';
+import { LiveSession } from '../methods/live-session';
+import { AI, Content, LiveGenerationConfig, LiveModelParams, Tool, ToolConfig } from '../public-types';
+import { WebSocketHandler } from '../websocket';
+/**
+ * Class for Live generative model APIs. The Live API enables low-latency, two-way multimodal
+ * interactions with Gemini.
+ *
+ * This class should only be instantiated with {@link getLiveGenerativeModel}.
+ *
+ * @beta
+ */
+export declare class LiveGenerativeModel extends AIModel {
+    /**
+     * @internal
+     */
+    private _webSocketHandler;
+    generationConfig: LiveGenerationConfig;
+    tools?: Tool[];
+    toolConfig?: ToolConfig;
+    systemInstruction?: Content;
+    /**
+     * @internal
+     */
+    constructor(ai: AI, modelParams: LiveModelParams, 
+    /**
+     * @internal
+     */
+    _webSocketHandler: WebSocketHandler);
+    /**
+     * Starts a {@link LiveSession}.
+     *
+     * @returns A {@link LiveSession}.
+     * @throws If the connection failed to be established with the server.
+     *
+     * @beta
+     */
+    connect(): Promise<LiveSession>;
+}

package/dist/src/public-types.d.ts

@@ -35,6 +35,10 @@ export interface AI {
      * Vertex AI Gemini API (using {@link VertexAIBackend}).
      */
     backend: Backend;
+    /**
+     * Options applied to this {@link AI} instance.
+     */
+    options?: AIOptions;
     /**
      * @deprecated use `AI.backend.location` instead.
      *
@@ -83,6 +87,11 @@ export type BackendType = (typeof BackendType)[keyof typeof BackendType];
 export interface AIOptions {
     /**
      * The backend configuration to use for the AI service instance.
+     * Defaults to the Gemini Developer API backend ({@link GoogleAIBackend}).
      */
-    backend: Backend;
+    backend?: Backend;
+    /**
+     * Whether to use App Check limited use tokens. Defaults to false.
+     */
+    useLimitedUseAppCheckTokens?: boolean;
 }

package/dist/src/requests/request.d.ts

@@ -35,6 +35,12 @@ export declare class RequestUrl {
     private get modelPath();
     private get queryParams();
 }
+export declare class WebSocketUrl {
+    apiSettings: ApiSettings;
+    constructor(apiSettings: ApiSettings);
+    toString(): string;
+    private get pathname();
+}
 export declare function getHeaders(url: RequestUrl): Promise<Headers>;
 export declare function constructRequest(model: string, task: Task, apiSettings: ApiSettings, stream: boolean, body: string, requestOptions?: RequestOptions): Promise<{
     url: string;

package/dist/src/requests/response-helpers.d.ts

@@ -14,7 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { EnhancedGenerateContentResponse, FunctionCall, GenerateContentResponse, ImagenGCSImage, ImagenInlineImage, InlineDataPart } from '../types';
+import { EnhancedGenerateContentResponse, FunctionCall, GenerateContentResponse, ImagenGCSImage, ImagenInlineImage, InlineDataPart, Part } from '../types';
 /**
  * Creates an EnhancedGenerateContentResponse object that has helper functions and
  * other modifications that improve usability.
@@ -26,15 +26,19 @@ export declare function createEnhancedContentResponse(response: GenerateContentR
  */
 export declare function addHelpers(response: GenerateContentResponse): EnhancedGenerateContentResponse;
 /**
- * Returns all text found in all parts of first candidate.
+ * Returns all text from the first candidate's parts, filtering by whether
+ * `partFilter()` returns true.
+ *
+ * @param response - The `GenerateContentResponse` from which to extract text.
+ * @param partFilter - Only return `Part`s for which this returns true
  */
-export declare function getText(response: GenerateContentResponse): string;
+export declare function getText(response: GenerateContentResponse, partFilter: (part: Part) => boolean): string;
 /**
- * Returns {@link FunctionCall}s associated with first candidate.
+ * Returns every {@link FunctionCall} associated with first candidate.
  */
 export declare function getFunctionCalls(response: GenerateContentResponse): FunctionCall[] | undefined;
 /**
- * Returns {@link InlineDataPart}s in the first candidate if present.
+ * Returns every {@link InlineDataPart} in the first candidate if present.
  *
  * @internal
  */

package/dist/src/service.d.ts

@@ -15,17 +15,22 @@
  * limitations under the License.
  */
 import { FirebaseApp, _FirebaseService } from '@firebase/app';
-import { AI } from './public-types';
+import { AI, AIOptions, InferenceMode, OnDeviceParams } from './public-types';
 import { AppCheckInternalComponentName, FirebaseAppCheckInternal } from '@firebase/app-check-interop-types';
 import { Provider } from '@firebase/component';
 import { FirebaseAuthInternal, FirebaseAuthInternalName } from '@firebase/auth-interop-types';
 import { Backend } from './backend';
+import { ChromeAdapterImpl } from './methods/chrome-adapter';
 export declare class AIService implements AI, _FirebaseService {
     app: FirebaseApp;
     backend: Backend;
+    chromeAdapterFactory?: ((mode: InferenceMode, window?: Window, params?: OnDeviceParams) => ChromeAdapterImpl | undefined) | undefined;
     auth: FirebaseAuthInternal | null;
     appCheck: FirebaseAppCheckInternal | null;
+    _options?: Omit<AIOptions, 'backend'>;
     location: string;
-    constructor(app: FirebaseApp, backend: Backend, authProvider?: Provider<FirebaseAuthInternalName>, appCheckProvider?: Provider<AppCheckInternalComponentName>);
+    constructor(app: FirebaseApp, backend: Backend, authProvider?: Provider<FirebaseAuthInternalName>, appCheckProvider?: Provider<AppCheckInternalComponentName>, chromeAdapterFactory?: ((mode: InferenceMode, window?: Window, params?: OnDeviceParams) => ChromeAdapterImpl | undefined) | undefined);
     _delete(): Promise<void>;
+    set options(optionsToSet: AIOptions);
+    get options(): AIOptions | undefined;
 }

package/dist/src/types/chrome-adapter.d.ts

@@ -34,16 +34,18 @@ export interface ChromeAdapter {
     /**
      * Generates content using on-device inference.
      *
-     * <p>This is comparable to {@link GenerativeModel.generateContent} for generating
-     * content using in-cloud inference.</p>
+     * @remarks
+     * This is comparable to {@link GenerativeModel.generateContent} for generating
+     * content using in-cloud inference.
      * @param request - a standard Firebase AI {@link GenerateContentRequest}
      */
     generateContent(request: GenerateContentRequest): Promise<Response>;
     /**
      * Generates a content stream using on-device inference.
      *
-     * <p>This is comparable to {@link GenerativeModel.generateContentStream} for generating
-     * a content stream using in-cloud inference.</p>
+     * @remarks
+     * This is comparable to {@link GenerativeModel.generateContentStream} for generating
+     * a content stream using in-cloud inference.
      * @param request - a standard Firebase AI {@link GenerateContentRequest}
      */
     generateContentStream(request: GenerateContentRequest): Promise<Response>;