libretto 0.5.5 → 0.6.0

package/dist/{shared/llm/client.js → cli/core/resolve-model.js}

@@ -1,4 +1,3 @@
-import { generateObject } from "ai";
 const GEMINI_API_KEY_ENV_VARS = [
   "GEMINI_API_KEY",
   "GOOGLE_GENERATIVE_AI_API_KEY"
@@ -108,76 +107,13 @@ async function getProviderModel(provider, modelId) {
     }
   }
 }
-function convertUserContentParts(parts) {
-  return parts.map((part) => {
-    if (part.type === "text") {
-      return { type: "text", text: part.text };
-    }
-    return {
-      type: "image",
-      image: part.image,
-      ...part.mediaType ? { mediaType: part.mediaType } : {}
-    };
-  });
-}
-function convertAssistantContentParts(parts) {
-  return parts.filter(
-    (part) => part.type === "text"
-  ).map((part) => ({ type: "text", text: part.text }));
-}
-function convertMessages(messages) {
-  return messages.map((msg) => {
-    if (msg.role === "user") {
-      if (typeof msg.content === "string") {
-        return { role: "user", content: msg.content };
-      }
-      return {
-        role: "user",
-        content: convertUserContentParts(msg.content)
-      };
-    }
-    if (typeof msg.content === "string") {
-      return { role: "assistant", content: msg.content };
-    }
-    return {
-      role: "assistant",
-      content: convertAssistantContentParts(msg.content)
-    };
-  });
-}
-function createLLMClient(model) {
+async function resolveModel(model) {
   const { provider, modelId } = parseModel(model);
-  let modelPromise = null;
-  const getModel = () => {
-    modelPromise ??= getProviderModel(provider, modelId);
-    return modelPromise;
-  };
-  return {
-    async generateObject(opts) {
-      const aiModel = await getModel();
-      const result = await generateObject({
-        model: aiModel,
-        prompt: opts.prompt,
-        schema: opts.schema,
-        temperature: opts.temperature ?? 0
-      });
-      return result.object;
-    },
-    async generateObjectFromMessages(opts) {
-      const aiModel = await getModel();
-      const result = await generateObject({
-        model: aiModel,
-        messages: convertMessages(opts.messages),
-        schema: opts.schema,
-        temperature: opts.temperature ?? 0
-      });
-      return result.object;
-    }
-  };
+  return getProviderModel(provider, modelId);
 }
 export {
-  createLLMClient,
   hasProviderCredentials,
   missingProviderCredentialsMessage,
-  parseModel
+  parseModel,
+  resolveModel
 };

package/dist/cli/core/session.js

@@ -13,6 +13,7 @@ import {
   LIBRETTO_SESSIONS_DIR
 } from "./context.js";
 import {
+  SessionAccessModeSchema,
   SESSION_STATE_VERSION,
   parseSessionStateContent,
   serializeSessionState
@@ -28,6 +29,9 @@ function generateSessionName() {
   }
   return `ses-${id}`;
 }
+function resolveSessionAccessMode(state) {
+  return SessionAccessModeSchema.parse(state?.mode);
+}
 function logFileForSession(session) {
   validateSessionName(session);
   const dir = getSessionDir(session);
@@ -85,6 +89,21 @@ function listSessionsWithStateFile() {
 function listActiveSessions() {
   return listSessionsWithStateFile();
 }
+function listRunningSessions() {
+  const sessions = listSessionsWithStateFile();
+  const running = [];
+  for (const name of sessions) {
+    const state = readSessionState(name);
+    if (!state) continue;
+    if (state.provider) {
+      running.push(state);
+      continue;
+    }
+    if (state.pid == null || !isPidRunning(state.pid)) continue;
+    running.push(state);
+  }
+  return running;
+}
 function throwSessionNotFoundError(session) {
   const active = listActiveSessions();
   const lines = [`No session "${session}" found.`];
@@ -132,10 +151,34 @@ function writeSessionState(state, logger) {
   logger?.info("session-state-write", {
     session: state.session,
     stateFile,
+    mode: state.mode,
     port: state.port,
     pid: state.pid
   });
 }
+function setSessionMode(session, mode, logger) {
+  const state = readSessionStateOrThrow(session);
+  const normalizedMode = SessionAccessModeSchema.parse(mode);
+  if (state.mode === normalizedMode) {
+    return state;
+  }
+  const nextState = {
+    ...state,
+    mode: normalizedMode
+  };
+  writeSessionState(nextState, logger);
+  return nextState;
+}
+function assertSessionAllowsCommand(state, commandName, allowedModes) {
+  const mode = resolveSessionAccessMode(state);
+  if (allowedModes.includes(mode)) {
+    return;
+  }
+  const supportedModes = [...allowedModes].join(", ");
+  throw new Error(
+    `Command "${commandName}" is blocked for session "${state.session}" because it is in ${mode} mode. Allowed modes for this command: ${supportedModes}. Run \`libretto session-mode write-access --session ${state.session}\` to unlock the session.`
+  );
+}
 function clearSessionState(session, logger) {
   const stateFile = getStateFilePath(session);
   if (!existsSync(stateFile)) {
@@ -168,6 +211,11 @@ function setSessionStatus(session, status, logger) {
 function assertSessionAvailableForStart(session, logger) {
   const existingState = readSessionState(session, logger);
   if (!existingState) return;
+  if (existingState.provider && existingState.cdpEndpoint) {
+    throw new Error(
+      `Session "${session}" is already open via ${existingState.provider.name} provider. Close it first with: libretto close --session ${session}`
+    );
+  }
   if (existingState.pid == null || !isPidRunning(existingState.pid)) {
     setSessionStatus(session, "exited", logger);
     return;
@@ -181,15 +229,20 @@ export {
   SESSION_BROWSER_AGENT,
   SESSION_DEV_SERVER,
   SESSION_STATE_VERSION,
+  assertSessionAllowsCommand,
   assertSessionAvailableForStart,
   assertSessionStateExistsOrThrow,
   clearSessionState,
   generateSessionName,
   getStateFilePath,
+  isPidRunning,
+  listRunningSessions,
   listSessionsWithStateFile,
   logFileForSession,
   readSessionState,
   readSessionStateOrThrow,
+  resolveSessionAccessMode,
+  setSessionMode,
   setSessionStatus,
   validateSessionName,
   writeSessionState

package/dist/cli/core/skill-version.js

@@ -0,0 +1,73 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { REPO_ROOT } from "./context.js";
+const INSTALLED_SKILL_PATHS = [
+  [".agents", "skills", "libretto", "SKILL.md"],
+  [".claude", "skills", "libretto", "SKILL.md"]
+];
+let cachedCliVersion = null;
+function readCurrentCliVersion() {
+  if (cachedCliVersion) {
+    return cachedCliVersion;
+  }
+  const packageJsonPath = fileURLToPath(
+    new URL("../../../package.json", import.meta.url)
+  );
+  const manifest = JSON.parse(
+    readFileSync(packageJsonPath, "utf8")
+  );
+  if (!manifest.version) {
+    throw new Error(
+      `Unable to determine current libretto version from ${packageJsonPath}.`
+    );
+  }
+  cachedCliVersion = manifest.version;
+  return cachedCliVersion;
+}
+function readInstalledSkillVersion(skillPath) {
+  if (!existsSync(skillPath)) {
+    return null;
+  }
+  const contents = readFileSync(skillPath, "utf8");
+  const frontmatterMatch = contents.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!frontmatterMatch) {
+    return null;
+  }
+  const metadataBlock = frontmatterMatch[1].match(
+    /^metadata:\s*\r?\n((?:[ \t]+.*(?:\r?\n|$))*)/m
+  )?.[1];
+  if (!metadataBlock) {
+    return null;
+  }
+  const versionMatch = metadataBlock.match(
+    /^[ \t]+version:\s*["']?([^"'\r\n]+)["']?\s*$/m
+  );
+  return versionMatch?.[1]?.trim() ?? null;
+}
+function findInstalledSkillVersionMismatch() {
+  const cliVersion = readCurrentCliVersion();
+  for (const relativePathParts of INSTALLED_SKILL_PATHS) {
+    const skillPath = join(REPO_ROOT, ...relativePathParts);
+    const installedVersion = readInstalledSkillVersion(skillPath);
+    if (installedVersion && installedVersion !== cliVersion) {
+      return { installedVersion, cliVersion };
+    }
+  }
+  return null;
+}
+function warnIfInstalledSkillOutOfDate() {
+  try {
+    const mismatch = findInstalledSkillVersionMismatch();
+    if (!mismatch) {
+      return;
+    }
+    console.error(
+      `Warning: Your agent skill (${mismatch.installedVersion}) is out of date with your Libretto CLI (${mismatch.cliVersion}). Please run \`npx libretto setup\` to update your skills to the correct version.`
+    );
+  } catch {
+  }
+}
+export {
+  warnIfInstalledSkillOutOfDate
+};

package/dist/cli/core/telemetry.js

@@ -1,8 +1,7 @@
 import {
   appendFileSync,
   existsSync,
-  readFileSync,
-  writeFileSync
+  readFileSync
 } from "node:fs";
 import {
   getSessionActionsLogPath,
@@ -34,30 +33,6 @@ function readNetworkLog(session, opts = {}) {
   }
   return entries;
 }
-function formatNetworkEntry(e) {
-  const time = e.ts.replace(/.*T/, "").replace(/\.\d+Z$/, "");
-  const duration = e.durationMs != null ? `${e.durationMs}ms` : "?ms";
-  const size = e.size != null ? `${e.size}B` : "";
-  const parts = [
-    `[${time}]`,
-    `${e.status}`,
-    `${e.method.padEnd(6)}`,
-    e.url,
-    duration,
-    size
-  ].filter(Boolean);
-  let line = parts.join(" ");
-  if (e.postData) {
-    line += `
-         body: ${e.postData.substring(0, 120)}${e.postData.length > 120 ? "..." : ""}`;
-  }
-  return line;
-}
-function clearNetworkLog(session) {
-  assertSessionStateExistsOrThrow(session);
-  const logPath = getSessionNetworkLogPath(session);
-  writeFileSync(logPath, "");
-}
 function parentLogAction(session, entry) {
   try {
     const record = { ts: (/* @__PURE__ */ new Date()).toISOString(), ...entry };
@@ -99,30 +74,6 @@ function readActionLog(session, opts = {}) {
   }
   return entries;
 }
-function formatActionEntry(e) {
-  const time = e.ts.replace(/.*T/, "").replace(/\.\d+Z$/, "");
-  const src = e.source.toUpperCase().padEnd(5);
-  const displaySelector = e.bestSemanticSelector || e.selector;
-  const parts = [`[${time}]`, `[${src}]`, e.action];
-  if (displaySelector) parts.push(displaySelector);
-  if (e.targetSelector && e.targetSelector !== displaySelector) {
-    parts.push(`target=${e.targetSelector}`);
-  }
-  if (e.nearbyText) parts.push(`text="${e.nearbyText}"`);
-  if (e.coordinates) {
-    parts.push(`@(${e.coordinates.x},${e.coordinates.y})`);
-  }
-  if (e.value) parts.push(`"${e.value}"`);
-  if (e.url) parts.push(e.url);
-  if (e.duration != null) parts.push(`${e.duration}ms`);
-  if (!e.success) parts.push(`ERROR: ${e.error || "unknown"}`);
-  return parts.join(" ");
-}
-function clearActionLog(session) {
-  assertSessionStateExistsOrThrow(session);
-  const logPath = getSessionActionsLogPath(session);
-  writeFileSync(logPath, "");
-}
 const LOCATOR_ACTION_METHODS = [
   "click",
   "dblclick",
@@ -367,10 +318,6 @@ function wrapPageForActionLogging(page, session, pageId, onActivity) {
   }
 }
 export {
-  clearActionLog,
-  clearNetworkLog,
-  formatActionEntry,
-  formatNetworkEntry,
   parentLogAction,
   readActionLog,
   readNetworkLog,

package/dist/cli/index.js

@@ -1,14 +1,8 @@
 #!/usr/bin/env node
 import { runLibrettoCLI } from "./cli.js";
-import {
-  maybeConfigureLLMClientFactoryFromEnv,
-  setLLMClientFactory
-} from "./core/context.js";
 import { runClose } from "./commands/browser.js";
-maybeConfigureLLMClientFactoryFromEnv();
 void runLibrettoCLI();
 export {
   runClose,
-  runLibrettoCLI,
-  setLLMClientFactory
+  runLibrettoCLI
 };

package/dist/cli/router.js

@@ -2,17 +2,17 @@ import { aiCommands } from "./commands/ai.js";
 import { browserCommands } from "./commands/browser.js";
 import { deployCommand } from "./commands/deploy.js";
 import { executionCommands } from "./commands/execution.js";
-import { initCommand } from "./commands/init.js";
-import { logCommands } from "./commands/logs.js";
+import { setupCommand } from "./commands/setup.js";
+import { statusCommand } from "./commands/status.js";
 import { snapshotCommand } from "./commands/snapshot.js";
 import { SimpleCLI } from "./framework/simple-cli.js";
 const cliRoutes = {
   ...browserCommands,
   deploy: deployCommand,
   ...executionCommands,
-  ...logCommands,
   ai: aiCommands,
-  init: initCommand,
+  setup: setupCommand,
+  status: statusCommand,
   snapshot: snapshotCommand
 };
 function createCLIApp() {

package/dist/cli/workers/run-integration-runtime.js

@@ -4,7 +4,7 @@ import { cwd } from "node:process";
 import { isAbsolute, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import {
-  getWorkflowFromModuleExports,
+  getDefaultWorkflowFromModuleExports,
   getWorkflowsFromModuleExports,
   instrumentContext,
   launchBrowser
@@ -89,7 +89,7 @@ function getAbsoluteIntegrationPath(integrationPath) {
   }
   return absolutePath;
 }
-async function loadWorkflowByName(absolutePath, workflowName) {
+async function loadDefaultWorkflow(absolutePath) {
   let loadedModule;
   try {
     loadedModule = await import(pathToFileURL(absolutePath).href);
@@ -101,16 +101,20 @@ ${TSCONFIG_HINT}` : "";
       `Failed to import integration module at ${absolutePath}: ${message}${compileHint}`
     );
   }
-  const workflow = getWorkflowFromModuleExports(loadedModule, workflowName);
-  if (workflow) {
-    return workflow;
+  const defaultWorkflow = getDefaultWorkflowFromModuleExports(loadedModule);
+  if (defaultWorkflow) {
+    return defaultWorkflow;
   }
-  const availableWorkflows = getWorkflowsFromModuleExports(loadedModule).map(
+  const availableWorkflowNames = getWorkflowsFromModuleExports(loadedModule).map(
     (candidate) => candidate.name
   );
-  const detail = availableWorkflows.length > 0 ? ` Available workflows: ${availableWorkflows.join(", ")}` : ' No workflows found in this file. Export a workflow() instance from "libretto" directly or via `export const workflows = { ... }`.';
+  if (availableWorkflowNames.length === 0) {
+    throw new Error(
+      `No default-exported workflow found in ${absolutePath}. Export the workflow with \`export default workflow("name", handler)\`.`
+    );
+  }
   throw new Error(
-    `Workflow "${workflowName}" not found in ${absolutePath}.${detail}`
+    `No default-exported workflow found in ${absolutePath}. libretto run only uses the file's default export. Available named workflows: ${availableWorkflowNames.join(", ")}`
   );
 }
 async function installHeadedWorkflowVisualization(args) {
@@ -122,7 +126,7 @@ async function installHeadedWorkflowVisualization(args) {
 async function runIntegrationInternal(args, options) {
   const { logger } = options;
   const absolutePath = getAbsoluteIntegrationPath(args.integrationPath);
-  const workflow = await loadWorkflowByName(absolutePath, args.workflowName);
+  const workflow = await loadDefaultWorkflow(absolutePath);
   const signalPaths = getPauseSignalPaths(args.session);
   await removeSignalIfExists(signalPaths.pausedSignalPath);
   await removeSignalIfExists(signalPaths.resumeSignalPath);
@@ -130,11 +134,11 @@ async function runIntegrationInternal(args, options) {
   await removeSignalIfExists(signalPaths.failedSignalPath);
   const restoreStdout = mirrorStdoutToFile(signalPaths.outputSignalPath);
   console.log(
-    `Running workflow "${args.workflowName}" from ${absolutePath} (${args.headless ? "headless" : "headed"})...`
+    `Running workflow "${workflow.name}" from ${absolutePath} (${args.headless ? "headless" : "headed"})...`
   );
   const integrationLogger = logger.withScope("integration-run", {
     integrationPath: absolutePath,
-    workflowName: args.workflowName,
+    workflowName: workflow.name,
     session: args.session
   });
   const authProfileDomain = args.authProfileDomain;
@@ -153,7 +157,10 @@ async function runIntegrationInternal(args, options) {
     sessionName: args.session,
     headless: args.headless,
     storageStatePath,
-    viewport: args.viewport
+    viewport: args.viewport,
+    accessMode: args.accessMode,
+    cdpEndpoint: args.cdpEndpoint,
+    provider: args.provider
   });
   if (!args.headless && args.visualize !== false) {
     await installHeadedWorkflowVisualization({
@@ -208,7 +215,6 @@ async function runIntegrationInternal(args, options) {
       JSON.stringify({ completedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2),
       "utf8"
     );
-    console.log("Integration completed.");
     return { status: "completed" };
   } finally {
     restoreStdout();

package/dist/cli/workers/run-integration-worker-protocol.js

@@ -1,13 +1,16 @@
 import { z } from "zod";
+import { SessionAccessModeSchema } from "../../shared/state/index.js";
 const RunIntegrationWorkerRequestSchema = z.object({
   integrationPath: z.string().min(1),
-  workflowName: z.string().min(1),
   session: z.string().min(1),
   params: z.unknown(),
   headless: z.boolean(),
   visualize: z.boolean().default(true),
   authProfileDomain: z.string().optional(),
-  viewport: z.object({ width: z.number(), height: z.number() }).optional()
+  viewport: z.object({ width: z.number(), height: z.number() }).optional(),
+  accessMode: SessionAccessModeSchema.default("write-access"),
+  cdpEndpoint: z.string().optional(),
+  provider: z.object({ name: z.string(), sessionId: z.string() }).optional()
 });
 export {
   RunIntegrationWorkerRequestSchema

package/dist/index.d.ts

@@ -1,7 +1,5 @@
 export { LogOptions, Logger, LoggerApi, LoggerSink, MinimalLogger, defaultLogger } from './shared/logger/logger.js';
 export { createFileLogSink, jsonlConsoleSink, prettyConsoleSink } from './shared/logger/sinks.js';
-export { LLMClient, Message, MessageContentPart } from './shared/llm/types.js';
-export { createLLMClientFromModel } from './shared/llm/ai-sdk-adapter.js';
 export { SESSION_STATE_VERSION, SessionState, SessionStateFile, SessionStateFileSchema, SessionStatus, SessionStatusSchema, parseSessionStateContent, parseSessionStateData, serializeSessionState } from './shared/state/session-state.js';
 export { executeRecoveryAgent } from './runtime/recovery/agent.js';
 export { attemptWithRecovery } from './runtime/recovery/recovery.js';
@@ -14,7 +12,7 @@ export { InstrumentationOptions, InstrumentedPage, installInstrumentation, instr
 export { GhostCursorOptions, ensureGhostCursor, ghostClick, hideGhostCursor, moveGhostCursor } from './shared/visualization/ghost-cursor.js';
 export { HighlightOptions, clearHighlights, ensureHighlightLayer, showHighlight } from './shared/visualization/highlight.js';
 export { BrowserSession, LaunchBrowserArgs, launchBrowser } from './shared/run/browser.js';
-export { ExportedLibrettoWorkflow, LIBRETTO_WORKFLOW_BRAND, LibrettoWorkflow, LibrettoWorkflowContext, LibrettoWorkflowHandler, getWorkflowFromModuleExports, getWorkflowsFromModuleExports, isLibrettoWorkflow, workflow } from './shared/workflow/workflow.js';
+export { ExportedLibrettoWorkflow, LIBRETTO_WORKFLOW_BRAND, LibrettoWorkflow, LibrettoWorkflowContext, LibrettoWorkflowHandler, getDefaultWorkflowFromModuleExports, getWorkflowFromModuleExports, getWorkflowsFromModuleExports, isLibrettoWorkflow, workflow } from './shared/workflow/workflow.js';
 import 'zod';
-import 'ai';
 import 'playwright';
+import 'ai';

package/dist/index.js

@@ -9,7 +9,6 @@ import {
   prettyConsoleSink,
   jsonlConsoleSink
 } from "./shared/logger/sinks.js";
-import { createLLMClientFromModel } from "./shared/llm/ai-sdk-adapter.js";
 import {
   SESSION_STATE_VERSION,
   SessionStatusSchema,
@@ -54,6 +53,7 @@ import {
   launchBrowser
 } from "./shared/run/api.js";
 import {
+  getDefaultWorkflowFromModuleExports,
   getWorkflowFromModuleExports,
   getWorkflowsFromModuleExports,
   isLibrettoWorkflow,
@@ -86,7 +86,6 @@ export {
   attemptWithRecovery,
   clearHighlights,
   createFileLogSink,
-  createLLMClientFromModel,
   defaultLogger,
   detectSubmissionError,
   downloadAndSave,
@@ -95,6 +94,7 @@ export {
   ensureHighlightLayer,
   executeRecoveryAgent,
   extractFromPage,
+  getDefaultWorkflowFromModuleExports,
   getWorkflowFromModuleExports,
   getWorkflowsFromModuleExports,
   ghostClick,

package/dist/runtime/extract/extract.d.ts

@@ -1,13 +1,13 @@
 import { Page } from 'playwright';
 import z from 'zod';
 import { MinimalLogger } from '../../shared/logger/logger.js';
-import { LLMClient } from '../../shared/llm/types.js';
+import { LanguageModel } from 'ai';
 
 type ExtractOptions<T extends z.ZodType> = {
     page: Page;
     instruction: string;
     schema: T;
-    llmClient: LLMClient;
+    model: LanguageModel;
     logger?: MinimalLogger;
     /** Optional CSS selector to scope extraction to a specific element. */
     selector?: string;

package/dist/runtime/extract/extract.js

@@ -1,6 +1,7 @@
 import {
   defaultLogger
 } from "../../shared/logger/logger.js";
+import { generateObject } from "ai";
 async function extractFromPage(options) {
   const {
     page,
@@ -8,7 +9,7 @@ async function extractFromPage(options) {
     schema,
     selector,
     logger = defaultLogger,
-    llmClient
+    model
   } = options;
   let screenshot;
   let domContent;
@@ -49,7 +50,8 @@ ${domContent}
 </html>` : ""}
 
 Extract the requested information from the screenshot and return it in the specified format. Be precise and only extract what is visible.`;
-  const result = await llmClient.generateObjectFromMessages({
+  const { object: result } = await generateObject({
+    model,
     schema,
     messages: [
       {

package/dist/runtime/extract/index.d.ts

@@ -2,4 +2,4 @@ export { ExtractOptions, extractFromPage } from './extract.js';
 import 'playwright';
 import 'zod';
 import '../../shared/logger/logger.js';
-import '../../shared/llm/types.js';
+import 'ai';

package/dist/runtime/recovery/agent.d.ts

@@ -1,13 +1,12 @@
 import { Page } from 'playwright';
 import { MinimalLogger } from '../../shared/logger/logger.js';
-import { LLMClient } from '../../shared/llm/types.js';
-import 'zod';
+import { LanguageModel } from 'ai';
 
 /**
  * Executes a vision-based recovery agent to recover from browser automation failures.
  * Takes a screenshot, sends it to the LLM with the instruction, and executes
  * the LLM's suggested browser actions.
  */
-declare function executeRecoveryAgent(page: Page, instruction: string, logger?: MinimalLogger, llmClient?: LLMClient): Promise<void>;
+declare function executeRecoveryAgent(page: Page, instruction: string, logger?: MinimalLogger, model?: LanguageModel): Promise<void>;
 
 export { executeRecoveryAgent };

package/dist/runtime/recovery/agent.js

@@ -1,6 +1,7 @@
 import {
   defaultLogger
 } from "../../shared/logger/logger.js";
+import { generateObject } from "ai";
 function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -137,8 +138,8 @@ const recoveryActionSchema = z.object({
     })
   ])
 });
-async function executeRecoveryAgent(page, instruction, logger, llmClient) {
-  if (!llmClient) {
+async function executeRecoveryAgent(page, instruction, logger, model) {
+  if (!model) {
     return;
   }
   const log = logger ?? defaultLogger;
@@ -158,7 +159,8 @@ async function executeRecoveryAgent(page, instruction, logger, llmClient) {
   }
   const maxSteps = 3;
   for (let step = 1; step <= maxSteps; step++) {
-    const result = await llmClient.generateObjectFromMessages({
+    const { object: result } = await generateObject({
+      model,
       schema: recoveryActionSchema,
       messages: [
         {

package/dist/runtime/recovery/errors.d.ts

@@ -1,7 +1,6 @@
 import { Page } from 'playwright';
 import { MinimalLogger } from '../../shared/logger/logger.js';
-import { LLMClient } from '../../shared/llm/types.js';
-import 'zod';
+import { LanguageModel } from 'ai';
 
 /**
  * Known error type for classifying submission errors.
@@ -26,6 +25,6 @@ type DetectedSubmissionError = {
  * @returns DetectedSubmissionError if a known error is matched
  * @throws The original error if no known error matches
  */
-declare function detectSubmissionError(page: Page, error: unknown, logContext: string, llmClient: LLMClient, knownErrors?: KnownSubmissionError[], logger?: MinimalLogger): Promise<DetectedSubmissionError>;
+declare function detectSubmissionError(page: Page, error: unknown, logContext: string, model: LanguageModel, knownErrors?: KnownSubmissionError[], logger?: MinimalLogger): Promise<DetectedSubmissionError>;
 
 export { type DetectedSubmissionError, type KnownSubmissionError, detectSubmissionError };