@effect-uai/core 0.8.0 → 0.10.0

package/dist/browser/BrowserError.mjs

@@ -0,0 +1,89 @@
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { Data, Match } from "effect";
+//#region src/browser/BrowserError.ts
+var BrowserError_exports = /* @__PURE__ */ __exportAll({
+	BrowserActionFailed: () => BrowserActionFailed,
+	BrowserAuthFailed: () => BrowserAuthFailed,
+	BrowserCreateFailed: () => BrowserCreateFailed,
+	BrowserInvalidRequest: () => BrowserInvalidRequest,
+	BrowserQuotaExceeded: () => BrowserQuotaExceeded,
+	BrowserSessionExpired: () => BrowserSessionExpired,
+	BrowserSessionNotFound: () => BrowserSessionNotFound,
+	BrowserTimeout: () => BrowserTimeout,
+	BrowserUnsupported: () => BrowserUnsupported,
+	describe: () => describe
+});
+/**
+* Failed to provision a browser session: the transport could not connect,
+* a launched engine did not come up, or the provider refused to mint a
+* session. Provider's structured reason on `reason`; the raw transport /
+* SDK error on `raw`.
+*/
+var BrowserCreateFailed = class extends Data.TaggedError("BrowserCreateFailed") {};
+/**
+* The requested session id does not exist. Raised by `attach` / `destroy`
+* against a stale or never-known id. Distinct from
+* {@link BrowserSessionExpired}, which is a session that existed and has
+* since ended.
+*/
+var BrowserSessionNotFound = class extends Data.TaggedError("BrowserSessionNotFound") {};
+/**
+* An operation was issued against a session that has ended: it reached its
+* max lifetime (the create-time `timeout`), was destroyed, or the provider
+* reaped it. The handle is dead; `create` or `attach` a live session.
+* Distinct from {@link BrowserTimeout} (a single live operation was too
+* slow).
+*/
+var BrowserSessionExpired = class extends Data.TaggedError("BrowserSessionExpired") {};
+/**
+* A single operation exceeded its own time budget while the session was
+* still alive (a navigation that never settled, a `waitFor` selector that
+* never appeared). Carries the breached budget for observability.
+*/
+var BrowserTimeout = class extends Data.TaggedError("BrowserTimeout") {};
+/**
+* An interaction or observation failed at the transport / protocol layer:
+* a selector resolved to nothing, an element was not actionable, an
+* `evaluate` script threw, a navigation errored. `selector` and `reason`
+* carry what is known.
+*/
+var BrowserActionFailed = class extends Data.TaggedError("BrowserActionFailed") {};
+/**
+* Provider rejected the request because an account / project quota or
+* concurrency limit was exceeded. Separate from {@link BrowserCreateFailed}
+* so callers can back off and retry.
+*/
+var BrowserQuotaExceeded = class extends Data.TaggedError("BrowserQuotaExceeded") {};
+/**
+* Caller's request shape is malformed for the wired provider. Adapters
+* should reject at the request-schema layer where possible; this is the
+* runtime fallback.
+*/
+var BrowserInvalidRequest = class extends Data.TaggedError("BrowserInvalidRequest") {};
+var BrowserAuthFailed = class extends Data.TaggedError("BrowserAuthFailed") {};
+/**
+* The wired provider does not implement the requested operation for these
+* inputs. Distinct from {@link BrowserInvalidRequest} (malformed request)
+* and from compile-time capability markers gating blanket provider gaps.
+*/
+var BrowserUnsupported = class extends Data.TaggedError("BrowserUnsupported") {};
+const withReason = (base, reason) => reason === void 0 ? base : `${base}: ${reason}`;
+/**
+* Short human-readable description of an error, for logs and model-facing
+* failure messages. Prose, not a contract; branch on `_tag` instead.
+*/
+const describe = Match.type().pipe(Match.discriminatorsExhaustive("_tag")({
+	BrowserCreateFailed: (e) => withReason("the browser session could not be created", e.reason),
+	BrowserSessionNotFound: () => "the browser session does not exist",
+	BrowserSessionExpired: () => "the browser session has expired",
+	BrowserTimeout: (e) => `the ${e.operation} operation timed out`,
+	BrowserActionFailed: (e) => withReason(`the ${e.operation} failed${e.selector === void 0 ? "" : ` on ${e.selector}`}`, e.reason),
+	BrowserQuotaExceeded: (e) => withReason("the browser quota is exceeded", e.reason),
+	BrowserInvalidRequest: (e) => withReason("the request was invalid", e.reason),
+	BrowserAuthFailed: (e) => `browser authentication failed (${e.subtype})`,
+	BrowserUnsupported: (e) => withReason(`this browser does not support ${e.capability}`, e.reason)
+}));
+//#endregion
+export { BrowserActionFailed, BrowserAuthFailed, BrowserCreateFailed, BrowserInvalidRequest, BrowserQuotaExceeded, BrowserSessionExpired, BrowserSessionNotFound, BrowserTimeout, BrowserUnsupported, describe, BrowserError_exports as t };
+
+//# sourceMappingURL=BrowserError.mjs.map

