@browserbasehq/orca 3.0.0-preview.0 → 3.0.0-preview.1

package/dist/lib/cache/BaseCache.d.ts

@@ -0,0 +1,66 @@
+import { LogLine } from "../../types/log";
+export interface CacheEntry {
+    timestamp: number;
+    data: unknown;
+    requestId: string;
+}
+export interface CacheStore {
+    [key: string]: CacheEntry;
+}
+export declare class BaseCache<T extends CacheEntry> {
+    private readonly CACHE_MAX_AGE_MS;
+    private readonly CLEANUP_PROBABILITY;
+    protected cacheDir: string;
+    protected cacheFile: string;
+    protected lockFile: string;
+    protected logger: (message: LogLine) => void;
+    private readonly LOCK_TIMEOUT_MS;
+    protected lockAcquired: boolean;
+    protected lockAcquireFailures: number;
+    protected requestIdToUsedHashes: {
+        [key: string]: string[];
+    };
+    constructor(logger: (message: LogLine) => void, cacheDir?: string, cacheFile?: string);
+    private setupProcessHandlers;
+    protected ensureCacheDirectory(): void;
+    protected createHash(data: unknown): string;
+    protected sleep(ms: number): Promise<void>;
+    acquireLock(): Promise<boolean>;
+    releaseLock(): void;
+    /**
+     * Cleans up stale cache entries that exceed the maximum age.
+     */
+    cleanupStaleEntries(): Promise<void>;
+    protected readCache(): CacheStore;
+    protected writeCache(cache: CacheStore): void;
+    /**
+     * Retrieves data from the cache based on the provided options.
+     * @param hashObj - The options used to generate the cache key.
+     * @param requestId - The identifier for the current request.
+     * @returns The cached data if available, otherwise null.
+     */
+    get(hashObj: Record<string, unknown> | string, requestId: string): Promise<T["data"] | null>;
+    /**
+     * Stores data in the cache based on the provided options and requestId.
+     * @param hashObj - The options used to generate the cache key.
+     * @param data - The data to be cached.
+     * @param requestId - The identifier for the cache entry.
+     */
+    set(hashObj: Record<string, unknown>, data: T["data"], requestId: string): Promise<void>;
+    delete(hashObj: Record<string, unknown>): Promise<void>;
+    /**
+     * Tracks the usage of a hash with a specific requestId.
+     * @param requestId - The identifier for the current request.
+     * @param hash - The cache key hash.
+     */
+    protected trackRequestIdUsage(requestId: string, hash: string): void;
+    /**
+     * Deletes all cache entries associated with a specific requestId.
+     * @param requestId - The identifier for the request whose cache entries should be deleted.
+     */
+    deleteCacheForRequestId(requestId: string): Promise<void>;
+    /**
+     * Resets the entire cache by clearing the cache file.
+     */
+    resetCache(): void;
+}

package/dist/lib/cache/LLMCache.d.ts

@@ -0,0 +1,22 @@
+import { BaseCache, CacheEntry } from "./BaseCache";
+export declare class LLMCache extends BaseCache<CacheEntry> {
+    constructor(logger: (message: {
+        category?: string;
+        message: string;
+        level?: number;
+    }) => void, cacheDir?: string, cacheFile?: string);
+    /**
+     * Overrides the get method to track used hashes by requestId.
+     * @param options - The options used to generate the cache key.
+     * @param requestId - The identifier for the current request.
+     * @returns The cached data if available, otherwise null.
+     */
+    get<T>(options: Record<string, unknown>, requestId: string): Promise<T | null>;
+    /**
+     * Overrides the set method to include cache cleanup logic.
+     * @param options - The options used to generate the cache key.
+     * @param data - The data to be cached.
+     * @param requestId - The identifier for the current request.
+     */
+    set(options: Record<string, unknown>, data: unknown, requestId: string): Promise<void>;
+}

package/dist/lib/cache.d.ts

