libretto 0.2.3 → 0.2.5

package/dist/cli/core/browser.js

@@ -12,12 +12,15 @@ import {
 import {
   assertSessionAvailableForStart,
   clearSessionState,
+  listSessionsWithStateFile,
   readSessionStateOrThrow,
   logFileForSession,
   readSessionState,
   writeSessionState
 } from "./session.js";
 import { installSessionTelemetry } from "./session-telemetry.js";
+const CLOSE_WAIT_MS = 1500;
+const FORCE_CLOSE_WAIT_MS = 300;
 async function pickFreePort() {
   return await new Promise((resolve2, reject) => {
     const server = createServer();
@@ -488,16 +491,137 @@ async function runClose(session, logger) {
     return;
   }
   logger.info("close-killing", { session, pid: state.pid, port: state.port });
-  try {
-    process.kill(state.pid, "SIGTERM");
-  } catch (err) {
-    logger.warn("close-kill-failed", { error: err, session, pid: state.pid });
-  }
-  await new Promise((r) => setTimeout(r, 1500));
+  sendSignalToProcessGroupOrPid(state.pid, "SIGTERM", logger, session);
+  await waitForCloseSignalWindow(CLOSE_WAIT_MS);
   clearSessionState(session, logger);
   logger.info("close-success", { session });
   console.log(`Browser closed (session: ${session}).`);
 }
+function waitForCloseSignalWindow(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function isPidRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function sendSignalToProcessGroupOrPid(pid, signal, logger, session) {
+  try {
+    process.kill(pid, signal);
+    logger.info("close-signal-pid", { session, pid, signal });
+  } catch (pidErr) {
+    const pidCode = pidErr.code;
+    if (pidCode !== "ESRCH") {
+      logger.warn("close-signal-pid-failed", {
+        session,
+        pid,
+        signal,
+        error: pidErr
+      });
+    }
+  }
+}
+function formatSessionList(targets) {
+  return targets.map((target) => `"${target.session}"`).join(", ");
+}
+function resolveClosableSessions(logger) {
+  const sessions = listSessionsWithStateFile();
+  const closable = [];
+  let clearedUnreadableStates = 0;
+  for (const session of sessions) {
+    const state = readSessionState(session, logger);
+    if (!state) {
+      clearSessionState(session, logger);
+      clearedUnreadableStates += 1;
+      continue;
+    }
+    closable.push({
+      session,
+      pid: state.pid,
+      port: state.port
+    });
+  }
+  return { closable, clearedUnreadableStates };
+}
+function clearStoppedSessionStates(sessions, logger) {
+  let cleared = 0;
+  for (const session of sessions) {
+    if (!isPidRunning(session.pid)) {
+      clearSessionState(session.session, logger);
+      cleared += 1;
+    }
+  }
+  return cleared;
+}
+async function runCloseAll(logger, options) {
+  const force = Boolean(options?.force);
+  logger.info("close-all-start", { force });
+  const { closable, clearedUnreadableStates } = resolveClosableSessions(logger);
+  if (closable.length === 0) {
+    if (clearedUnreadableStates > 0) {
+      console.log(
+        `Cleared ${clearedUnreadableStates} unreadable session state file(s).`
+      );
+    }
+    console.log("No browser sessions found.");
+    return;
+  }
+  for (const target of closable) {
+    logger.info("close-all-sigterm", {
+      session: target.session,
+      pid: target.pid,
+      port: target.port
+    });
+    sendSignalToProcessGroupOrPid(target.pid, "SIGTERM", logger, target.session);
+  }
+  await waitForCloseSignalWindow(CLOSE_WAIT_MS);
+  let survivors = closable.filter((target) => isPidRunning(target.pid));
+  if (survivors.length > 0 && !force) {
+    const closed = clearStoppedSessionStates(closable, logger);
+    throw new Error(
+      [
+        `Failed to close ${survivors.length} session(s) gracefully: ${formatSessionList(survivors)}.`,
+        `Closed ${closed} session(s).`,
+        "Retry with: libretto-cli close --all --force"
+      ].join("\n")
+    );
+  }
+  let forceKilled = 0;
+  if (survivors.length > 0) {
+    for (const survivor of survivors) {
+      logger.warn("close-all-sigkill", {
+        session: survivor.session,
+        pid: survivor.pid
+      });
+      sendSignalToProcessGroupOrPid(survivor.pid, "SIGKILL", logger, survivor.session);
+      forceKilled += 1;
+    }
+    await waitForCloseSignalWindow(FORCE_CLOSE_WAIT_MS);
+    survivors = survivors.filter((target) => isPidRunning(target.pid));
+    if (survivors.length > 0) {
+      const closed = clearStoppedSessionStates(closable, logger);
+      throw new Error(
+        [
+          `Failed to force-close ${survivors.length} session(s): ${formatSessionList(survivors)}.`,
+          `Closed ${closed} session(s).`
+        ].join("\n")
+      );
+    }
+  }
+  clearStoppedSessionStates(closable, logger);
+  if (clearedUnreadableStates > 0) {
+    console.log(
+      `Cleared ${clearedUnreadableStates} unreadable session state file(s).`
+    );
+  }
+  console.log(`Closed ${closable.length} session(s).`);
+  if (forceKilled > 0) {
+    console.log(`Force-killed ${forceKilled} session(s).`);
+  }
+}
 function resolvePath(filePath) {
   return join(process.cwd(), filePath);
 }
@@ -517,6 +641,7 @@ export {
   normalizeUrl,
   resolvePath,
   runClose,
+  runCloseAll,
   runOpen,
   runPages,
   runSave

package/dist/cli/core/context.js

@@ -53,6 +53,11 @@ function ensureLibrettoSetup() {
   if (!existsSync(LIBRETTO_GITIGNORE_PATH)) {
     writeFileSync(LIBRETTO_GITIGNORE_PATH, LIBRETTO_GITIGNORE_CONTENT, "utf-8");
   }
+  const agentsSkillsDir = join(REPO_ROOT, ".agents", "skills", "libretto");
+  const claudeSkillsDir = join(REPO_ROOT, ".claude", "skills", "libretto");
+  if (!existsSync(agentsSkillsDir) && !existsSync(claudeSkillsDir)) {
+    console.log("[libretto] Skills not installed. Run 'npx libretto init' to complete setup.");
+  }
 }
 function createLoggerForSession(session) {
   validateSessionName(session);

package/dist/cli/core/session.js

@@ -14,7 +14,6 @@ import {
 } from "./context.js";
 import {
   SESSION_STATE_VERSION,
-  SessionStatusSchema,
   parseSessionStateContent,
   serializeSessionState
 } from "../../shared/state/index.js";
@@ -65,11 +64,19 @@ function readSessionState(session, logger) {
     return null;
   }
 }
-function listActiveSessions() {
+function listSessionsWithStateFile() {
   if (!existsSync(LIBRETTO_SESSIONS_DIR)) return [];
-  return readdirSync(LIBRETTO_SESSIONS_DIR).filter(
-    (session) => existsSync(getSessionStatePath(session))
-  );
+  return readdirSync(LIBRETTO_SESSIONS_DIR).filter((session) => {
+    try {
+      validateSessionName(session);
+    } catch {
+      return false;
+    }
+    return existsSync(getSessionStatePath(session));
+  }).sort();
+}
+function listActiveSessions() {
+  return listSessionsWithStateFile();
 }
 function throwSessionNotFoundError(session) {
   const active = listActiveSessions();
@@ -128,9 +135,6 @@ function clearSessionState(session, logger) {
   unlinkSync(stateFile);
   logger?.info("session-state-cleared", { session, stateFile });
 }
-function isSessionStatus(value) {
-  return SessionStatusSchema.safeParse(value).success;
-}
 function isPidRunning(pid) {
   try {
     process.kill(pid, 0);
@@ -151,11 +155,6 @@ function setSessionStatus(session, status, logger) {
 function assertSessionAvailableForStart(session, logger) {
   const existingState = readSessionState(session, logger);
   if (!existingState) return;
-  if (isSessionStatus(existingState.status)) {
-    if (existingState.status === "completed" || existingState.status === "failed" || existingState.status === "exited") {
-      return;
-    }
-  }
   if (!isPidRunning(existingState.pid)) {
     setSessionStatus(session, "exited", logger);
     return;
@@ -174,6 +173,7 @@ export {
   assertSessionStateExistsOrThrow,
   clearSessionState,
   getStateFilePath,
+  listSessionsWithStateFile,
   logFileForSession,
   readSessionState,
   readSessionStateOrThrow,

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

@@ -1,21 +1,23 @@
-import { appendFileSync, existsSync } from "node:fs";
-import { mkdir, writeFile } from "node:fs/promises";
+import { appendFileSync, existsSync, readFileSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
 import { cwd } from "node:process";
 import { isAbsolute, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import {
   launchBrowser
 } from "../../index.js";
+import { setSessionForPause } from "../../shared/debug/pause.js";
+import { parseSessionStateContent } from "../../shared/state/index.js";
 import { getProfilePath, normalizeDomain } from "../core/browser.js";
 import {
   getSessionActionsLogPath,
-  getSessionDir,
-  getSessionNetworkLogPath
+  getSessionNetworkLogPath,
+  getSessionStatePath
 } from "../core/context.js";
 import { getPauseSignalPaths, removeSignalIfExists } from "../core/pause-signals.js";
 import { installSessionTelemetry } from "../core/session-telemetry.js";
 const LIBRETTO_WORKFLOW_BRAND = /* @__PURE__ */ Symbol.for("libretto.workflow");
-const RESUME_POLL_INTERVAL_MS = 250;
+const FAILURE_HOLD_POLL_INTERVAL_MS = 250;
 function mirrorStdoutToFile(filePath) {
   const stdout = process.stdout;
   const originalWrite = stdout.write.bind(stdout);
@@ -31,23 +33,32 @@ function mirrorStdoutToFile(filePath) {
     stdout.write = originalWrite;
   };
 }
-async function waitForResumeSignal(args) {
-  const { pausedSignalPath, resumeSignalPath } = args.signalPaths;
-  await mkdir(getSessionDir(args.session), { recursive: true });
-  await removeSignalIfExists(resumeSignalPath);
-  await writeFile(
-    pausedSignalPath,
-    JSON.stringify(args.details, null, 2),
-    "utf8"
-  );
-  await args.onPaused?.(args.details);
-  while (!existsSync(resumeSignalPath)) {
+function readSessionStatePid(session) {
+  const statePath = getSessionStatePath(session);
+  if (!existsSync(statePath)) return null;
+  try {
+    return parseSessionStateContent(readFileSync(statePath, "utf8"), statePath).pid;
+  } catch {
+    return null;
+  }
+}
+async function waitForFailureSessionRelease(args) {
+  const { session, expectedPid, logger } = args;
+  logger.info("run-failure-session-hold", { session, expectedPid });
+  while (true) {
+    const currentPid = readSessionStatePid(session);
+    if (currentPid !== expectedPid) {
+      logger.info("run-failure-session-released", {
+        session,
+        expectedPid,
+        currentPid
+      });
+      return;
+    }
     await new Promise(
-      (resolveWait) => setTimeout(resolveWait, RESUME_POLL_INTERVAL_MS)
+      (resolveWait) => setTimeout(resolveWait, FAILURE_HOLD_POLL_INTERVAL_MS)
     );
   }
-  await removeSignalIfExists(resumeSignalPath);
-  await removeSignalIfExists(pausedSignalPath);
 }
 function isLoadedLibrettoWorkflow(value) {
   if (!value || typeof value !== "object") return false;
@@ -57,13 +68,6 @@ function isLoadedLibrettoWorkflow(value) {
 function resolveLocalAuthProfilePath(domain) {
   return getProfilePath(normalizeDomain(domain));
 }
-function resolveWorkflowStorageStatePath(workflow) {
-  const authProfile = workflow.metadata.authProfile;
-  if (authProfile?.type !== "local") {
-    return void 0;
-  }
-  return resolveLocalAuthProfilePath(authProfile.domain);
-}
 function getMissingLocalAuthProfileError(args) {
   const normalizedDomain = normalizeDomain(args.domain);
   return [
@@ -101,7 +105,24 @@ async function loadWorkflowExport(absolutePath, exportName) {
   }
   if (!isLoadedLibrettoWorkflow(targetExport)) {
     throw new Error(
-      `Export "${exportName}" in ${absolutePath} must be a Libretto workflow instance. Use workflow(...) from "libretto".`
+      [
+        `Export "${exportName}" in ${absolutePath} is not a valid Libretto workflow.`,
+        "",
+        'A workflow must be created using the workflow() function from "libretto":',
+        "",
+        '  import { workflow } from "libretto";',
+        "",
+        `  export const ${exportName} = workflow<InputType, OutputType>(`,
+        "    {},",
+        "    async (ctx, input) => {",
+        "      // ctx.page     \u2014 Playwright Page instance",
+        "      // ctx.logger   \u2014 MinimalLogger",
+        "      // ctx.services \u2014 injected dependencies (generic, default {})",
+        "      // input        \u2014 JSON-serializable input matching InputType",
+        "      return output; // must match OutputType",
+        "    },",
+        "  );"
+      ].join("\n")
     );
   }
   return targetExport;
@@ -125,12 +146,12 @@ async function runIntegrationInternal(args, options) {
     integrationExport: args.exportName,
     session: args.session
   });
-  const authProfile = workflow.metadata.authProfile;
-  const storageStatePath = resolveWorkflowStorageStatePath(workflow);
-  if (authProfile?.type === "local" && storageStatePath && !existsSync(storageStatePath)) {
+  const authProfileDomain = args.authProfileDomain;
+  const storageStatePath = authProfileDomain ? resolveLocalAuthProfilePath(authProfileDomain) : void 0;
+  if (authProfileDomain && storageStatePath && !existsSync(storageStatePath)) {
     throw new Error(
       getMissingLocalAuthProfileError({
-        domain: authProfile.domain,
+        domain: authProfileDomain,
         profilePath: storageStatePath,
         session: args.session
       })
@@ -154,50 +175,35 @@ async function runIntegrationInternal(args, options) {
       appendFileSync(networkLogPath, JSON.stringify(entry) + "\n");
     }
   });
+  setSessionForPause(args.session);
   const workflowContext = {
     logger: integrationLogger,
     page: browserSession.page,
-    context: browserSession.context,
-    browser: browserSession.browser,
-    session: args.session,
-    integrationPath: absolutePath,
-    exportName: args.exportName,
-    headless: args.headless,
-    debug: args.debug,
-    pause: async () => {
-      const details = {
-        sessionName: args.session,
-        pausedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        url: browserSession.page.url()
-      };
-      console.log(`[pause] Paused at ${details.url}`);
-      console.log("[pause] Waiting for resume signal...");
-      await waitForResumeSignal({
-        signalPaths,
-        session: args.session,
-        details,
-        onPaused: options.onPaused
-      });
-      console.log("[pause] Resume signal received. Continuing workflow...");
-    }
+    services: {}
   };
   try {
     try {
       await workflow.run(workflowContext, args.params ?? {});
     } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
       await writeFile(
         signalPaths.failedSignalPath,
         JSON.stringify(
           {
             failedAt: (/* @__PURE__ */ new Date()).toISOString(),
-            message: error instanceof Error ? error.message : String(error)
+            message: errorMessage
           },
           null,
           2
         ),
         "utf8"
       );
-      throw error;
+      await waitForFailureSessionRelease({
+        session: args.session,
+        expectedPid: process.pid,
+        logger
+      });
+      return { status: "failed-held" };
     }
     await writeFile(
       signalPaths.completedSignalPath,
@@ -211,10 +217,9 @@ async function runIntegrationInternal(args, options) {
     await browserSession.close();
   }
 }
-async function runIntegrationFromFileInWorker(args, logger, onPaused) {
+async function runIntegrationFromFileInWorker(args, logger) {
   return await runIntegrationInternal(args, {
-    logger,
-    onPaused
+    logger
   });
 }
 export {

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

@@ -0,0 +1,12 @@
+import { z } from "zod";
+const RunIntegrationWorkerRequestSchema = z.object({
+  integrationPath: z.string().min(1),
+  exportName: z.string().min(1),
+  session: z.string().min(1),
+  params: z.unknown(),
+  headless: z.boolean(),
+  authProfileDomain: z.string().optional()
+});
+export {
+  RunIntegrationWorkerRequestSchema
+};

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

@@ -1,17 +1,14 @@
 import { writeFile } from "node:fs/promises";
+import { ZodError } from "zod";
+import {
+  RunIntegrationWorkerRequestSchema
+} from "./run-integration-worker-protocol.js";
 import { runIntegrationFromFileInWorker } from "./run-integration-runtime.js";
 import {
   ensureLibrettoSetup,
   withSessionLogger
 } from "../core/context.js";
 import { getPauseSignalPaths } from "../core/pause-signals.js";
-function sendMessage(message) {
-  if (typeof process.send !== "function" || !process.connected) return;
-  try {
-    process.send(message);
-  } catch {
-  }
-}
 function parseWorkerRequest(argv) {
   const rawPayload = argv[2];
   if (!rawPayload) {
@@ -25,21 +22,15 @@ function parseWorkerRequest(argv) {
       `Invalid worker payload JSON: ${error instanceof Error ? error.message : String(error)}`
     );
   }
-  if (!parsed || typeof parsed !== "object") {
-    throw new Error("Worker payload must be an object.");
-  }
-  const candidate = parsed;
-  if (typeof candidate.integrationPath !== "string" || typeof candidate.exportName !== "string" || typeof candidate.session !== "string" || typeof candidate.headless !== "boolean" || typeof candidate.debug !== "boolean" || !("params" in candidate)) {
-    throw new Error("Worker payload is missing required fields.");
+  try {
+    return RunIntegrationWorkerRequestSchema.parse(parsed);
+  } catch (error) {
+    if (error instanceof ZodError) {
+      const details = error.issues.map((issue) => `${issue.path.join(".") || "root"}: ${issue.message}`).join("; ");
+      throw new Error(`Worker payload is invalid: ${details}`);
+    }
+    throw error;
   }
-  return {
-    integrationPath: candidate.integrationPath,
-    exportName: candidate.exportName,
-    session: candidate.session,
-    headless: candidate.headless,
-    debug: candidate.debug,
-    params: candidate.params
-  };
 }
 async function main() {
   let request = null;
@@ -49,15 +40,8 @@ async function main() {
     const workerRequest = request;
     ensureLibrettoSetup();
     await withSessionLogger(workerRequest.session, async (logger) => {
-      await runIntegrationFromFileInWorker(
-        workerRequest,
-        logger,
-        async (details) => {
-          sendMessage({ type: "paused", details });
-        }
-      );
+      await runIntegrationFromFileInWorker(workerRequest, logger);
     });
-    sendMessage({ type: "completed" });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     if (request) {
@@ -75,7 +59,6 @@ async function main() {
         "utf8"
       );
     }
-    sendMessage({ type: "failed", message });
     exitCode = 1;
   }
   process.exit(exitCode);

package/dist/index.cjs

@@ -18,18 +18,16 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var index_exports = {};
 __export(index_exports, {
-  DebugPauseSignal: () => import_pause.DebugPauseSignal,
   LIBRETTO_WORKFLOW_BRAND: () => import_workflow.LIBRETTO_WORKFLOW_BRAND,
   LibrettoWorkflow: () => import_workflow.LibrettoWorkflow,
   Logger: () => import_logger.Logger,
-  RunDebugPauseSignal: () => import_api.DebugPauseSignal,
   SESSION_STATE_VERSION: () => import_state.SESSION_STATE_VERSION,
   SessionStateFileSchema: () => import_state.SessionStateFileSchema,
   SessionStatusSchema: () => import_state.SessionStatusSchema,
   attemptWithRecovery: () => import_recovery.attemptWithRecovery,
   clearHighlights: () => import_highlight.clearHighlights,
   createFileLogSink: () => import_sinks.createFileLogSink,
-  debugPause: () => import_pause.debugPause,
+  createLLMClientFromModel: () => import_ai_sdk_adapter.createLLMClientFromModel,
   defaultLogger: () => import_logger.defaultLogger,
   detectSubmissionError: () => import_errors.detectSubmissionError,
   downloadAndSave: () => import_download.downloadAndSave,
@@ -44,17 +42,15 @@ __export(index_exports, {
   instrumentContext: () => import_instrument.instrumentContext,
   instrumentPage: () => import_instrument.instrumentPage,
   isDebugMode: () => import_config.isDebugMode,
-  isDebugPauseSignal: () => import_pause.isDebugPauseSignal,
   isDryRun: () => import_config.isDryRun,
-  isRunDebugPauseSignal: () => import_api.isDebugPauseSignal,
   jsonlConsoleSink: () => import_sinks.jsonlConsoleSink,
   launchBrowser: () => import_api.launchBrowser,
   moveGhostCursor: () => import_ghost_cursor.moveGhostCursor,
   pageRequest: () => import_network.pageRequest,
   parseSessionStateContent: () => import_state.parseSessionStateContent,
   parseSessionStateData: () => import_state.parseSessionStateData,
+  pause: () => import_pause.pause,
   prettyConsoleSink: () => import_sinks.prettyConsoleSink,
-  runDebugPause: () => import_api.debugPause,
   serializeSessionState: () => import_state.serializeSessionState,
   shouldPauseBeforeMutation: () => import_config.shouldPauseBeforeMutation,
   showHighlight: () => import_highlight.showHighlight,
@@ -63,6 +59,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 var import_logger = require("./shared/logger/logger.js");
 var import_sinks = require("./shared/logger/sinks.js");
+var import_ai_sdk_adapter = require("./shared/llm/ai-sdk-adapter.js");
 var import_state = require("./shared/state/index.js");
 var import_agent = require("./runtime/recovery/agent.js");
 var import_recovery = require("./runtime/recovery/recovery.js");
@@ -79,18 +76,16 @@ var import_api = require("./shared/run/api.js");
 var import_workflow = require("./shared/workflow/workflow.js");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  DebugPauseSignal,
   LIBRETTO_WORKFLOW_BRAND,
   LibrettoWorkflow,
   Logger,
-  RunDebugPauseSignal,
   SESSION_STATE_VERSION,
   SessionStateFileSchema,
   SessionStatusSchema,
   attemptWithRecovery,
   clearHighlights,
   createFileLogSink,
-  debugPause,
+  createLLMClientFromModel,
   defaultLogger,
   detectSubmissionError,
   downloadAndSave,
@@ -105,17 +100,15 @@ var import_workflow = require("./shared/workflow/workflow.js");
   instrumentContext,
   instrumentPage,
   isDebugMode,
-  isDebugPauseSignal,
   isDryRun,
-  isRunDebugPauseSignal,
   jsonlConsoleSink,
   launchBrowser,
   moveGhostCursor,
   pageRequest,
   parseSessionStateContent,
   parseSessionStateData,
+  pause,
   prettyConsoleSink,
-  runDebugPause,
   serializeSessionState,
   shouldPauseBeforeMutation,
   showHighlight,

package/dist/index.d.cts

@@ -1,6 +1,7 @@
 export { LogOptions, Logger, LoggerApi, LoggerSink, MinimalLogger, defaultLogger } from './shared/logger/logger.cjs';
 export { createFileLogSink, jsonlConsoleSink, prettyConsoleSink } from './shared/logger/sinks.cjs';
 export { LLMClient, Message, MessageContentPart } from './shared/llm/types.cjs';
+export { createLLMClientFromModel } from './shared/llm/ai-sdk-adapter.cjs';
 export { SESSION_STATE_VERSION, SessionState, SessionStateFile, SessionStateFileSchema, SessionStatus, SessionStatusSchema, parseSessionStateContent, parseSessionStateData, serializeSessionState } from './shared/state/session-state.cjs';
 export { executeRecoveryAgent } from './runtime/recovery/agent.cjs';
 export { attemptWithRecovery } from './runtime/recovery/recovery.cjs';
@@ -8,12 +9,13 @@ export { DetectedSubmissionError, KnownSubmissionError, detectSubmissionError }
 export { ExtractOptions, extractFromPage } from './runtime/extract/extract.cjs';
 export { PageRequestOptions, RequestConfig, pageRequest } from './runtime/network/network.cjs';
 export { DownloadResult, DownloadViaClickOptions, SaveDownloadOptions, downloadAndSave, downloadViaClick } from './runtime/download/download.cjs';
-export { DebugPauseContext, DebugPauseDetails, DebugPauseSignal, DebugPauseContext as RunDebugPauseContext, DebugPauseDetails as RunDebugPauseDetails, DebugPauseSignal as RunDebugPauseSignal, debugPause, isDebugPauseSignal, isDebugPauseSignal as isRunDebugPauseSignal, debugPause as runDebugPause } from './shared/debug/pause.cjs';
+export { pause } from './shared/debug/pause.cjs';
 export { isDebugMode, isDryRun, shouldPauseBeforeMutation } from './shared/config/config.cjs';
 export { InstrumentationOptions, InstrumentedPage, installInstrumentation, instrumentContext, instrumentPage } from './shared/instrumentation/instrument.cjs';
 export { GhostCursorOptions, ensureGhostCursor, ghostClick, hideGhostCursor, moveGhostCursor } from './shared/visualization/ghost-cursor.cjs';
 export { HighlightOptions, clearHighlights, ensureHighlightLayer, showHighlight } from './shared/visualization/highlight.cjs';
 export { BrowserSession, LaunchBrowserArgs, launchBrowser } from './shared/run/browser.cjs';
-export { LIBRETTO_WORKFLOW_BRAND, LibrettoAuthProfile, LibrettoWorkflow, LibrettoWorkflowContext, LibrettoWorkflowHandler, LibrettoWorkflowMetadata, workflow } from './shared/workflow/workflow.cjs';
+export { LIBRETTO_WORKFLOW_BRAND, LibrettoWorkflow, LibrettoWorkflowContext, LibrettoWorkflowHandler, LibrettoWorkflowMetadata, workflow } from './shared/workflow/workflow.cjs';
 import 'zod';
+import 'ai';
 import 'playwright';

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 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';
@@ -8,12 +9,13 @@ export { DetectedSubmissionError, KnownSubmissionError, detectSubmissionError }
 export { ExtractOptions, extractFromPage } from './runtime/extract/extract.js';
 export { PageRequestOptions, RequestConfig, pageRequest } from './runtime/network/network.js';
 export { DownloadResult, DownloadViaClickOptions, SaveDownloadOptions, downloadAndSave, downloadViaClick } from './runtime/download/download.js';
-export { DebugPauseContext, DebugPauseDetails, DebugPauseSignal, DebugPauseContext as RunDebugPauseContext, DebugPauseDetails as RunDebugPauseDetails, DebugPauseSignal as RunDebugPauseSignal, debugPause, isDebugPauseSignal, isDebugPauseSignal as isRunDebugPauseSignal, debugPause as runDebugPause } from './shared/debug/pause.js';
+export { pause } from './shared/debug/pause.js';
 export { isDebugMode, isDryRun, shouldPauseBeforeMutation } from './shared/config/config.js';
 export { InstrumentationOptions, InstrumentedPage, installInstrumentation, instrumentContext, instrumentPage } from './shared/instrumentation/instrument.js';
 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 { LIBRETTO_WORKFLOW_BRAND, LibrettoAuthProfile, LibrettoWorkflow, LibrettoWorkflowContext, LibrettoWorkflowHandler, LibrettoWorkflowMetadata, workflow } from './shared/workflow/workflow.js';
+export { LIBRETTO_WORKFLOW_BRAND, LibrettoWorkflow, LibrettoWorkflowContext, LibrettoWorkflowHandler, LibrettoWorkflowMetadata, workflow } from './shared/workflow/workflow.js';
 import 'zod';
+import 'ai';
 import 'playwright';