libretto 0.6.21 → 0.6.23

package/docs/understand-libretto/error-handling-and-recovery.mdx

@@ -0,0 +1,45 @@
+# Error recovery
+
+Libretto helps your agent handle failures in two ways: inspect failed runs so it can fix the deterministic workflow, or add a narrow runtime recovery action for expected nondeterminism.
+
+Most workflow failures should be fixed with better selectors, waits, or assertions. Runtime recovery is for cases where the workflow is on the right path but the site sometimes shows unexpected UI that blocks the next action.
+
+## Debugging failed runs
+
+When a workflow fails during development, the Libretto CLI helps your agent debug the code by preserving the browser session. The agent can run headed, add `pause(ctx.session)` at useful checkpoints, inspect the page state, iterate on code, and use `resume` to continue from the pause before redeploying.
+
+For deployed workflows on the hosted platform, a failed run automatically starts an analysis agent. It reviews the error, logs, recording, screenshots, and browser state so it can explain what went wrong and suggest the code change.
+
+## Runtime recovery actions
+
+Add `recoveryAction` to a workflow when you want Libretto to recover after a supported Page or Locator action fails. Libretto calls the recovery action, then retries the original action once.
+
+```typescript
+export default workflow("reviewOrder", {
+  input,
+  output,
+  recoveryAction: popupRecoveryAction({
+    provider: "openai",
+    apiKey: process.env.OPENAI_API_KEY!,
+    model: "gpt-5.5",
+    maxSteps: 3,
+  }),
+  handler: async ({ page }, params) => {
+    await page.goto(params.url);
+    await page.locator("#review").click();
+    return { complete: true };
+  },
+});
+```
+
+## AI vision recovery
+
+The computer use recovery action looks at the current screen and takes one or more browser actions to get back to the expected path. It is useful for nondeterministic blockers such as cookie banners, popups, modals, interstitials, and overlays that intercept clicks.
+
+It uses a viewport screenshot, asks the model for an action, scales the returned screenshot coordinates to Playwright coordinates, and executes the action.
+
+`popupRecoveryAction()` is the built-in preset for closing popups and other blockers. Use `computerUseRecoveryAction()` when you want to provide your own instruction.
+
+Simple sites without nondeterministic UI usually do not need AI vision recovery. For complicated sites automated through the DOM, add it when exploration shows blockers across sessions, accounts, or time. Do not use it to make business decisions that belong in the workflow handler.
+
+Supported provider shortcut models are `gpt-5.5` and `claude-sonnet-4-6`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libretto",
-  "version": "0.6.21",
+  "version": "0.6.23",
   "description": "AI-powered browser automation library and CLI built on Playwright",
   "license": "MIT",
   "homepage": "https://libretto.sh",
@@ -31,30 +31,20 @@
     }
   },
   "peerDependencies": {
-    "@ai-sdk/anthropic": "^3.0.58",
     "@ai-sdk/google": "^3.0.51",
-    "@ai-sdk/google-vertex": "^4.0.80",
-    "@ai-sdk/openai": "^3.0.41"
+    "@ai-sdk/google-vertex": "^4.0.80"
   },
   "peerDependenciesMeta": {
-    "@ai-sdk/anthropic": {
-      "optional": true
-    },
     "@ai-sdk/google": {
       "optional": true
     },
     "@ai-sdk/google-vertex": {
       "optional": true
-    },
-    "@ai-sdk/openai": {
-      "optional": true
     }
   },
   "devDependencies": {
-    "@ai-sdk/anthropic": "^3.0.58",
     "@ai-sdk/google": "^3.0.51",
     "@ai-sdk/google-vertex": "^4.0.80",
-    "@ai-sdk/openai": "^3.0.41",
     "@anthropic-ai/claude-agent-sdk": "^0.2.75",
     "@mariozechner/pi-agent-core": "^0.62.0",
     "@mariozechner/pi-ai": "^0.62.0",
@@ -70,6 +60,8 @@
     "vitest": "^4.1.5"
   },
   "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.66",
+    "@ai-sdk/openai": "^3.0.66",
     "ai": "^6.0.116",
     "esbuild": "^0.27.0",
     "playwright": "^1.58.2",

package/skills/libretto/SKILL.md

@@ -4,7 +4,7 @@ description: "Browser automation CLI for building, maintaining, and running brow
 license: MIT
 metadata:
   author: saffron-health
