@browserbasehq/eve 0.1.0

package/README.md

@@ -0,0 +1,117 @@
+# Browserbase for Eve
+
+An [Eve extension](https://eve.dev/docs/extensions) that gives an agent
+Browserbase Search and Fetch plus a persistent Browserbase browser powered by
+[Stagehand](https://docs.stagehand.dev/). It exposes Stagehand's focused
+primitives (`act`, `observe`, and `extract`) plus navigation and autonomous agent
+tools.
+
+## Install
+
+```bash
+pnpm add @browserbasehq/eve
+```
+
+Add your credentials to the consuming Eve app:
+
+```bash
+BROWSERBASE_API_KEY=bb_live_...
+```
+
+## Mount the extension
+
+The filename under `agent/extensions/` becomes the tool namespace. Mounting the
+extension as `browserbase.ts` creates tools such as `browserbase__search`,
+`browserbase__fetch`, `browserbase__create_session`, and
+`browserbase__navigate`.
+
+```ts
+// agent/extensions/browserbase.ts
+import browserbase from '@browserbasehq/eve';
+
+export default browserbase({
+  apiKey: process.env.BROWSERBASE_API_KEY!,
+  model: 'openai/gpt-5.4-mini',
+});
+```
+
+Start Eve and give the agent a browser task:
+
+```bash
+pnpm exec eve dev
+```
+
+```text
+Open https://news.ycombinator.com and extract the titles and URLs of the first
+five stories.
+```
+
+The extension keeps the Browserbase session ID in Eve's durable per-session
+state. Each browser tool reconnects to that browser, performs one operation,
+and disconnects without terminating it. `browserbase__create_session` creates
+or reconnects the browser explicitly, and `browserbase__stop_session`
+terminates it.
+
+## Tools
+
+| Tool             | Purpose                                                 |
+| ---------------- | ------------------------------------------------------- |
+| `search`         | Find relevant public web pages with Browserbase Search. |
+| `fetch`          | Retrieve raw, markdown, or structured page content.     |
+| `create_session` | Create or reconnect the Browserbase session.            |
+| `stop_session`   | Stop the Browserbase session and release resources.     |
+| `navigate`       | Open a URL in the current browser.                      |
+| `observe`        | Find relevant elements and candidate actions.           |
+| `act`            | Perform one natural-language page interaction.          |
+| `extract`        | Return data validated against a supplied JSON Schema.   |
+| `agent`          | Run a multi-step autonomous Stagehand task.             |
+
+Use Search → Fetch → browser as an escalation path: discover sources cheaply,
+retrieve straightforward content without a session, and create a browser only
+when the page requires JavaScript or interaction. Fetch supports Browserbase's
+`raw`, `markdown`, and schema-driven `json` formats.
+
+For predictable and efficient runs, use `create_session` → `navigate` →
+`observe` → `act` or `extract`, then `stop_session`. Reserve `agent` for
+workflows that need Stagehand to plan several steps on its own.
+
+## Configuration
+
+| Option                  | Default               | Description                                         |
+| ----------------------- | --------------------- | --------------------------------------------------- |
+| `apiKey`                | required              | Browserbase API key for browsers and Model Gateway. |
+| `model`                 | `openai/gpt-5.4-mini` | Stagehand Model Gateway model identifier.           |
+| `sessionTimeoutSeconds` | `900`                 | Session timeout, from 60 to 21,600 seconds.         |
+| `proxies`               | `false`               | Enable Browserbase proxies for new sessions.        |
+
+Stagehand runs through Browserbase Model Gateway, so consumers do not need an
+OpenAI or other model-provider API key. The Browserbase API key covers both the
+browser session and Stagehand inference.
+
+The extension uses Browserbase `keepAlive` sessions so it can reconnect across
+Eve workflow steps and Vercel function invocations. Parallel browser calls made
+inside one Eve workflow step are queued in that step's managed runtime; durable
+state reconnects later steps and invocations. Close the session after the task
+to avoid leaving billable browser time running. Keep-alive availability depends
+on your Browserbase plan.
+
+## Build
+
+```bash
+nvm use
+pnpm install
+pnpm check
+```
+
+Eve requires Node.js 24 or newer. This directory's `.nvmrc` pins Node 24.16.0;
+run `nvm install 24.16.0` first if needed.
+
+`eve extension build` writes the publishable extension and type declarations to
+`dist/`.
+
+## Example agent
+
+The [`eve-example`](../../examples/integrations/vercel/eve-example/) directory
+contains a runnable Eve agent that mounts this package locally. It includes the
+agent instructions, environment template, and a Browserbase research prompt for
+a complete smoke test.

package/dist/extension/_manifest.json

@@ -0,0 +1,13 @@
+{
+  "kind": "eve-extension",
+  "formatVersion": 1,
+  "builtWithEve": "0.25.3",
+  "requires": {
+    "extension": 1,
+    "tool": 1,
+    "dynamicTool": 1,
+    "instructions": 1,
+    "config": 1,
+    "state": 1
+  }
+}

package/dist/extension/extension.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+declare const _default: import("eve/extension").ExtensionHandle<z.ZodObject<{
+    apiKey: z.ZodString;
+    model: z.ZodDefault<z.ZodString>;
+    sessionTimeoutSeconds: z.ZodDefault<z.ZodNumber>;
+    proxies: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>>;
+export default _default;

package/dist/extension/extension.mjs

@@ -0,0 +1,14 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+__eveDirname(__eveFileURLToPath(import.meta.url));
+__eveCreateRequire(import.meta.url);
+import { defineExtension } from "eve/extension";
+import { z } from "zod";
+var extension_default = defineExtension({ config: z.object({
+	apiKey: z.string().min(1),
+	model: z.string().min(1).default("openai/gpt-5.4-mini"),
+	sessionTimeoutSeconds: z.number().int().min(60).max(21600).default(900),
+	proxies: z.boolean().default(false)
+}) });
+export { extension_default as default };

package/dist/extension/instructions/browser.md

@@ -0,0 +1,9 @@
+Use Browserbase Search to discover relevant URLs and Browserbase Fetch for quick
+retrievals that do not need JavaScript or interaction. Escalate to a browser
+session when a page needs rendering or interaction: create a session, navigate,
+then use observe to plan, act for one interaction, and extract for structured
+results. Use agent only for genuinely multi-step work. Browser tools share one
+Browserbase session per Eve session. Parallel browser calls from the same Eve
+workflow step are queued within that step; later steps reconnect through durable
+state. Prefer calling tools sequentially, and stop the browser session when the
+task is complete.

package/dist/extension/lib/browserbase.d.ts

@@ -0,0 +1,2 @@
+import Browserbase from '@browserbasehq/sdk';
+export declare function createBrowserbaseClient(): Browserbase;

package/dist/extension/lib/browserbase.mjs

@@ -0,0 +1,11 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+__eveDirname(__eveFileURLToPath(import.meta.url));
+__eveCreateRequire(import.meta.url);
+import extension_default from "../extension.mjs";
+import Browserbase from "@browserbasehq/sdk";
+function createBrowserbaseClient() {
+	return new Browserbase({ apiKey: extension_default.config.apiKey });
+}
+export { createBrowserbaseClient };

package/dist/extension/lib/disconnect.d.ts

@@ -0,0 +1,5 @@
+interface ClosableStagehand {
+    close(): Promise<void>;
+}
+export declare function disconnectStagehand(stagehand: ClosableStagehand): Promise<void>;
+export {};

package/dist/extension/lib/disconnect.mjs

@@ -0,0 +1,9 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+__eveDirname(__eveFileURLToPath(import.meta.url));
+__eveCreateRequire(import.meta.url);
+async function disconnectStagehand(stagehand) {
+	await stagehand.close().catch(() => {});
+}
+export { disconnectStagehand };

package/dist/extension/lib/release-session.d.ts

@@ -0,0 +1,14 @@
+type BrowserbaseSessionStatus = 'PENDING' | 'RUNNING' | 'ERROR' | 'TIMED_OUT' | 'COMPLETED';
+interface BrowserbaseSessionRecord {
+    status: BrowserbaseSessionStatus;
+}
+interface BrowserbaseSessionApi {
+    retrieve(sessionId: string): Promise<BrowserbaseSessionRecord>;
+    update(sessionId: string, body: {
+        status: 'REQUEST_RELEASE';
+    }): Promise<BrowserbaseSessionRecord>;
+}
+export type RemoteSessionState = 'active' | 'terminal' | 'unknown';
+export declare function getRemoteSessionState(sessions: Pick<BrowserbaseSessionApi, 'retrieve'>, sessionId: string): Promise<RemoteSessionState>;
+export declare function releaseBrowserbaseSession(sessions: BrowserbaseSessionApi, sessionId: string, wait?: (milliseconds: number) => Promise<void>): Promise<void>;
+export {};

package/dist/extension/lib/release-session.mjs

@@ -0,0 +1,38 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+__eveDirname(__eveFileURLToPath(import.meta.url));
+__eveCreateRequire(import.meta.url);
+import { APIError } from "@browserbasehq/sdk";
+const RELEASE_POLL_DELAYS_MS = [
+	100,
+	250,
+	500,
+	1e3
+];
+function isActiveSessionStatus(status) {
+	return status === "PENDING" || status === "RUNNING";
+}
+async function getRemoteSessionState(sessions, sessionId) {
+	try {
+		return isActiveSessionStatus((await sessions.retrieve(sessionId)).status) ? "active" : "terminal";
+	} catch (error) {
+		return error instanceof APIError && error.status === 404 ? "terminal" : "unknown";
+	}
+}
+async function releaseBrowserbaseSession(sessions, sessionId, wait = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds))) {
+	try {
+		if (!isActiveSessionStatus((await sessions.update(sessionId, { status: "REQUEST_RELEASE" })).status)) return;
+	} catch (error) {
+		if (error instanceof APIError && error.status === 404) return;
+		throw error;
+	}
+	for (const delay of RELEASE_POLL_DELAYS_MS) {
+		await wait(delay);
+		const state = await getRemoteSessionState(sessions, sessionId);
+		if (state === "terminal") return;
+		if (state === "unknown") throw new Error(`Unable to confirm Browserbase session ${sessionId} was released.`);
+	}
+	throw new Error(`Browserbase session ${sessionId} is still active after requesting release.`);
+}
+export { getRemoteSessionState, releaseBrowserbaseSession };

package/dist/extension/lib/session-lock.d.ts

@@ -0,0 +1 @@
+export declare function withSessionLock<T>(sessionId: string, operation: () => Promise<T>): Promise<T>;

package/dist/extension/lib/session-lock.mjs

@@ -0,0 +1,22 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+__eveDirname(__eveFileURLToPath(import.meta.url));
+__eveCreateRequire(import.meta.url);
+const sessionTails = new Map();
+async function withSessionLock(sessionId, operation) {
+	const previous = sessionTails.get(sessionId) ?? Promise.resolve();
+	let release = () => {};
+	const current = new Promise((resolve) => {
+		release = resolve;
+	});
+	sessionTails.set(sessionId, current);
+	await previous;
+	try {
+		return await operation();
+	} finally {
+		release();
+		if (sessionTails.get(sessionId) === current) sessionTails.delete(sessionId);
+	}
+}
+export { withSessionLock };

package/dist/extension/lib/session-state.d.ts

@@ -0,0 +1,5 @@
+export interface BrowserSessionState {
+    id: string | null;
+    url: string | null;
+}
+export declare const browserSession: import("eve/context").StateHandle<BrowserSessionState>;

package/dist/extension/lib/session-state.mjs

@@ -0,0 +1,11 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+__eveDirname(__eveFileURLToPath(import.meta.url));
+__eveCreateRequire(import.meta.url);
+import { defineState } from "eve/context";
+const browserSession = defineState("browser-session", () => ({
+	id: null,
+	url: null
+}));
+export { browserSession };

package/dist/extension/lib/stagehand.d.ts

@@ -0,0 +1,10 @@
+import { Stagehand } from '@browserbasehq/stagehand';
+import { type BrowserSessionState } from './session-state';
+type StagehandOperation<T> = (stagehand: Stagehand) => Promise<T>;
+export interface BrowserSessionResult extends BrowserSessionState {
+    created: boolean;
+}
+export declare function withStagehand<T>(sessionId: string, operation: StagehandOperation<T>): Promise<T>;
+export declare function createBrowserSession(sessionId: string): Promise<BrowserSessionResult>;
+export declare function closeBrowserSession(sessionId: string): Promise<BrowserSessionState>;
+export {};

package/dist/extension/lib/stagehand.mjs

@@ -0,0 +1,118 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+__eveDirname(__eveFileURLToPath(import.meta.url));
+__eveCreateRequire(import.meta.url);
+import extension_default from "../extension.mjs";
+import { createBrowserbaseClient } from "./browserbase.mjs";
+import { disconnectStagehand } from "./disconnect.mjs";
+import { getRemoteSessionState, releaseBrowserbaseSession } from "./release-session.mjs";
+import { withSessionLock } from "./session-lock.mjs";
+import { browserSession } from "./session-state.mjs";
+import { Stagehand } from "@browserbasehq/stagehand";
+function createStagehand() {
+	const { apiKey, model, proxies, sessionTimeoutSeconds } = extension_default.config;
+	return new Stagehand({
+		env: "BROWSERBASE",
+		apiKey,
+		model,
+		disablePino: true,
+		keepAlive: true,
+		browserbaseSessionCreateParams: {
+			keepAlive: true,
+			timeout: sessionTimeoutSeconds,
+			proxies
+		}
+	});
+}
+function resumeStagehand(sessionId) {
+	const { apiKey, model } = extension_default.config;
+	return new Stagehand({
+		env: "BROWSERBASE",
+		apiKey,
+		model,
+		disablePino: true,
+		keepAlive: true,
+		browserbaseSessionID: sessionId
+	});
+}
+async function connect() {
+	const current = browserSession.get();
+	if (current.id) {
+		const resumed = resumeStagehand(current.id);
+		try {
+			await resumed.init();
+			return {
+				stagehand: resumed,
+				created: false
+			};
+		} catch (error) {
+			await disconnectStagehand(resumed);
+			const sessions = createBrowserbaseClient().sessions;
+			if (await getRemoteSessionState(sessions, current.id) !== "terminal") throw error;
+			browserSession.update(() => ({
+				id: null,
+				url: null
+			}));
+		}
+	}
+	const created = createStagehand();
+	try {
+		await created.init();
+	} catch (error) {
+		await disconnectStagehand(created);
+		throw error;
+	}
+	browserSession.update(() => ({
+		id: created.browserbaseSessionID ?? null,
+		url: created.browserbaseSessionURL ?? null
+	}));
+	return {
+		stagehand: created,
+		created: true
+	};
+}
+async function withStagehand(sessionId, operation) {
+	return withSessionLock(sessionId, async () => {
+		const { stagehand } = await connect();
+		try {
+			return await operation(stagehand);
+		} finally {
+			await disconnectStagehand(stagehand);
+		}
+	});
+}
+async function createBrowserSession(sessionId) {
+	return withSessionLock(sessionId, async () => {
+		const { stagehand, created } = await connect();
+		try {
+			return {
+				...browserSession.get(),
+				created
+			};
+		} finally {
+			await disconnectStagehand(stagehand);
+		}
+	});
+}
+async function closeBrowserSession(sessionId) {
+	return withSessionLock(sessionId, async () => {
+		const current = browserSession.get();
+		if (!current.id) return current;
+		const sessions = createBrowserbaseClient().sessions;
+		if (await getRemoteSessionState(sessions, current.id) === "terminal") {
+			browserSession.update(() => ({
+				id: null,
+				url: null
+			}));
+			return current;
+		}
+		await releaseBrowserbaseSession(sessions, current.id);
+		browserSession.update(() => ({
+			id: null,
+			url: null
+		}));
+		return current;
+	});
+}
+export { closeBrowserSession, createBrowserSession, withStagehand };

package/dist/extension/tools/act.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("eve/tools").ToolDefinition<{
+    instruction: string;
+}, import("@browserbasehq/stagehand").ActResult>;
+export default _default;

package/dist/extension/tools/act.mjs

@@ -0,0 +1,16 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+__eveDirname(__eveFileURLToPath(import.meta.url));
+__eveCreateRequire(import.meta.url);
+import { withStagehand } from "../lib/stagehand.mjs";
+import { z } from "zod";
+import { defineTool } from "eve/tools";
+var act_default = defineTool({
+	description: "Perform one natural-language action in the current Browserbase page with Stagehand.",
+	inputSchema: z.object({ instruction: z.string().min(1).describe("A precise single action, such as clicking or filling a field.") }),
+	async execute({ instruction }, ctx) {
+		return withStagehand(ctx.session.id, (stagehand) => stagehand.act(instruction));
+	}
+});
+export { act_default as default };

package/dist/extension/tools/agent.d.ts

@@ -0,0 +1,5 @@
+declare const _default: import("eve/tools").ToolDefinition<{
+    instruction: string;
+    maxSteps: number;
+}, import("@browserbasehq/stagehand").AgentResult>;
+export default _default;

package/dist/extension/tools/agent.mjs

@@ -0,0 +1,24 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+__eveDirname(__eveFileURLToPath(import.meta.url));
+__eveCreateRequire(import.meta.url);
+import { withStagehand } from "../lib/stagehand.mjs";
+import { z } from "zod";
+import { defineTool } from "eve/tools";
+var agent_default = defineTool({
+	description: "Run an autonomous multi-step Stagehand browser task in the current Browserbase session. Prefer act, observe, and extract for targeted work.",
+	inputSchema: z.object({
+		instruction: z.string().min(1).describe("The browser task to complete."),
+		maxSteps: z.number().int().min(1).max(50).default(20)
+	}),
+	async execute({ instruction, maxSteps }, ctx) {
+		return withStagehand(ctx.session.id, async (stagehand) => {
+			return stagehand.agent().execute({
+				instruction,
+				maxSteps
+			});
+		});
+	}
+});
+export { agent_default as default };

package/dist/extension/tools/extract.d.ts

@@ -0,0 +1,5 @@
+declare const _default: import("eve/tools").ToolDefinition<{
+    instruction: string;
+    schema: Record<string, unknown>;
+}, unknown>;
+export default _default;

package/dist/extension/tools/extract.mjs

@@ -0,0 +1,21 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+__eveDirname(__eveFileURLToPath(import.meta.url));
+__eveCreateRequire(import.meta.url);
+import { withStagehand } from "../lib/stagehand.mjs";
+import { z } from "zod";
+import { defineTool } from "eve/tools";
+const jsonSchema = z.record(z.string(), z.unknown()).describe("A JSON Schema describing the exact data shape to return.");
+var extract_default = defineTool({
+	description: "Extract structured data from the current Browserbase page with Stagehand and validate it against a JSON Schema.",
+	inputSchema: z.object({
+		instruction: z.string().min(1).describe("What data to extract."),
+		schema: jsonSchema
+	}),
+	async execute({ instruction, schema }, ctx) {
+		const outputSchema = z.fromJSONSchema(schema);
+		return withStagehand(ctx.session.id, (stagehand) => stagehand.extract(instruction, outputSchema));
+	}
+});
+export { extract_default as default };

package/dist/extension/tools/fetch.d.ts

@@ -0,0 +1,9 @@
+declare const _default: import("eve/tools").ToolDefinition<{
+    url: string;
+    format: "json" | "markdown" | "raw";
+    schema?: Record<string, unknown> | undefined;
+    allowRedirects: boolean;
+    allowInsecureSsl: boolean;
+    proxies: boolean;
+}, import("@browserbasehq/sdk/resources/fetch-api.mjs").FetchAPICreateResponse>;
+export default _default;

package/dist/extension/tools/fetch.mjs

@@ -0,0 +1,37 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+__eveDirname(__eveFileURLToPath(import.meta.url));
+__eveCreateRequire(import.meta.url);
+import { createBrowserbaseClient } from "../lib/browserbase.mjs";
+import { z } from "zod";
+import { defineTool } from "eve/tools";
+const jsonSchema = z.record(z.string(), z.unknown()).optional().describe("A JSON Schema for structured extraction. Required with the json format and invalid with other formats.");
+var fetch_default = defineTool({
+	description: "Retrieve a URL through Browserbase Fetch without starting a browser session. Use raw for the original response, markdown for agent-friendly content, or json with a schema for structured extraction.",
+	inputSchema: z.object({
+		url: z.url().describe("The absolute URL to retrieve."),
+		format: z.enum([
+			"raw",
+			"markdown",
+			"json"
+		]).default("raw").describe("The response content format."),
+		schema: jsonSchema,
+		allowRedirects: z.boolean().default(false).describe("Whether to follow HTTP redirects."),
+		allowInsecureSsl: z.boolean().default(false).describe("Whether to bypass TLS certificate verification."),
+		proxies: z.boolean().default(false).describe("Whether to route the request through Browserbase proxies.")
+	}),
+	async execute({ url, format, schema, allowRedirects, allowInsecureSsl, proxies }) {
+		if (format === "json" && !schema) throw new Error("schema is required when format is json.");
+		if (format !== "json" && schema) throw new Error("schema can only be used when format is json.");
+		return createBrowserbaseClient().fetchAPI.create({
+			url,
+			format,
+			schema,
+			allowRedirects,
+			allowInsecureSsl,
+			proxies
+		});
+	}
+});
+export { fetch_default as default };

package/dist/extension/tools/navigate.d.ts

@@ -0,0 +1,7 @@
+declare const _default: import("eve/tools").ToolDefinition<{
+    url: string;
+}, {
+    url: string;
+    title: string;
+}>;
+export default _default;

package/dist/extension/tools/navigate.mjs

@@ -0,0 +1,23 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+__eveDirname(__eveFileURLToPath(import.meta.url));
+__eveCreateRequire(import.meta.url);
+import { withStagehand } from "../lib/stagehand.mjs";
+import { z } from "zod";
+import { defineTool } from "eve/tools";
+var navigate_default = defineTool({
+	description: "Navigate the Browserbase browser to a URL. Call this before using other browser tools on a new site.",
+	inputSchema: z.object({ url: z.url().describe("The absolute URL to open.") }),
+	async execute({ url }, ctx) {
+		return withStagehand(ctx.session.id, async (stagehand) => {
+			const page = await stagehand.context.awaitActivePage();
+			await page.goto(url);
+			return {
+				url: page.url(),
+				title: await page.title()
+			};
+		});
+	}
+});
+export { navigate_default as default };

package/dist/extension/tools/observe.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("eve/tools").ToolDefinition<{
+    instruction: string;
+}, import("@browserbasehq/stagehand").Action[]>;
+export default _default;

package/dist/extension/tools/observe.mjs

@@ -0,0 +1,16 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+__eveDirname(__eveFileURLToPath(import.meta.url));
+__eveCreateRequire(import.meta.url);
+import { withStagehand } from "../lib/stagehand.mjs";
+import { z } from "zod";
+import { defineTool } from "eve/tools";
+var observe_default = defineTool({
+	description: "Inspect the current Browserbase page with Stagehand and return candidate elements and actions.",
+	inputSchema: z.object({ instruction: z.string().min(1).describe("The elements or actions to find on the page.") }),
+	async execute({ instruction }, ctx) {
+		return withStagehand(ctx.session.id, (stagehand) => stagehand.observe(instruction));
+	}
+});
+export { observe_default as default };

package/dist/extension/tools/search.d.ts

@@ -0,0 +1,5 @@
+declare const _default: import("eve/tools").ToolDefinition<{
+    query: string;
+    numResults: number;
+}, import("@browserbasehq/sdk/resources/search.mjs").SearchWebResponse>;
+export default _default;

package/dist/extension/tools/search.mjs

@@ -0,0 +1,22 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+__eveDirname(__eveFileURLToPath(import.meta.url));
+__eveCreateRequire(import.meta.url);
+import { createBrowserbaseClient } from "../lib/browserbase.mjs";
+import { z } from "zod";
+import { defineTool } from "eve/tools";
+var search_default = defineTool({
+	description: "Search the public web with Browserbase Search. Use this to discover relevant URLs before fetching content or opening a browser session.",
+	inputSchema: z.object({
+		query: z.string().min(1).max(200).describe("The web search query, from 1 to 200 characters."),
+		numResults: z.number().int().min(1).max(25).default(10).describe("The number of results to return, from 1 to 25.")
+	}),
+	async execute({ query, numResults }) {
+		return createBrowserbaseClient().search.web({
+			query,
+			numResults
+		});
+	}
+});
+export { search_default as default };

package/dist/extension/tools/session.d.ts

@@ -0,0 +1,9 @@
+declare const _default: import("eve/tools").DynamicSentinel<{
+    create_session: import("eve/tools").ToolDefinition<Record<string, never>, import("../lib/stagehand").BrowserSessionResult>;
+    stop_session: import("eve/tools").ToolDefinition<Record<string, never>, {
+        id: string | null;
+        url: string | null;
+        stopped: boolean;
+    }>;
+}>;
+export default _default;

package/dist/extension/tools/session.mjs

@@ -0,0 +1,29 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+__eveDirname(__eveFileURLToPath(import.meta.url));
+__eveCreateRequire(import.meta.url);
+import { closeBrowserSession, createBrowserSession } from "../lib/stagehand.mjs";
+import { z } from "zod";
+import { defineDynamic, defineTool } from "eve/tools";
+var session_default = defineDynamic({ events: { "session.started": () => ({
+	create_session: defineTool({
+		description: "Create a Browserbase browser session for this Eve conversation, or reconnect if one already exists.",
+		inputSchema: z.object({}),
+		async execute(_input, ctx) {
+			return createBrowserSession(ctx.session.id);
+		}
+	}),
+	stop_session: defineTool({
+		description: "Stop the Browserbase browser session for this Eve conversation and release its resources.",
+		inputSchema: z.object({}),
+		async execute(_input, ctx) {
+			const session = await closeBrowserSession(ctx.session.id);
+			return {
+				...session,
+				stopped: Boolean(session.id)
+			};
+		}
+	})
+}) } });
+export { session_default as default };

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+// Generated by eve. Do not edit by hand.
+
+export { default } from "./extension/extension.js";
+export { default as eve } from "./extension/extension.js";

package/dist/index.mjs

@@ -0,0 +1,7 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+__eveDirname(__eveFileURLToPath(import.meta.url));
+__eveCreateRequire(import.meta.url);
+import extension_default from "./extension/extension.mjs";
+export { extension_default as default, extension_default as eve };

package/dist/tools/index.d.ts

@@ -0,0 +1,10 @@
+// Generated by eve. Do not edit by hand.
+
+export { default as act } from "../extension/tools/act.js";
+export { default as agent } from "../extension/tools/agent.js";
+export { default as extract } from "../extension/tools/extract.js";
+export { default as fetch } from "../extension/tools/fetch.js";
+export { default as navigate } from "../extension/tools/navigate.js";
+export { default as observe } from "../extension/tools/observe.js";
+export { default as search } from "../extension/tools/search.js";
+export { default as session } from "../extension/tools/session.js";

package/dist/tools/index.mjs

@@ -0,0 +1,14 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+__eveDirname(__eveFileURLToPath(import.meta.url));
+__eveCreateRequire(import.meta.url);
+import act_default from "../extension/tools/act.mjs";
+import agent_default from "../extension/tools/agent.mjs";
+import extract_default from "../extension/tools/extract.mjs";
+import fetch_default from "../extension/tools/fetch.mjs";
+import navigate_default from "../extension/tools/navigate.mjs";
+import observe_default from "../extension/tools/observe.mjs";
+import search_default from "../extension/tools/search.mjs";
+import session_default from "../extension/tools/session.mjs";
+export { act_default as act, agent_default as agent, extract_default as extract, fetch_default as fetch, navigate_default as navigate, observe_default as observe, search_default as search, session_default as session };

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@browserbasehq/eve",
+  "version": "0.1.0",
+  "description": "An Eve extension that gives agents Browserbase-powered Stagehand browser tools.",
+  "type": "module",
+  "packageManager": "pnpm@10.9.0",
+  "license": "MIT",
+  "keywords": [
+    "browserbase",
+    "eve",
+    "stagehand",
+    "browser-automation",
+    "ai-agents"
+  ],
+  "eve": {
+    "extension": {
+      "source": "./extension",
+      "dist": "./dist/extension"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.mjs"
+    },
+    "./tools": {
+      "types": "./dist/tools/index.d.ts",
+      "default": "./dist/tools/index.mjs"
+    }
+  },
+  "scripts": {
+    "build": "eve extension build",
+    "prepare": "eve extension build",
+    "typecheck": "tsc",
+    "check": "pnpm typecheck && pnpm build"
+  },
+  "dependencies": {
+    "@browserbasehq/sdk": "2.16.0",
+    "@browserbasehq/stagehand": "3.7.0",
+    "zod": "4.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "24.10.1",
+    "eve": "0.25.3",
+    "typescript": "7.0.2"
+  },
+  "peerDependencies": {
+    "eve": "*"
+  },
+  "engines": {
+    "node": ">=24"
+  }
+}