azure/bedrock api integration

CHANGELOG.md

@@ -233,15 +233,13 @@
   We're thrilled to announce the release of Stagehand 2.0, bringing significant improvements to make browser automation more powerful, faster, and easier to use than ever before.
 
   ### 🚀 New Features
-
   - **Introducing `stagehand.agent`**: A powerful new way to integrate SOTA Computer use models or Browserbase's [Open Operator](https://operator.browserbase.com) into Stagehand with one line of code! Perfect for multi-step workflows and complex interactions. [Learn more](https://docs.stagehand.dev/concepts/agent)
   - **Lightning-fast `act` and `extract`**: Major performance improvements to make your automations run significantly faster.
   - **Enhanced Logging**: Better visibility into what's happening during automation with improved logging and debugging capabilities.
   - **Comprehensive Documentation**: A completely revamped documentation site with better examples, guides, and best practices.
   - **Improved Error Handling**: More descriptive errors and better error recovery to help you debug issues faster.
 
   ### 🛠️ Developer Experience
-
   - **Better TypeScript Support**: Enhanced type definitions and better IDE integration
   - **Better Error Messages**: Clearer, more actionable error messages to help you debug faster
   - **Improved Caching**: More reliable action caching for better performance
@@ -502,7 +500,6 @@
 - [#316](https://github.com/browserbase/stagehand/pull/316) [`902e633`](https://github.com/browserbase/stagehand/commit/902e633e126a58b80b757ea0ecada01a7675a473) Thanks [@kamath](https://github.com/kamath)! - rename browserbaseResumeSessionID -> browserbaseSessionID
 
 - [#296](https://github.com/browserbase/stagehand/pull/296) [`f11da27`](https://github.com/browserbase/stagehand/commit/f11da27a20409c240ceeea2003d520f676def61a) Thanks [@kamath](https://github.com/kamath)! - - Deprecate fields in `init` in favor of constructor options
-
   - Deprecate `initFromPage` in favor of `browserbaseResumeSessionID` in constructor
   - Rename `browserBaseSessionCreateParams` -> `browserbaseSessionCreateParams`
 

examples/example-bedrock.ts

@@ -0,0 +1,101 @@
+import { Stagehand } from "@browserbasehq/stagehand";
+import { z } from "zod/v3";
+
+/**
+ * AWS Bedrock Integration Example for Stagehand
+ *
+ * This example demonstrates how to use Stagehand with AWS Bedrock models.
+ * Anthropic models work best for advanced features like structured extraction
+ * and observation, while OpenAI models work well for navigation and basic operations.
+ *
+ * SETUP:
+ *
+ * 1. Enable model access in AWS Bedrock Console:
+ *    - Visit: https://console.aws.amazon.com/bedrock/
+ *    - Go to "Model access" → "Enable model access"
+ *    - Enable desired models (e.g., Anthropic Claude, OpenAI models)
+ *    - Wait for approval
+ *
+ * 2. Authentication (choose one):
+ *
+ *    Option A - Bearer Token:
+ *    ```
+ *    AWS_BEARER_TOKEN_BEDROCK=bedrock-api-key-[your-base64-token]
+ *    ```
+ *
+ *    Option B - Standard AWS Credentials:
+ *    ```
+ *    AWS_ACCESS_KEY_ID=your-access-key
+ *    AWS_SECRET_ACCESS_KEY=your-secret-key
+ *    ```
+ *
+ * 3. Set region and model:
+ *    ```
+ *    AWS_REGION=us-east-1
+ *    ```
+ *
+ * RECOMMENDED MODELS:
+ * - anthropic.claude-3-5-sonnet-20240620-v1:0 (best for extraction/observation)
+ * - anthropic.claude-3-haiku-20240307-v1:0 (faster, good for basic tasks)
+ * - openai.gpt-oss-120b-1:0 (good for navigation and simple operations)
+ */
+
+async function runBedrockExample() {
+  // Initialize Stagehand with AWS Bedrock
+  const stagehand = new Stagehand({
+    env: "BROWSERBASE",
+    modelName: "bedrock/us.anthropic.claude-sonnet-4-20250514-v1:0",
+    modelClientOptions: {
+      region: "us-west-2", // Will use environment variables if not specified
+    },
+  });
+
+  try {
+    await stagehand.init();
+    const page = stagehand.page;
+
+    console.log("🚀 Stagehand initialized with AWS Bedrock");
+
+    // Navigate to a website
+    await page.goto("https://example.com");
+    console.log("📄 Navigated to example.com");
+
+    // Perform actions on the page
+    await page.act("click the link");
+    console.log("🎯 Clicked the 'More information...' link");
+
+    // Extract structured data
+    const pageInfo = await page.extract({
+      instruction: "Extract the page title and text",
+      schema: z.object({
+        title: z.string(),
+        text: z.string(),
+      }),
+    });
+
+    console.log("📊 Extracted data:", pageInfo);
+
+    // Observe elements on the page
+    const elements = await page.observe();
+    console.log(`👀 Found ${elements.length} interactive elements`);
+
+    console.log("✅ AWS Bedrock example completed successfully!");
+  } catch (error) {
+    console.error("❌ Error:", error);
+
+    // Common troubleshooting hints
+    if (error.message?.includes("access")) {
+      console.error("💡 Check model access in AWS Bedrock Console");
+    } else if (
+      error.message?.includes("credentials") ||
+      error.message?.includes("authentication")
+    ) {
+      console.error("💡 Verify your AWS credentials are set correctly");
+    }
+  } finally {
+    await stagehand.close();
+  }
+}
+
+// Run the example
+runBedrockExample();

lib/StagehandPage.ts

@@ -747,6 +747,7 @@ ${scriptContent} \
             const result = await this.api.act({
               ...observeResult,
               frameId: this.rootFrameId,
+              modelClientOptions: this.stagehand["modelClientOptions"],
             });
             this.stagehand.addToHistory("act", observeResult, result);
             return result;
@@ -783,6 +784,7 @@ ${scriptContent} \
           frameId: this.rootFrameId,
           modelClientOptions:
             modelClientOptions || this.stagehand["modelClientOptions"],
+          modelName: modelName || this.stagehand["modelName"],
         };
         const result = await this.api.act(opts);
         this.stagehand.addToHistory("act", actionOrOptions, result);
@@ -844,7 +846,10 @@ ${scriptContent} \
       if (!instructionOrOptions) {
         let result: ExtractResult<T>;
         if (this.api) {
-          result = await this.api.extract<T>({ frameId: this.rootFrameId });
+          result = await this.api.extract<T>({
+            frameId: this.rootFrameId,
+            modelClientOptions: this.stagehand["modelClientOptions"],
+          });
         } else {
           result = await this.extractHandler.extract();
         }
@@ -882,6 +887,7 @@ ${scriptContent} \
           frameId: this.rootFrameId,
           modelClientOptions:
             modelClientOptions || this.stagehand["modelClientOptions"],
+          modelName: modelName || this.stagehand["modelName"],
         };
         const result = await this.api.extract<T>(opts);
         this.stagehand.addToHistory("extract", instructionOrOptions, result);
@@ -991,6 +997,7 @@ ${scriptContent} \
           frameId: this.rootFrameId,
           modelClientOptions:
             modelClientOptions || this.stagehand["modelClientOptions"],
+          modelName: modelName || this.stagehand["modelName"],
         };
         const result = await this.api.observe(opts);
         this.stagehand.addToHistory("observe", instructionOrOptions, result);