-  version: "0.6.21"
+  version: "0.6.23"
 ---
 
 ## How Libretto Works
@@ -24,7 +24,7 @@ Full documentation is published at [libretto.sh](https://libretto.sh). Available
 - Workflow guides: [one-shot generation](https://libretto.sh/docs/guides/one-shot-workflow-generation), [interactive building](https://libretto.sh/docs/guides/interactive-workflow-building), [debugging workflows](https://libretto.sh/docs/guides/debugging-workflows), [convert to network requests](https://libretto.sh/docs/guides/convert-to-network-requests)
 - CLI reference: [open and connect](https://libretto.sh/docs/reference/cli/open-and-connect), [sessions](https://libretto.sh/docs/reference/cli/sessions), [profiles](https://libretto.sh/docs/reference/cli/profiles), [snapshot](https://libretto.sh/docs/reference/cli/snapshot), [exec](https://libretto.sh/docs/reference/cli/exec), [run and resume](https://libretto.sh/docs/reference/cli/run-and-resume), [session logs](https://libretto.sh/docs/reference/cli/session-logs), [pages](https://libretto.sh/docs/reference/cli/pages)
 - Library API: [workflow](https://libretto.sh/docs/reference/runtime/workflow), [AI extraction](https://libretto.sh/docs/reference/runtime/ai-extraction), [network requests](https://libretto.sh/docs/reference/runtime/network-requests), [file downloads](https://libretto.sh/docs/reference/runtime/file-downloads)
-- Libretto Cloud Hosting: [overview](https://libretto.sh/docs/libretto-cloud-hosting/overview), [authentication](https://libretto.sh/docs/libretto-cloud-hosting/authentication), [deployments](https://libretto.sh/docs/libretto-cloud-hosting/deployments)
+- Libretto Cloud Hosting: [overview](https://libretto.sh/docs/libretto-cloud-hosting/overview), [authentication](https://libretto.sh/docs/libretto-cloud-hosting/authentication), [deployments](https://libretto.sh/docs/libretto-cloud-hosting/deployments), [stealth](https://libretto.sh/docs/libretto-cloud-hosting/stealth)
 - Alternative providers: [overview](https://libretto.sh/docs/alternative-providers/overview), [Kernel](https://libretto.sh/docs/alternative-providers/kernel), [Browserbase](https://libretto.sh/docs/alternative-providers/browserbase), [Steel](https://libretto.sh/docs/alternative-providers/steel), [GCP](https://libretto.sh/docs/alternative-providers/gcp), [AWS](https://libretto.sh/docs/alternative-providers/aws)
 
 ## Default Integration Approach
@@ -37,6 +37,12 @@ Mix strategies freely across steps on a site.
 
 Prefer to enter sites at a user-facing URL (homepage, login, etc.) on the first navigation — deep URLs on a cold session are commonly blocked by edge bot protection.
 
+## CAPTCHA Handling
+
+- If a CAPTCHA, Cloudflare challenge, or similar bot check appears in a local Chromium session, try to solve it in the visible browser and continue from the solved state.
+- If the same challenge appears while the session is using a hosted browser provider, wait up to 2 minutes for automatic CAPTCHA handling before deciding the workflow is blocked.
+- When a CAPTCHA was observed during exploration, generated workflow code should include an explicit timeout wait at that point with a short comment linking to the hosted platform stealth docs. Follow `references/code-generation-rules.md` for the code shape.
+
 ## Setup
 
 - Use the package manager convention for the target project. The examples use `npx libretto`; pnpm, yarn, and bun projects should use their equivalent package-manager execution form.

package/skills/libretto/references/code-generation-rules.md

@@ -23,10 +23,10 @@ const outputSchema = z.object({
   results: z.array(z.object({ name: z.string(), value: z.string() })),
 });
 
-export default workflow(
-  "myWorkflow",
-  { input: inputSchema, output: outputSchema },
-  async (ctx: LibrettoWorkflowContext, input) => {
+export default workflow("myWorkflow", {
+  input: inputSchema,
+  output: outputSchema,
+  handler: async (ctx: LibrettoWorkflowContext, input) => {
     const { session, page } = ctx;
 
     console.log("workflow-start", { session, query: input.query });
@@ -35,12 +35,12 @@ export default workflow(
 
     return { results: [] };
   },
-);
+});
 ```
 
 Key points:
 
-- `workflow(name, { input, output }, handler)` takes a unique workflow name, a pair of Zod schemas describing input and output, and the async handler. The handler's `input` parameter is inferred from the input schema — do not redeclare it with a separate `type Input = ...`.
+- `workflow(name, { input, output, recoveryAction, handler })` takes a unique workflow name, optional Zod input/output schemas, an optional recovery action, and the async handler. The handler's `input` parameter is inferred from the input schema — do not redeclare it with a separate `type Input = ...`.
 - At run time, Libretto validates `input` against `inputSchema` before calling the handler. Invalid input throws a clear error listing each failing field; the workflow handler never sees malformed input.
 - `npx libretto run ./file.ts` executes the file's default-exported workflow, so always use `export default workflow(...)`.
 - `ctx` provides `session` and `page`. Use `console.log`/`console.warn`/`console.error` for logging — the runtime wraps these with structured metadata automatically.
@@ -49,6 +49,12 @@ Key points:
 - After validation is complete and the workflow is confirmed working end to end, remove all `pause()` calls and pause-only workflow params unless the user explicitly says to keep them.
 - The browser is launched and closed automatically by the CLI. Do not launch or close it in the handler.
 
+## Workflow Error Handling
+
+Do not add runtime recovery by default. Add `recoveryAction` only when exploration shows nondeterministic blockers such as popups, cookie banners, modals, or overlays.
+
+Use `popupRecoveryAction()` for generic popup and modal dismissal. Use a custom `RecoveryAction` function when the site needs specific recovery steps around the popup recovery agent. Tell the user when you add runtime recovery and keep primary workflow logic in the handler.
+
 ## Playwright DOM Interaction Rules
 
 Generated code must use Playwright locator APIs for all DOM interactions. Do not use `page.evaluate()` with `document.querySelector`, `querySelectorAll`, `textContent`, `click()`, or other DOM APIs when a Playwright locator can do the same thing.
@@ -57,6 +63,17 @@ During the interactive `exec` phase, `page.evaluate` is fine for quick prototypi
 
 Before extracting data (for example text, rows, or field values), wait for the target content itself to be ready, not just its container.
 
+## CAPTCHA Waits
+
+If a CAPTCHA, Cloudflare challenge, or similar bot check appeared during exploration, preserve that recovery point in generated workflow code with an explicit 2 minute timeout wait. Put a short comment immediately above the wait linking to the hosted platform stealth docs:
+
+```typescript
+// Wait for hosted CAPTCHA solving; see https://libretto.sh/docs/libretto-cloud-hosting/stealth.
+await page.waitForTimeout(120_000);
+```
+
+Use the wait only where a challenge was actually observed or is expected from the site's normal flow. After the wait, continue with a concrete locator or URL assertion for the real page state so the workflow fails clearly if the challenge was not solved.
+
 ### Anti-Patterns
 
 These patterns come up frequently during interactive sessions and should not carry over into production code:

package/skills/libretto-readonly/SKILL.md

@@ -4,7 +4,7 @@ description: "Read-only Libretto workflow for diagnosing live browser state with
 license: MIT
 metadata:
   author: saffron-health
-  version: "0.6.21"
+  version: "0.6.23"
 ---
 
 ## How Libretto Read-Only Works

package/src/cli/commands/execution.ts

@@ -628,7 +628,11 @@ async function runIntegrationFromFile(
       stayOpenOnSuccess: args.stayOpenOnSuccess,
       daemonSocketPath,
       provider: provider
-        ? { name: provider.name, sessionId: provider.sessionId }
+        ? {
+            name: provider.name,
+            sessionId: provider.sessionId,
+            recordingUrl: provider.recordingUrl,
+          }
         : undefined,
     },
     logger,
@@ -636,6 +640,9 @@ async function runIntegrationFromFile(
   if (provider?.liveViewUrl) {
     console.log(`View live session: ${provider.liveViewUrl}`);
   }
+  if (provider?.recordingUrl) {
+    console.log(`View recording: ${provider.recordingUrl}`);
+  }
 
   let outcome: WorkflowOutcome;
   try {

package/src/cli/core/browser.ts

@@ -568,11 +568,15 @@ export async function runOpenWithProvider(
     sessionId: providerSession.sessionId,
     cdpEndpoint: providerSession.cdpEndpoint,
     liveViewUrl: providerSession.liveViewUrl,
+    recordingUrl: providerSession.recordingUrl,
   });
 
   if (providerSession.liveViewUrl) {
     console.log(`View live session: ${providerSession.liveViewUrl}`);
   }
+  if (providerSession.recordingUrl) {
+    console.log(`View recording: ${providerSession.recordingUrl}`);
+  }
 
   writeSessionState(
     {
@@ -587,6 +591,7 @@ export async function runOpenWithProvider(
       provider: {
         name: providerName,
         sessionId: providerSession.sessionId,
+        recordingUrl: providerSession.recordingUrl,
       },
     },
     logger,
@@ -867,7 +872,7 @@ async function waitForCloseAllTargets(
 
 async function closeProviderSessionDirectly(
   session: string,
-  providerState: { name: string; sessionId: string },
+  providerState: { name: string; sessionId: string; recordingUrl?: string },
   logger: LoggerApi,
 ): Promise<string | undefined> {
   try {
@@ -879,7 +884,7 @@ async function closeProviderSessionDirectly(
       sessionId: providerState.sessionId,
       replayUrl: result.replayUrl,
     });
-    return result.replayUrl;
+    return result.replayUrl ?? providerState.recordingUrl;
   } catch (error) {
     logger.warn("close-provider-direct-fallback-failed", {
       session,

package/src/cli/core/daemon/daemon.ts

@@ -182,6 +182,7 @@ class BrowserDaemon {
       provider: ProviderApi;
       name: string;
       sessionId: string;
+      recordingUrl?: string;
     },
   ) {
     this.logger = logger.withScope("child");
@@ -230,11 +231,13 @@ class BrowserDaemon {
       sessionId: string;
       cdpEndpoint: string;
       liveViewUrl?: string;
+      recordingUrl?: string;
     };
     providerSession?: {
       provider: ProviderApi;
       name: string;
       sessionId: string;
+      recordingUrl?: string;
     };
     beforeReady?: () => void;
   }): Promise<BrowserDaemon> {
@@ -516,11 +519,13 @@ class BrowserDaemon {
           sessionId: providerSession.sessionId,
           cdpEndpoint: providerSession.cdpEndpoint,
           liveViewUrl: providerSession.liveViewUrl,
+          recordingUrl: providerSession.recordingUrl,
         },
         providerSession: {
           provider,
           name: config.providerName,
           sessionId: providerSession.sessionId,
+          recordingUrl: providerSession.recordingUrl,
         },
         beforeReady: startupCleanup.dispose,
       });
@@ -593,13 +598,13 @@ class BrowserDaemon {
         const result = await this.providerSession.provider.closeSession(
           this.providerSession.sessionId,
         );
-        replayUrl = result.replayUrl;
-        if (result.replayUrl) {
+        replayUrl = result.replayUrl ?? this.providerSession.recordingUrl;
+        if (replayUrl) {
           this.logger.info("provider-recording", {
             session: this.session,
             provider: this.providerSession.name,
             sessionId: this.providerSession.sessionId,
-            replayUrl: result.replayUrl,
+            replayUrl,
           });
         }
         writeFileSync(
@@ -608,7 +613,7 @@ class BrowserDaemon {
             {
               provider: this.providerSession.name,
               sessionId: this.providerSession.sessionId,
-              replayUrl: result.replayUrl,
+              replayUrl,
             },
             null,
             2,

package/src/cli/core/daemon/ipc.ts

@@ -98,6 +98,7 @@ export type DaemonReadyMessage = {
     sessionId: string;
     cdpEndpoint: string;
     liveViewUrl?: string;
+    recordingUrl?: string;
   };
 };
 

package/src/cli/core/providers/kernel.ts

@@ -1,51 +1,175 @@
 import type { ProviderApi } from "./types.js";
 
-const KERNEL_API_ENDPOINT = "https://api.onkernel.com";
+export type KernelProviderOptions = {
+  apiKey?: string;
+  headless?: boolean;
+  stealth?: boolean;
+  timeoutSeconds?: number;
+  enableRecording?: boolean;
+};
 
-export function createKernelProvider(): ProviderApi {
-  const apiKey = process.env.KERNEL_API_KEY;
+type KernelBrowserResponse = {
+  session_id: string;
+  cdp_ws_url: string;
+  browser_live_view_url?: string | null;
+};
+
+type KernelReplayResponse = {
+  replay_id: string;
+  replay_view_url?: string | null;
+};
+
+function readBooleanEnv(name: string, defaultValue: boolean): boolean {
+  const value = process.env[name]?.trim().toLowerCase();
+  if (!value) return defaultValue;
+  return value === "1" || value === "true" || value === "yes";
+}
+
+function readTimeoutSeconds(options: KernelProviderOptions): number {
+  if (options.timeoutSeconds !== undefined) return options.timeoutSeconds;
+  return Number(process.env.KERNEL_TIMEOUT_SECONDS ?? 300);
+}
+
+async function kernelFetchJson<T>(
+  endpoint: string,
+  apiKey: string,
+  path: string,
+  init: RequestInit,
+): Promise<T> {
+  const resp = await fetch(`${endpoint}${path}`, {
+    ...init,
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json",
+      ...init.headers,
+    },
+  });
+  if (!resp.ok) {
+    const body = await resp.text();
+    throw new Error(`Kernel API error (${resp.status}): ${body}`);
+  }
+  return (await resp.json()) as T;
+}
+
+async function kernelFetchNoBody(
+  endpoint: string,
+  apiKey: string,
+  path: string,
+  init: RequestInit,
+): Promise<void> {
+  const resp = await fetch(`${endpoint}${path}`, {
+    ...init,
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      ...init.headers,
+    },
+  });
+  if (!resp.ok) {
+    const body = await resp.text();
+    throw new Error(`Kernel API error (${resp.status}): ${body}`);
+  }
+}
+
+function readEndpoint(): string {
+  return (
+    process.env.KERNEL_API_ENDPOINT?.trim() ||
+    process.env.KERNEL_ENDPOINT?.trim() ||
+    "https://api.onkernel.com"
+  );
+}
+
+export function createKernelProvider(
+  options: KernelProviderOptions = {},
+): ProviderApi {
+  const apiKey = options.apiKey ?? process.env.KERNEL_API_KEY;
   if (!apiKey)
     throw new Error("KERNEL_API_KEY is required for Kernel provider.");
+  const endpoint = readEndpoint();
+  const headless = options.headless ?? process.env.KERNEL_HEADLESS !== "false";
+  const stealth = options.stealth ?? readBooleanEnv("KERNEL_STEALTH", false);
+  const timeoutSeconds = readTimeoutSeconds(options);
+  const enableRecording =
+    options.enableRecording ?? readBooleanEnv("KERNEL_ENABLE_RECORDING", false);
+  const replays = new Map<
+    string,
+    {
+      replayId: string;
+      replayViewUrl?: string;
+    }
+  >();
 
   return {
     async createSession() {
-      const resp = await fetch(`${KERNEL_API_ENDPOINT}/browsers`, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${apiKey}`,
-          "Content-Type": "application/json",
+      const json = await kernelFetchJson<KernelBrowserResponse>(
+        endpoint,
+        apiKey,
+        "/browsers",
+        {
+          method: "POST",
+          body: JSON.stringify({
+            headless,
+            stealth,
+            timeout_seconds: timeoutSeconds,
+          }),
         },
-        body: JSON.stringify({
-          headless: process.env.KERNEL_HEADLESS !== "false",
-          stealth: process.env.KERNEL_STEALTH === "true",
-          timeout_seconds: Number(process.env.KERNEL_TIMEOUT_SECONDS ?? 300),
-        }),
-      });
-      if (!resp.ok) {
-        const body = await resp.text();
-        throw new Error(`Kernel API error (${resp.status}): ${body}`);
+      );
+
+      let replay: KernelReplayResponse | undefined;
+      if (enableRecording) {
+        try {
+          replay = await kernelFetchJson<KernelReplayResponse>(
+            endpoint,
+            apiKey,
+            `/browsers/${json.session_id}/replays`,
+            { method: "POST", body: JSON.stringify({}) },
+          );
+          replays.set(json.session_id, {
+            replayId: replay.replay_id,
+            replayViewUrl: replay.replay_view_url ?? undefined,
+          });
+        } catch (error) {
+          await kernelFetchNoBody(
+            endpoint,
+            apiKey,
+            `/browsers/${json.session_id}`,
+            { method: "DELETE" },
+          ).catch(() => {});
+          throw error;
+        }
       }
-      const json = (await resp.json()) as {
-        session_id: string;
-        cdp_ws_url: string;
-      };
+
       return {
         sessionId: json.session_id,
         cdpEndpoint: json.cdp_ws_url,
+        liveViewUrl: json.browser_live_view_url ?? undefined,
+        recordingUrl: replay?.replay_view_url ?? undefined,
       };
     },
     async closeSession(sessionId) {
-      const resp = await fetch(`${KERNEL_API_ENDPOINT}/browsers/${sessionId}`, {
+      const replay = replays.get(sessionId);
+      let replayStopError: unknown;
+      if (replay) {
+        try {
+          await kernelFetchNoBody(
+            endpoint,
+            apiKey,
+            `/browsers/${sessionId}/replays/${replay.replayId}/stop`,
+            { method: "POST" },
+          );
+        } catch (error) {
+          replayStopError = error;
+        }
+      }
+
+      await kernelFetchNoBody(endpoint, apiKey, `/browsers/${sessionId}`, {
         method: "DELETE",
-        headers: { Authorization: `Bearer ${apiKey}` },
       });
-      if (!resp.ok) {
-        const body = await resp.text();
-        throw new Error(
-          `Kernel API error closing session ${sessionId} (${resp.status}): ${body}`,
-        );
+      replays.delete(sessionId);
+
+      if (replayStopError) {
+        throw replayStopError;
       }
-      return {};
+      return { replayUrl: replay?.replayViewUrl };
     },
   };
 }

package/src/cli/core/providers/steel.ts

@@ -8,6 +8,16 @@ type SteelSessionResponse = {
   sessionViewerUrl?: string;
 };
 
+const STEEL_STEALTH_SESSION_OPTIONS = {
+  solveCaptcha: true,
+  useProxy: true,
+  stealthConfig: {
+    humanizeInteractions: true,
+    autoCaptchaSolving: true,
+    skipFingerprintInjection: false,
+  },
+};
+
 export type SteelProviderOptions = {
   apiKey?: string;
 };
@@ -30,7 +40,7 @@ export function createSteelProvider(
           "steel-api-key": apiKey,
           "Content-Type": "application/json",
         },
-        body: JSON.stringify({}),
+        body: JSON.stringify(STEEL_STEALTH_SESSION_OPTIONS),
       });
       if (!resp.ok) {
         const body = await resp.text();

package/src/cli/core/providers/types.ts

@@ -5,6 +5,9 @@ export type ProviderSession = {
   // Only libretto-cloud surfaces this today; direct-SDK providers leave it
   // undefined.
   liveViewUrl?: string;
+  // Provider-hosted URL for watching the recording for this session. It may be
+  // available as soon as recording starts, before the provider has finalized it.
+  recordingUrl?: string;
 };
 
 export type ProviderCloseResult = {

package/src/index.ts

@@ -29,13 +29,33 @@ export {
 } from "./shared/state/index.js";
 
 // Recovery
-export { executeRecoveryAgent } from "./runtime/recovery/agent.js";
+export {
+  executeRecoveryAgent,
+  type BrowserAction,
+  type RecoveryAgentResult,
+  type RecoveryAgentStep,
+} from "./runtime/recovery/agent.js";
 export { attemptWithRecovery } from "./runtime/recovery/recovery.js";
 export {
   detectSubmissionError,
   type KnownSubmissionError,
   type DetectedSubmissionError,
 } from "./runtime/recovery/errors.js";
+export {
+  COMPUTER_USE_RECOVERY_MODELS,
+  POPUP_RECOVERY_INSTRUCTION,
+  computerUseRecoveryAction,
+  createRecoveryPage,
+  popupRecoveryAction,
+  type ComputerUseRecoveryActionOptions,
+  type PopupRecoveryActionOptions,
+  type RecoveryActionContext,
+  type RecoveryAction,
+  type RecoveryActionHandler,
+  type RecoveryActionOptions,
+  type RecoveryActionResult,
+  type RecoveryActionTargetType,
+} from "./runtime/recovery/page-fallbacks.js";
 
 // AI extraction
 export {
@@ -105,7 +125,7 @@ export {
   type ExportedLibrettoWorkflow,
   type LibrettoWorkflowContext,
   type LibrettoWorkflowHandler,
-  type LibrettoWorkflowSchemas,
+  type LibrettoWorkflowOptions,
   type WorkflowInputValidator,
 } from "./shared/workflow/workflow.js";
 const isDirectExecution = (): boolean => {