package/dist/browser/BrowserError.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"BrowserError.mjs","names":[],"sources":["../../src/browser/BrowserError.ts"],"sourcesContent":["import { Data, Duration, Match } from \"effect\"\n\n/**\n * Failed to provision a browser session: the transport could not connect,\n * a launched engine did not come up, or the provider refused to mint a\n * session. Provider's structured reason on `reason`; the raw transport /\n * SDK error on `raw`.\n */\nexport class BrowserCreateFailed extends Data.TaggedError(\"BrowserCreateFailed\")<{\n  provider: string\n  reason?: string\n  raw: unknown\n}> {}\n\n/**\n * The requested session id does not exist. Raised by `attach` / `destroy`\n * against a stale or never-known id. Distinct from\n * {@link BrowserSessionExpired}, which is a session that existed and has\n * since ended.\n */\nexport class BrowserSessionNotFound extends Data.TaggedError(\"BrowserSessionNotFound\")<{\n  provider: string\n  id: string\n}> {}\n\n/**\n * An operation was issued against a session that has ended: it reached its\n * max lifetime (the create-time `timeout`), was destroyed, or the provider\n * reaped it. The handle is dead; `create` or `attach` a live session.\n * Distinct from {@link BrowserTimeout} (a single live operation was too\n * slow).\n */\nexport class BrowserSessionExpired extends Data.TaggedError(\"BrowserSessionExpired\")<{\n  provider: string\n  id: string\n}> {}\n\n/**\n * A single operation exceeded its own time budget while the session was\n * still alive (a navigation that never settled, a `waitFor` selector that\n * never appeared). Carries the breached budget for observability.\n */\nexport class BrowserTimeout extends Data.TaggedError(\"BrowserTimeout\")<{\n  provider: string\n  operation: \"create\" | \"attach\" | \"navigate\" | \"action\" | \"query\"\n  budget?: Duration.Duration\n  raw?: unknown\n}> {}\n\n/**\n * An interaction or observation failed at the transport / protocol layer:\n * a selector resolved to nothing, an element was not actionable, an\n * `evaluate` script threw, a navigation errored. `selector` and `reason`\n * carry what is known.\n */\nexport class BrowserActionFailed extends Data.TaggedError(\"BrowserActionFailed\")<{\n  provider: string\n  operation: \"navigate\" | \"interact\" | \"observe\" | \"evaluate\" | \"cookies\"\n  selector?: string\n  reason?: string\n  raw: unknown\n}> {}\n\n/**\n * Provider rejected the request because an account / project quota or\n * concurrency limit was exceeded. Separate from {@link BrowserCreateFailed}\n * so callers can back off and retry.\n */\nexport class BrowserQuotaExceeded extends Data.TaggedError(\"BrowserQuotaExceeded\")<{\n  provider: string\n  reason?: string\n  raw: unknown\n}> {}\n\n/**\n * Caller's request shape is malformed for the wired provider. Adapters\n * should reject at the request-schema layer where possible; this is the\n * runtime fallback.\n */\nexport class BrowserInvalidRequest extends Data.TaggedError(\"BrowserInvalidRequest\")<{\n  provider: string\n  param?: string\n  reason?: string\n  raw?: unknown\n}> {}\n\n/**\n * Transport could not authenticate against the provider. Subtype mirrors\n * the model-side `AiError.AuthFailed` shape for consistency.\n */\nexport type BrowserAuthSubtype = \"auth\" | \"permission\" | \"billing\" | \"quota\"\n\nexport class BrowserAuthFailed extends Data.TaggedError(\"BrowserAuthFailed\")<{\n  provider: string\n  subtype: BrowserAuthSubtype\n  raw: unknown\n}> {}\n\n/**\n * The wired provider does not implement the requested operation for these\n * inputs. Distinct from {@link BrowserInvalidRequest} (malformed request)\n * and from compile-time capability markers gating blanket provider gaps.\n */\nexport class BrowserUnsupported extends Data.TaggedError(\"BrowserUnsupported\")<{\n  provider: string\n  capability: string\n  reason?: string\n}> {}\n\nexport type BrowserError =\n  | BrowserCreateFailed\n  | BrowserSessionNotFound\n  | BrowserSessionExpired\n  | BrowserTimeout\n  | BrowserActionFailed\n  | BrowserQuotaExceeded\n  | BrowserInvalidRequest\n  | BrowserAuthFailed\n  | BrowserUnsupported\n\nconst withReason = (base: string, reason: string | undefined): string =>\n  reason === undefined ? base : `${base}: ${reason}`\n\n/**\n * Short human-readable description of an error, for logs and model-facing\n * failure messages. Prose, not a contract; branch on `_tag` instead.\n */\nexport const describe: (e: BrowserError) => string = Match.type<BrowserError>().pipe(\n  Match.discriminatorsExhaustive(\"_tag\")({\n    BrowserCreateFailed: (e) => withReason(\"the browser session could not be created\", e.reason),\n    BrowserSessionNotFound: () => \"the browser session does not exist\",\n    BrowserSessionExpired: () => \"the browser session has expired\",\n    BrowserTimeout: (e) => `the ${e.operation} operation timed out`,\n    BrowserActionFailed: (e) =>\n      withReason(\n        `the ${e.operation} failed${e.selector === undefined ? \"\" : ` on ${e.selector}`}`,\n        e.reason,\n      ),\n    BrowserQuotaExceeded: (e) => withReason(\"the browser quota is exceeded\", e.reason),\n    BrowserInvalidRequest: (e) => withReason(\"the request was invalid\", e.reason),\n    BrowserAuthFailed: (e) => `browser authentication failed (${e.subtype})`,\n    BrowserUnsupported: (e) =>\n      withReason(`this browser does not support ${e.capability}`, e.reason),\n  }),\n)\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAQA,IAAa,sBAAb,cAAyC,KAAK,YAAY,sBAAsB,CAI7E;;;;;;;AAQH,IAAa,yBAAb,cAA4C,KAAK,YAAY,yBAAyB,CAGnF;;;;;;;;AASH,IAAa,wBAAb,cAA2C,KAAK,YAAY,wBAAwB,CAGjF;;;;;;AAOH,IAAa,iBAAb,cAAoC,KAAK,YAAY,iBAAiB,CAKnE;;;;;;;AAQH,IAAa,sBAAb,cAAyC,KAAK,YAAY,sBAAsB,CAM7E;;;;;;AAOH,IAAa,uBAAb,cAA0C,KAAK,YAAY,uBAAuB,CAI/E;;;;;;AAOH,IAAa,wBAAb,cAA2C,KAAK,YAAY,wBAAwB,CAKjF;AAQH,IAAa,oBAAb,cAAuC,KAAK,YAAY,oBAAoB,CAIzE;;;;;;AAOH,IAAa,qBAAb,cAAwC,KAAK,YAAY,qBAAqB,CAI3E;AAaH,MAAM,cAAc,MAAc,WAChC,WAAW,KAAA,IAAY,OAAO,GAAG,KAAK,IAAI;;;;;AAM5C,MAAa,WAAwC,MAAM,MAAoB,CAAC,KAC9E,MAAM,yBAAyB,OAAO,CAAC;CACrC,sBAAsB,MAAM,WAAW,4CAA4C,EAAE,OAAO;CAC5F,8BAA8B;CAC9B,6BAA6B;CAC7B,iBAAiB,MAAM,OAAO,EAAE,UAAU;CAC1C,sBAAsB,MACpB,WACE,OAAO,EAAE,UAAU,SAAS,EAAE,aAAa,KAAA,IAAY,KAAK,OAAO,EAAE,cACrE,EAAE,OACH;CACH,uBAAuB,MAAM,WAAW,iCAAiC,EAAE,OAAO;CAClF,wBAAwB,MAAM,WAAW,2BAA2B,EAAE,OAAO;CAC7E,oBAAoB,MAAM,kCAAkC,EAAE,QAAQ;CACtE,qBAAqB,MACnB,WAAW,iCAAiC,EAAE,cAAc,EAAE,OAAO;CACxE,CAAC,CACH"}

