azure/bedrock api integration

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: 2,
+    });
+
     const response = await this.request(url, {
       method: "POST",
       body: JSON.stringify(args),

lib/handlers/stagehandAgentHandler.ts

@@ -1,17 +1,15 @@
 import {
+  ActToolResult,
   AgentAction,
   AgentExecuteOptions,
   AgentResult,
-  ActToolResult,
 } from "@/types/agent";
 import { LogLine } from "@/types/log";
-import { LLMClient } from "../llm/LLMClient";
-import { CoreMessage, wrapLanguageModel } from "ai";
-import { LanguageModel } from "ai";
-import { processMessages } from "../agent/utils/messageProcessing";
+import { CoreMessage, LanguageModel, ToolSet, wrapLanguageModel } from "ai";
 import { createAgentTools } from "../agent/tools";
-import { ToolSet } from "ai";
+import { processMessages } from "../agent/utils/messageProcessing";
 import { Stagehand } from "../index";
+import { LLMClient } from "../llm/LLMClient";
 
 export class StagehandAgentHandler {
   private stagehand: Stagehand;
@@ -280,7 +278,7 @@ STRATEGY:
 - Keep actions atomic and verify outcomes before proceeding.
 
 For each action, provide clear reasoning about why you're taking that step.
-Today's date is ${new Date().toLocaleDateString()}. You're currently on the website: ${this.stagehand.page.url}.`;
+Today's date is ${new Date().toLocaleDateString()}. You're currently on the website: ${this.stagehand.page.url()}.`;
   }
 
   private createTools() {

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,
@@ -914,11 +931,13 @@ export class Stagehand {
     ) => Promise<AgentResult>;
     setScreenshotCollector?: (collector: unknown) => void;
   } {
-    this.log({
-      category: "agent",
-      message: "Creating agent instance",
-      level: 1,
-    });
+    if (!this.usingAPI) {
+      this.log({
+        category: "agent",
+        message: "Creating agent instance",
+        level: 1,
+      });
+    }
     let agentHandler: StagehandAgentHandler | CuaAgentHandler | undefined;
     if (options?.integrations && !this.experimental) {
       throw new StagehandError(
@@ -989,7 +1008,10 @@ export class Stagehand {
           }
 
           if (!options.options) {
-            options.options = {};
+            options.options = this.modelClientOptions as Record<
+              string,
+              unknown
+            >;
           }
           if (options.provider) {
             if (options.provider === "anthropic") {

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,5 @@
-import OpenAI from "openai";
-import type { ClientOptions } from "openai";
+import { CreateChatCompletionResponseError } from "@/types/stagehandErrors";
+import OpenAI, { type ClientOptions } from "openai";
 import { zodToJsonSchema } from "zod-to-json-schema";
 import { LogLine } from "../../types/log";
 import { AvailableModel } from "../../types/model";
@@ -10,14 +10,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) {