@@ -0,0 +1,29 @@
+/**
+ * A file system cache to skip inference when repeating steps
+ * It also acts as the source of truth for identifying previously seen actions and observations
+ */
+declare class Cache {
+    disabled: boolean;
+    constructor({ disabled }?: {
+        disabled?: boolean;
+    });
+    readObservations(): any;
+    readActions(): any;
+    writeObservations({ key, value, }: {
+        key: string;
+        value: {
+            id: string;
+            result: string;
+        };
+    }): void;
+    writeActions({ key, value, }: {
+        key: string;
+        value: {
+            id: string;
+            result: string;
+        };
+    }): void;
+    evictCache(): void;
+    private initCache;
+}
+export default Cache;

package/dist/lib/dom/elementCheckUtils.d.ts

@@ -0,0 +1,2 @@
+export declare function isElementNode(node: Node): node is Element;
+export declare function isTextNode(node: Node): node is Text;

package/dist/lib/dom/genDomScripts.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/dom/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./process";
+export * from "./utils";

package/dist/lib/dom/process.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Finds and returns a list of scrollable elements on the page,
+ * ordered from the element with the largest scrollHeight to the smallest.
+ *
+ * @param topN Optional maximum number of scrollable elements to return.
+ *             If not provided, all found scrollable elements are returned.
+ * @returns An array of HTMLElements sorted by descending scrollHeight.
+ */
+export declare function getScrollableElements(topN?: number): HTMLElement[];
+/**
+ * Calls getScrollableElements, then for each element calls generateXPaths,
+ * and returns the first XPath for each.
+ *
+ * @param topN (optional) integer limit on how many scrollable elements to process
+ * @returns string[] list of XPaths (1 for each scrollable element)
+ */
+export declare function getScrollableElementXpaths(topN?: number): Promise<string[]>;

package/dist/lib/dom/utils.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Tests if the element actually responds to .scrollTo(...)
+ * and that scrollTop changes as expected.
+ */
+export declare function canElementScroll(elem: HTMLElement): boolean;
+export declare function getNodeFromXpath(xpath: string): Node;
+export declare function waitForElementScrollEnd(element: HTMLElement, idleMs?: number): Promise<void>;

package/dist/lib/dom/xpathUtils.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Escapes a string for use in an XPath expression.
+ * Handles special characters, including single and double quotes.
+ * @param value - The string to escape.
+ * @returns The escaped string safe for XPath.
+ */
+export declare function escapeXPathString(value: string): string;
+/**
+ * Generates both a complicated XPath and a standard XPath for a given DOM element.
+ * @param element - The target DOM element.
+ * @param documentOverride - Optional document override.
+ * @returns An object containing both XPaths.
+ */
+export declare function generateXPathsForElement(element: ChildNode): Promise<string[]>;

package/dist/lib/handlers/actHandler.d.ts

@@ -0,0 +1,33 @@
+import { LogLine } from "../../types/log";
+import { LLMClient } from "../llm/LLMClient";
+import { StagehandPage } from "../StagehandPage";
+import { ActResult, ObserveResult, ActOptions } from "@/types/stagehand";
+import { StagehandObserveHandler } from "@/lib/handlers/observeHandler";
+/**
+ * NOTE: Vision support has been removed from this version of Stagehand.
+ * If useVision or verifierUseVision is set to true, a warning is logged and
+ * the flow continues as if vision = false.
+ */
+export declare class StagehandActHandler {
+    private readonly stagehandPage;
+    private readonly logger;
+    private readonly selfHeal;
+    private readonly experimental;
+    constructor({ logger, stagehandPage, selfHeal, experimental, }: {
+        logger: (logLine: LogLine) => void;
+        stagehandPage: StagehandPage;
+        selfHeal: boolean;
+        experimental: boolean;
+    });
+    /**
+     * Perform an immediate Playwright action based on an ObserveResult object
+     * that was returned from `page.observe(...)`.
+     */
+    actFromObserveResult(observe: ObserveResult, domSettleTimeoutMs?: number): Promise<ActResult>;
+    /**
+     * Perform an act based on an instruction.
+     * This method will observe the page and then perform the act on the first element returned.
+     */
+    observeAct(actionOrOptions: ActOptions, observeHandler: StagehandObserveHandler, llmClient: LLMClient, requestId: string): Promise<ActResult>;
+    private _performPlaywrightMethod;
+}

package/dist/lib/handlers/cuaAgentHandler.d.ts