package/dist/browser/BrowserTool.d.mts

@@ -0,0 +1,58 @@
+import { BrowserError } from "./BrowserError.mjs";
+import { BrowserSession } from "./Browser.mjs";
+import { l as Tool } from "../Tool-2lC_XMth.mjs";
+
+//#region src/browser/BrowserTool.d.ts
+declare namespace BrowserTool_d_exports {
+  export { browserToolkit, clickTool, fillTool, gotoTool, pressTool, scrollTool };
+}
+declare const gotoTool: (session: BrowserSession) => Tool<"browser_goto", {
+  readonly url: string;
+}, unknown, string, BrowserError, never>;
+declare const clickTool: (session: BrowserSession) => Tool<"browser_click", {
+  readonly ref: string;
+}, unknown, string, BrowserError, never>;
+declare const fillTool: (session: BrowserSession) => Tool<"browser_fill", {
+  readonly ref: string;
+  readonly text: string;
+}, unknown, string, BrowserError, never>;
+declare const pressTool: (session: BrowserSession) => Tool<"browser_press", {
+  readonly key: string;
+}, unknown, string, BrowserError, never>;
+declare const scrollTool: (session: BrowserSession) => Tool<"browser_scroll", {
+  readonly direction: "up" | "down";
+}, unknown, string, BrowserError, never>;
+/**
+ * The canonical browser action verbs bundled as a `Toolkit`, closed over a
+ * live `BrowserSession`. Compose it with a recipe-local page-reading tool and
+ * whatever finish/signal tools the agent needs:
+ *
+ *   const toolkit = yield* Toolkit.compose(
+ *     browserToolkit(session),
+ *     Toolkit.make(readPageTool(session), finishTool),
+ *   )
+ *
+ * For an à-la-carte subset, use the individual `gotoTool` / `clickTool` / …
+ * constructors directly. Run a turn's calls with `{ concurrency: 1 }`.
+ */
+declare const browserToolkit: (session: BrowserSession) => {
+  browser_goto: Tool<"browser_goto", {
+    readonly url: string;
+  }, unknown, string, BrowserError, never>;
+  browser_click: Tool<"browser_click", {
+    readonly ref: string;
+  }, unknown, string, BrowserError, never>;
+  browser_fill: Tool<"browser_fill", {
+    readonly ref: string;
+    readonly text: string;
+  }, unknown, string, BrowserError, never>;
+  browser_press: Tool<"browser_press", {
+    readonly key: string;
+  }, unknown, string, BrowserError, never>;
+  browser_scroll: Tool<"browser_scroll", {
+    readonly direction: "up" | "down";
+  }, unknown, string, BrowserError, never>;
+};
+//#endregion
+export { browserToolkit, clickTool, fillTool, gotoTool, pressTool, scrollTool, BrowserTool_d_exports as t };
+//# sourceMappingURL=BrowserTool.d.mts.map

