@daf-sdk/runtime 1.0.0

package/dist/protocol/index.js

@@ -0,0 +1,735 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/protocol/index.ts
+var protocol_exports = {};
+__export(protocol_exports, {
+  ACTION_TYPES: () => ACTION_TYPES,
+  DAFDocumentBuilder: () => DAFDocumentBuilder,
+  DAF_VERSION: () => DAF_VERSION,
+  DEFAULT_SCRAPE_TIMEOUT: () => DEFAULT_SCRAPE_TIMEOUT,
+  DEFAULT_SEARCH_LIMIT: () => DEFAULT_SEARCH_LIMIT,
+  EDITOR_ACTION_TYPES: () => EDITOR_ACTION_TYPES,
+  LOOP_TYPES: () => LOOP_TYPES,
+  MAX_PROCESS_DEPTH: () => MAX_PROCESS_DEPTH,
+  PROCESS_TYPES: () => PROCESS_TYPES,
+  ProcessBuilder: () => ProcessBuilder,
+  RESOURCE_TYPES: () => RESOURCE_TYPES,
+  STEP_TYPES: () => STEP_TYPES,
+  SUPPORTED_VERSIONS: () => SUPPORTED_VERSIONS,
+  WRITE_OPERATIONS: () => WRITE_OPERATIONS,
+  actionSchema: () => actionSchema,
+  addDocumentAction: () => addDocumentAction,
+  addFolderAction: () => addFolderAction,
+  completeSentenceAction: () => completeSentenceAction,
+  completionWithoutPromptStep: () => completionWithoutPromptStep,
+  conditionalLoopStep: () => conditionalLoopStep,
+  createDatabaseAction: () => createDatabaseAction,
+  dafDocumentSchema: () => dafDocumentSchema,
+  deleteDatabaseAction: () => deleteDatabaseAction,
+  directiveAction: () => directiveAction,
+  directiveParamsSchema: () => directiveParamsSchema,
+  duplicateDatabaseAction: () => duplicateDatabaseAction,
+  duplicateDocumentAction: () => duplicateDocumentAction,
+  editorActionBaseParamsSchema: () => editorActionBaseParamsSchema,
+  editorActionSchema: () => editorActionSchema,
+  extendTextAction: () => extendTextAction,
+  fixSpellingGrammarAction: () => fixSpellingGrammarAction,
+  fixedLoopStep: () => fixedLoopStep,
+  formatDocumentAction: () => formatDocumentAction,
+  formatTextAction: () => formatTextAction,
+  googleDocResource: () => googleDocResource,
+  googleDriveFolderResource: () => googleDriveFolderResource,
+  isValidAction: () => isValidAction,
+  isValidDAFDocument: () => isValidDAFDocument,
+  isValidEditorAction: () => isValidEditorAction,
+  isValidProcess: () => isValidProcess,
+  isValidResource: () => isValidResource,
+  isValidStep: () => isValidStep,
+  newsSearchAction: () => newsSearchAction,
+  newsSearchParamsSchema: () => newsSearchParamsSchema,
+  notionPageResource: () => notionPageResource,
+  previewSearchAction: () => previewSearchAction,
+  previewSearchParamsSchema: () => previewSearchParamsSchema,
+  processSchema: () => processSchema,
+  processStep: () => processStep,
+  promptStep: () => promptStep,
+  readDatabaseAction: () => readDatabaseAction,
+  readDocumentAction: () => readDocumentAction,
+  readDocumentParamsSchema: () => readDocumentParamsSchema,
+  readFolderAction: () => readFolderAction,
+  reduceTextAction: () => reduceTextAction,
+  removeDocumentAction: () => removeDocumentAction,
+  removeFolderAction: () => removeFolderAction,
+  renameDocumentAction: () => renameDocumentAction,
+  renameFolderAction: () => renameFolderAction,
+  resourceSchema: () => resourceSchema,
+  rewriteAction: () => rewriteAction,
+  scrapeAction: () => scrapeAction,
+  scrapeParamsSchema: () => scrapeParamsSchema,
+  searchAction: () => searchAction,
+  searchParamsSchema: () => searchParamsSchema,
+  sendEmailAction: () => sendEmailAction,
+  sendEmailParamsSchema: () => sendEmailParamsSchema,
+  simplifyAction: () => simplifyAction,
+  skipCompletionStep: () => skipCompletionStep,
+  stepSchema: () => stepSchema,
+  tavilySearchAction: () => tavilySearchAction,
+  tavilySearchParamsSchema: () => tavilySearchParamsSchema,
+  translateAction: () => translateAction,
+  translateParamsSchema: () => translateParamsSchema,
+  updateDatabaseAction: () => updateDatabaseAction,
+  userFeedbackStep: () => userFeedbackStep,
+  validateAction: () => validateAction,
+  validateDAFDocument: () => validateDAFDocument,
+  validateEditorAction: () => validateEditorAction,
+  validateProcess: () => validateProcess,
+  validateResource: () => validateResource,
+  validateStep: () => validateStep,
+  writeDatabaseAction: () => writeDatabaseAction,
+  writeDocumentAction: () => writeDocumentAction,
+  writeDocumentParamsSchema: () => writeDocumentParamsSchema
+});
+module.exports = __toCommonJS(protocol_exports);
+
+// src/protocol/constants.ts
+var DAF_VERSION = "1.2.0";
+var SUPPORTED_VERSIONS = ["1.0.0", "1.1.0", "1.2.0"];
+var PROCESS_TYPES = {
+  STATIC_DIALOGUE: "STATIC_DIALOGUE",
+  ADVANCED_DIALOGUE: "ADVANCED_DIALOGUE"
+};
+var STEP_TYPES = {
+  PROMPT: "prompt",
+  PROCESS: "process",
+  USER_FEEDBACK: "userFeedback",
+  COMPLETION_WITHOUT_PROMPT: "completionWithoutPrompt"
+};
+var LOOP_TYPES = {
+  FIXED: "fixed",
+  STOP_ON: "stopOn"
+};
+var ACTION_TYPES = {
+  SEND_EMAIL: "sendEmail",
+  SCRAPE: "scrape",
+  SEARCH: "search",
+  NEWS_SEARCH: "newsSearch",
+  PREVIEW_SEARCH: "previewSearch",
+  TAVILY_SEARCH: "tavilySearch",
+  READ_DOCUMENT: "readDocument",
+  WRITE_DOCUMENT: "writeDocument",
+  FORMAT_DOCUMENT: "formatDocument",
+  REMOVE_DOCUMENT: "removeDocument",
+  RENAME_DOCUMENT: "renameDocument",
+  DUPLICATE_DOCUMENT: "duplicateDocument",
+  ADD_DOCUMENT: "addDocument",
+  ADD_FOLDER: "addFolder",
+  REMOVE_FOLDER: "removeFolder",
+  READ_FOLDER: "readFolder",
+  RENAME_FOLDER: "renameFolder",
+  CREATE_DATABASE: "createDatabase",
+  READ_DATABASE: "readDatabase",
+  UPDATE_DATABASE: "updateDatabase",
+  DELETE_DATABASE: "deleteDatabase",
+  WRITE_DATABASE: "writeDatabase",
+  DUPLICATE_DATABASE: "duplicateDatabase"
+};
+var EDITOR_ACTION_TYPES = {
+  FIX_SPELLING_GRAMMAR: "fixSpellingGrammar",
+  REWRITE: "rewrite",
+  EXTEND_TEXT: "extendText",
+  REDUCE_TEXT: "reduceText",
+  SIMPLIFY: "simplify",
+  COMPLETE_SENTENCE: "completeSentence",
+  TRANSLATE: "translate",
+  FORMAT_TEXT: "formatText",
+  DIRECTIVE: "directive"
+};
+var RESOURCE_TYPES = {
+  GOOGLE_DOC: "google_doc",
+  NOTION_PAGE: "notion_page",
+  GOOGLE_DRIVE_FOLDER: "google_drive_folder"
+};
+var WRITE_OPERATIONS = {
+  REPLACE: "replace",
+  APPEND: "append",
+  SELECTIVE: "selective"
+};
+var MAX_PROCESS_DEPTH = 10;
+var DEFAULT_SCRAPE_TIMEOUT = 3e4;
+var DEFAULT_SEARCH_LIMIT = 5;
+
+// src/protocol/schemas.ts
+var import_zod = require("zod");
+var resourceSchema = import_zod.z.object({
+  name: import_zod.z.string().min(1, "Resource name is required"),
+  type: import_zod.z.enum([
+    RESOURCE_TYPES.GOOGLE_DOC,
+    RESOURCE_TYPES.NOTION_PAGE,
+    RESOURCE_TYPES.GOOGLE_DRIVE_FOLDER
+  ]),
+  url: import_zod.z.url("Resource URL must be valid"),
+  isGlobal: import_zod.z.boolean()
+});
+var stepSchema = import_zod.z.object({
+  type: import_zod.z.enum([
+    STEP_TYPES.PROMPT,
+    STEP_TYPES.PROCESS,
+    STEP_TYPES.USER_FEEDBACK,
+    STEP_TYPES.COMPLETION_WITHOUT_PROMPT
+  ]),
+  prompt: import_zod.z.string().optional(),
+  processId: import_zod.z.string().optional(),
+  loopType: import_zod.z.enum([LOOP_TYPES.FIXED, LOOP_TYPES.STOP_ON]).optional(),
+  forLoopCount: import_zod.z.int().positive().optional(),
+  stopOnKeyword: import_zod.z.string().optional(),
+  stopOnMaxLoops: import_zod.z.int().positive().optional(),
+  skipCompletion: import_zod.z.boolean().optional()
+}).refine(
+  (data) => {
+    if (data.type === STEP_TYPES.PROMPT && !data.prompt) return false;
+    if (data.type === STEP_TYPES.PROCESS && !data.processId) return false;
+    if (data.loopType === LOOP_TYPES.FIXED && !data.forLoopCount) return false;
+    if (data.loopType === LOOP_TYPES.STOP_ON && !data.stopOnKeyword) return false;
+    return true;
+  },
+  { error: "Invalid step configuration" }
+);
+var processSchema = import_zod.z.object({
+  name: import_zod.z.string().min(1, "Process name is required"),
+  description: import_zod.z.string().optional(),
+  processType: import_zod.z.enum([PROCESS_TYPES.STATIC_DIALOGUE, PROCESS_TYPES.ADVANCED_DIALOGUE]),
+  stopProcessKeyword: import_zod.z.string().optional(),
+  resources: import_zod.z.array(resourceSchema).optional(),
+  steps: import_zod.z.array(stepSchema).min(1, "Process must have at least one step")
+}).refine(
+  (data) => {
+    if (data.stopProcessKeyword && data.processType !== PROCESS_TYPES.ADVANCED_DIALOGUE) return false;
+    return true;
+  },
+  { error: "stopProcessKeyword is only valid for ADVANCED_DIALOGUE processes" }
+);
+var dafDocumentSchema = import_zod.z.object({
+  dafVersion: import_zod.z.enum(SUPPORTED_VERSIONS, {
+    message: `DAF version must be one of: ${SUPPORTED_VERSIONS.join(", ")}`
+  }),
+  variables: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional(),
+  resources: import_zod.z.array(resourceSchema).optional(),
+  processes: import_zod.z.array(processSchema).min(1, "At least one process is required")
+});
+var sendEmailParamsSchema = import_zod.z.object({
+  to: import_zod.z.email("Invalid email address"),
+  subject: import_zod.z.string().min(1, "Subject is required"),
+  content: import_zod.z.string().min(1, "Content is required")
+});
+var scrapeParamsSchema = import_zod.z.object({
+  url: import_zod.z.url("Invalid URL"),
+  timeout: import_zod.z.int().positive().optional()
+});
+var searchParamsSchema = import_zod.z.object({
+  query: import_zod.z.string().min(1, "Query is required"),
+  limit: import_zod.z.int().positive().optional()
+});
+var readDocumentParamsSchema = import_zod.z.object({
+  resourceName: import_zod.z.string().min(1, "Resource name is required")
+});
+var writeDocumentParamsSchema = import_zod.z.object({
+  resourceName: import_zod.z.string().min(1, "Resource name is required"),
+  operation: import_zod.z.enum([WRITE_OPERATIONS.REPLACE, WRITE_OPERATIONS.APPEND, WRITE_OPERATIONS.SELECTIVE]),
+  content: import_zod.z.string().min(1, "Content is required"),
+  findText: import_zod.z.string().optional(),
+  replaceText: import_zod.z.string().optional(),
+  replaceWithContent: import_zod.z.boolean().optional()
+}).refine(
+  (data) => {
+    if (data.operation === WRITE_OPERATIONS.SELECTIVE && !data.findText) return false;
+    return true;
+  },
+  { error: "Selective operation requires findText parameter" }
+);
+var newsSearchParamsSchema = import_zod.z.object({
+  query: import_zod.z.string().min(1, "Query is required"),
+  limit: import_zod.z.int().positive().optional(),
+  ignoreInvalidURLs: import_zod.z.boolean().optional(),
+  tbs: import_zod.z.string().optional(),
+  location: import_zod.z.string().optional()
+});
+var previewSearchParamsSchema = import_zod.z.object({
+  query: import_zod.z.string().min(1, "Query is required"),
+  limit: import_zod.z.int().positive().optional(),
+  sources: import_zod.z.array(import_zod.z.enum(["web", "news"])).optional()
+});
+var tavilySearchParamsSchema = import_zod.z.object({
+  query: import_zod.z.string().min(1, "Query is required"),
+  maxResults: import_zod.z.int().positive().optional(),
+  searchDepth: import_zod.z.enum(["basic", "advanced"]).optional(),
+  includeAnswer: import_zod.z.boolean().optional()
+});
+var editorActionBaseParamsSchema = import_zod.z.object({
+  selectedText: import_zod.z.string().min(1, "selectedText is required"),
+  from: import_zod.z.int().nonnegative().optional(),
+  to: import_zod.z.int().nonnegative().optional()
+});
+var translateParamsSchema = editorActionBaseParamsSchema.extend({
+  language: import_zod.z.string().min(1, "language is required")
+});
+var directiveParamsSchema = editorActionBaseParamsSchema.extend({
+  directive: import_zod.z.string().min(1, "directive is required")
+});
+var actionSchema = import_zod.z.object({
+  type: import_zod.z.literal("action"),
+  variant: import_zod.z.enum([
+    ACTION_TYPES.SEND_EMAIL,
+    ACTION_TYPES.SCRAPE,
+    ACTION_TYPES.SEARCH,
+    ACTION_TYPES.NEWS_SEARCH,
+    ACTION_TYPES.PREVIEW_SEARCH,
+    ACTION_TYPES.TAVILY_SEARCH,
+    ACTION_TYPES.READ_DOCUMENT,
+    ACTION_TYPES.WRITE_DOCUMENT,
+    ACTION_TYPES.FORMAT_DOCUMENT,
+    ACTION_TYPES.REMOVE_DOCUMENT,
+    ACTION_TYPES.RENAME_DOCUMENT,
+    ACTION_TYPES.DUPLICATE_DOCUMENT,
+    ACTION_TYPES.ADD_DOCUMENT,
+    ACTION_TYPES.ADD_FOLDER,
+    ACTION_TYPES.REMOVE_FOLDER,
+    ACTION_TYPES.READ_FOLDER,
+    ACTION_TYPES.RENAME_FOLDER,
+    ACTION_TYPES.CREATE_DATABASE,
+    ACTION_TYPES.READ_DATABASE,
+    ACTION_TYPES.UPDATE_DATABASE,
+    ACTION_TYPES.DELETE_DATABASE,
+    ACTION_TYPES.WRITE_DATABASE,
+    ACTION_TYPES.DUPLICATE_DATABASE
+  ]),
+  parameters: import_zod.z.record(import_zod.z.string(), import_zod.z.any())
+});
+var editorActionSchema = import_zod.z.object({
+  type: import_zod.z.literal("editorAction"),
+  variant: import_zod.z.enum([
+    EDITOR_ACTION_TYPES.FIX_SPELLING_GRAMMAR,
+    EDITOR_ACTION_TYPES.REWRITE,
+    EDITOR_ACTION_TYPES.EXTEND_TEXT,
+    EDITOR_ACTION_TYPES.REDUCE_TEXT,
+    EDITOR_ACTION_TYPES.SIMPLIFY,
+    EDITOR_ACTION_TYPES.COMPLETE_SENTENCE,
+    EDITOR_ACTION_TYPES.TRANSLATE,
+    EDITOR_ACTION_TYPES.FORMAT_TEXT,
+    EDITOR_ACTION_TYPES.DIRECTIVE
+  ]),
+  parameters: import_zod.z.record(import_zod.z.string(), import_zod.z.any())
+});
+
+// src/protocol/validators.ts
+var import_zod2 = require("zod");
+function zodToValidationErrors(error) {
+  return error.issues.map((issue) => ({
+    path: issue.path.join("."),
+    message: issue.message,
+    code: issue.code
+  }));
+}
+function validateDAFDocument(doc) {
+  try {
+    dafDocumentSchema.parse(doc);
+    return { valid: true, errors: [] };
+  } catch (error) {
+    if (error instanceof import_zod2.ZodError) return { valid: false, errors: zodToValidationErrors(error) };
+    return { valid: false, errors: [{ path: "", message: "Unknown validation error" }] };
+  }
+}
+function validateProcess(process) {
+  try {
+    processSchema.parse(process);
+    return { valid: true, errors: [] };
+  } catch (error) {
+    if (error instanceof import_zod2.ZodError) return { valid: false, errors: zodToValidationErrors(error) };
+    return { valid: false, errors: [{ path: "", message: "Unknown validation error" }] };
+  }
+}
+function validateStep(step) {
+  try {
+    stepSchema.parse(step);
+    return { valid: true, errors: [] };
+  } catch (error) {
+    if (error instanceof import_zod2.ZodError) return { valid: false, errors: zodToValidationErrors(error) };
+    return { valid: false, errors: [{ path: "", message: "Unknown validation error" }] };
+  }
+}
+function validateResource(resource) {
+  try {
+    resourceSchema.parse(resource);
+    return { valid: true, errors: [] };
+  } catch (error) {
+    if (error instanceof import_zod2.ZodError) return { valid: false, errors: zodToValidationErrors(error) };
+    return { valid: false, errors: [{ path: "", message: "Unknown validation error" }] };
+  }
+}
+function validateAction(action) {
+  try {
+    const validAction = actionSchema.parse(action);
+    switch (validAction.variant) {
+      case "sendEmail":
+        sendEmailParamsSchema.parse(validAction.parameters);
+        break;
+      case "scrape":
+        scrapeParamsSchema.parse(validAction.parameters);
+        break;
+      case "search":
+        searchParamsSchema.parse(validAction.parameters);
+        break;
+      case "newsSearch":
+        newsSearchParamsSchema.parse(validAction.parameters);
+        break;
+      case "previewSearch":
+        previewSearchParamsSchema.parse(validAction.parameters);
+        break;
+      case "tavilySearch":
+        tavilySearchParamsSchema.parse(validAction.parameters);
+        break;
+      case "readDocument":
+        readDocumentParamsSchema.parse(validAction.parameters);
+        break;
+      case "writeDocument":
+        writeDocumentParamsSchema.parse(validAction.parameters);
+        break;
+    }
+    return { valid: true, errors: [] };
+  } catch (error) {
+    if (error instanceof import_zod2.ZodError) return { valid: false, errors: zodToValidationErrors(error) };
+    return { valid: false, errors: [{ path: "", message: "Unknown validation error" }] };
+  }
+}
+function validateEditorAction(action) {
+  try {
+    const validAction = editorActionSchema.parse(action);
+    switch (validAction.variant) {
+      case "translate":
+        translateParamsSchema.parse(validAction.parameters);
+        break;
+      case "directive":
+        directiveParamsSchema.parse(validAction.parameters);
+        break;
+      default:
+        editorActionBaseParamsSchema.parse(validAction.parameters);
+        break;
+    }
+    return { valid: true, errors: [] };
+  } catch (error) {
+    if (error instanceof import_zod2.ZodError) return { valid: false, errors: zodToValidationErrors(error) };
+    return { valid: false, errors: [{ path: "", message: "Unknown validation error" }] };
+  }
+}
+function isValidDAFDocument(doc) {
+  return validateDAFDocument(doc).valid;
+}
+function isValidProcess(process) {
+  return validateProcess(process).valid;
+}
+function isValidStep(step) {
+  return validateStep(step).valid;
+}
+function isValidResource(resource) {
+  return validateResource(resource).valid;
+}
+function isValidAction(action) {
+  return validateAction(action).valid;
+}
+function isValidEditorAction(action) {
+  return validateEditorAction(action).valid;
+}
+
+// src/protocol/builders.ts
+var DAFDocumentBuilder = class {
+  constructor() {
+    this.doc = { dafVersion: DAF_VERSION, processes: [] };
+  }
+  variables(vars) {
+    this.doc.variables = vars;
+    return this;
+  }
+  variable(name, value) {
+    if (!this.doc.variables) this.doc.variables = {};
+    this.doc.variables[name] = value;
+    return this;
+  }
+  resources(resources) {
+    this.doc.resources = resources;
+    return this;
+  }
+  resource(resource) {
+    if (!this.doc.resources) this.doc.resources = [];
+    this.doc.resources.push(resource);
+    return this;
+  }
+  process(process) {
+    this.doc.processes.push(process);
+    return this;
+  }
+  build() {
+    return this.doc;
+  }
+};
+var ProcessBuilder = class {
+  constructor(name, processType = "STATIC_DIALOGUE") {
+    this.process = { name, processType, steps: [] };
+  }
+  description(desc) {
+    this.process.description = desc;
+    return this;
+  }
+  stopKeyword(keyword) {
+    this.process.stopProcessKeyword = keyword;
+    return this;
+  }
+  resources(resources) {
+    this.process.resources = resources;
+    return this;
+  }
+  resource(resource) {
+    if (!this.process.resources) this.process.resources = [];
+    this.process.resources.push(resource);
+    return this;
+  }
+  step(step) {
+    this.process.steps.push(step);
+    return this;
+  }
+  build() {
+    return this.process;
+  }
+};
+function promptStep(prompt) {
+  return { type: "prompt", prompt };
+}
+function processStep(processId) {
+  return { type: "process", processId };
+}
+function fixedLoopStep(prompt, count) {
+  return { type: "prompt", prompt, loopType: "fixed", forLoopCount: count };
+}
+function conditionalLoopStep(prompt, stopKeyword, maxLoops) {
+  return { type: "prompt", prompt, loopType: "stopOn", stopOnKeyword: stopKeyword, stopOnMaxLoops: maxLoops };
+}
+function skipCompletionStep(prompt) {
+  return { type: "prompt", prompt, skipCompletion: true };
+}
+function userFeedbackStep() {
+  return { type: "userFeedback" };
+}
+function completionWithoutPromptStep() {
+  return { type: "completionWithoutPrompt" };
+}
+function googleDocResource(name, url, isGlobal = false) {
+  return { name, type: "google_doc", url, isGlobal };
+}
+function notionPageResource(name, url, isGlobal = false) {
+  return { name, type: "notion_page", url, isGlobal };
+}
+function googleDriveFolderResource(name, url, isGlobal = false) {
+  return { name, type: "google_drive_folder", url, isGlobal };
+}
+function sendEmailAction(to, subject, content) {
+  return { type: "action", variant: "sendEmail", parameters: { to, subject, content } };
+}
+function scrapeAction(url, timeout) {
+  return { type: "action", variant: "scrape", parameters: { url, timeout } };
+}
+function searchAction(query, limit) {
+  return { type: "action", variant: "search", parameters: { query, limit } };
+}
+function readDocumentAction(resourceName) {
+  return { type: "action", variant: "readDocument", parameters: { resourceName } };
+}
+function writeDocumentAction(resourceName, operation, content, options) {
+  return { type: "action", variant: "writeDocument", parameters: { resourceName, operation, content, ...options } };
+}
+function formatDocumentAction(resourceUrl, formatting, range) {
+  return { type: "action", variant: "formatDocument", parameters: { resourceUrl, formatting, range } };
+}
+function removeDocumentAction(resourceUrl) {
+  return { type: "action", variant: "removeDocument", parameters: { resourceUrl } };
+}
+function renameDocumentAction(resourceUrl, newName) {
+  return { type: "action", variant: "renameDocument", parameters: { resourceUrl, newName } };
+}
+function duplicateDocumentAction(resourceUrl, newName) {
+  return { type: "action", variant: "duplicateDocument", parameters: { resourceUrl, newName } };
+}
+function addFolderAction(folderName, provider, parentUrl) {
+  return { type: "action", variant: "addFolder", parameters: { folderName, provider, parentUrl } };
+}
+function removeFolderAction(folderUrl) {
+  return { type: "action", variant: "removeFolder", parameters: { folderUrl } };
+}
+function readFolderAction(folderUrl) {
+  return { type: "action", variant: "readFolder", parameters: { folderUrl } };
+}
+function renameFolderAction(folderUrl, newName) {
+  return { type: "action", variant: "renameFolder", parameters: { folderUrl, newName } };
+}
+function addDocumentAction(documentName, provider, locationUrl, content) {
+  return { type: "action", variant: "addDocument", parameters: { documentName, provider, locationUrl, content } };
+}
+function createDatabaseAction(databaseName, parentPageUrl) {
+  return { type: "action", variant: "createDatabase", parameters: { databaseName, parentPageUrl } };
+}
+function readDatabaseAction(databaseUrl) {
+  return { type: "action", variant: "readDatabase", parameters: { databaseUrl } };
+}
+function updateDatabaseAction(databaseUrl, options) {
+  return { type: "action", variant: "updateDatabase", parameters: { databaseUrl, ...options } };
+}
+function deleteDatabaseAction(databaseUrl) {
+  return { type: "action", variant: "deleteDatabase", parameters: { databaseUrl } };
+}
+function writeDatabaseAction(databaseUrl, properties, content) {
+  return { type: "action", variant: "writeDatabase", parameters: { databaseUrl, properties, content } };
+}
+function duplicateDatabaseAction(databaseUrl, newDatabaseName) {
+  return { type: "action", variant: "duplicateDatabase", parameters: { databaseUrl, newDatabaseName } };
+}
+function newsSearchAction(query, options) {
+  return { type: "action", variant: "newsSearch", parameters: { query, ...options } };
+}
+function previewSearchAction(query, options) {
+  return { type: "action", variant: "previewSearch", parameters: { query, ...options } };
+}
+function tavilySearchAction(query, options) {
+  return { type: "action", variant: "tavilySearch", parameters: { query, ...options } };
+}
+function editorAction(variant, params) {
+  return { type: "editorAction", variant, parameters: params };
+}
+function fixSpellingGrammarAction(selectedText, options) {
+  return editorAction("fixSpellingGrammar", { selectedText, ...options });
+}
+function rewriteAction(selectedText, options) {
+  return editorAction("rewrite", { selectedText, ...options });
+}
+function extendTextAction(selectedText, options) {
+  return editorAction("extendText", { selectedText, ...options });
+}
+function reduceTextAction(selectedText, options) {
+  return editorAction("reduceText", { selectedText, ...options });
+}
+function simplifyAction(selectedText, options) {
+  return editorAction("simplify", { selectedText, ...options });
+}
+function completeSentenceAction(selectedText, options) {
+  return editorAction("completeSentence", { selectedText, ...options });
+}
+function translateAction(selectedText, language, options) {
+  return editorAction("translate", { selectedText, language, ...options });
+}
+function formatTextAction(selectedText, options) {
+  return editorAction("formatText", { selectedText, ...options });
+}
+function directiveAction(selectedText, directive, options) {
+  return editorAction("directive", { selectedText, directive, ...options });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ACTION_TYPES,
+  DAFDocumentBuilder,
+  DAF_VERSION,
+  DEFAULT_SCRAPE_TIMEOUT,
+  DEFAULT_SEARCH_LIMIT,
+  EDITOR_ACTION_TYPES,
+  LOOP_TYPES,
+  MAX_PROCESS_DEPTH,
+  PROCESS_TYPES,
+  ProcessBuilder,
+  RESOURCE_TYPES,
+  STEP_TYPES,
+  SUPPORTED_VERSIONS,
+  WRITE_OPERATIONS,
+  actionSchema,
+  addDocumentAction,
+  addFolderAction,
+  completeSentenceAction,
+  completionWithoutPromptStep,
+  conditionalLoopStep,
+  createDatabaseAction,
+  dafDocumentSchema,
+  deleteDatabaseAction,
+  directiveAction,
+  directiveParamsSchema,
+  duplicateDatabaseAction,
+  duplicateDocumentAction,
+  editorActionBaseParamsSchema,
+  editorActionSchema,
+  extendTextAction,
+  fixSpellingGrammarAction,
+  fixedLoopStep,
+  formatDocumentAction,
+  formatTextAction,
+  googleDocResource,
+  googleDriveFolderResource,
+  isValidAction,
+  isValidDAFDocument,
+  isValidEditorAction,
+  isValidProcess,
+  isValidResource,
+  isValidStep,
+  newsSearchAction,
+  newsSearchParamsSchema,
+  notionPageResource,
+  previewSearchAction,
+  previewSearchParamsSchema,
+  processSchema,
+  processStep,
+  promptStep,
+  readDatabaseAction,
+  readDocumentAction,
+  readDocumentParamsSchema,
+  readFolderAction,
+  reduceTextAction,
+  removeDocumentAction,
+  removeFolderAction,
+  renameDocumentAction,
+  renameFolderAction,
+  resourceSchema,
+  rewriteAction,
+  scrapeAction,
+  scrapeParamsSchema,
+  searchAction,
+  searchParamsSchema,
+  sendEmailAction,
+  sendEmailParamsSchema,
+  simplifyAction,
+  skipCompletionStep,
+  stepSchema,
+  tavilySearchAction,
+  tavilySearchParamsSchema,
+  translateAction,
+  translateParamsSchema,
+  updateDatabaseAction,
+  userFeedbackStep,
+  validateAction,
+  validateDAFDocument,
+  validateEditorAction,
+  validateProcess,
+  validateResource,
+  validateStep,
+  writeDatabaseAction,
+  writeDocumentAction,
+  writeDocumentParamsSchema
+});