@@ -0,0 +1,58 @@
+import { AgentExecuteOptions, AgentHandlerOptions, AgentResult } from "@/types/agent";
+import { ToolSet } from "ai/dist";
+import { LogLine } from "../../types/log";
+import { StagehandPage } from "../StagehandPage";
+import { AgentClient } from "../agent/AgentClient";
+import { StagehandAgent } from "../agent/StagehandAgent";
+import { Stagehand } from "../index";
+export declare class CuaAgentHandler {
+    private stagehand;
+    private stagehandPage;
+    private agent;
+    private provider;
+    private logger;
+    private agentClient;
+    private options;
+    private screenshotCollector?;
+    private highlightCursor;
+    constructor(stagehand: Stagehand, stagehandPage: StagehandPage, logger: (message: LogLine) => void, options: AgentHandlerOptions, tools?: ToolSet);
+    private setupAgentClient;
+    /**
+     * Execute a task with the agent
+     */
+    execute(optionsOrInstruction: AgentExecuteOptions | string): Promise<AgentResult>;
+    /**
+     * Execute a single action on the page
+     */
+    private executeAction;
+    private updateClientViewport;
+    private updateClientUrl;
+    getAgent(): StagehandAgent;
+    getClient(): AgentClient;
+    captureAndSendScreenshot(): Promise<unknown>;
+    /**
+     * Inject a cursor element into the page for visual feedback
+     */
+    private injectCursor;
+    /**
+     * Update the cursor position on the page
+     */
+    private updateCursorPosition;
+    /**
+     * Animate a click at the given position
+     */
+    private animateClick;
+    private get page();
+    /**
+     * Set the screenshot collector for this agent handler
+     */
+    setScreenshotCollector(collector: any): void;
+    /**
+     * Get the screenshot collector
+     */
+    getScreenshotCollector(): any;
+    /**
+     * Set the tools for this agent handler
+     */
+    setTools(tools: ToolSet): void;
+}

package/dist/lib/handlers/extractHandler.d.ts

@@ -0,0 +1,54 @@
+import { z } from "zod/v3";
+import { ZodPathSegments } from "../../types/stagehand";
+import { LLMClient } from "../llm/LLMClient";
+import { StagehandPage } from "../StagehandPage";
+import { Stagehand } from "../index";
+export declare class StagehandExtractHandler {
+    private readonly stagehand;
+    private readonly stagehandPage;
+    private readonly logger;
+    private readonly userProvidedInstructions?;
+    private readonly experimental;
+    constructor({ stagehand, logger, stagehandPage, userProvidedInstructions, experimental, }: {
+        stagehand: Stagehand;
+        logger: (message: {
+            category?: string;
+            message: string;
+            level?: number;
+            auxiliary?: {
+                [key: string]: {
+                    value: string;
+                    type: string;
+                };
+            };
+        }) => void;
+        stagehandPage: StagehandPage;
+        userProvidedInstructions?: string;
+        experimental: boolean;
+    });
+    extract<T extends z.AnyZodObject>({ instruction, schema, content, llmClient, requestId, domSettleTimeoutMs, useTextExtract, selector, iframes, }?: {
+        instruction?: string;
+        schema?: T;
+        content?: z.infer<T>;
+        chunksSeen?: Array<number>;
+        llmClient?: LLMClient;
+        requestId?: string;
+        domSettleTimeoutMs?: number;
+        useTextExtract?: boolean;
+        selector?: string;
+        iframes?: boolean;
+    }): Promise<z.infer<T>>;
+    private extractPageText;
+    private domExtract;
+}
+/**
+ * Scans the provided Zod schema for any `z.string().url()` fields and
+ * replaces them with `z.number()`.
+ *
+ * @param schema - The Zod object schema to transform.
+ * @returns A tuple containing:
+ *   1. The transformed schema (or the original schema if no changes were needed).
+ *   2. An array of {@link ZodPathSegments} objects representing all the replaced URL fields,
+ *      with each path segment showing where in the schema the replacement occurred.
+ */
+export declare function transformUrlStringsToNumericIds<T extends z.ZodObject<z.ZodRawShape>>(schema: T): [T, ZodPathSegments[]];

package/dist/lib/handlers/handlerUtils/actHandlerUtils.d.ts