package/dist/browser/BrowserTool.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BrowserTool.d.mts","names":[],"sources":["../../src/browser/BrowserTool.ts"],"mappings":";;;;;;;;cAoEa,QAAA,GAAY,OAAA,EAAS,cAAA,KAAc,IAAA;EAAA;oBAAA,YAAA;AAAA,cAcnC,SAAA,GAAa,OAAA,EAAS,cAAA,KAAc,IAAA;EAAA;oBAAA,YAAA;AAAA,cAcpC,QAAA,GAAY,OAAA,EAAS,cAAA,KAAc,IAAA;EAAA;;oBAAA,YAAA;AAAA,cAenC,SAAA,GAAa,OAAA,EAAS,cAAA,KAAc,IAAA;EAAA;oBAAA,YAAA;AAAA,cAcpC,UAAA,GAAc,OAAA,EAAS,cAAA,KAAc,IAAA;EAAA;oBAAA,YAAA;;;;;;;;;;;;;AA3ClD;cAuEa,cAAA,GAAkB,OAAA,EAAS,cAAA;;;sBAAc,YAAA"}

package/dist/browser/BrowserTool.mjs

@@ -0,0 +1,86 @@
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { fromEffectSchema, make } from "../tool/Tool.mjs";
+import { make as make$1 } from "../tool/Toolkit.mjs";
+import { Effect, Schema } from "effect";
+//#region src/browser/BrowserTool.ts
+var BrowserTool_exports = /* @__PURE__ */ __exportAll({
+	browserToolkit: () => browserToolkit,
+	clickTool: () => clickTool,
+	fillTool: () => fillTool,
+	gotoTool: () => gotoTool,
+	pressTool: () => pressTool,
+	scrollTool: () => scrollTool
+});
+const GotoArgs = Schema.Struct({ url: Schema.String.annotate({ description: "Absolute URL to navigate to." }) });
+const ClickArgs = Schema.Struct({ ref: Schema.String.annotate({ description: "A CSS selector, or an element @ref if a page-reading tool provides one." }) });
+const FillArgs = Schema.Struct({
+	ref: Schema.String.annotate({ description: "A CSS selector (or element @ref) of the input to fill." }),
+	text: Schema.String.annotate({ description: "The text to put in the input." })
+});
+const PressArgs = Schema.Struct({ key: Schema.String.annotate({ description: "Key to press, e.g. \"Enter\" to submit the focused input, \"Tab\", \"Escape\"." }) });
+const ScrollArgs = Schema.Struct({ direction: Schema.Literals(["up", "down"]).annotate({ description: "Scroll the viewport up or down." }) });
+const currentUrl = (session) => session.evaluate("location.href").pipe(Effect.flatMap(Schema.decodeUnknownEffect(Schema.String)), Effect.orElseSucceed(() => "(unknown)"));
+const okAt = (session) => Effect.map(currentUrl(session), (url) => `ok (now at ${url})`);
+const gotoTool = (session) => make({
+	name: "browser_goto",
+	description: "Navigate the browser to an absolute URL.",
+	inputSchema: fromEffectSchema(GotoArgs),
+	run: (args) => Effect.andThen(session.goto(args.url), okAt(session)).pipe(Effect.withSpan("browser_goto", {
+		kind: "client",
+		attributes: { "browser.url": args.url }
+	}))
+});
+const clickTool = (session) => make({
+	name: "browser_click",
+	description: "Click the element named by ref. A click may navigate to a new page.",
+	inputSchema: fromEffectSchema(ClickArgs),
+	run: (args) => Effect.andThen(session.click(args.ref), okAt(session)).pipe(Effect.withSpan("browser_click", {
+		kind: "client",
+		attributes: { "browser.ref": args.ref }
+	}))
+});
+const fillTool = (session) => make({
+	name: "browser_fill",
+	description: "Put text into the input named by ref. Filling alone does not submit; press Enter to submit the input.",
+	inputSchema: fromEffectSchema(FillArgs),
+	run: (args) => Effect.andThen(session.fill(args.ref, args.text), okAt(session)).pipe(Effect.withSpan("browser_fill", {
+		kind: "client",
+		attributes: { "browser.ref": args.ref }
+	}))
+});
+const pressTool = (session) => make({
+	name: "browser_press",
+	description: "Press a keyboard key against the focused element.",
+	inputSchema: fromEffectSchema(PressArgs),
+	run: (args) => Effect.andThen(session.press(args.key), okAt(session)).pipe(Effect.withSpan("browser_press", {
+		kind: "client",
+		attributes: { "browser.key": args.key }
+	}))
+});
+const scrollTool = (session) => make({
+	name: "browser_scroll",
+	description: "Scroll the viewport. Only useful to bring an element into view - a page-reading tool's text is already scroll-independent.",
+	inputSchema: fromEffectSchema(ScrollArgs),
+	run: (args) => Effect.andThen(session.scroll({ direction: args.direction }), okAt(session)).pipe(Effect.withSpan("browser_scroll", {
+		kind: "client",
+		attributes: { "browser.direction": args.direction }
+	}))
+});
+/**
+* The canonical browser action verbs bundled as a `Toolkit`, closed over a
+* live `BrowserSession`. Compose it with a recipe-local page-reading tool and
+* whatever finish/signal tools the agent needs:
+*
+*   const toolkit = yield* Toolkit.compose(
+*     browserToolkit(session),
+*     Toolkit.make(readPageTool(session), finishTool),
+*   )
+*
+* For an à-la-carte subset, use the individual `gotoTool` / `clickTool` / …
+* constructors directly. Run a turn's calls with `{ concurrency: 1 }`.
+*/
+const browserToolkit = (session) => make$1(gotoTool(session), clickTool(session), fillTool(session), pressTool(session), scrollTool(session));
+//#endregion
+export { browserToolkit, clickTool, fillTool, gotoTool, pressTool, scrollTool, BrowserTool_exports as t };
+
+//# sourceMappingURL=BrowserTool.mjs.map

