@meetopenbot/stagehand 1.0.2 → 1.0.3

package/dist/index.js

@@ -1,134 +1,88 @@
-// index.ts
+// src/index.ts
+import { defineAgentPlugin } from "@meetopenbot/plugin-sdk";
+
+// src/agent.ts
 import { Stagehand } from "@browserbasehq/stagehand";
+
+// src/config.ts
 import {
-  agentOutput,
-  definePlugin,
-  shouldHandleInvoke,
-  uiWidget
+  lookupSecret,
+  readConfigModel,
+  trimmedString
 } from "@meetopenbot/plugin-sdk";
-var PROVIDER_CONFIG = {
-  openai: { label: "OpenAI", envVar: "OPENAI_API_KEY", defaultModel: "openai/gpt-4o-mini" },
-  anthropic: { label: "Anthropic", envVar: "ANTHROPIC_API_KEY", defaultModel: "anthropic/claude-sonnet-4-5-20250929" },
-  google: { label: "Google Generative AI", envVar: "GOOGLE_GENERATIVE_AI_API_KEY", defaultModel: "google/gemini-2.5-flash" }
-};
-var configSchema = {
+var pluginConfigSchema = {
   type: "object",
   properties: {
-    apiKey: { type: "string", format: "password" },
-    provider: { type: "string", enum: ["openai", "anthropic", "google"] },
-    model: { type: "string" },
-    env: { type: "string", enum: ["LOCAL", "BROWSERBASE"] },
-    browserbaseApiKey: { type: "string", format: "password" },
-    browserbaseProjectId: { type: "string" },
-    headless: { type: "boolean", default: true },
-    maxSteps: { type: "integer", default: 25 },
-    mode: { type: "string", enum: ["dom", "hybrid", "cua"] }
+    env: { type: "string", enum: ["LOCAL", "BROWSERBASE"], description: "Browser environment." }
   }
 };
-var plugin = definePlugin({
-  name: "Stagehand",
-  description: "Stagehand AI browser automation",
-  configSchema,
-  factory: (context) => (builder) => {
-    const env = process.env ?? {};
-    builder.on("agent:invoke", async function* (event) {
-      if (!shouldHandleInvoke(event, context.agentId)) return;
-      const content = event.data?.content;
-      const threadId = event.meta?.threadId;
-      if (!content) return;
-      const config = context.config;
-      const requestedEnv = config.env || (env.BROWSERBASE_API_KEY ? "BROWSERBASE" : "LOCAL");
-      const provider = config.provider || "openai";
-      const pConfig = PROVIDER_CONFIG[provider] || PROVIDER_CONFIG.openai;
-      const apiKey = config.apiKey || env[pConfig.envVar];
-      const model = config.model || pConfig.defaultModel;
-      if (!apiKey && requestedEnv === "LOCAL") {
-        yield uiWidget({
-          agentId: context.agentId,
-          threadId,
-          widget: {
-            widgetId: `stagehand_api_key_${Date.now()}`,
-            kind: "form",
-            title: "API Key Required",
-            description: `Stagehand needs an API key for ${pConfig.label}.`,
-            fields: [
-              { id: "provider", label: "Provider", type: "select", options: Object.entries(PROVIDER_CONFIG).map(([k, v]) => ({ value: k, label: v.label })), defaultValue: provider, required: true },
-              { id: "apiKey", label: "API Key", type: "text", required: true }
-            ],
-            submitLabel: "Save Key",
-            metadata: { type: "api_key_request" }
-          }
-        });
-        return;
-      }
-      let stagehand = null;
-      try {
-        yield agentOutput({ agentId: context.agentId, threadId, content: `Starting Stagehand (${requestedEnv.toLowerCase()})...` });
-        stagehand = new Stagehand({
-          env: requestedEnv,
-          model: apiKey ? { modelName: model, apiKey } : model,
-          apiKey: config.browserbaseApiKey ?? env.BROWSERBASE_API_KEY,
-          projectId: config.browserbaseProjectId ?? env.BROWSERBASE_PROJECT_ID,
-          localBrowserLaunchOptions: { headless: config.headless ?? true },
-          experimental: true
-        });
-        await stagehand.init();
-        const agent = stagehand.agent({
-          systemPrompt: context.agentDetails?.instructions ?? void 0,
-          mode: config.mode,
-          stream: true
-        });
-        const streamResult = await agent.execute({
-          instruction: content,
-          maxSteps: config.maxSteps ?? 25
-        });
-        for await (const part of streamResult.fullStream) {
-          if (part.type === "tool-call") {
-            yield agentOutput({
-              agentId: context.agentId,
-              threadId,
-              content: `
-> [Tool Call] ${part.toolName}: ${JSON.stringify(part.input, null, 2)}
-`
-            });
-          }
-          if (part.type === "tool-result") {
-            yield agentOutput({
-              agentId: context.agentId,
-              threadId,
-              content: `
-> [Tool Result] ${part.toolName}: ${JSON.stringify(part.output, null, 2).slice(0, 800)}
-`
-            });
-          }
-        }
-        const result = await streamResult.result;
-        if (result.message) yield agentOutput({ agentId: context.agentId, threadId, content: result.message });
-        if (result.output && Object.keys(result.output).length > 0) {
-          yield agentOutput({ agentId: context.agentId, threadId, content: "```json\n" + JSON.stringify(result.output, null, 2) + "\n```" });
-        }
-      } catch (error) {
-        yield agentOutput({ agentId: context.agentId, threadId, content: `Error: ${error.message}` });
-      } finally {
-        if (stagehand) await stagehand.close().catch(() => {
-        });
-      }
+function resolveStagehandConfig(config) {
+  const browserbaseApiKey = lookupSecret({ envKeys: ["BROWSERBASE_API_KEY"] });
+  const requestedEnv = trimmedString(config.env) || (browserbaseApiKey ? "BROWSERBASE" : "LOCAL");
+  return {
+    requestedEnv,
+    model: readConfigModel(config, "openai/gpt-4o-mini"),
+    apiKey: lookupSecret({ envKeys: ["OPENAI_API_KEY"] }),
+    browserbaseApiKey,
+    browserbaseProjectId: lookupSecret({ envKeys: ["BROWSERBASE_PROJECT_ID"] }),
+    headless: true,
+    maxSteps: 25
+  };
+}
+
+// src/agent.ts
+async function runStagehandTurn({ prompt, context }) {
+  const config = resolveStagehandConfig(context.config);
+  if (config.requestedEnv === "BROWSERBASE" && (!config.browserbaseApiKey || !config.browserbaseProjectId)) {
+    return "Stagehand Browserbase setup is incomplete. Set `BROWSERBASE_API_KEY` and `BROWSERBASE_PROJECT_ID` in workspace settings.";
+  }
+  if (config.requestedEnv === "LOCAL" && !config.apiKey) {
+    return "Stagehand local setup is incomplete. Set `OPENAI_API_KEY` in workspace settings.";
+  }
+  let stagehand = null;
+  try {
+    stagehand = new Stagehand({
+      env: config.requestedEnv,
+      model: config.apiKey ? { modelName: config.model, apiKey: config.apiKey } : config.model,
+      apiKey: config.browserbaseApiKey,
+      projectId: config.browserbaseProjectId,
+      localBrowserLaunchOptions: { headless: config.headless },
+      experimental: true
     });
-    builder.on("client:ui:widget:response", async function* (event) {
-      const { metadata, values, widgetId } = event.data ?? {};
-      if (metadata?.type !== "api_key_request") return;
-      const provider = values?.provider;
-      const apiKey = values?.apiKey;
-      const pConfig = PROVIDER_CONFIG[provider];
-      if (pConfig && apiKey) {
-        await context.storage.createVariable({ key: pConfig.envVar, value: apiKey, secret: true });
-        env[pConfig.envVar] = apiKey;
-        yield uiWidget({ agentId: context.agentId, widget: { widgetId, kind: "message", title: "Success", body: "API key saved. Please retry your request.", state: "submitted", actions: [{ id: "ok", label: "OK" }] } });
-      }
+    await stagehand.init();
+    const agent = stagehand.agent({
+      systemPrompt: context.agentDetails?.instructions ?? void 0,
+      stream: true
+    });
+    const streamResult = await agent.execute({
+      instruction: prompt,
+      maxSteps: config.maxSteps
+    });
+    for await (const _part of streamResult.fullStream) {
+    }
+    const result = await streamResult.result;
+    const parts = [];
+    if (result.message) parts.push(result.message);
+    if (result.output && Object.keys(result.output).length > 0) {
+      parts.push(JSON.stringify(result.output, null, 2));
+    }
+    return parts.join("\n\n");
+  } finally {
+    if (stagehand) await stagehand.close().catch(() => {
     });
   }
+}
+
+// src/index.ts
+var plugin = await defineAgentPlugin({
+  name: "Stagehand",
+  description: "Stagehand AI browser automation",
+  models: { providers: ["openai"], default: "openai/gpt-4o-mini" },
+  configSchema: pluginConfigSchema,
+  run: runStagehandTurn
 });
-var plugin_stagehand_default = plugin;
+var src_default = plugin;
 export {
-  plugin_stagehand_default as default
+  src_default as default,
+  plugin
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meetopenbot/stagehand",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "type": "module",
   "description": "Stagehand AI browser automation plugin for OpenBot",
   "main": "./dist/index.js",
@@ -24,7 +24,7 @@
     "@browserbasehq/stagehand": "^3.3.0",
     "playwright": "^1.52.0",
     "zod": "^4.3.5",
-    "@meetopenbot/plugin-sdk": "^0.2.0"
+    "@meetopenbot/plugin-sdk": "^0.3.0"
   },
   "devDependencies": {
     "@types/node": "^20.10.1",
@@ -32,9 +32,9 @@
   },
   "types": "./dist/index.d.ts",
   "scripts": {
-    "build": "esbuild index.ts --bundle --platform=node --target=node18 --format=esm --packages=external --outfile=dist/index.js && node ../../scripts/write-plugin-declaration.mjs",
+    "build": "esbuild src/index.ts --bundle --platform=node --target=node18 --format=esm --packages=external --outfile=dist/index.js && node ../../scripts/write-plugin-declaration.mjs",
     "setup:browser": "playwright install chromium",
-    "dev": "esbuild index.ts --bundle --platform=node --target=node18 --format=esm --packages=external --outfile=dist/index.js --watch",
-    "typecheck": "tsc --noEmit --allowImportingTsExtensions --module ESNext --moduleResolution Bundler --target ES2022 --skipLibCheck index.ts"
+    "dev": "esbuild src/index.ts --bundle --platform=node --target=node18 --format=esm --packages=external --outfile=dist/index.js --watch",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
   }
 }