lib/api.ts

@@ -48,7 +48,6 @@ export class StagehandAPI {
 
   async init({
     modelName,
-    modelApiKey,
     domSettleTimeoutMs,
     verbose,
     debugDom,
@@ -59,11 +58,6 @@ export class StagehandAPI {
     browserbaseSessionCreateParams,
     browserbaseSessionID,
   }: StartSessionParams): Promise<StartSessionResult> {
-    if (!modelApiKey) {
-      throw new StagehandAPIError("modelApiKey is required");
-    }
-    this.modelApiKey = modelApiKey;
-
     const region = browserbaseSessionCreateParams?.region;
     if (region && region !== "us-west-2") {
       return { sessionId: browserbaseSessionID ?? null, available: false };
@@ -191,6 +185,12 @@ export class StagehandAPI {
     const queryString = urlParams.toString();
     const url = `/sessions/${this.sessionId}/${method}${queryString ? `?${queryString}` : ""}`;
 
+    this.logger({
+      category: "execute",
+      message: `Executing ${method} with args: ${JSON.stringify(args)}`,
+      level: 1,
+    });
+
     const response = await this.request(url, {
       method: "POST",
       body: JSON.stringify(args),

lib/index.ts

@@ -45,7 +45,11 @@ import { StagehandAgentHandler } from "./handlers/stagehandAgentHandler";
 import { StagehandLogger } from "./logger";
 import { connectToMCPServer } from "./mcp/connection";
 import { resolveTools } from "./mcp/utils";
-import { isRunningInBun, loadApiKeyFromEnv } from "./utils";
+import {
+  isRunningInBun,
+  loadApiKeyFromEnv,
+  loadBedrockClientOptions,
+} from "./utils";
 
 dotenv.config({ path: ".env" });
 
@@ -588,28 +592,41 @@ export class Stagehand {
     if (!modelClientOptions?.apiKey) {
       // If no API key is provided, try to load it from the environment
       if (LLMProvider.getModelProvider(this.modelName) === "aisdk") {
-        modelApiKey = loadApiKeyFromEnv(
-          this.modelName.split("/")[0],
-          this.logger,
-        );
+        const provider = this.modelName.split("/")[0];
+
+        // Special handling for Amazon Bedrock's complex authentication
+        if (provider === "bedrock") {
+          const bedrockOptions = loadBedrockClientOptions(
+            this.logger,
+            modelClientOptions,
+          );
+          this.modelClientOptions = {
+            ...modelClientOptions,
+            ...bedrockOptions,
+          };
+        } else {
+          // Standard single API key handling for other AISDK providers
+          modelApiKey = loadApiKeyFromEnv(provider, this.logger);
+          this.modelClientOptions = {
+            ...modelClientOptions,
+            apiKey: modelApiKey,
+          };
+        }
       } else {
         // Temporary add for legacy providers
         modelApiKey =
           LLMProvider.getModelProvider(this.modelName) === "openai"
-            ? process.env.OPENAI_API_KEY ||
-              this.llmClient?.clientOptions?.apiKey
+            ? process.env.OPENAI_API_KEY
             : LLMProvider.getModelProvider(this.modelName) === "anthropic"
-              ? process.env.ANTHROPIC_API_KEY ||
-                this.llmClient?.clientOptions?.apiKey
+              ? process.env.ANTHROPIC_API_KEY
               : LLMProvider.getModelProvider(this.modelName) === "google"
-                ? process.env.GOOGLE_API_KEY ||
-                  this.llmClient?.clientOptions?.apiKey
+                ? process.env.GOOGLE_API_KEY
                 : undefined;
+        this.modelClientOptions = {
+          ...modelClientOptions,
+          apiKey: modelApiKey,
+        };
       }
-      this.modelClientOptions = {
-        ...modelClientOptions,
-        apiKey: modelApiKey,
-      };
     } else {
       this.modelClientOptions = modelClientOptions;
     }
@@ -757,7 +774,7 @@ export class Stagehand {
         logger: this.logger,
       });
 
-      const modelApiKey = this.modelClientOptions?.apiKey;
+      const modelApiKey = this.modelClientOptions?.apiKey as string;
       const { sessionId, available } = await this.apiClient.init({
         modelName: this.modelName,
         modelApiKey: modelApiKey,

lib/llm/AnthropicClient.ts

@@ -1,3 +1,4 @@
+import { CreateChatCompletionResponseError } from "@/types/stagehandErrors";
 import Anthropic, { ClientOptions } from "@anthropic-ai/sdk";
 import {
   ImageBlockParam,
@@ -14,14 +15,13 @@ import {
   LLMClient,
   LLMResponse,
 } from "./LLMClient";
-import { CreateChatCompletionResponseError } from "@/types/stagehandErrors";
 
 export class AnthropicClient extends LLMClient {
   public type = "anthropic" as const;
   private client: Anthropic;
   private cache: LLMCache | undefined;
   private enableCaching: boolean;
-  public clientOptions: ClientOptions;
+  public clientOptions?: ClientOptions;
 
   constructor({
     enableCaching = false,

lib/llm/CerebrasClient.ts

@@ -1,5 +1,6 @@
-import OpenAI from "openai";
+import { CreateChatCompletionResponseError } from "@/types/stagehandErrors";
 import type { ClientOptions } from "openai";
+import OpenAI from "openai";
 import { zodToJsonSchema } from "zod-to-json-schema";
 import { LogLine } from "../../types/log";
 import { AvailableModel } from "../../types/model";
@@ -10,14 +11,13 @@ import {
   LLMClient,
   LLMResponse,
 } from "./LLMClient";
-import { CreateChatCompletionResponseError } from "@/types/stagehandErrors";
 
 export class CerebrasClient extends LLMClient {
   public type = "cerebras" as const;
   private client: OpenAI;
   private cache: LLMCache | undefined;
   private enableCaching: boolean;
-  public clientOptions: ClientOptions;
+  public clientOptions?: ClientOptions;
   public hasVision = false;
 
   constructor({

lib/llm/GoogleClient.ts

@@ -83,7 +83,7 @@ export class GoogleClient extends LLMClient {
       clientOptions.apiKey = loadApiKeyFromEnv("google_legacy", logger);
     }
     this.clientOptions = clientOptions;
-    this.client = new GoogleGenAI({ apiKey: clientOptions.apiKey });
+    this.client = new GoogleGenAI({ apiKey: clientOptions.apiKey as string });
     this.cache = cache;
     this.enableCaching = enableCaching;
     this.modelName = modelName;

lib/llm/LLMClient.ts

@@ -13,7 +13,7 @@ import {
 } from "ai";
 import { ZodType } from "zod/v3";
 import { LogLine } from "../../types/log";
-import { AvailableModel, ClientOptions } from "../../types/model";
+import { AvailableModel } from "../../types/model";
 
 export interface ChatMessage {
   role: "system" | "user" | "assistant";
@@ -101,7 +101,6 @@ export abstract class LLMClient {
   public type: "openai" | "anthropic" | "cerebras" | "groq" | (string & {});
   public modelName: AvailableModel | (string & {});
   public hasVision: boolean;
-  public clientOptions: ClientOptions;
   public userProvidedInstructions?: string;
 
   constructor(modelName: AvailableModel, userProvidedInstructions?: string) {