@@ -0,0 +1,21 @@
+import { Page, Locator, FrameLocator } from "playwright";
+import { MethodHandlerContext } from "@/types/act";
+export declare function deepLocatorWithShadow(root: Page | FrameLocator, xpath: string): Promise<Locator>;
+export declare function deepLocator(root: Page | FrameLocator, xpath: string): Locator;
+/**
+ * A mapping of playwright methods that may be chosen by the LLM to their
+ * implementation.
+ */
+export declare const methodHandlerMap: Record<string, (ctx: MethodHandlerContext) => Promise<void>>;
+export declare function scrollToNextChunk(ctx: MethodHandlerContext): Promise<void>;
+export declare function scrollToPreviousChunk(ctx: MethodHandlerContext): Promise<void>;
+export declare function scrollElementIntoView(ctx: MethodHandlerContext): Promise<void>;
+export declare function scrollElementToPercentage(ctx: MethodHandlerContext): Promise<void>;
+export declare function fillOrType(ctx: MethodHandlerContext): Promise<void>;
+export declare function pressKey(ctx: MethodHandlerContext): Promise<void>;
+export declare function selectOption(ctx: MethodHandlerContext): Promise<void>;
+export declare function clickElement(ctx: MethodHandlerContext): Promise<void>;
+/**
+ * Fallback method: if method is not in our map but *is* a valid Playwright locator method.
+ */
+export declare function fallbackLocatorMethod(ctx: MethodHandlerContext): Promise<void>;

package/dist/lib/handlers/observeHandler.d.ts

@@ -0,0 +1,40 @@
+import { LogLine } from "../../types/log";
+import { Stagehand } from "../index";
+import { LLMClient } from "../llm/LLMClient";
+import { StagehandPage } from "../StagehandPage";
+export declare class StagehandObserveHandler {
+    private readonly stagehand;
+    private readonly logger;
+    private readonly stagehandPage;
+    private readonly experimental;
+    private readonly userProvidedInstructions?;
+    constructor({ stagehand, logger, stagehandPage, userProvidedInstructions, experimental, }: {
+        stagehand: Stagehand;
+        logger: (logLine: LogLine) => void;
+        stagehandPage: StagehandPage;
+        userProvidedInstructions?: string;
+        experimental: boolean;
+    });
+    observe({ instruction, llmClient, requestId, returnAction, onlyVisible, drawOverlay, fromAct, iframes, }: {
+        instruction: string;
+        llmClient: LLMClient;
+        requestId: string;
+        domSettleTimeoutMs?: number;
+        returnAction?: boolean;
+        /**
+         * @deprecated The `onlyVisible` parameter has no effect in this version of Stagehand and will be removed in later versions.
+         */
+        onlyVisible?: boolean;
+        drawOverlay?: boolean;
+        fromAct?: boolean;
+        iframes?: boolean;
+    }): Promise<({
+        selector: string;
+        description: string;
+    } | {
+        selector: string;
+        method: string;
+        arguments: string[];
+        description: string;
+    })[]>;
+}

package/dist/lib/handlers/stagehandAgentHandler.d.ts

@@ -0,0 +1,27 @@
+import { AgentExecuteOptions, AgentResult } from "@/types/agent";
+import { LogLine } from "@/types/log";
+import { LLMClient } from "../llm/LLMClient";
+import { ToolSet } from "ai";
+import { Stagehand } from "../index";
+export declare class StagehandAgentHandler {
+    private stagehand;
+    private logger;
+    private llmClient;
+    private executionModel?;
+    private systemInstructions?;
+    private tools?;
+    private screenshotCollector?;
+    constructor(stagehand: Stagehand, logger: (message: LogLine) => void, llmClient: LLMClient, executionModel?: string, systemInstructions?: string, tools?: ToolSet);
+    execute(instructionOrOptions: string | AgentExecuteOptions): Promise<AgentResult>;
+    private buildSystemPrompt;
+    private createTools;
+    /**
+     * Set the screenshot collector for this agent handler
+     */
+    setScreenshotCollector(collector: any): void;
+    /**
+     * Get the screenshot collector
+     */
+    getScreenshotCollector(): any;
+    setTools(tools: ToolSet): void;
+}

package/dist/lib/index.d.ts