package/dist/browser/BrowserTool.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"BrowserTool.mjs","names":["Tool.make","Tool.fromEffectSchema","Toolkit.make"],"sources":["../../src/browser/BrowserTool.ts"],"sourcesContent":["import { Effect, Schema } from \"effect\"\nimport * as Tool from \"../tool/Tool.js\"\nimport * as Toolkit from \"../tool/Toolkit.js\"\nimport type { BrowserSession } from \"./Browser.js\"\n\n// ---------------------------------------------------------------------------\n// Model-facing argument schemas. Annotated so the descriptions reach the\n// model through the rendered JSON Schema (JSDoc does not).\n// ---------------------------------------------------------------------------\n\nconst GotoArgs = Schema.Struct({\n  url: Schema.String.annotate({ description: \"Absolute URL to navigate to.\" }),\n})\n\nconst ClickArgs = Schema.Struct({\n  ref: Schema.String.annotate({\n    description: \"A CSS selector, or an element @ref if a page-reading tool provides one.\",\n  }),\n})\n\nconst FillArgs = Schema.Struct({\n  ref: Schema.String.annotate({\n    description: \"A CSS selector (or element @ref) of the input to fill.\",\n  }),\n  text: Schema.String.annotate({ description: \"The text to put in the input.\" }),\n})\n\nconst PressArgs = Schema.Struct({\n  key: Schema.String.annotate({\n    description: 'Key to press, e.g. \"Enter\" to submit the focused input, \"Tab\", \"Escape\".',\n  }),\n})\n\nconst ScrollArgs = Schema.Struct({\n  direction: Schema.Literals([\"up\", \"down\"]).annotate({\n    description: \"Scroll the viewport up or down.\",\n  }),\n})\n\n// ---------------------------------------------------------------------------\n// Uniform action outcome: the model always learns where the action left it.\n// ---------------------------------------------------------------------------\n\nconst currentUrl = (session: BrowserSession): Effect.Effect<string> =>\n  session.evaluate(\"location.href\").pipe(\n    Effect.flatMap(Schema.decodeUnknownEffect(Schema.String)),\n    Effect.orElseSucceed(() => \"(unknown)\"),\n  )\n\nconst okAt = (session: BrowserSession): Effect.Effect<string> =>\n  Effect.map(currentUrl(session), (url) => `ok (now at ${url})`)\n\n// ---------------------------------------------------------------------------\n// The canonical browser action tools, each closed over a live `BrowserSession`\n// and failing with the full `BrowserError`. `Output` is a compact outcome\n// (`ok (now at <url>)`), not a page dump - a page-reading tool is the recipe's\n// to define, so history does not accumulate a full page per action.\n//\n// A failed action (stale ref, dead control, timeout) fails typed on the error\n// channel. Whether the model gets to recover from it is the loop's decision:\n// wrap the toolkit in `Toolkit.describeFailures(BrowserError.describe)` to\n// surface failures to the model, or map selectively to keep session/infra\n// errors (e.g. `BrowserSessionExpired`) fatal.\n//\n// Browser actions are order-dependent (fill, then press Enter): run a turn's\n// calls with `{ concurrency: 1 }`.\n// ---------------------------------------------------------------------------\n\nexport const gotoTool = (session: BrowserSession) =>\n  Tool.make({\n    name: \"browser_goto\",\n    description: \"Navigate the browser to an absolute URL.\",\n    inputSchema: Tool.fromEffectSchema(GotoArgs),\n    run: (args) =>\n      Effect.andThen(session.goto(args.url), okAt(session)).pipe(\n        Effect.withSpan(\"browser_goto\", {\n          kind: \"client\",\n          attributes: { \"browser.url\": args.url },\n        }),\n      ),\n  })\n\nexport const clickTool = (session: BrowserSession) =>\n  Tool.make({\n    name: \"browser_click\",\n    description: \"Click the element named by ref. A click may navigate to a new page.\",\n    inputSchema: Tool.fromEffectSchema(ClickArgs),\n    run: (args) =>\n      Effect.andThen(session.click(args.ref), okAt(session)).pipe(\n        Effect.withSpan(\"browser_click\", {\n          kind: \"client\",\n          attributes: { \"browser.ref\": args.ref },\n        }),\n      ),\n  })\n\nexport const fillTool = (session: BrowserSession) =>\n  Tool.make({\n    name: \"browser_fill\",\n    description:\n      \"Put text into the input named by ref. Filling alone does not submit; press Enter to submit the input.\",\n    inputSchema: Tool.fromEffectSchema(FillArgs),\n    run: (args) =>\n      Effect.andThen(session.fill(args.ref, args.text), okAt(session)).pipe(\n        Effect.withSpan(\"browser_fill\", {\n          kind: \"client\",\n          attributes: { \"browser.ref\": args.ref },\n        }),\n      ),\n  })\n\nexport const pressTool = (session: BrowserSession) =>\n  Tool.make({\n    name: \"browser_press\",\n    description: \"Press a keyboard key against the focused element.\",\n    inputSchema: Tool.fromEffectSchema(PressArgs),\n    run: (args) =>\n      Effect.andThen(session.press(args.key), okAt(session)).pipe(\n        Effect.withSpan(\"browser_press\", {\n          kind: \"client\",\n          attributes: { \"browser.key\": args.key },\n        }),\n      ),\n  })\n\nexport const scrollTool = (session: BrowserSession) =>\n  Tool.make({\n    name: \"browser_scroll\",\n    description:\n      \"Scroll the viewport. Only useful to bring an element into view - a page-reading tool's text is already scroll-independent.\",\n    inputSchema: Tool.fromEffectSchema(ScrollArgs),\n    run: (args) =>\n      Effect.andThen(session.scroll({ direction: args.direction }), okAt(session)).pipe(\n        Effect.withSpan(\"browser_scroll\", {\n          kind: \"client\",\n          attributes: { \"browser.direction\": args.direction },\n        }),\n      ),\n  })\n\n/**\n * The canonical browser action verbs bundled as a `Toolkit`, closed over a\n * live `BrowserSession`. Compose it with a recipe-local page-reading tool and\n * whatever finish/signal tools the agent needs:\n *\n *   const toolkit = yield* Toolkit.compose(\n *     browserToolkit(session),\n *     Toolkit.make(readPageTool(session), finishTool),\n *   )\n *\n * For an à-la-carte subset, use the individual `gotoTool` / `clickTool` / …\n * constructors directly. Run a turn's calls with `{ concurrency: 1 }`.\n */\nexport const browserToolkit = (session: BrowserSession) =>\n  Toolkit.make(\n    gotoTool(session),\n    clickTool(session),\n    fillTool(session),\n    pressTool(session),\n    scrollTool(session),\n  )\n"],"mappings":";;;;;;;;;;;;;AAUA,MAAM,WAAW,OAAO,OAAO,EAC7B,KAAK,OAAO,OAAO,SAAS,EAAE,aAAa,gCAAgC,CAAC,EAC7E,CAAC;AAEF,MAAM,YAAY,OAAO,OAAO,EAC9B,KAAK,OAAO,OAAO,SAAS,EAC1B,aAAa,2EACd,CAAC,EACH,CAAC;AAEF,MAAM,WAAW,OAAO,OAAO;CAC7B,KAAK,OAAO,OAAO,SAAS,EAC1B,aAAa,0DACd,CAAC;CACF,MAAM,OAAO,OAAO,SAAS,EAAE,aAAa,iCAAiC,CAAC;CAC/E,CAAC;AAEF,MAAM,YAAY,OAAO,OAAO,EAC9B,KAAK,OAAO,OAAO,SAAS,EAC1B,aAAa,kFACd,CAAC,EACH,CAAC;AAEF,MAAM,aAAa,OAAO,OAAO,EAC/B,WAAW,OAAO,SAAS,CAAC,MAAM,OAAO,CAAC,CAAC,SAAS,EAClD,aAAa,mCACd,CAAC,EACH,CAAC;AAMF,MAAM,cAAc,YAClB,QAAQ,SAAS,gBAAgB,CAAC,KAChC,OAAO,QAAQ,OAAO,oBAAoB,OAAO,OAAO,CAAC,EACzD,OAAO,oBAAoB,YAAY,CACxC;AAEH,MAAM,QAAQ,YACZ,OAAO,IAAI,WAAW,QAAQ,GAAG,QAAQ,cAAc,IAAI,GAAG;AAkBhE,MAAa,YAAY,YACvBA,KAAU;CACR,MAAM;CACN,aAAa;CACb,aAAaC,iBAAsB,SAAS;CAC5C,MAAM,SACJ,OAAO,QAAQ,QAAQ,KAAK,KAAK,IAAI,EAAE,KAAK,QAAQ,CAAC,CAAC,KACpD,OAAO,SAAS,gBAAgB;EAC9B,MAAM;EACN,YAAY,EAAE,eAAe,KAAK,KAAK;EACxC,CAAC,CACH;CACJ,CAAC;AAEJ,MAAa,aAAa,YACxBD,KAAU;CACR,MAAM;CACN,aAAa;CACb,aAAaC,iBAAsB,UAAU;CAC7C,MAAM,SACJ,OAAO,QAAQ,QAAQ,MAAM,KAAK,IAAI,EAAE,KAAK,QAAQ,CAAC,CAAC,KACrD,OAAO,SAAS,iBAAiB;EAC/B,MAAM;EACN,YAAY,EAAE,eAAe,KAAK,KAAK;EACxC,CAAC,CACH;CACJ,CAAC;AAEJ,MAAa,YAAY,YACvBD,KAAU;CACR,MAAM;CACN,aACE;CACF,aAAaC,iBAAsB,SAAS;CAC5C,MAAM,SACJ,OAAO,QAAQ,QAAQ,KAAK,KAAK,KAAK,KAAK,KAAK,EAAE,KAAK,QAAQ,CAAC,CAAC,KAC/D,OAAO,SAAS,gBAAgB;EAC9B,MAAM;EACN,YAAY,EAAE,eAAe,KAAK,KAAK;EACxC,CAAC,CACH;CACJ,CAAC;AAEJ,MAAa,aAAa,YACxBD,KAAU;CACR,MAAM;CACN,aAAa;CACb,aAAaC,iBAAsB,UAAU;CAC7C,MAAM,SACJ,OAAO,QAAQ,QAAQ,MAAM,KAAK,IAAI,EAAE,KAAK,QAAQ,CAAC,CAAC,KACrD,OAAO,SAAS,iBAAiB;EAC/B,MAAM;EACN,YAAY,EAAE,eAAe,KAAK,KAAK;EACxC,CAAC,CACH;CACJ,CAAC;AAEJ,MAAa,cAAc,YACzBD,KAAU;CACR,MAAM;CACN,aACE;CACF,aAAaC,iBAAsB,WAAW;CAC9C,MAAM,SACJ,OAAO,QAAQ,QAAQ,OAAO,EAAE,WAAW,KAAK,WAAW,CAAC,EAAE,KAAK,QAAQ,CAAC,CAAC,KAC3E,OAAO,SAAS,kBAAkB;EAChC,MAAM;EACN,YAAY,EAAE,qBAAqB,KAAK,WAAW;EACpD,CAAC,CACH;CACJ,CAAC;;;;;;;;;;;;;;AAeJ,MAAa,kBAAkB,YAC7BC,OACE,SAAS,QAAQ,EACjB,UAAU,QAAQ,EAClB,SAAS,QAAQ,EACjB,UAAU,QAAQ,EAClB,WAAW,QAAQ,CACpB"}

package/dist/{dist-DV5ISja1.mjs → dist-B04dlFHg.mjs}

@@ -10243,7 +10243,7 @@ function memo(fn) {
 	};
 }
 async function saveInlineSnapshots(environment, snapshots) {
-	const MagicString = (await import("./magic-string.es-BgIV5Mu3.mjs")).default;
+	const MagicString = (await import("./magic-string.es-Dk-MMA0F.mjs")).default;
 	const files = new Set(snapshots.map((i) => i.file));
 	await Promise.all(Array.from(files).map(async (file) => {
 		const snaps = snapshots.filter((i) => i.file === file);
@@ -13777,6 +13777,6 @@ var import_dist = (/* @__PURE__ */ __commonJSMin(((exports) => {
 	exports.expectTypeOf = expectTypeOf;
 })))();
 //#endregion
-export { it as i, globalExpect as n, describe as r, import_dist as t };
+export { describe as a, beforeAll as i, globalExpect as n, it as o, afterAll as r, import_dist as t };
 
-//# sourceMappingURL=dist-DV5ISja1.mjs.map
+//# sourceMappingURL=dist-B04dlFHg.mjs.map