@@ -0,0 +1,94 @@
+import { GotoOptions } from "@/types/playwright";
+import { z } from "zod/v3";
+import { AgentExecuteOptions, AgentResult } from "../types/agent";
+import { EnhancedContext } from "../types/context";
+import { LogLine } from "../types/log";
+import { ClientOptions } from "../types/model";
+import { Page } from "../types/page";
+import { ActOptions, AgentConfig, ConstructorParams, ExtractOptions, HistoryEntry, InitResult, ObserveOptions, StagehandFunctionName, StagehandMetrics } from "../types/stagehand";
+import { StagehandPage } from "./StagehandPage";
+import { StagehandAPI } from "./api";
+import { LLMClient } from "./llm/LLMClient";
+import { LLMProvider } from "./llm/LLMProvider";
+import { connectToMCPServer } from "./mcp/connection";
+export declare class Stagehand {
+    private stagehandPage;
+    private stagehandContext;
+    browserbaseSessionID?: string;
+    readonly domSettleTimeoutMs: number;
+    readonly debugDom: boolean;
+    readonly headless: boolean;
+    verbose: 0 | 1 | 2;
+    llmProvider: LLMProvider;
+    enableCaching: boolean;
+    protected apiKey: string | undefined;
+    private projectId;
+    private externalLogger?;
+    private browserbaseSessionCreateParams?;
+    variables: {
+        [key: string]: unknown;
+    };
+    private contextPath?;
+    llmClient: LLMClient;
+    readonly userProvidedInstructions?: string;
+    private usingAPI;
+    private modelName;
+    apiClient: StagehandAPI | undefined;
+    readonly waitForCaptchaSolves: boolean;
+    private localBrowserLaunchOptions?;
+    readonly selfHeal: boolean;
+    private cleanupCalled;
+    readonly actTimeoutMs: number;
+    readonly logInferenceToFile?: boolean;
+    private stagehandLogger;
+    private disablePino;
+    protected modelClientOptions: ClientOptions;
+    private _env;
+    private _browser;
+    private _isClosed;
+    private _history;
+    readonly experimental: boolean;
+    private _livePageProxy?;
+    private createLivePageProxy;
+    get history(): ReadonlyArray<HistoryEntry>;
+    protected setActivePage(page: StagehandPage): void;
+    get page(): Page;
+    stagehandMetrics: StagehandMetrics;
+    get metrics(): StagehandMetrics;
+    get isClosed(): boolean;
+    updateMetrics(functionName: StagehandFunctionName, promptTokens: number, completionTokens: number, inferenceTimeMs: number): void;
+    private updateTotalMetrics;
+    constructor({ env, apiKey, projectId, verbose, llmProvider, llmClient, logger, browserbaseSessionCreateParams, domSettleTimeoutMs, enableCaching, browserbaseSessionID, modelName, modelClientOptions, systemPrompt, useAPI, localBrowserLaunchOptions, waitForCaptchaSolves, logInferenceToFile, selfHeal, disablePino, experimental, }?: ConstructorParams);
+    private registerSignalHandlers;
+    get logger(): (logLine: LogLine) => void;
+    get env(): "LOCAL" | "BROWSERBASE";
+    get downloadsPath(): string;
+    get context(): EnhancedContext;
+    init(): Promise<InitResult>;
+    log(logObj: LogLine): void;
+    close(): Promise<void>;
+    addToHistory(method: HistoryEntry["method"], parameters: ActOptions | ExtractOptions<z.AnyZodObject> | ObserveOptions | {
+        url: string;
+        options: GotoOptions;
+    } | string, result?: unknown): void;
+    /**
+     * Create an agent instance that can be executed with different instructions
+     * @returns An agent instance with execute() method
+     */
+    agent(options?: AgentConfig): {
+        execute: (instructionOrOptions: string | AgentExecuteOptions) => Promise<AgentResult>;
+        setScreenshotCollector?: (collector: unknown) => void;
+    };
+}
+export * from "../types/agent";
+export * from "../types/browser";
+export * from "../types/log";
+export * from "../types/model";
+export * from "../types/page";
+export * from "../types/playwright";
+export * from "../types/stagehand";
+export * from "../types/stagehandApiErrors";
+export * from "../types/stagehandErrors";
+export * from "./llm/LLMClient";
+export * from "./llm/aisdk";
+export { connectToMCPServer };

package/dist/lib/llm/AnthropicClient.d.ts

@@ -0,0 +1,21 @@
+import { ClientOptions } from "@anthropic-ai/sdk";
+import { LogLine } from "../../types/log";
+import { AvailableModel } from "../../types/model";
+import { LLMCache } from "../cache/LLMCache";
+import { CreateChatCompletionOptions, LLMClient, LLMResponse } from "./LLMClient";
+export declare class AnthropicClient extends LLMClient {
+    type: "anthropic";
+    private client;
+    private cache;
+    private enableCaching;
+    clientOptions: ClientOptions;
+    constructor({ enableCaching, cache, modelName, clientOptions, userProvidedInstructions, }: {
+        logger: (message: LogLine) => void;
+        enableCaching?: boolean;
+        cache?: LLMCache;
+        modelName: AvailableModel;
+        clientOptions?: ClientOptions;
+        userProvidedInstructions?: string;
+    });
+    createChatCompletion<T = LLMResponse>({ options, retries, logger, }: CreateChatCompletionOptions): Promise<T>;
+}

package/dist/lib/llm/CerebrasClient.d.ts

@@ -0,0 +1,22 @@
+import type { ClientOptions } from "openai";
+import { LogLine } from "../../types/log";
+import { AvailableModel } from "../../types/model";
+import { LLMCache } from "../cache/LLMCache";
+import { CreateChatCompletionOptions, LLMClient, LLMResponse } from "./LLMClient";
+export declare class CerebrasClient extends LLMClient {
+    type: "cerebras";
+    private client;
+    private cache;
+    private enableCaching;
+    clientOptions: ClientOptions;
+    hasVision: boolean;
+    constructor({ enableCaching, cache, modelName, clientOptions, userProvidedInstructions, }: {
+        logger: (message: LogLine) => void;
+        enableCaching?: boolean;
+        cache?: LLMCache;
+        modelName: AvailableModel;
+        clientOptions?: ClientOptions;
+        userProvidedInstructions?: string;
+    });
+    createChatCompletion<T = LLMResponse>({ options, retries, logger, }: CreateChatCompletionOptions): Promise<T>;
+}

package/dist/lib/llm/GoogleClient.d.ts

@@ -0,0 +1,24 @@
+import { LogLine } from "../../types/log";
+import { AvailableModel, ClientOptions } from "../../types/model";
+import { LLMCache } from "../cache/LLMCache";
+import { CreateChatCompletionOptions, LLMClient, LLMResponse } from "./LLMClient";
+export declare class GoogleClient extends LLMClient {
+    type: "google";
+    private client;
+    private cache;
+    private enableCaching;
+    clientOptions: ClientOptions;
+    hasVision: boolean;
+    private logger;
+    constructor({ logger, // Added logger based on other clients
+    enableCaching, cache, modelName, clientOptions, }: {
+        logger: (message: LogLine) => void;
+        enableCaching?: boolean;
+        cache?: LLMCache;
+        modelName: AvailableModel;
+        clientOptions?: ClientOptions;
+    });
+    private formatMessages;
+    private formatTools;
+    createChatCompletion<T = LLMResponse>({ options, logger, retries, }: CreateChatCompletionOptions): Promise<T>;
+}

package/dist/lib/llm/GroqClient.d.ts

@@ -0,0 +1,22 @@
+import type { ClientOptions } from "openai";
+import { LogLine } from "../../types/log";
+import { AvailableModel } from "../../types/model";
+import { LLMCache } from "../cache/LLMCache";
+import { CreateChatCompletionOptions, LLMClient, LLMResponse } from "./LLMClient";
+export declare class GroqClient extends LLMClient {
+    type: "groq";
+    private client;
+    private cache;
+    private enableCaching;
+    clientOptions: ClientOptions;
+    hasVision: boolean;
+    constructor({ enableCaching, cache, modelName, clientOptions, userProvidedInstructions, }: {
+        logger: (message: LogLine) => void;
+        enableCaching?: boolean;
+        cache?: LLMCache;
+        modelName: AvailableModel;
+        clientOptions?: ClientOptions;
+        userProvidedInstructions?: string;
+    });
+    createChatCompletion<T = LLMResponse>({ options, retries, logger, }: CreateChatCompletionOptions): Promise<T>;
+}