@bubblelab/shared-schemas 0.1.12 → 0.1.13

package/dist/index.js

@@ -1,31 +1,3329 @@
-// Re-export all schemas and types from the routes file
-// Note: All schemas are defined in routes.ts
-export * from './api-schema.js';
-export * from './database-definition-schema.js';
-export * from './credential-schema.js';
-export * from './bubble-definition-schema.js';
-export * from './types.js';
-export * from './streaming-events.js';
-export * from './mock-data-generator.js';
-export * from './oauth-schema.js';
-export * from './waitlist-schema.js';
-export * from './bubbleflow-schema.js';
-export * from './bubbleflow-execution-schema.js';
-export * from './generate-bubbleflow-schema.js';
-export * from './webhook-schema.js';
-export * from './subscription-status-schema.js';
-export * from './api-schema.js';
-export * from './milk-tea.js';
-export * from './pearl.js';
-export * from './coffee.js';
-export * from './rice.js';
-export * from './ai-models.js';
-export * from './cron-utils.js';
-export * from './trigger.js';
-export * from './bubbleflow-generation-prompts.js';
-export * from './storage-utils.js';
-export * from './param-utils.js';
-export * from './error-enhancer.js';
-export * from './hash-utils.js';
-export * from './agent-memory.js';
+// src/api-schema.ts
+import { z } from "@hono/zod-openapi";
+var errorResponseSchema = z.object({
+  error: z.string().openapi({
+    description: "Error message",
+    example: "Validation failed"
+  }),
+  details: z.string().optional().openapi({
+    description: "Additional error details",
+    example: "Invalid field: name is required"
+  })
+}).openapi("ErrorResponse");
+var slackUrlVerificationSchema = z.object({
+  token: z.string(),
+  challenge: z.string(),
+  type: z.literal("url_verification")
+});
+var slackUrlVerificationResponseSchema = z.object({
+  challenge: z.string().openapi({ description: "Slack URL verification challenge" })
+}).openapi("SlackUrlVerificationResponse");
+
+// src/database-definition-schema.ts
+import { z as z2 } from "@hono/zod-openapi";
+var databaseMetadataSchema = z2.object({
+  // Core database definition - mapping of table names to column definitions
+  // Format: { [tableName]: { [columnName]: columnType } }
+  tables: z2.record(
+    z2.string(),
+    // table name
+    z2.record(
+      z2.string(),
+      // column name
+      z2.string()
+      // notes about it
+    )
+  ),
+  // Table-level notes - mapping of table names to notes about the entire table
+  tableNotes: z2.record(z2.string(), z2.string()).optional(),
+  // Optional metadata
+  databaseName: z2.string().optional(),
+  databaseType: z2.enum(["postgresql", "mysql", "sqlite", "mssql", "oracle"]).optional(),
+  // Rules and constraints - simplified to match frontend
+  rules: z2.array(
+    z2.object({
+      id: z2.string(),
+      text: z2.string(),
+      enabled: z2.boolean(),
+      createdAt: z2.string(),
+      // ISO string
+      updatedAt: z2.string()
+      // ISO string
+    })
+  ).optional(),
+  // Additional context
+  notes: z2.string().optional(),
+  tags: z2.array(z2.string()).optional()
+});
+
+// src/types.ts
+var CredentialType = /* @__PURE__ */ ((CredentialType2) => {
+  CredentialType2["OPENAI_CRED"] = "OPENAI_CRED";
+  CredentialType2["GOOGLE_GEMINI_CRED"] = "GOOGLE_GEMINI_CRED";
+  CredentialType2["ANTHROPIC_CRED"] = "ANTHROPIC_CRED";
+  CredentialType2["OPENROUTER_CRED"] = "OPENROUTER_CRED";
+  CredentialType2["FIRECRAWL_API_KEY"] = "FIRECRAWL_API_KEY";
+  CredentialType2["DATABASE_CRED"] = "DATABASE_CRED";
+  CredentialType2["SLACK_CRED"] = "SLACK_CRED";
+  CredentialType2["TELEGRAM_BOT_TOKEN"] = "TELEGRAM_BOT_TOKEN";
+  CredentialType2["RESEND_CRED"] = "RESEND_CRED";
+  CredentialType2["CLOUDFLARE_R2_ACCESS_KEY"] = "CLOUDFLARE_R2_ACCESS_KEY";
+  CredentialType2["CLOUDFLARE_R2_SECRET_KEY"] = "CLOUDFLARE_R2_SECRET_KEY";
+  CredentialType2["CLOUDFLARE_R2_ACCOUNT_ID"] = "CLOUDFLARE_R2_ACCOUNT_ID";
+  CredentialType2["APIFY_CRED"] = "APIFY_CRED";
+  CredentialType2["ELEVENLABS_API_KEY"] = "ELEVENLABS_API_KEY";
+  CredentialType2["GOOGLE_DRIVE_CRED"] = "GOOGLE_DRIVE_CRED";
+  CredentialType2["GMAIL_CRED"] = "GMAIL_CRED";
+  CredentialType2["GOOGLE_SHEETS_CRED"] = "GOOGLE_SHEETS_CRED";
+  CredentialType2["GOOGLE_CALENDAR_CRED"] = "GOOGLE_CALENDAR_CRED";
+  CredentialType2["FUB_CRED"] = "FUB_CRED";
+  CredentialType2["NOTION_OAUTH_TOKEN"] = "NOTION_OAUTH_TOKEN";
+  CredentialType2["GITHUB_TOKEN"] = "GITHUB_TOKEN";
+  CredentialType2["AGI_API_KEY"] = "AGI_API_KEY";
+  CredentialType2["AIRTABLE_CRED"] = "AIRTABLE_CRED";
+  CredentialType2["INSFORGE_BASE_URL"] = "INSFORGE_BASE_URL";
+  CredentialType2["INSFORGE_API_KEY"] = "INSFORGE_API_KEY";
+  CredentialType2["CUSTOM_AUTH_KEY"] = "CUSTOM_AUTH_KEY";
+  CredentialType2["AMAZON_CRED"] = "AMAZON_CRED";
+  return CredentialType2;
+})(CredentialType || {});
+
+// src/credential-schema.ts
+import { z as z3 } from "@hono/zod-openapi";
+var CREDENTIAL_TYPE_CONFIG = {
+  ["OPENAI_CRED" /* OPENAI_CRED */]: {
+    label: "OpenAI",
+    description: "API key for OpenAI services (GPT models, embeddings, etc.)",
+    placeholder: "sk-...",
+    namePlaceholder: "My OpenAI API Key",
+    credentialConfigurations: {}
+  },
+  ["GOOGLE_GEMINI_CRED" /* GOOGLE_GEMINI_CRED */]: {
+    label: "Google Gemini",
+    description: "API key for Google Gemini AI models",
+    placeholder: "AIza...",
+    namePlaceholder: "My Google Gemini Key",
+    credentialConfigurations: {
+      ignoreSSL: false
+    }
+  },
+  ["ANTHROPIC_CRED" /* ANTHROPIC_CRED */]: {
+    label: "Anthropic",
+    description: "API key for Anthropic Claude models",
+    placeholder: "sk-ant-...",
+    namePlaceholder: "My Anthropic API Key",
+    credentialConfigurations: {
+      ignoreSSL: false
+    }
+  },
+  ["DATABASE_CRED" /* DATABASE_CRED */]: {
+    label: "Database (PostgreSQL)",
+    description: "Database connection string for PostgreSQL",
+    placeholder: "postgresql://user:pass@host:port/dbname",
+    namePlaceholder: "My PostgreSQL Database",
+    credentialConfigurations: {
+      ignoreSSL: false
+    }
+  },
+  ["FIRECRAWL_API_KEY" /* FIRECRAWL_API_KEY */]: {
+    label: "Firecrawl",
+    description: "API key for Firecrawl web scraping and search services",
+    placeholder: "fc-...",
+    namePlaceholder: "My Firecrawl API Key",
+    credentialConfigurations: {
+      ignoreSSL: false
+    }
+  },
+  ["SLACK_CRED" /* SLACK_CRED */]: {
+    label: "Slack",
+    description: "Slack Bot token (xoxb-) or User token (xoxp-) from api.slack.com/apps. Configure scopes in OAuth & Permissions.",
+    placeholder: "xoxb-... or xoxp-...",
+    namePlaceholder: "My Slack Token",
+    credentialConfigurations: {
+      ignoreSSL: false
+    }
+  },
+  ["RESEND_CRED" /* RESEND_CRED */]: {
+    label: "Resend",
+    description: "Your Resend API key for email services",
+    placeholder: "re_...",
+    namePlaceholder: "My Resend API Key",
+    credentialConfigurations: {
+      ignoreSSL: false
+    }
+  },
+  ["OPENROUTER_CRED" /* OPENROUTER_CRED */]: {
+    label: "OpenRouter",
+    description: "API key for OpenRouter services",
+    placeholder: "sk-or-...",
+    namePlaceholder: "My OpenRouter API Key",
+    credentialConfigurations: {
+      ignoreSSL: false
+    }
+  },
+  ["CLOUDFLARE_R2_ACCESS_KEY" /* CLOUDFLARE_R2_ACCESS_KEY */]: {
+    label: "Cloudflare R2 Access Key",
+    description: "Access key for Cloudflare R2 storage",
+    placeholder: "Enter your access key",
+    namePlaceholder: "My R2 Access Key",
+    credentialConfigurations: {
+      ignoreSSL: false
+    }
+  },
+  ["CLOUDFLARE_R2_SECRET_KEY" /* CLOUDFLARE_R2_SECRET_KEY */]: {
+    label: "Cloudflare R2 Secret Key",
+    description: "Secret key for Cloudflare R2 storage",
+    placeholder: "Enter your secret key",
+    namePlaceholder: "My R2 Secret Key",
+    credentialConfigurations: {
+      ignoreSSL: false
+    }
+  },
+  ["CLOUDFLARE_R2_ACCOUNT_ID" /* CLOUDFLARE_R2_ACCOUNT_ID */]: {
+    label: "Cloudflare R2 Account ID",
+    description: "Account ID for Cloudflare R2 storage",
+    placeholder: "Enter your account ID",
+    namePlaceholder: "My R2 Account ID",
+    credentialConfigurations: {
+      ignoreSSL: false
+    }
+  },
+  ["APIFY_CRED" /* APIFY_CRED */]: {
+    label: "Apify",
+    description: "API token for Apify platform (web scraping, automation)",
+    placeholder: "apify_api_...",
+    namePlaceholder: "My Apify API Token",
+    credentialConfigurations: {}
+  },
+  ["GOOGLE_DRIVE_CRED" /* GOOGLE_DRIVE_CRED */]: {
+    label: "Google Drive",
+    description: "OAuth connection to Google Drive for file access",
+    placeholder: "",
+    // Not used for OAuth
+    namePlaceholder: "My Google Drive Connection",
+    credentialConfigurations: {
+      ignoreSSL: false
+    }
+  },
+  ["GMAIL_CRED" /* GMAIL_CRED */]: {
+    label: "Gmail",
+    description: "OAuth connection to Gmail for email management",
+    placeholder: "",
+    // Not used for OAuth
+    namePlaceholder: "My Gmail Connection",
+    credentialConfigurations: {
+      ignoreSSL: false
+    }
+  },
+  ["GOOGLE_SHEETS_CRED" /* GOOGLE_SHEETS_CRED */]: {
+    label: "Google Sheets",
+    description: "OAuth connection to Google Sheets for spreadsheet management",
+    placeholder: "",
+    // Not used for OAuth
+    namePlaceholder: "My Google Sheets Connection",
+    credentialConfigurations: {
+      ignoreSSL: false
+    }
+  },
+  ["GOOGLE_CALENDAR_CRED" /* GOOGLE_CALENDAR_CRED */]: {
+    label: "Google Calendar",
+    description: "OAuth connection to Google Calendar for events and schedules",
+    placeholder: "",
+    // Not used for OAuth
+    namePlaceholder: "My Google Calendar Connection",
+    credentialConfigurations: {
+      ignoreSSL: false
+    }
+  },
+  ["FUB_CRED" /* FUB_CRED */]: {
+    label: "Follow Up Boss",
+    description: "OAuth connection to Follow Up Boss CRM for contacts, tasks, and deals",
+    placeholder: "",
+    // Not used for OAuth
+    namePlaceholder: "My Follow Up Boss Connection",
+    credentialConfigurations: {}
+  },
+  ["NOTION_OAUTH_TOKEN" /* NOTION_OAUTH_TOKEN */]: {
+    label: "Notion",
+    description: "OAuth connection to your Notion workspace (pages, databases, search)",
+    placeholder: "",
+    // Not used for OAuth
+    namePlaceholder: "My Notion Connection",
+    credentialConfigurations: {}
+  },
+  ["GITHUB_TOKEN" /* GITHUB_TOKEN */]: {
+    label: "GitHub",
+    description: "Personal Access Token for GitHub API (read repos, PRs, issues)",
+    placeholder: "github_pat...",
+    namePlaceholder: "My GitHub Token",
+    credentialConfigurations: {}
+  },
+  ["ELEVENLABS_API_KEY" /* ELEVENLABS_API_KEY */]: {
+    label: "Eleven Labs API Key",
+    description: "Your API key from Eleven Labs",
+    placeholder: "agent_...",
+    namePlaceholder: "My Eleven Labs Key",
+    credentialConfigurations: {}
+  },
+  ["AGI_API_KEY" /* AGI_API_KEY */]: {
+    label: "AGI Inc API Key",
+    description: "Your API key from AGI Inc",
+    placeholder: "api_...",
+    namePlaceholder: "My AGI Inc Key",
+    credentialConfigurations: {}
+  },
+  ["TELEGRAM_BOT_TOKEN" /* TELEGRAM_BOT_TOKEN */]: {
+    label: "Telegram Bot Token",
+    description: "Your Telegram bot token",
+    placeholder: "bot_...",
+    namePlaceholder: "My Telegram Bot Token",
+    credentialConfigurations: {}
+  },
+  ["AIRTABLE_CRED" /* AIRTABLE_CRED */]: {
+    label: "Airtable",
+    description: "Personal Access Token for Airtable API (manage bases, tables, records)",
+    placeholder: "pat...",
+    namePlaceholder: "My Airtable Token",
+    credentialConfigurations: {}
+  },
+  ["INSFORGE_BASE_URL" /* INSFORGE_BASE_URL */]: {
+    label: "InsForge Base URL",
+    description: "Base URL for your InsForge backend (e.g., https://your-app.region.insforge.app)",
+    placeholder: "https://your-app.region.insforge.app",
+    namePlaceholder: "My InsForge Backend URL",
+    credentialConfigurations: {}
+  },
+  ["INSFORGE_API_KEY" /* INSFORGE_API_KEY */]: {
+    label: "InsForge API Key",
+    description: "API key for your InsForge backend",
+    placeholder: "ik_...",
+    namePlaceholder: "My InsForge API Key",
+    credentialConfigurations: {}
+  },
+  ["CUSTOM_AUTH_KEY" /* CUSTOM_AUTH_KEY */]: {
+    label: "Custom Authentication Key",
+    description: "Custom API key or authentication token for HTTP requests (Bearer, Basic, X-API-Key, etc.)",
+    placeholder: "Enter your API key or token...",
+    namePlaceholder: "My Custom Auth Key",
+    credentialConfigurations: {}
+  },
+  ["AMAZON_CRED" /* AMAZON_CRED */]: {
+    label: "Amazon",
+    description: "Browser session authentication for Amazon shopping (cart, orders, purchases). Authenticate by logging into your Amazon account in a secure browser session.",
+    placeholder: "",
+    // Not used for browser session auth
+    namePlaceholder: "My Amazon Account",
+    credentialConfigurations: {}
+  }
+};
+function generateCredentialsSummary() {
+  const lines = ["Available credentials that users can configure:"];
+  for (const [credType, config] of Object.entries(CREDENTIAL_TYPE_CONFIG)) {
+    lines.push(`- ${config.label} (${credType}): ${config.description}`);
+  }
+  return lines.join("\n");
+}
+var CREDENTIAL_ENV_MAP = {
+  ["OPENAI_CRED" /* OPENAI_CRED */]: "OPENAI_API_KEY",
+  ["GOOGLE_GEMINI_CRED" /* GOOGLE_GEMINI_CRED */]: "GOOGLE_API_KEY",
+  ["ANTHROPIC_CRED" /* ANTHROPIC_CRED */]: "ANTHROPIC_API_KEY",
+  ["FIRECRAWL_API_KEY" /* FIRECRAWL_API_KEY */]: "FIRE_CRAWL_API_KEY",
+  ["DATABASE_CRED" /* DATABASE_CRED */]: "BUBBLE_CONNECTING_STRING_URL",
+  ["SLACK_CRED" /* SLACK_CRED */]: "SLACK_TOKEN",
+  ["TELEGRAM_BOT_TOKEN" /* TELEGRAM_BOT_TOKEN */]: "TELEGRAM_BOT_TOKEN",
+  ["RESEND_CRED" /* RESEND_CRED */]: "RESEND_API_KEY",
+  ["OPENROUTER_CRED" /* OPENROUTER_CRED */]: "OPENROUTER_API_KEY",
+  ["CLOUDFLARE_R2_ACCESS_KEY" /* CLOUDFLARE_R2_ACCESS_KEY */]: "CLOUDFLARE_R2_ACCESS_KEY",
+  ["CLOUDFLARE_R2_SECRET_KEY" /* CLOUDFLARE_R2_SECRET_KEY */]: "CLOUDFLARE_R2_SECRET_KEY",
+  ["CLOUDFLARE_R2_ACCOUNT_ID" /* CLOUDFLARE_R2_ACCOUNT_ID */]: "CLOUDFLARE_R2_ACCOUNT_ID",
+  ["APIFY_CRED" /* APIFY_CRED */]: "APIFY_API_TOKEN",
+  ["ELEVENLABS_API_KEY" /* ELEVENLABS_API_KEY */]: "ELEVENLABS_API_KEY",
+  ["GOOGLE_DRIVE_CRED" /* GOOGLE_DRIVE_CRED */]: "",
+  ["GMAIL_CRED" /* GMAIL_CRED */]: "",
+  ["GOOGLE_SHEETS_CRED" /* GOOGLE_SHEETS_CRED */]: "",
+  ["GOOGLE_CALENDAR_CRED" /* GOOGLE_CALENDAR_CRED */]: "",
+  ["FUB_CRED" /* FUB_CRED */]: "",
+  ["GITHUB_TOKEN" /* GITHUB_TOKEN */]: "GITHUB_TOKEN",
+  ["AGI_API_KEY" /* AGI_API_KEY */]: "AGI_API_KEY",
+  ["AIRTABLE_CRED" /* AIRTABLE_CRED */]: "AIRTABLE_API_KEY",
+  ["NOTION_OAUTH_TOKEN" /* NOTION_OAUTH_TOKEN */]: "",
+  ["INSFORGE_BASE_URL" /* INSFORGE_BASE_URL */]: "INSFORGE_BASE_URL",
+  ["INSFORGE_API_KEY" /* INSFORGE_API_KEY */]: "INSFORGE_API_KEY",
+  ["CUSTOM_AUTH_KEY" /* CUSTOM_AUTH_KEY */]: "",
+  // User-provided, no env var
+  ["AMAZON_CRED" /* AMAZON_CRED */]: ""
+  // Browser session credential, no env var
+};
+var SYSTEM_CREDENTIALS = /* @__PURE__ */ new Set([
+  "GOOGLE_GEMINI_CRED" /* GOOGLE_GEMINI_CRED */,
+  "FIRECRAWL_API_KEY" /* FIRECRAWL_API_KEY */,
+  "OPENAI_CRED" /* OPENAI_CRED */,
+  "ANTHROPIC_CRED" /* ANTHROPIC_CRED */,
+  "RESEND_CRED" /* RESEND_CRED */,
+  "OPENROUTER_CRED" /* OPENROUTER_CRED */,
+  // Cloudflare R2 Storage credentials
+  "CLOUDFLARE_R2_ACCESS_KEY" /* CLOUDFLARE_R2_ACCESS_KEY */,
+  "CLOUDFLARE_R2_SECRET_KEY" /* CLOUDFLARE_R2_SECRET_KEY */,
+  "CLOUDFLARE_R2_ACCOUNT_ID" /* CLOUDFLARE_R2_ACCOUNT_ID */,
+  // Scraping credentials
+  "APIFY_CRED" /* APIFY_CRED */
+]);
+var OPTIONAL_CREDENTIALS = /* @__PURE__ */ new Set([
+  "CUSTOM_AUTH_KEY" /* CUSTOM_AUTH_KEY */
+]);
+var OAUTH_PROVIDERS = {
+  google: {
+    name: "google",
+    displayName: "Google",
+    credentialTypes: {
+      ["GOOGLE_DRIVE_CRED" /* GOOGLE_DRIVE_CRED */]: {
+        displayName: "Google Drive",
+        defaultScopes: [
+          "https://www.googleapis.com/auth/drive.file",
+          "https://www.googleapis.com/auth/documents",
+          "https://www.googleapis.com/auth/spreadsheets",
+          "https://www.googleapis.com/auth/drive"
+        ],
+        description: "Access Google Drive files and folders",
+        scopeDescriptions: [
+          {
+            scope: "https://www.googleapis.com/auth/drive.file",
+            description: "View and manage Google Drive files and folders that you have created with Bubble Lab",
+            defaultEnabled: true
+          },
+          {
+            scope: "https://www.googleapis.com/auth/documents",
+            description: "View and manage your Google Docs documents",
+            defaultEnabled: true
+          },
+          {
+            scope: "https://www.googleapis.com/auth/spreadsheets",
+            description: "View and manage your Google Sheets spreadsheets",
+            defaultEnabled: true
+          },
+          {
+            scope: "https://www.googleapis.com/auth/drive",
+            description: 'View and manage all ofyour Google Drive files and folders (will see a warning about an "untrusted app" during authentication. Choose only if you need extra permissions)',
+            defaultEnabled: false
+          }
+        ]
+      },
+      ["GMAIL_CRED" /* GMAIL_CRED */]: {
+        displayName: "Gmail",
+        defaultScopes: [
+          "https://www.googleapis.com/auth/gmail.send",
+          "https://www.googleapis.com/auth/gmail.modify"
+        ],
+        description: "Access Gmail for sending emails",
+        scopeDescriptions: [
+          {
+            scope: "https://www.googleapis.com/auth/gmail.send",
+            description: "Send email on your behalf",
+            defaultEnabled: true
+          },
+          {
+            scope: "https://www.googleapis.com/auth/gmail.modify",
+            description: 'View and manage all of your Gmail emails and labels (might see a warning about an "untrusted app" during authentication. Choose only if you need extra permissions)',
+            defaultEnabled: false
+          }
+        ]
+      },
+      ["GOOGLE_SHEETS_CRED" /* GOOGLE_SHEETS_CRED */]: {
+        displayName: "Google Sheets",
+        defaultScopes: ["https://www.googleapis.com/auth/spreadsheets"],
+        description: "Access Google Sheets for reading and writing spreadsheet data",
+        scopeDescriptions: [
+          {
+            scope: "https://www.googleapis.com/auth/spreadsheets",
+            description: "View and manage your Google Sheets spreadsheets",
+            defaultEnabled: true
+          }
+        ]
+      },
+      ["GOOGLE_CALENDAR_CRED" /* GOOGLE_CALENDAR_CRED */]: {
+        displayName: "Google Calendar",
+        defaultScopes: ["https://www.googleapis.com/auth/calendar"],
+        description: "Access Google Calendar for reading and managing events",
+        scopeDescriptions: [
+          {
+            scope: "https://www.googleapis.com/auth/calendar",
+            description: "View and manage events on all your calendars",
+            defaultEnabled: true
+          }
+        ]
+      }
+    },
+    authorizationParams: {
+      access_type: "offline",
+      // Required for refresh tokens
+      prompt: "consent"
+      // Force consent screen to ensure refresh token is issued
+    }
+  },
+  followupboss: {
+    name: "followupboss",
+    displayName: "Follow Up Boss",
+    credentialTypes: {
+      ["FUB_CRED" /* FUB_CRED */]: {
+        displayName: "Follow Up Boss",
+        defaultScopes: [],
+        // FUB doesn't use granular scopes
+        description: "Access Follow Up Boss CRM for managing contacts, tasks, deals, and more"
+      }
+    },
+    authorizationParams: {
+      response_type: "auth_code",
+      // FUB uses 'auth_code' instead of standard 'code'
+      prompt: "login"
+      // FUB supports 'login' to force re-authentication
+    }
+  },
+  notion: {
+    name: "notion",
+    displayName: "Notion",
+    credentialTypes: {
+      ["NOTION_OAUTH_TOKEN" /* NOTION_OAUTH_TOKEN */]: {
+        displayName: "Notion Workspace",
+        defaultScopes: [],
+        // Notion scopes are managed in the integration capabilities
+        description: "Authorize access to your Notion workspace for searching and reading pages/databases"
+      }
+    }
+  }
+};
+function getOAuthProvider(credentialType) {
+  for (const [providerName, config] of Object.entries(OAUTH_PROVIDERS)) {
+    if (config.credentialTypes[credentialType]) {
+      return providerName;
+    }
+  }
+  return null;
+}
+function isOAuthCredential(credentialType) {
+  return getOAuthProvider(credentialType) !== null;
+}
+function getScopeDescriptions(credentialType) {
+  const provider = getOAuthProvider(credentialType);
+  if (!provider) {
+    return [];
+  }
+  const providerConfig = OAUTH_PROVIDERS[provider];
+  const credentialConfig = providerConfig?.credentialTypes[credentialType];
+  if (!credentialConfig?.scopeDescriptions) {
+    return credentialConfig?.defaultScopes.map((scope) => ({
+      scope,
+      description: `Access: ${scope}`,
+      defaultEnabled: true
+      // Default to enabled if in defaultScopes
+    })) || [];
+  }
+  return credentialConfig.scopeDescriptions;
+}
+var BROWSER_SESSION_PROVIDERS = {
+  browserbase: {
+    name: "browserbase",
+    displayName: "BrowserBase",
+    credentialTypes: {
+      ["AMAZON_CRED" /* AMAZON_CRED */]: {
+        displayName: "Amazon Account",
+        description: "Log into Amazon to enable cart, order, and purchase automation",
+        targetUrl: "https://www.amazon.com",
+        cookieDomain: "amazon"
+      }
+    }
+  }
+};
+function getBrowserSessionProvider(credentialType) {
+  for (const [providerName, config] of Object.entries(
+    BROWSER_SESSION_PROVIDERS
+  )) {
+    if (config.credentialTypes[credentialType]) {
+      return providerName;
+    }
+  }
+  return null;
+}
+function isBrowserSessionCredential(credentialType) {
+  return getBrowserSessionProvider(credentialType) !== null;
+}
+var BUBBLE_CREDENTIAL_OPTIONS = {
+  "ai-agent": [
+    "OPENAI_CRED" /* OPENAI_CRED */,
+    "GOOGLE_GEMINI_CRED" /* GOOGLE_GEMINI_CRED */,
+    "ANTHROPIC_CRED" /* ANTHROPIC_CRED */,
+    "FIRECRAWL_API_KEY" /* FIRECRAWL_API_KEY */,
+    "OPENROUTER_CRED" /* OPENROUTER_CRED */
+  ],
+  postgresql: ["DATABASE_CRED" /* DATABASE_CRED */],
+  slack: ["SLACK_CRED" /* SLACK_CRED */],
+  telegram: ["TELEGRAM_BOT_TOKEN" /* TELEGRAM_BOT_TOKEN */],
+  resend: ["RESEND_CRED" /* RESEND_CRED */],
+  "database-analyzer": ["DATABASE_CRED" /* DATABASE_CRED */],
+  "slack-notifier": [
+    "SLACK_CRED" /* SLACK_CRED */,
+    "OPENAI_CRED" /* OPENAI_CRED */,
+    "GOOGLE_GEMINI_CRED" /* GOOGLE_GEMINI_CRED */,
+    "ANTHROPIC_CRED" /* ANTHROPIC_CRED */
+  ],
+  "slack-formatter-agent": [
+    "OPENAI_CRED" /* OPENAI_CRED */,
+    "GOOGLE_GEMINI_CRED" /* GOOGLE_GEMINI_CRED */,
+    "ANTHROPIC_CRED" /* ANTHROPIC_CRED */
+  ],
+  "slack-data-assistant": [
+    "DATABASE_CRED" /* DATABASE_CRED */,
+    "SLACK_CRED" /* SLACK_CRED */,
+    "OPENAI_CRED" /* OPENAI_CRED */,
+    "GOOGLE_GEMINI_CRED" /* GOOGLE_GEMINI_CRED */,
+    "ANTHROPIC_CRED" /* ANTHROPIC_CRED */
+  ],
+  "hello-world": [],
+  http: ["CUSTOM_AUTH_KEY" /* CUSTOM_AUTH_KEY */],
+  "get-bubble-details-tool": [],
+  "list-bubbles-tool": [],
+  "sql-query-tool": ["DATABASE_CRED" /* DATABASE_CRED */],
+  "chart-js-tool": [],
+  "bubbleflow-validation-tool": [],
+  "code-edit-tool": ["OPENROUTER_CRED" /* OPENROUTER_CRED */],
+  "web-search-tool": ["FIRECRAWL_API_KEY" /* FIRECRAWL_API_KEY */],
+  "web-scrape-tool": ["FIRECRAWL_API_KEY" /* FIRECRAWL_API_KEY */],
+  "web-crawl-tool": [
+    "FIRECRAWL_API_KEY" /* FIRECRAWL_API_KEY */,
+    "GOOGLE_GEMINI_CRED" /* GOOGLE_GEMINI_CRED */
+  ],
+  "web-extract-tool": ["FIRECRAWL_API_KEY" /* FIRECRAWL_API_KEY */],
+  "research-agent-tool": [
+    "FIRECRAWL_API_KEY" /* FIRECRAWL_API_KEY */,
+    "GOOGLE_GEMINI_CRED" /* GOOGLE_GEMINI_CRED */,
+    "APIFY_CRED" /* APIFY_CRED */
+  ],
+  "reddit-scrape-tool": [],
+  "bubbleflow-code-generator": [],
+  "bubbleflow-generator": [
+    "GOOGLE_GEMINI_CRED" /* GOOGLE_GEMINI_CRED */,
+    "OPENROUTER_CRED" /* OPENROUTER_CRED */
+  ],
+  "pdf-form-operations": [
+    "GOOGLE_GEMINI_CRED" /* GOOGLE_GEMINI_CRED */,
+    "OPENAI_CRED" /* OPENAI_CRED */,
+    "ANTHROPIC_CRED" /* ANTHROPIC_CRED */,
+    "OPENROUTER_CRED" /* OPENROUTER_CRED */
+  ],
+  "pdf-ocr-workflow": [
+    "GOOGLE_GEMINI_CRED" /* GOOGLE_GEMINI_CRED */,
+    "OPENAI_CRED" /* OPENAI_CRED */,
+    "ANTHROPIC_CRED" /* ANTHROPIC_CRED */,
+    "OPENROUTER_CRED" /* OPENROUTER_CRED */
+  ],
+  "generate-document-workflow": [
+    "GOOGLE_GEMINI_CRED" /* GOOGLE_GEMINI_CRED */,
+    "OPENAI_CRED" /* OPENAI_CRED */,
+    "ANTHROPIC_CRED" /* ANTHROPIC_CRED */,
+    "OPENROUTER_CRED" /* OPENROUTER_CRED */
+  ],
+  "parse-document-workflow": [
+    "GOOGLE_GEMINI_CRED" /* GOOGLE_GEMINI_CRED */,
+    "OPENAI_CRED" /* OPENAI_CRED */,
+    "ANTHROPIC_CRED" /* ANTHROPIC_CRED */,
+    "OPENROUTER_CRED" /* OPENROUTER_CRED */,
+    "CLOUDFLARE_R2_ACCESS_KEY" /* CLOUDFLARE_R2_ACCESS_KEY */,
+    "CLOUDFLARE_R2_SECRET_KEY" /* CLOUDFLARE_R2_SECRET_KEY */,
+    "CLOUDFLARE_R2_ACCOUNT_ID" /* CLOUDFLARE_R2_ACCOUNT_ID */
+  ],
+  storage: [
+    "CLOUDFLARE_R2_ACCESS_KEY" /* CLOUDFLARE_R2_ACCESS_KEY */,
+    "CLOUDFLARE_R2_SECRET_KEY" /* CLOUDFLARE_R2_SECRET_KEY */,
+    "CLOUDFLARE_R2_ACCOUNT_ID" /* CLOUDFLARE_R2_ACCOUNT_ID */
+  ],
+  "google-drive": ["GOOGLE_DRIVE_CRED" /* GOOGLE_DRIVE_CRED */],
+  gmail: ["GMAIL_CRED" /* GMAIL_CRED */],
+  "google-sheets": ["GOOGLE_SHEETS_CRED" /* GOOGLE_SHEETS_CRED */],
+  "google-calendar": ["GOOGLE_CALENDAR_CRED" /* GOOGLE_CALENDAR_CRED */],
+  apify: ["APIFY_CRED" /* APIFY_CRED */],
+  "instagram-tool": ["APIFY_CRED" /* APIFY_CRED */],
+  "linkedin-tool": ["APIFY_CRED" /* APIFY_CRED */],
+  "tiktok-tool": ["APIFY_CRED" /* APIFY_CRED */],
+  "twitter-tool": ["APIFY_CRED" /* APIFY_CRED */],
+  "google-maps-tool": ["APIFY_CRED" /* APIFY_CRED */],
+  "youtube-tool": ["APIFY_CRED" /* APIFY_CRED */],
+  github: ["GITHUB_TOKEN" /* GITHUB_TOKEN */],
+  "eleven-labs": ["ELEVENLABS_API_KEY" /* ELEVENLABS_API_KEY */],
+  followupboss: ["FUB_CRED" /* FUB_CRED */],
+  "agi-inc": ["AGI_API_KEY" /* AGI_API_KEY */],
+  airtable: ["AIRTABLE_CRED" /* AIRTABLE_CRED */],
+  notion: ["NOTION_OAUTH_TOKEN" /* NOTION_OAUTH_TOKEN */],
+  firecrawl: ["FIRECRAWL_API_KEY" /* FIRECRAWL_API_KEY */],
+  "insforge-db": [
+    "INSFORGE_BASE_URL" /* INSFORGE_BASE_URL */,
+    "INSFORGE_API_KEY" /* INSFORGE_API_KEY */
+  ],
+  browserbase: [
+    "AMAZON_CRED" /* AMAZON_CRED */,
+    "CLOUDFLARE_R2_ACCESS_KEY" /* CLOUDFLARE_R2_ACCESS_KEY */,
+    "CLOUDFLARE_R2_SECRET_KEY" /* CLOUDFLARE_R2_SECRET_KEY */,
+    "CLOUDFLARE_R2_ACCOUNT_ID" /* CLOUDFLARE_R2_ACCOUNT_ID */
+  ],
+  "amazon-shopping-tool": [
+    "AMAZON_CRED" /* AMAZON_CRED */,
+    "CLOUDFLARE_R2_ACCESS_KEY" /* CLOUDFLARE_R2_ACCESS_KEY */,
+    "CLOUDFLARE_R2_SECRET_KEY" /* CLOUDFLARE_R2_SECRET_KEY */,
+    "CLOUDFLARE_R2_ACCOUNT_ID" /* CLOUDFLARE_R2_ACCOUNT_ID */
+  ]
+};
+var createCredentialSchema = z3.object({
+  credentialType: z3.nativeEnum(CredentialType).openapi({
+    description: "Type of credential to store",
+    example: "OPENAI_CRED" /* OPENAI_CRED */
+  }),
+  value: z3.string().min(1).openapi({
+    description: "The credential value (will be encrypted)",
+    example: "sk-1234567890abcdef"
+  }),
+  name: z3.string().optional().openapi({
+    description: "Optional user-friendly name for the credential",
+    example: "My OpenAI Key"
+  }),
+  skipValidation: z3.boolean().optional().openapi({
+    description: "Skip credential validation before storing (for testing/admin use)",
+    example: false
+  }),
+  credentialConfigurations: z3.record(z3.string(), z3.unknown()).optional().openapi({
+    description: "Optional configurations for credential validation (e.g., ignoreSSL for PostgreSQL)",
+    example: { ignoreSSL: true }
+  }),
+  metadata: databaseMetadataSchema.optional().openapi({
+    description: "Optional metadata for the credential (e.g., database schema for DATABASE_CRED)",
+    example: {
+      tables: {
+        users: {
+          id: "integer",
+          email: "character varying",
+          created_at: "timestamp with time zone"
+        }
+      },
+      rules: [
+        {
+          id: "rule-1",
+          text: "No direct DELETE on users table",
+          enabled: true,
+          createdAt: "2024-01-01T00:00:00Z",
+          updatedAt: "2024-01-01T00:00:00Z"
+        }
+      ]
+    }
+  })
+}).openapi("CreateCredentialRequest");
+var updateCredentialSchema = z3.object({
+  value: z3.string().optional().openapi({
+    description: "The credential value (will be encrypted). Leave empty to keep current value.",
+    example: "sk-1234567890abcdef"
+  }),
+  name: z3.string().optional().openapi({
+    description: "Optional user-friendly name for the credential",
+    example: "My OpenAI Key"
+  }),
+  skipValidation: z3.boolean().optional().openapi({
+    description: "Skip credential validation before storing (for testing/admin use)",
+    example: false
+  }),
+  credentialConfigurations: z3.record(z3.string(), z3.unknown()).optional().openapi({
+    description: "Optional configurations for credential validation (e.g., ignoreSSL for PostgreSQL)",
+    example: { ignoreSSL: true }
+  }),
+  metadata: databaseMetadataSchema.optional().openapi({
+    description: "Optional metadata for the credential (e.g., database schema for DATABASE_CRED)",
+    example: {
+      tables: {
+        users: {
+          id: "integer",
+          email: "character varying",
+          created_at: "timestamp with time zone"
+        }
+      }
+    }
+  })
+}).openapi("UpdateCredentialRequest");
+var credentialResponseSchema = z3.object({
+  id: z3.number().openapi({ description: "Credential ID" }),
+  credentialType: z3.string().openapi({ description: "Type of credential" }),
+  name: z3.string().optional().openapi({ description: "Credential name" }),
+  metadata: databaseMetadataSchema.optional().openapi({ description: "Credential metadata" }),
+  createdAt: z3.string().openapi({ description: "Creation timestamp" }),
+  // OAuth-specific fields
+  isOauth: z3.boolean().optional().openapi({ description: "Whether this is an OAuth credential" }),
+  oauthProvider: z3.string().optional().openapi({ description: "OAuth provider name" }),
+  oauthExpiresAt: z3.string().optional().openapi({ description: "OAuth token expiration timestamp" }),
+  oauthScopes: z3.array(z3.string()).optional().openapi({ description: "OAuth scopes granted" }),
+  oauthStatus: z3.enum(["active", "expired", "needs_refresh"]).optional().openapi({ description: "OAuth token status" }),
+  // Browser session-specific fields
+  isBrowserSession: z3.boolean().optional().openapi({ description: "Whether this is a browser session credential" }),
+  browserbaseSessionData: z3.object({
+    capturedAt: z3.string(),
+    cookieCount: z3.number(),
+    domain: z3.string()
+  }).optional().openapi({ description: "Browser session metadata" })
+}).openapi("CredentialResponse");
+var createCredentialResponseSchema = z3.object({
+  id: z3.number().openapi({ description: "Credential ID" }),
+  message: z3.string().openapi({ description: "Success message" })
+}).openapi("CreateCredentialResponse");
+var updateCredentialResponseSchema = z3.object({
+  id: z3.number().openapi({ description: "Credential ID" }),
+  message: z3.string().openapi({ description: "Success message" })
+}).openapi("UpdateCredentialResponse");
+var successMessageResponseSchema = z3.object({
+  message: z3.string().openapi({ description: "Success message" })
+}).openapi("SuccessMessageResponse");
+var browserbaseSessionCreateRequestSchema = z3.object({
+  credentialType: z3.nativeEnum(CredentialType).openapi({
+    description: "Type of credential requiring browser authentication",
+    example: "AMAZON_CRED" /* AMAZON_CRED */
+  }),
+  name: z3.string().optional().openapi({
+    description: "User-friendly name for the credential",
+    example: "My Amazon Account"
+  })
+}).openapi("BrowserbaseSessionCreateRequest");
+var browserbaseSessionCreateResponseSchema = z3.object({
+  sessionId: z3.string().openapi({
+    description: "BrowserBase session ID"
+  }),
+  debugUrl: z3.string().openapi({
+    description: "URL to open for manual browser interaction"
+  }),
+  contextId: z3.string().openapi({
+    description: "BrowserBase context ID for session persistence"
+  }),
+  state: z3.string().openapi({
+    description: "State token for CSRF protection"
+  })
+}).openapi("BrowserbaseSessionCreateResponse");
+var browserbaseSessionCompleteRequestSchema = z3.object({
+  sessionId: z3.string().openapi({
+    description: "BrowserBase session ID to complete"
+  }),
+  state: z3.string().openapi({
+    description: "State token for verification"
+  }),
+  name: z3.string().optional().openapi({
+    description: "User-friendly name for the credential"
+  })
+}).openapi("BrowserbaseSessionCompleteRequest");
+var browserbaseSessionCompleteResponseSchema = z3.object({
+  id: z3.number().openapi({
+    description: "Created credential ID"
+  }),
+  message: z3.string().openapi({
+    description: "Success message"
+  })
+}).openapi("BrowserbaseSessionCompleteResponse");
+var browserbaseSessionReopenRequestSchema = z3.object({
+  credentialId: z3.number().openapi({
+    description: "ID of the credential to reopen session for"
+  })
+}).openapi("BrowserbaseSessionReopenRequest");
+var browserbaseSessionReopenResponseSchema = z3.object({
+  sessionId: z3.string().openapi({
+    description: "BrowserBase session ID"
+  }),
+  debugUrl: z3.string().openapi({
+    description: "URL to open for manual browser interaction"
+  })
+}).openapi("BrowserbaseSessionReopenResponse");
+
+// src/bubble-definition-schema.ts
+import { z as z4 } from "zod";
+var BubbleParameterType = /* @__PURE__ */ ((BubbleParameterType2) => {
+  BubbleParameterType2["STRING"] = "string";
+  BubbleParameterType2["NUMBER"] = "number";
+  BubbleParameterType2["BOOLEAN"] = "boolean";
+  BubbleParameterType2["OBJECT"] = "object";
+  BubbleParameterType2["ARRAY"] = "array";
+  BubbleParameterType2["ENV"] = "env";
+  BubbleParameterType2["VARIABLE"] = "variable";
+  BubbleParameterType2["EXPRESSION"] = "expression";
+  BubbleParameterType2["UNKNOWN"] = "unknown";
+  return BubbleParameterType2;
+})(BubbleParameterType || {});
+var CREDENTIAL_CONFIGURATION_MAP = {
+  ["DATABASE_CRED" /* DATABASE_CRED */]: {
+    ignoreSSL: "boolean" /* BOOLEAN */
+  },
+  ["TELEGRAM_BOT_TOKEN" /* TELEGRAM_BOT_TOKEN */]: {},
+  ["AGI_API_KEY" /* AGI_API_KEY */]: {},
+  ["FUB_CRED" /* FUB_CRED */]: {},
+  ["OPENAI_CRED" /* OPENAI_CRED */]: {},
+  ["GOOGLE_GEMINI_CRED" /* GOOGLE_GEMINI_CRED */]: {},
+  ["ANTHROPIC_CRED" /* ANTHROPIC_CRED */]: {},
+  ["FIRECRAWL_API_KEY" /* FIRECRAWL_API_KEY */]: {},
+  ["SLACK_CRED" /* SLACK_CRED */]: {},
+  ["RESEND_CRED" /* RESEND_CRED */]: {},
+  ["OPENROUTER_CRED" /* OPENROUTER_CRED */]: {},
+  ["CLOUDFLARE_R2_ACCESS_KEY" /* CLOUDFLARE_R2_ACCESS_KEY */]: {},
+  ["CLOUDFLARE_R2_SECRET_KEY" /* CLOUDFLARE_R2_SECRET_KEY */]: {},
+  ["CLOUDFLARE_R2_ACCOUNT_ID" /* CLOUDFLARE_R2_ACCOUNT_ID */]: {},
+  ["APIFY_CRED" /* APIFY_CRED */]: {},
+  ["ELEVENLABS_API_KEY" /* ELEVENLABS_API_KEY */]: {},
+  ["GOOGLE_DRIVE_CRED" /* GOOGLE_DRIVE_CRED */]: {},
+  ["GMAIL_CRED" /* GMAIL_CRED */]: {},
+  ["GOOGLE_SHEETS_CRED" /* GOOGLE_SHEETS_CRED */]: {},
+  ["GOOGLE_CALENDAR_CRED" /* GOOGLE_CALENDAR_CRED */]: {},
+  ["GITHUB_TOKEN" /* GITHUB_TOKEN */]: {},
+  ["AIRTABLE_CRED" /* AIRTABLE_CRED */]: {},
+  ["NOTION_OAUTH_TOKEN" /* NOTION_OAUTH_TOKEN */]: {},
+  ["INSFORGE_BASE_URL" /* INSFORGE_BASE_URL */]: {},
+  ["INSFORGE_API_KEY" /* INSFORGE_API_KEY */]: {},
+  ["CUSTOM_AUTH_KEY" /* CUSTOM_AUTH_KEY */]: {},
+  ["AMAZON_CRED" /* AMAZON_CRED */]: {}
+};
+var BUBBLE_NAMES_WITH_CONTEXT_INJECTION = [
+  "database-analyzer",
+  "slack-data-assistant"
+];
+var BubbleParameterTypeSchema = z4.nativeEnum(BubbleParameterType);
+var BubbleParameterSchema = z4.object({
+  location: z4.optional(
+    z4.object({
+      startLine: z4.number(),
+      startCol: z4.number(),
+      endLine: z4.number(),
+      endCol: z4.number()
+    })
+  ),
+  variableId: z4.number().optional().describe("The variable id of the parameter"),
+  name: z4.string().describe("The name of the parameter"),
+  value: z4.union([
+    z4.string(),
+    z4.number(),
+    z4.boolean(),
+    z4.record(z4.unknown()),
+    z4.array(z4.unknown())
+  ]).describe("The value of the parameter"),
+  type: BubbleParameterTypeSchema,
+  /**
+   * Source of the parameter - indicates whether it came from an object literal property
+   * or represents the entire first argument. Used to determine if spread pattern should be applied.
+   * Ex.
+   * const abc = '1234567890';
+   * new GoogleDriveBubble({
+   *   fileId: abc,
+   * })
+   * source: 'object-property',
+   *
+   * new GoogleDriveBubble({
+   *   url: 'https://www.google.com',
+   *   ...args,
+   * })
+   * source: 'spread',
+   *
+   * source = 'first-arg'
+   * new GoogleDriveBubble(args)
+   */
+  source: z4.enum(["object-property", "first-arg", "spread"]).optional().describe(
+    "Source of the parameter - indicates if it came from an object literal property, represents the entire first argument, or came from a spread operator"
+  )
+});
+var BubbleNodeTypeSchema = z4.enum([
+  "service",
+  "tool",
+  "workflow",
+  "unknown"
+]);
+var DependencyGraphNodeSchema = z4.lazy(
+  () => z4.object({
+    name: z4.string(),
+    variableName: z4.string().optional(),
+    nodeType: BubbleNodeTypeSchema,
+    uniqueId: z4.string().optional(),
+    variableId: z4.number().optional(),
+    dependencies: z4.array(DependencyGraphNodeSchema),
+    // Use lazy reference since FunctionCallWorkflowNodeSchema is defined later
+    functionCallChildren: z4.lazy(() => z4.array(FunctionCallWorkflowNodeSchema)).optional()
+  })
+);
+var ParsedBubbleSchema = z4.object({
+  variableName: z4.string(),
+  bubbleName: z4.string(),
+  className: z4.string(),
+  parameters: z4.array(BubbleParameterSchema),
+  hasAwait: z4.boolean(),
+  hasActionCall: z4.boolean(),
+  dependencies: z4.array(z4.string()).optional(),
+  dependencyGraph: DependencyGraphNodeSchema.optional()
+});
+var BubbleDependencySpecSchema = z4.object({
+  name: z4.string(),
+  tools: z4.array(z4.string()).optional()
+});
+var ParsedBubbleWithInfoSchema = z4.object({
+  variableName: z4.string(),
+  bubbleName: z4.string(),
+  className: z4.string(),
+  parameters: z4.array(BubbleParameterSchema),
+  hasAwait: z4.boolean(),
+  hasActionCall: z4.boolean(),
+  dependencies: z4.array(z4.string()).optional(),
+  dependencyGraph: DependencyGraphNodeSchema.optional(),
+  variableId: z4.number(),
+  nodeType: BubbleNodeTypeSchema,
+  location: z4.object({
+    startLine: z4.number(),
+    startCol: z4.number(),
+    endLine: z4.number(),
+    endCol: z4.number()
+  }),
+  description: z4.string().optional(),
+  invocationCallSiteKey: z4.string().optional(),
+  clonedFromVariableId: z4.number().optional(),
+  isInsideCustomTool: z4.boolean().optional(),
+  containingCustomToolId: z4.string().optional()
+});
+var WorkflowNodeTypeSchema = z4.enum([
+  "bubble",
+  "if",
+  "for",
+  "while",
+  "try_catch",
+  "variable_declaration",
+  "return",
+  "function_call",
+  "code_block",
+  "parallel_execution",
+  "transformation_function"
+]);
+var LocationSchema = z4.object({
+  startLine: z4.number(),
+  startCol: z4.number(),
+  endLine: z4.number(),
+  endCol: z4.number()
+});
+var BubbleWorkflowNodeSchema = z4.object(
+  {
+    type: z4.literal("bubble"),
+    variableId: z4.number()
+  }
+);
+var ControlFlowWorkflowNodeSchema = z4.lazy(
+  () => z4.object({
+    type: z4.enum(["if", "for", "while"]),
+    location: LocationSchema,
+    condition: z4.string().optional(),
+    children: z4.array(WorkflowNodeSchema),
+    elseBranch: z4.array(WorkflowNodeSchema).optional(),
+    thenTerminates: z4.boolean().optional(),
+    elseTerminates: z4.boolean().optional()
+  })
+);
+var TryCatchWorkflowNodeSchema = z4.lazy(
+  () => z4.object({
+    type: z4.literal("try_catch"),
+    location: LocationSchema,
+    children: z4.array(WorkflowNodeSchema),
+    catchBlock: z4.array(WorkflowNodeSchema).optional()
+  })
+);
+var CodeBlockWorkflowNodeSchema = z4.lazy(
+  () => z4.object({
+    type: z4.literal("code_block"),
+    location: LocationSchema,
+    code: z4.string(),
+    children: z4.array(WorkflowNodeSchema)
+  })
+);
+var VariableDeclarationBlockNodeSchema = z4.lazy(
+  () => z4.object({
+    type: z4.literal("variable_declaration"),
+    location: LocationSchema,
+    code: z4.string(),
+    variables: z4.array(
+      z4.object({
+        name: z4.string(),
+        type: z4.enum(["const", "let", "var"]),
+        hasInitializer: z4.boolean()
+      })
+    ),
+    children: z4.array(WorkflowNodeSchema)
+  })
+);
+var ReturnWorkflowNodeSchema = z4.lazy(
+  () => z4.object({
+    type: z4.literal("return"),
+    location: LocationSchema,
+    code: z4.string(),
+    value: z4.string().optional(),
+    children: z4.array(WorkflowNodeSchema)
+  })
+);
+var FunctionCallWorkflowNodeSchema = z4.lazy(
+  () => z4.object({
+    type: z4.literal("function_call"),
+    location: LocationSchema,
+    functionName: z4.string(),
+    isMethodCall: z4.boolean(),
+    description: z4.string().optional(),
+    arguments: z4.string().optional(),
+    code: z4.string(),
+    variableId: z4.number(),
+    variableDeclaration: z4.object({
+      variableName: z4.string(),
+      variableType: z4.enum(["const", "let", "var"])
+    }).optional(),
+    methodDefinition: z4.object({
+      location: z4.object({
+        startLine: z4.number(),
+        endLine: z4.number()
+      }),
+      isAsync: z4.boolean(),
+      parameters: z4.array(z4.string())
+    }).optional(),
+    children: z4.array(WorkflowNodeSchema)
+  })
+);
+var ParallelExecutionWorkflowNodeSchema = z4.lazy(
+  () => z4.object({
+    type: z4.literal("parallel_execution"),
+    location: LocationSchema,
+    code: z4.string(),
+    variableDeclaration: z4.object({
+      variableNames: z4.array(z4.string()),
+      variableType: z4.enum(["const", "let", "var"])
+    }).optional(),
+    children: z4.array(WorkflowNodeSchema)
+  })
+);
+var TransformationFunctionWorkflowNodeSchema = z4.object({
+  type: z4.literal("transformation_function"),
+  location: LocationSchema,
+  code: z4.string(),
+  functionName: z4.string(),
+  isMethodCall: z4.boolean(),
+  description: z4.string().optional(),
+  arguments: z4.string().optional(),
+  variableId: z4.number(),
+  variableDeclaration: z4.object({
+    variableName: z4.string(),
+    variableType: z4.enum(["const", "let", "var"])
+  }).optional(),
+  methodDefinition: z4.object({
+    location: z4.object({
+      startLine: z4.number(),
+      endLine: z4.number()
+    }),
+    isAsync: z4.boolean(),
+    parameters: z4.array(z4.string())
+  }).optional()
+});
+var WorkflowNodeSchema = z4.lazy(
+  () => z4.union([
+    BubbleWorkflowNodeSchema,
+    ControlFlowWorkflowNodeSchema,
+    TryCatchWorkflowNodeSchema,
+    CodeBlockWorkflowNodeSchema,
+    VariableDeclarationBlockNodeSchema,
+    ReturnWorkflowNodeSchema,
+    FunctionCallWorkflowNodeSchema,
+    ParallelExecutionWorkflowNodeSchema,
+    TransformationFunctionWorkflowNodeSchema
+  ])
+);
+var ParsedWorkflowSchema = z4.object({
+  root: z4.array(WorkflowNodeSchema),
+  bubbles: z4.record(z4.number(), ParsedBubbleWithInfoSchema)
+});
+
+// src/mock-data-generator.ts
+function generateUUID() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+var MockDataGenerator = class {
+  /**
+   * Generate a complete mock BubbleResult from a result schema
+   */
+  static generateMockResult(resultSchema) {
+    const mockData = this.generateMockFromSchema(resultSchema);
+    return {
+      success: true,
+      data: mockData,
+      executionId: generateUUID(),
+      error: "",
+      timestamp: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Generate mock data from JSON Schema
+   * Converts JSON Schema to mock data with realistic values
+   */
+  static generateMockFromJsonSchema(jsonSchema) {
+    const mockData = {};
+    if (!jsonSchema || typeof jsonSchema !== "object") {
+      return mockData;
+    }
+    if (jsonSchema.type === "object" && jsonSchema.properties) {
+      const properties = jsonSchema.properties;
+      for (const [key, propertySchema] of Object.entries(properties)) {
+        if (propertySchema && typeof propertySchema === "object") {
+          const value = this.generateMockValueFromJsonSchema(
+            propertySchema
+          );
+          if (value !== void 0) {
+            mockData[key] = value;
+          }
+        }
+      }
+    }
+    return mockData;
+  }
+  /**
+   * Generate a mock value for a specific JSON Schema property
+   */
+  static generateMockValueFromJsonSchema(schema) {
+    const type = schema.type;
+    switch (type) {
+      case "string": {
+        if (schema.enum && Array.isArray(schema.enum)) {
+          return schema.enum[Math.floor(Math.random() * schema.enum.length)];
+        }
+        if (schema.format === "email") {
+          return "test@example.com";
+        }
+        if (schema.format === "date-time") {
+          return (/* @__PURE__ */ new Date()).toISOString();
+        }
+        if (schema.format === "uuid") {
+          return generateUUID();
+        }
+        const minLength = typeof schema.minLength === "number" ? schema.minLength : 1;
+        const maxLength = typeof schema.maxLength === "number" ? schema.maxLength : 10;
+        const length = Math.floor(Math.random() * (maxLength - minLength + 1)) + minLength;
+        return "sample_" + Math.random().toString(36).substring(2, 2 + length);
+      }
+      case "number":
+      case "integer": {
+        const min = typeof schema.minimum === "number" ? schema.minimum : 0;
+        const max = typeof schema.maximum === "number" ? schema.maximum : 100;
+        const value = Math.random() * (max - min) + min;
+        return type === "integer" ? Math.floor(value) : Math.round(value * 100) / 100;
+      }
+      case "boolean": {
+        return Math.random() > 0.5;
+      }
+      case "array": {
+        const items = schema.items;
+        if (items) {
+          const minItems = typeof schema.minItems === "number" ? schema.minItems : 1;
+          const maxItems = typeof schema.maxItems === "number" ? schema.maxItems : 3;
+          const length = Math.floor(Math.random() * (maxItems - minItems + 1)) + minItems;
+          return Array.from(
+            { length },
+            () => this.generateMockValueFromJsonSchema(items)
+          );
+        }
+        return [];
+      }
+      case "object": {
+        return this.generateMockFromJsonSchema(schema);
+      }
+      default: {
+        return null;
+      }
+    }
+  }
+  /**
+   * Generate mock data object from a Zod schema
+   * Recursively handles nested objects, arrays, and primitive types
+   */
+  static generateMockFromSchema(schema) {
+    const mockData = {};
+    if (!schema || typeof schema !== "object" || !("shape" in schema)) {
+      return mockData;
+    }
+    const shape = schema.shape;
+    for (const [key, zodType] of Object.entries(shape)) {
+      if (key === "success" || key === "error") {
+        continue;
+      }
+      if (zodType && typeof zodType === "object" && "_def" in zodType) {
+        const value = this.generateMockValue(zodType);
+        if (value !== void 0) {
+          mockData[key] = value;
+        }
+      }
+    }
+    return mockData;
+  }
+  /**
+   * Generate a mock value for a specific Zod type
+   */
+  static generateMockValue(zodType) {
+    const def = zodType._def;
+    switch (def.typeName) {
+      case "ZodString": {
+        return this.generateMockString(def);
+      }
+      case "ZodNumber": {
+        return this.generateMockNumber(def);
+      }
+      case "ZodBoolean": {
+        return Math.random() > 0.5;
+      }
+      case "ZodDate": {
+        return /* @__PURE__ */ new Date();
+      }
+      case "ZodArray": {
+        const elementType = def.type;
+        if (elementType) {
+          const arrayLength = Math.floor(Math.random() * 3) + 1;
+          return Array.from(
+            { length: arrayLength },
+            () => this.generateMockValue(elementType)
+          );
+        }
+        return [];
+      }
+      case "ZodObject": {
+        if ("shape" in zodType) {
+          const nestedMock = {};
+          const shape = zodType.shape;
+          for (const [key, value] of Object.entries(shape)) {
+            if (value && typeof value === "object" && "_def" in value) {
+              const nestedValue = this.generateMockValue(value);
+              if (nestedValue !== void 0) {
+                nestedMock[key] = nestedValue;
+              }
+            }
+          }
+          return nestedMock;
+        }
+        return {};
+      }
+      case "ZodOptional": {
+        if (Math.random() > 0.3) {
+          return this.generateMockValue(def.innerType);
+        }
+        return void 0;
+      }
+      case "ZodDefault": {
+        if (Math.random() > 0.5) {
+          return def.defaultValue();
+        }
+        return this.generateMockValue(def.innerType);
+      }
+      case "ZodEnum": {
+        const values = def.values;
+        return values[Math.floor(Math.random() * values.length)];
+      }
+      case "ZodLiteral": {
+        return def.value;
+      }
+      case "ZodUnion": {
+        const options = def.options;
+        const randomOption = options[Math.floor(Math.random() * options.length)];
+        return this.generateMockValue(randomOption);
+      }
+      case "ZodDiscriminatedUnion": {
+        const discriminatedOptions = def.options;
+        const randomDiscriminatedOption = discriminatedOptions[Math.floor(Math.random() * discriminatedOptions.length)];
+        return this.generateMockValue(randomDiscriminatedOption);
+      }
+      case "ZodRecord": {
+        const recordMock = {};
+        const numKeys = Math.floor(Math.random() * 3) + 1;
+        for (let i = 0; i < numKeys; i++) {
+          const key = `key${i + 1}`;
+          const value = this.generateMockValue(def.valueType);
+          if (value !== void 0) {
+            recordMock[key] = value;
+          }
+        }
+        return recordMock;
+      }
+      case "ZodNullable": {
+        if (Math.random() > 0.2) {
+          return this.generateMockValue(def.innerType);
+        }
+        return null;
+      }
+      default: {
+        console.warn(`Unknown Zod type for mock generation: ${def.typeName}`);
+        return `mock_${def.typeName}`;
+      }
+    }
+  }
+  /**
+   * Generate mock string values with format-specific handling
+   */
+  static generateMockString(def) {
+    if (def.checks) {
+      for (const check of def.checks) {
+        switch (check.kind) {
+          case "email": {
+            return "test@example.com";
+          }
+          case "url": {
+            return "https://example.com";
+          }
+          case "uuid": {
+            return generateUUID();
+          }
+          case "regex": {
+            const pattern = check.regex;
+            if (pattern.source.includes("\\d+")) {
+              return "12345";
+            }
+            if (pattern.source.includes("[a-z]")) {
+              return "abcde";
+            }
+            return "mock_regex_match";
+          }
+          case "min": {
+            return "a".repeat(check.value);
+          }
+          case "max": {
+            return "mock".substring(0, check.value);
+          }
+        }
+      }
+    }
+    return "mock string";
+  }
+  /**
+   * Generate mock number values respecting constraints
+   */
+  static generateMockNumber(def) {
+    let min = 0;
+    let max = 100;
+    let isInt = false;
+    if (def.checks) {
+      for (const check of def.checks) {
+        switch (check.kind) {
+          case "min": {
+            min = check.value;
+            break;
+          }
+          case "max": {
+            max = check.value;
+            break;
+          }
+          case "int": {
+            isInt = true;
+            break;
+          }
+        }
+      }
+    }
+    const value = Math.random() * (max - min) + min;
+    return isInt ? Math.floor(value) : Math.round(value * 100) / 100;
+  }
+  /**
+   * Generate mock data with custom seed for reproducible results
+   */
+  static generateMockWithSeed(resultSchema, seed) {
+    let currentSeed = seed;
+    const seededRandom = () => {
+      currentSeed = (currentSeed * 9301 + 49297) % 233280;
+      return currentSeed / 233280;
+    };
+    const originalRandom = Math.random;
+    Math.random = seededRandom;
+    try {
+      const mockData = this.generateMockFromSchema(resultSchema);
+      const executionId = generateUUID();
+      return {
+        success: true,
+        data: mockData,
+        executionId,
+        error: "",
+        timestamp: /* @__PURE__ */ new Date()
+      };
+    } finally {
+      Math.random = originalRandom;
+    }
+  }
+};
+
+// src/oauth-schema.ts
+import { z as z5 } from "@hono/zod-openapi";
+var oauthInitiateRequestSchema = z5.object({
+  credentialType: z5.nativeEnum(CredentialType).openapi({
+    description: "The type of credential to create",
+    example: "GOOGLE_DRIVE_CRED" /* GOOGLE_DRIVE_CRED */
+  }),
+  name: z5.string().optional().openapi({
+    description: "Optional name for the credential",
+    example: "My Google Drive"
+  }),
+  scopes: z5.array(z5.string()).optional().openapi({
+    description: "Optional OAuth scopes to request (defaults based on credential type)",
+    example: ["https://www.googleapis.com/auth/drive.readonly"]
+  })
+}).openapi("OAuthInitiateRequest");
+var oauthInitiateResponseSchema = z5.object({
+  authUrl: z5.string().url().openapi({
+    description: "OAuth authorization URL to redirect user to",
+    example: "https://accounts.google.com/oauth2/auth?client_id=..."
+  }),
+  state: z5.string().openapi({
+    description: "CSRF protection state parameter",
+    example: "abc123-def456-ghi789"
+  })
+}).openapi("OAuthInitiateResponse");
+var oauthCallbackRequestSchema = z5.object({
+  code: z5.string().openapi({
+    description: "OAuth authorization code from provider",
+    example: "abc123def456"
+  }),
+  state: z5.string().openapi({
+    description: "CSRF protection state parameter",
+    example: "abc123-def456-ghi789"
+  }),
+  name: z5.string().openapi({
+    description: "Name for the credential",
+    example: "My Google Drive"
+  }),
+  description: z5.string().optional().openapi({
+    description: "Optional description for the credential"
+  })
+}).openapi("OAuthCallbackRequest");
+var oauthTokenRefreshResponseSchema = z5.object({
+  message: z5.string().openapi({
+    description: "Success message",
+    example: "Token refreshed successfully"
+  })
+}).openapi("OAuthTokenRefreshResponse");
+var oauthRevokeResponseSchema = z5.object({
+  message: z5.string().openapi({
+    description: "Success message",
+    example: "Credential revoked successfully"
+  })
+}).openapi("OAuthRevokeResponse");
+
+// src/waitlist-schema.ts
+import { z as z6 } from "@hono/zod-openapi";
+var joinWaitlistSchema = z6.object({
+  name: z6.string().min(1, "Name is required").openapi({
+    description: "Full name of the user",
+    example: "John Doe"
+  }),
+  email: z6.string().email("Valid email is required").openapi({
+    description: "Email address of the user",
+    example: "john.doe@example.com"
+  }),
+  database: z6.string().min(1, "Database selection is required").openapi({
+    description: "Database type the user wants to use",
+    example: "postgres"
+  }),
+  otherDatabase: z6.string().optional().openapi({
+    description: 'Other database type if "other" was selected',
+    example: "Redis"
+  })
+}).openapi("JoinWaitlistRequest");
+var joinWaitlistResponseSchema = z6.object({
+  success: z6.boolean().openapi({
+    description: "Whether the request was successful",
+    example: true
+  }),
+  message: z6.string().openapi({
+    description: "Success message",
+    example: "Successfully joined the waitlist! Check your email for next steps."
+  })
+}).openapi("JoinWaitlistResponse");
+
+// src/bubbleflow-schema.ts
+import { z as z7 } from "@hono/zod-openapi";
+var createBubbleFlowSchema = z7.object({
+  name: z7.string().min(1).max(100).openapi({
+    description: "Name of the BubbleFlow",
+    example: "My First BubbleFlow"
+  }),
+  description: z7.string().optional().openapi({
+    description: "Optional description of what this BubbleFlow does",
+    example: "A flow that processes webhook data"
+  }),
+  prompt: z7.string().optional().openapi({
+    description: "Optional prompt used to generate the flow",
+    example: "Create a flow that processes webhook data and sends notifications"
+  }),
+  code: z7.string().min(1).openapi({
+    description: "TypeScript code that defines the BubbleFlow class",
+    example: "export class MyFlow extends BubbleFlow { ... }"
+  }),
+  eventType: z7.string().min(1).openapi({
+    description: "Event type this BubbleFlow responds to",
+    example: "webhook/http"
+  }),
+  webhookPath: z7.string().min(1).max(50).regex(/^[a-zA-Z0-9-_]+$/).optional().openapi({
+    description: "Custom webhook path (auto-generated if not provided)",
+    example: "my-webhook"
+  }),
+  webhookActive: z7.boolean().default(false).optional().openapi({
+    description: "Whether the webhook should be active immediately",
+    example: true
+  }),
+  bubbleParameters: z7.record(z7.string(), ParsedBubbleWithInfoSchema).optional().openapi({
+    description: "Optional pre-parsed bubble parameters with descriptions (from AI generation). If provided, will be used instead of re-parsing the code."
+  })
+}).openapi("CreateBubbleFlowRequest");
+var createEmptyBubbleFlowSchema = z7.object({
+  name: z7.string().min(1).max(100).openapi({
+    description: "Name of the BubbleFlow",
+    example: "My First BubbleFlow"
+  }),
+  description: z7.string().optional().openapi({
+    description: "Optional description of what this BubbleFlow does",
+    example: "A flow that processes webhook data"
+  }),
+  prompt: z7.string().openapi({
+    description: "Prompt used to generate the flow code asynchronously",
+    example: "Create a flow that processes webhook data and sends notifications"
+  }),
+  eventType: z7.string().min(1).openapi({
+    description: "Event type this BubbleFlow responds to",
+    example: "webhook/http"
+  }),
+  webhookPath: z7.string().min(1).max(50).regex(/^[a-zA-Z0-9-_]+$/).optional().openapi({
+    description: "Custom webhook path (auto-generated if not provided)",
+    example: "my-webhook"
+  }),
+  webhookActive: z7.boolean().default(false).optional().openapi({
+    description: "Whether the webhook should be active immediately",
+    example: true
+  })
+}).openapi("CreateEmptyBubbleFlowRequest");
+var executeBubbleFlowSchema = z7.record(z7.string(), z7.unknown()).openapi("ExecuteBubbleFlowRequest");
+var updateBubbleFlowParametersSchema = z7.object({
+  bubbleParameters: z7.record(
+    z7.string(),
+    z7.union([ParsedBubbleWithInfoSchema, ParsedBubbleSchema])
+  )
+}).openapi("UpdateBubbleFlowParametersRequest");
+var updateBubbleFlowNameSchema = z7.object({
+  name: z7.string().min(1).max(100).openapi({
+    description: "New name for the BubbleFlow",
+    example: "My Updated Flow"
+  })
+}).openapi("UpdateBubbleFlowNameRequest");
+var createBubbleFlowResponseSchema = z7.object({
+  id: z7.number().openapi({
+    description: "ID of the created BubbleFlow",
+    example: 123
+  }),
+  message: z7.string().openapi({
+    description: "Success message",
+    example: "BubbleFlow created successfully"
+  }),
+  inputSchema: z7.record(z7.string(), z7.unknown()).optional().openapi({
+    description: "Input schema",
+    example: {
+      name: "string",
+      age: "number"
+    }
+  }),
+  bubbleParameters: z7.record(z7.string(), ParsedBubbleWithInfoSchema).openapi({
+    description: "Parsed bubble parameters from the BubbleFlow code"
+  }),
+  workflow: ParsedWorkflowSchema.optional().openapi({
+    description: "Hierarchical workflow structure with control flow"
+  }),
+  requiredCredentials: z7.record(z7.string(), z7.array(z7.nativeEnum(CredentialType))).optional().openapi({
+    description: "Mapping of bubble names to their required credential types",
+    example: {
+      "database-connection": ["DATABASE_CRED" /* DATABASE_CRED */],
+      "slack-notification": ["SLACK_CRED" /* SLACK_CRED */],
+      "ai-analysis": ["GOOGLE_GEMINI_CRED" /* GOOGLE_GEMINI_CRED */]
+    }
+  }),
+  eventType: z7.string().min(1).openapi({
+    description: "Event type this BubbleFlow responds to",
+    example: "webhook/http"
+  }),
+  webhook: z7.object({
+    id: z7.number().openapi({ description: "Webhook ID", example: 456 }),
+    url: z7.string().openapi({
+      description: "Full webhook URL",
+      example: "http://localhost:3001/webhook/user123/my-webhook"
+    }),
+    path: z7.string().openapi({
+      description: "Webhook path",
+      example: "my-webhook"
+    }),
+    active: z7.boolean().openapi({
+      description: "Whether webhook is active",
+      example: true
+    })
+  }).optional().openapi({
+    description: "Webhook information (if webhook was created)"
+  })
+}).openapi("CreateBubbleFlowResponse");
+var createEmptyBubbleFlowResponseSchema = z7.object({
+  id: z7.number().openapi({
+    description: "ID of the created BubbleFlow (code will be generated asynchronously)",
+    example: 123
+  }),
+  message: z7.string().openapi({
+    description: "Success message",
+    example: "BubbleFlow created successfully. Code generation in progress..."
+  }),
+  webhook: z7.object({
+    id: z7.number().openapi({ description: "Webhook ID", example: 456 }),
+    url: z7.string().openapi({
+      description: "Full webhook URL",
+      example: "http://localhost:3001/webhook/user123/my-webhook"
+    }),
+    path: z7.string().openapi({
+      description: "Webhook path",
+      example: "my-webhook"
+    }),
+    active: z7.boolean().openapi({
+      description: "Whether webhook is active",
+      example: false
+    })
+  }).optional().openapi({
+    description: "Webhook information (if webhook was created)"
+  })
+}).openapi("CreateEmptyBubbleFlowResponse");
+var bubbleFlowDetailsResponseSchema = z7.object({
+  id: z7.number().openapi({ description: "BubbleFlow ID" }),
+  name: z7.string().openapi({ description: "BubbleFlow name" }),
+  description: z7.string().optional().openapi({ description: "Description" }),
+  prompt: z7.string().optional().openapi({ description: "Original prompt used to generate the flow" }),
+  eventType: z7.string().openapi({ description: "Event type" }),
+  code: z7.string().openapi({ description: "TypeScript source code" }),
+  generationError: z7.string().nullable().optional().openapi({ description: "Error message if code generation failed" }),
+  inputSchema: z7.record(z7.string(), z7.unknown()).optional().openapi({ description: "Input schema" }),
+  cron: z7.string().nullable().optional().openapi({ description: "Cron expression" }),
+  cronActive: z7.boolean().optional().openapi({ description: "Whether cron scheduling is active" }),
+  defaultInputs: z7.record(z7.string(), z7.unknown()).optional().openapi({ description: "Default inputs for cron scheduling" }),
+  isActive: z7.boolean().openapi({ description: "Whether the BubbleFlow is active" }),
+  requiredCredentials: z7.record(z7.string(), z7.array(z7.nativeEnum(CredentialType))).openapi({ description: "Required credentials by bubble" }),
+  displayedBubbleParameters: z7.record(
+    z7.string(),
+    z7.object({
+      variableName: z7.string(),
+      bubbleName: z7.string(),
+      className: z7.string(),
+      parameters: z7.array(
+        z7.object({
+          name: z7.string(),
+          value: z7.unknown(),
+          type: z7.nativeEnum(BubbleParameterType)
+        })
+      ),
+      hasAwait: z7.boolean(),
+      hasActionCall: z7.boolean()
+    })
+  ).optional().openapi({
+    description: "Displayed bubble parameters for visualization"
+  }),
+  bubbleParameters: z7.record(z7.string(), ParsedBubbleWithInfoSchema).openapi({
+    description: "Bubble parameters"
+  }),
+  workflow: ParsedWorkflowSchema.optional().openapi({
+    description: "Hierarchical workflow structure with control flow"
+  }),
+  metadata: z7.record(z7.string(), z7.unknown()).optional().openapi({
+    description: "Flow metadata including conversation messages from generation"
+  }),
+  createdAt: z7.string().openapi({ description: "Creation timestamp" }),
+  updatedAt: z7.string().openapi({ description: "Update timestamp" }),
+  webhook_url: z7.string().openapi({ description: "Webhook URL for this bubble flow" })
+}).openapi("BubbleFlowDetailsResponse");
+var bubbleFlowListItemSchema = z7.object({
+  id: z7.number().openapi({ description: "BubbleFlow ID" }),
+  name: z7.string().openapi({ description: "BubbleFlow name" }),
+  description: z7.string().optional().openapi({ description: "Description" }),
+  eventType: z7.string().openapi({ description: "Event type" }),
+  isActive: z7.boolean().openapi({ description: "Whether the BubbleFlow is active" }),
+  cronActive: z7.boolean().openapi({ description: "Whether cron scheduling is active" }),
+  cronSchedule: z7.string().optional().openapi({ description: "Cron schedule" }),
+  webhookExecutionCount: z7.number().openapi({ description: "Webhook execution count" }),
+  webhookFailureCount: z7.number().openapi({ description: "Webhook failure count" }),
+  executionCount: z7.number().openapi({ description: "Total number of executions in history" }),
+  bubbles: z7.array(
+    z7.object({
+      bubbleName: z7.string().openapi({ description: "Bubble name" }),
+      className: z7.string().openapi({ description: "Bubble class name" })
+    })
+  ).optional().openapi({ description: "List of bubbles used in this flow" }),
+  createdAt: z7.string().openapi({ description: "Creation timestamp" }),
+  updatedAt: z7.string().openapi({ description: "Update timestamp" })
+});
+var bubbleFlowListResponseSchema = z7.object({
+  bubbleFlows: z7.array(bubbleFlowListItemSchema).default([]),
+  userMonthlyUsage: z7.object({
+    count: z7.number().openapi({ description: "Current monthly usage count" })
+  }).openapi({ description: "User monthly usage information" })
+});
+var activateBubbleFlowResponseSchema = z7.object({
+  success: z7.boolean().openapi({
+    description: "Whether the activation was successful",
+    example: true
+  }),
+  webhookUrl: z7.string().openapi({
+    description: "Webhook URL for the activated workflow",
+    example: "https://api.nodex.dev/webhook/user123/workflow-123"
+  }),
+  message: z7.string().openapi({
+    description: "Success message",
+    example: "Workflow activated successfully! Your Slack bot is now ready."
+  })
+}).openapi("ActivateBubbleFlowResponse");
+
+// src/bubbleflow-execution-schema.ts
+import { z as z8 } from "@hono/zod-openapi";
+var ServiceUsageSchema = z8.object({
+  service: z8.nativeEnum(CredentialType).openapi({
+    description: "Service identifier",
+    example: "OPENAI_CRED" /* OPENAI_CRED */
+  }),
+  subService: z8.string().optional().openapi({
+    description: "Sub-service identifier",
+    example: "gpt-4"
+  }),
+  unit: z8.string().openapi({
+    description: "Unit type for this service",
+    example: "per_1m_tokens"
+  }),
+  usage: z8.number().openapi({
+    description: "Units used this month",
+    example: 225e4
+  }),
+  unitCost: z8.number().openapi({
+    description: "Bubble Lab price per unit (with multiplier applied)",
+    example: 2.1
+  }),
+  totalCost: z8.number().openapi({
+    description: "Total cost for this service (usage * unitCost)",
+    example: 4.725
+  })
+}).openapi("ServiceUsage");
+var ExecutionSummarySchema = z8.object({
+  result: z8.any().optional().openapi({
+    description: "Execution result",
+    example: "Execution completed successfully"
+  }),
+  totalDuration: z8.number().openapi({
+    description: "Total execution duration in milliseconds",
+    example: 1500
+  }),
+  lineExecutionCount: z8.number().optional().openapi({
+    description: "Number of lines executed",
+    example: 25
+  }),
+  bubbleExecutionCount: z8.number().optional().openapi({
+    description: "Number of bubbles executed",
+    example: 5
+  }),
+  errorCount: z8.number().optional().openapi({
+    description: "Number of errors encountered",
+    example: 0
+  }),
+  totalCost: z8.number().openapi({ description: "Total cost of the execution" }),
+  warningCount: z8.number().optional().openapi({
+    description: "Number of warnings encountered",
+    example: 1
+  }),
+  errors: z8.array(
+    z8.object({
+      message: z8.string().openapi({
+        description: "Error message",
+        example: "Failed to execute bubble"
+      }),
+      timestamp: z8.number().openapi({
+        description: "Error timestamp (Unix timestamp)",
+        example: 1703123457e3
+      }),
+      bubbleName: z8.string().optional().openapi({
+        description: "Name of the bubble that caused the error",
+        example: "AIAgentBubble"
+      }),
+      variableId: z8.number().optional().openapi({
+        description: "Variable ID associated with the error",
+        example: 1
+      }),
+      lineNumber: z8.number().optional().openapi({
+        description: "Line number where the error occurred",
+        example: 15
+      }),
+      additionalData: z8.any().optional().openapi({
+        description: "Additional error details"
+      })
+    })
+  ).optional().openapi({
+    description: "Array of errors encountered during execution"
+  }),
+  warnings: z8.array(
+    z8.object({
+      message: z8.string().openapi({
+        description: "Warning message",
+        example: "Deprecated API usage detected"
+      }),
+      timestamp: z8.number().openapi({
+        description: "Warning timestamp (Unix timestamp)",
+        example: 1703123457e3
+      }),
+      bubbleName: z8.string().optional().openapi({
+        description: "Name of the bubble that caused the warning",
+        example: "HttpBubble"
+      }),
+      variableId: z8.number().optional().openapi({
+        description: "Variable ID associated with the warning",
+        example: 2
+      }),
+      lineNumber: z8.number().optional().openapi({
+        description: "Line number where the warning occurred",
+        example: 20
+      }),
+      additionalData: z8.any().optional().openapi({
+        description: "Additional warning details"
+      })
+    })
+  ).optional().openapi({
+    description: "Array of warnings encountered during execution"
+  }),
+  averageLineExecutionTime: z8.number().optional().openapi({
+    description: "Average execution time per line in milliseconds",
+    example: 60
+  }),
+  slowestLines: z8.array(
+    z8.object({
+      lineNumber: z8.number().openapi({
+        description: "Line number",
+        example: 15
+      }),
+      duration: z8.number().openapi({
+        description: "Execution duration in milliseconds",
+        example: 250
+      }),
+      message: z8.string().openapi({
+        description: "Description of what was executed on this line",
+        example: "API call to external service"
+      })
+    })
+  ).optional().openapi({
+    description: "Array of the slowest executing lines"
+  }),
+  memoryPeakUsage: z8.any().optional().openapi({
+    description: "Peak memory usage during execution (NodeJS.MemoryUsage type)"
+  }),
+  // NodeJS.MemoryUsage type
+  startTime: z8.number().optional().openapi({
+    description: "Execution start timestamp (Unix timestamp)",
+    example: 1703123456789
+  }),
+  endTime: z8.number().optional().openapi({
+    description: "Execution end timestamp (Unix timestamp)",
+    example: 1703123458289
+  }),
+  serviceUsage: z8.array(ServiceUsageSchema).optional().openapi({
+    description: "Token usage during execution"
+  }),
+  serviceUsageByService: z8.record(z8.string(), ServiceUsageSchema).optional().openapi({
+    description: "Service usage breakdown by service"
+  })
+}).openapi("ExecutionSummary");
+var bubbleFlowExecutionSchema = z8.object({
+  id: z8.number().openapi({ description: "Execution ID" }),
+  status: z8.enum(["running", "success", "error"]).openapi({ description: "Execution status" }),
+  payload: z8.record(z8.string(), z8.any()).openapi({ description: "Execution payload" }),
+  result: z8.any().optional().openapi({ description: "Execution result data" }),
+  error: z8.string().optional().openapi({ description: "Error message if failed" }),
+  startedAt: z8.string().openapi({ description: "Execution start timestamp" }),
+  webhook_url: z8.string().openapi({ description: "Webhook URL" }),
+  completedAt: z8.string().optional().openapi({ description: "Execution completion timestamp" }),
+  code: z8.string().optional().openapi({
+    description: "The code that was executed (snapshot of the code at execution time)"
+  })
+});
+var listBubbleFlowExecutionsResponseSchema = z8.array(bubbleFlowExecutionSchema).openapi("ListBubbleFlowExecutionsResponse");
+var bubbleFlowExecutionDetailSchema = bubbleFlowExecutionSchema.extend(
+  {
+    executionLogs: z8.array(z8.any()).optional().openapi({
+      description: "Array of streaming log events from the execution"
+    })
+  }
+);
+var executeBubbleFlowResponseSchema = z8.object({
+  executionId: z8.number().openapi({
+    description: "ID of the execution record",
+    example: 789
+  }),
+  success: z8.boolean().openapi({
+    description: "Whether the execution was successful",
+    example: true
+  }),
+  data: z8.any().optional().openapi({
+    description: "Data returned by the BubbleFlow (if successful)",
+    example: { result: "processed successfully", count: 42 }
+  }),
+  summary: ExecutionSummarySchema.optional().openapi({
+    description: "Execution summary"
+  }),
+  error: z8.string().optional().openapi({
+    description: "Error message (if execution failed)",
+    example: "Validation error in BubbleFlow"
+  })
+}).openapi("ExecuteBubbleFlowResponse");
+var validateBubbleFlowCodeSchema = z8.object({
+  code: z8.string().min(1).openapi({
+    description: "TypeScript BubbleFlow code to validate",
+    example: 'export class TestFlow extends BubbleFlow<"webhook/http"> { async handle() { return {}; } }'
+  }),
+  options: z8.object({
+    includeDetails: z8.boolean().default(true).openapi({
+      description: "Include detailed bubble analysis"
+    }),
+    strictMode: z8.boolean().default(true).openapi({
+      description: "Enable strict TypeScript validation"
+    }),
+    syncInputsWithFlow: z8.boolean().default(false).openapi({
+      description: "Whether to sync input values with the flow"
+    })
+  }).optional().openapi({
+    description: "Validation options"
+  }),
+  flowId: z8.number().positive().optional().openapi({
+    description: "Optional BubbleFlow ID to update with validation results if user owns the flow",
+    example: 123
+  }),
+  credentials: z8.record(z8.string(), z8.record(z8.string(), z8.number())).optional().openapi({
+    description: "Optional credentials mapping: bubble name -> credential type -> credential ID",
+    example: {
+      "slack-sender": {
+        SLACK_CRED: 123
+      },
+      "ai-agent": {
+        OPENAI_CRED: 456
+      }
+    }
+  }),
+  defaultInputs: z8.record(z8.unknown()).optional().openapi({
+    description: "User-filled input values for cron execution",
+    example: {
+      message: "Hello World",
+      channel: "#general"
+    }
+  }),
+  activateCron: z8.boolean().optional().openapi({
+    description: "Whether to activate/deactivate cron scheduling",
+    example: true
+  })
+});
+var validateBubbleFlowCodeResponseSchema = z8.object({
+  eventType: z8.string().min(1).openapi({
+    description: "Event type this BubbleFlow responds to",
+    example: "webhook/http"
+  }),
+  webhookPath: z8.string().min(1).openapi({
+    description: "Custom webhook path (auto-generated if not provided)",
+    example: "my-webhook"
+  }),
+  valid: z8.boolean().openapi({
+    description: "Whether the code is valid"
+  }),
+  errors: z8.array(z8.string()).optional().openapi({
+    description: "List of validation errors if any"
+  }),
+  bubbleCount: z8.number().optional().openapi({
+    description: "Number of bubbles found in the code"
+  }),
+  inputSchema: z8.record(z8.string(), z8.unknown()).openapi({
+    description: "Input schema",
+    example: {
+      name: "string",
+      age: "number"
+    }
+  }),
+  bubbles: z8.record(z8.string(), ParsedBubbleWithInfoSchema).optional().openapi({
+    description: "Record mapping bubble IDs to their detailed information"
+  }),
+  workflow: ParsedWorkflowSchema.optional().openapi({
+    description: "Hierarchical workflow structure with control flow"
+  }),
+  requiredCredentials: z8.record(z8.string(), z8.array(z8.string())).optional().openapi({
+    description: "Required credentials for the bubbles in the code"
+  }),
+  metadata: z8.object({
+    validatedAt: z8.string().openapi({
+      description: "Timestamp when validation was performed"
+    }),
+    codeLength: z8.number().openapi({
+      description: "Length of the code in characters"
+    }),
+    strictMode: z8.boolean().openapi({
+      description: "Whether strict mode was used"
+    }),
+    flowUpdated: z8.boolean().optional().openapi({
+      description: "Whether the BubbleFlow was updated with validation results"
+    })
+  }).openapi({
+    description: "Validation metadata"
+  }),
+  cron: z8.string().nullable().optional().openapi({
+    description: "Cron expression extracted from code",
+    example: "0 0 * * *"
+  }),
+  cronActive: z8.boolean().optional().openapi({
+    description: "Whether cron scheduling is currently active",
+    example: false
+  }),
+  defaultInputs: z8.record(z8.unknown()).optional().openapi({
+    description: "User-filled input values for cron execution",
+    example: {
+      message: "Hello World",
+      channel: "#general"
+    }
+  }),
+  success: z8.boolean(),
+  error: z8.string()
+});
+
+// src/generate-bubbleflow-schema.ts
+import { z as z10 } from "@hono/zod-openapi";
+
+// src/coffee.ts
+import { z as z9 } from "zod";
+var COFFEE_MAX_ITERATIONS = 30;
+var COFFEE_MAX_QUESTIONS = 5;
+var COFFEE_DEFAULT_MODEL = "google/gemini-3-pro-preview";
+var ClarificationChoiceSchema = z9.object({
+  id: z9.string().describe("Unique identifier for this choice"),
+  label: z9.string().describe("Short display label for the choice"),
+  description: z9.string().optional().describe("Optional longer description explaining the choice")
+});
+var ClarificationQuestionSchema = z9.object({
+  id: z9.string().describe("Unique identifier for this question"),
+  question: z9.string().describe("The question text to display to the user"),
+  choices: z9.array(ClarificationChoiceSchema).min(2).describe("Available choices for the user (minimum 2 options)"),
+  context: z9.string().optional().describe("Optional context explaining why this question is being asked"),
+  allowMultiple: z9.boolean().optional().default(false).describe(
+    "If true, user can select multiple choices. Default is false (single selection)"
+  )
+});
+var CoffeeClarificationEventSchema = z9.object({
+  questions: z9.array(ClarificationQuestionSchema).min(1).max(COFFEE_MAX_QUESTIONS).describe(`List of clarification questions (1-${COFFEE_MAX_QUESTIONS})`)
+});
+var CoffeeRequestExternalContextEventSchema = z9.object({
+  flowId: z9.string().describe("Unique ID for this context request"),
+  flowCode: z9.string().describe("Validated BubbleFlow TypeScript code to execute"),
+  requiredCredentials: z9.array(z9.nativeEnum(CredentialType)).describe("List of credential types needed to run this flow"),
+  description: z9.string().describe("User-friendly description of what this flow will do")
+});
+var CoffeeContextAnswerSchema = z9.object({
+  flowId: z9.string().describe("ID of the context request being answered"),
+  status: z9.enum(["success", "rejected", "error"]).describe(
+    "Status: success (got context), rejected (user skipped), error (execution failed)"
+  ),
+  result: z9.unknown().optional().describe("The result data from running the context-gathering flow"),
+  error: z9.string().optional().describe("Error message if status is error"),
+  originalRequest: CoffeeRequestExternalContextEventSchema.optional().describe(
+    "The original context request that triggered this answer"
+  )
+});
+var CoffeeContextRequestInfoSchema = z9.object({
+  purpose: z9.string().describe("Why this context is needed"),
+  flowDescription: z9.string().describe("User-facing description of what the flow will do")
+});
+var CoffeeContextEventSchema = z9.object({
+  status: z9.enum(["gathering", "complete"]),
+  miniFlowDescription: z9.string().optional(),
+  result: z9.string().optional()
+});
+var PlanStepSchema = z9.object({
+  title: z9.string().describe("Short title for this step"),
+  description: z9.string().describe("Detailed description of what this step does"),
+  bubblesUsed: z9.array(z9.string()).optional().describe("Names of bubbles used in this step")
+});
+var CoffeePlanEventSchema = z9.object({
+  summary: z9.string().describe("Brief overview of the workflow"),
+  steps: z9.array(PlanStepSchema).describe("Step-by-step implementation plan"),
+  estimatedBubbles: z9.array(z9.string()).describe("All bubbles that will be used in the workflow")
+});
+var BaseMessageSchema = z9.object({
+  id: z9.string().describe("Unique message identifier"),
+  timestamp: z9.string().describe("ISO timestamp of message creation")
+});
+var UserMessageSchema = BaseMessageSchema.extend({
+  type: z9.literal("user"),
+  content: z9.string().describe("User message text")
+});
+var AssistantMessageSchema = BaseMessageSchema.extend({
+  type: z9.literal("assistant"),
+  content: z9.string().describe("Assistant response text"),
+  code: z9.string().optional().describe("Generated code if applicable"),
+  resultType: z9.enum(["code", "question", "answer", "reject"]).optional().describe("Type of assistant response"),
+  bubbleParameters: z9.record(z9.string(), z9.unknown()).optional().describe("Bubble parameters for code responses")
+});
+var ClarificationRequestMessageSchema = BaseMessageSchema.extend({
+  type: z9.literal("clarification_request"),
+  questions: z9.array(ClarificationQuestionSchema).describe("Questions being asked")
+});
+var ClarificationResponseMessageSchema = BaseMessageSchema.extend({
+  type: z9.literal("clarification_response"),
+  answers: z9.record(z9.string(), z9.array(z9.string())).describe("questionId -> choiceIds"),
+  originalQuestions: z9.array(ClarificationQuestionSchema).optional().describe("The questions that were answered (for display purposes)")
+});
+var ContextRequestMessageSchema = BaseMessageSchema.extend({
+  type: z9.literal("context_request"),
+  request: CoffeeRequestExternalContextEventSchema.describe(
+    "Context gathering request details"
+  )
+});
+var ContextResponseMessageSchema = BaseMessageSchema.extend({
+  type: z9.literal("context_response"),
+  answer: CoffeeContextAnswerSchema.describe(
+    "User response to context request"
+  ),
+  credentialTypes: z9.array(z9.string()).optional().describe("Credential types used (for display, not actual secrets)")
+});
+var PlanMessageSchema = BaseMessageSchema.extend({
+  type: z9.literal("plan"),
+  plan: CoffeePlanEventSchema.describe("Generated implementation plan")
+});
+var PlanApprovalMessageSchema = BaseMessageSchema.extend({
+  type: z9.literal("plan_approval"),
+  approved: z9.boolean().describe("Whether the plan was approved"),
+  comment: z9.string().optional().describe("Optional user comment on the plan")
+});
+var SystemMessageSchema = BaseMessageSchema.extend({
+  type: z9.literal("system"),
+  content: z9.string().describe("System message content")
+});
+var ToolResultMessageSchema = BaseMessageSchema.extend({
+  type: z9.literal("tool_result"),
+  toolName: z9.string().describe("Name of the tool that was called"),
+  toolCallId: z9.string().describe("Unique ID for this tool call"),
+  input: z9.unknown().describe("Input parameters passed to the tool"),
+  output: z9.unknown().describe("Output/result from the tool"),
+  duration: z9.number().describe("Duration of the tool call in milliseconds"),
+  success: z9.boolean().describe("Whether the tool call succeeded")
+});
+var CoffeeMessageSchema = z9.discriminatedUnion("type", [
+  UserMessageSchema,
+  AssistantMessageSchema,
+  ClarificationRequestMessageSchema,
+  ClarificationResponseMessageSchema,
+  ContextRequestMessageSchema,
+  ContextResponseMessageSchema,
+  PlanMessageSchema,
+  PlanApprovalMessageSchema,
+  SystemMessageSchema,
+  ToolResultMessageSchema
+]);
+var CoffeeRequestSchema = z9.object({
+  prompt: z9.string().min(1).describe("The user prompt describing the workflow"),
+  flowId: z9.number().optional().describe("Optional flow ID if updating existing flow"),
+  messages: z9.array(CoffeeMessageSchema).optional().describe(
+    "Full conversation history including clarification Q&A, context results, plan approvals"
+  )
+});
+var CoffeeResponseSchema = z9.object({
+  type: z9.enum(["clarification", "plan", "context_request", "error"]).describe("Response type"),
+  clarification: CoffeeClarificationEventSchema.optional(),
+  plan: CoffeePlanEventSchema.optional(),
+  contextRequest: CoffeeRequestExternalContextEventSchema.optional(),
+  error: z9.string().optional(),
+  success: z9.boolean().describe("Whether the operation completed successfully")
+});
+var CoffeeAgentOutputSchema = z9.object({
+  action: z9.enum(["askClarification", "generatePlan", "requestContext"]).describe("The action the agent wants to take"),
+  questions: z9.array(ClarificationQuestionSchema).optional(),
+  plan: CoffeePlanEventSchema.optional(),
+  contextRequest: CoffeeContextRequestInfoSchema.optional()
+});
+
+// src/generate-bubbleflow-schema.ts
+var generateBubbleFlowCodeSchema = z10.object({
+  prompt: z10.string().min(1).openapi({
+    description: "Natural language description of the desired BubbleFlow",
+    example: "Create a flow that queries my database and sends results to Slack"
+  }),
+  flowId: z10.number().optional().openapi({
+    description: "Optional flow ID to update with generated code (for async generation)",
+    example: 123
+  }),
+  // Coffee agent unified messages (for planning phase)
+  messages: z10.array(CoffeeMessageSchema).optional().openapi({
+    description: "Full conversation history including clarification Q&A, context results, plan approvals"
+  }),
+  // Plan context (passed to Boba for enriched code generation)
+  planContext: z10.string().optional().openapi({
+    description: "Plan context from Coffee agent (passed to Boba for enriched generation)",
+    example: "Plan: 1. Fetch data from API 2. Process with AI 3. Send to Slack"
+  })
+});
+var generateBubbleFlowCodeResponseSchema = z10.object({
+  generatedCode: z10.string().openapi({
+    description: "The generated BubbleFlow TypeScript code"
+  }),
+  isValid: z10.boolean().openapi({
+    description: "Whether the generated code is valid"
+  }),
+  success: z10.boolean(),
+  error: z10.string(),
+  bubbleParameters: z10.record(z10.string(), ParsedBubbleWithInfoSchema).openapi({
+    description: "Parsed bubble parameters from the generated code"
+  }),
+  requiredCredentials: z10.record(z10.string(), z10.array(z10.string())).openapi({
+    description: "Required credentials for the bubbles in the generated code"
+  })
+});
+var GenerationResultSchema = z10.object({
+  generatedCode: z10.string().describe("The generated BubbleFlow TypeScript code"),
+  isValid: z10.boolean().describe("Whether the generated code is valid"),
+  success: z10.boolean(),
+  error: z10.string(),
+  flowId: z10.number().optional().openapi({
+    description: "ID of the generated BubbleFlow",
+    example: 123
+  }),
+  toolCalls: z10.array(z10.unknown()).describe("The tool calls made by the AI agent"),
+  summary: z10.string().default("").describe("High-level instructions for using the validated flow"),
+  inputsSchema: z10.string().default("").describe("JSON Schema (string) representing the inputs of the flow"),
+  serviceUsage: z10.array(ServiceUsageSchema).optional().openapi({
+    description: "Service usage statistics for the generation (array of services used)"
+  }),
+  bubbleCount: z10.number().optional().openapi({
+    description: "Number of bubbles used in the generated flow"
+  }),
+  codeLength: z10.number().optional().openapi({
+    description: "Length of the generated code in characters"
+  }),
+  bubbleParameters: z10.record(z10.union([z10.string(), z10.number()]), ParsedBubbleWithInfoSchema).optional().openapi({
+    description: "Parsed bubble parameters with descriptions from AI generation"
+  })
+});
+var generateBubbleFlowTemplateSchema = z10.object({
+  name: z10.string().min(1).max(100).openapi({
+    description: "Name for the workflow",
+    example: "Sam Dix Data Scientist Bot"
+  }),
+  description: z10.string().min(10).max(500).openapi({
+    description: "Description of what the workflow should do",
+    example: "A Slack bot that helps analyze user engagement data and provides insights"
+  }),
+  roles: z10.string().min(10).max(1e3).openapi({
+    description: "Detailed description of the bot's roles and responsibilities",
+    example: "Be prepared to answer any question on user engagement and come up with proactive insights..."
+  }),
+  useCase: z10.literal("slack-data-scientist").openapi({
+    description: "The specific use case template to generate",
+    example: "slack-data-scientist"
+  }),
+  // Optional configuration parameters
+  verbosity: z10.enum(["1", "2", "3", "4", "5"]).optional().openapi({
+    description: "Response verbosity level (1=concise, 5=comprehensive)",
+    example: "3"
+  }),
+  technicality: z10.enum(["1", "2", "3", "4", "5"]).optional().openapi({
+    description: "Technical complexity level (1=plain English, 5=expert)",
+    example: "2"
+  }),
+  includeQuery: z10.boolean().optional().openapi({
+    description: "Include the SQL query in the response",
+    example: true
+  }),
+  includeExplanation: z10.boolean().optional().openapi({
+    description: "Include query explanation in the response",
+    example: true
+  }),
+  maxQueries: z10.number().optional().openapi({
+    description: "Maximum number of queries to run",
+    example: 10
+  })
+}).openapi("GenerateBubbleFlowTemplateRequest");
+var generateDocumentGenerationTemplateSchema = z10.object({
+  name: z10.string().min(1).max(100).openapi({
+    description: "Name for the document processing workflow",
+    example: "Expense Report Generator"
+  }),
+  description: z10.string().max(500).default("Document processing workflow").openapi({
+    description: "Description of what the document processing workflow should do (optional)",
+    example: "Process receipts and invoices to generate structured expense reports"
+  }),
+  outputDescription: z10.string().min(1).max(1e3).openapi({
+    description: "Detailed description of the desired output format and data extraction",
+    example: "Extract expense tracking data with vendor name, transaction date, amount, category, and description"
+  }),
+  // Optional configuration parameters
+  outputFormat: z10.enum(["html", "csv", "json"]).optional().openapi({
+    description: "Default output format for generated documents",
+    example: "html"
+  }),
+  conversionOptions: z10.object({
+    preserveStructure: z10.boolean().optional().openapi({
+      description: "Preserve document structure during parsing",
+      example: true
+    }),
+    includeVisualDescriptions: z10.boolean().optional().openapi({
+      description: "Include descriptions of visual elements",
+      example: true
+    }),
+    extractNumericalData: z10.boolean().optional().openapi({
+      description: "Extract and process numerical data",
+      example: true
+    }),
+    combinePages: z10.boolean().optional().openapi({
+      description: "Combine multiple pages into single output",
+      example: true
+    })
+  }).optional(),
+  imageOptions: z10.object({
+    format: z10.enum(["png", "jpg", "jpeg"]).optional().openapi({
+      description: "Image format for document conversion",
+      example: "png"
+    }),
+    quality: z10.number().min(0.1).max(1).optional().openapi({
+      description: "Image quality (0.1 to 1.0)",
+      example: 0.9
+    }),
+    dpi: z10.number().min(72).max(300).optional().openapi({
+      description: "Image DPI for conversion",
+      example: 200
+    })
+  }).optional(),
+  aiOptions: z10.object({
+    model: z10.string().optional().openapi({
+      description: "AI model to use for processing",
+      example: "google/gemini-2.5-flash"
+    }),
+    temperature: z10.number().min(0).max(2).optional().openapi({
+      description: "AI model temperature (0 to 2)",
+      example: 0.2
+    }),
+    maxTokens: z10.number().min(1e3).max(2e5).optional().openapi({
+      description: "Maximum tokens for AI processing",
+      example: 9e4
+    }),
+    jsonMode: z10.boolean().optional().openapi({
+      description: "Enable JSON mode for structured output",
+      example: false
+    })
+  }).optional(),
+  metadata: z10.record(z10.string(), z10.unknown()).optional().openapi({
+    description: "Additional metadata for the workflow (e.g., outputDescription)",
+    example: { outputDescription: "Extract expense data from receipts" }
+  })
+}).openapi("GenerateDocumentGenerationTemplateRequest");
+var bubbleFlowTemplateResponseSchema = z10.object({
+  id: z10.number().openapi({
+    description: "ID of the created BubbleFlow template",
+    example: 123
+  }),
+  name: z10.string().openapi({
+    description: "Name of the BubbleFlow",
+    example: "Sam Dix Data Scientist Bot"
+  }),
+  description: z10.string().openapi({
+    description: "Description of the BubbleFlow",
+    example: "A Slack bot that helps analyze user engagement data"
+  }),
+  eventType: z10.string().openapi({
+    description: "Event type this BubbleFlow responds to",
+    example: "slack/bot_mentioned"
+  }),
+  displayedBubbleParameters: z10.record(
+    z10.string(),
+    z10.object({
+      variableName: z10.string(),
+      bubbleName: z10.string(),
+      className: z10.string(),
+      parameters: z10.array(
+        z10.object({
+          name: z10.string(),
+          value: z10.unknown(),
+          type: z10.nativeEnum(BubbleParameterType)
+        })
+      ),
+      hasAwait: z10.boolean(),
+      hasActionCall: z10.boolean()
+    })
+  ),
+  bubbleParameters: z10.record(
+    z10.string(),
+    z10.object({
+      variableName: z10.string(),
+      bubbleName: z10.string(),
+      className: z10.string(),
+      parameters: z10.array(
+        z10.object({
+          name: z10.string(),
+          value: z10.unknown(),
+          type: z10.nativeEnum(BubbleParameterType)
+        })
+      ),
+      hasAwait: z10.boolean(),
+      hasActionCall: z10.boolean()
+    })
+  ).openapi({
+    description: "Parsed bubble parameters from the BubbleFlow code"
+  }),
+  requiredCredentials: z10.record(z10.string(), z10.array(z10.nativeEnum(CredentialType))).optional().openapi({
+    description: "Mapping of bubble names to their required credential types",
+    example: {
+      "database-connection": ["DATABASE_CRED" /* DATABASE_CRED */],
+      "slack-notification": ["SLACK_CRED" /* SLACK_CRED */],
+      "ai-analysis": ["GOOGLE_GEMINI_CRED" /* GOOGLE_GEMINI_CRED */]
+    }
+  }),
+  createdAt: z10.string().openapi({
+    description: "ISO timestamp when the template was created",
+    example: "2025-01-15T10:30:00.000Z"
+  }),
+  updatedAt: z10.string().openapi({
+    description: "ISO timestamp when the template was last updated",
+    example: "2025-01-15T10:30:00.000Z"
+  }),
+  webhook: z10.object({
+    id: z10.number().openapi({ description: "Webhook ID", example: 456 }),
+    url: z10.string().openapi({
+      description: "Full webhook URL",
+      example: "http://localhost:3001/webhook/user123/my-webhook"
+    }),
+    path: z10.string().openapi({
+      description: "Webhook path",
+      example: "my-webhook"
+    }),
+    active: z10.boolean().openapi({
+      description: "Whether webhook is active",
+      example: true
+    })
+  }).optional().openapi({
+    description: "Webhook information (if webhook was created)"
+  })
+}).openapi("BubbleFlowTemplateResponse");
+
+// src/webhook-schema.ts
+import { z as z11 } from "@hono/zod-openapi";
+var webhookExecutionResponseSchema = z11.object({
+  executionId: z11.number().openapi({ description: "Execution ID" }),
+  success: z11.boolean().openapi({ description: "Execution success" }),
+  data: z11.unknown().optional().openapi({ description: "Result data" }),
+  error: z11.string().optional().openapi({ description: "Error message" }),
+  webhook: z11.object({
+    userId: z11.string().openapi({ description: "User ID" }),
+    path: z11.string().openapi({ description: "Webhook path" }),
+    triggeredAt: z11.string().openapi({ description: "Trigger timestamp" }),
+    method: z11.string().openapi({ description: "HTTP method" })
+  }).openapi({ description: "Webhook info" })
+}).openapi("WebhookExecutionResponse");
+var webhookResponseSchema = z11.object({
+  // Slack verification fields
+  challenge: z11.string().optional().openapi({ description: "Slack URL verification challenge" }),
+  // Execution fields
+  executionId: z11.number().optional().openapi({ description: "Execution ID" }),
+  success: z11.boolean().optional().openapi({ description: "Execution success" }),
+  data: z11.record(z11.string(), z11.unknown()).or(z11.undefined()).optional().openapi({ description: "Result data" }),
+  error: z11.string().optional().openapi({ description: "Error message" }),
+  webhook: z11.object({
+    userId: z11.string().openapi({ description: "User ID" }),
+    path: z11.string().openapi({ description: "Webhook path" }),
+    triggeredAt: z11.string().openapi({ description: "Trigger timestamp" }),
+    method: z11.string().openapi({ description: "HTTP method" })
+  }).optional().openapi({ description: "Webhook info" })
+}).openapi("WebhookResponse");
+
+// src/subscription-status-schema.ts
+import { z as z12 } from "@hono/zod-openapi";
+var hackathonOfferSchema = z12.object({
+  isActive: z12.boolean().openapi({
+    description: "Whether a hackathon offer is currently active",
+    example: true
+  }),
+  expiresAt: z12.string().openapi({
+    description: "ISO date when the hackathon offer expires",
+    example: "2025-01-15T14:30:00.000Z"
+  }),
+  redeemedAt: z12.string().openapi({
+    description: "ISO date when the code was redeemed",
+    example: "2025-01-14T14:30:00.000Z"
+  })
+}).openapi("HackathonOffer");
+var specialOfferSchema = z12.object({
+  isActive: z12.boolean().openapi({
+    description: "Whether a special offer is currently active",
+    example: true
+  }),
+  plan: z12.string().openapi({
+    description: "The plan granted by the special offer",
+    example: "unlimited"
+  }),
+  expiresAt: z12.string().nullable().openapi({
+    description: "ISO date when the special offer expires (null = never expires)",
+    example: "2025-06-15T14:30:00.000Z"
+  })
+}).openapi("SpecialOffer");
+var redeemCouponRequestSchema = z12.object({
+  code: z12.string().min(1).openapi({
+    description: "The coupon code to redeem",
+    example: "HACKATHON2025"
+  })
+}).openapi("RedeemCouponRequest");
+var redeemCouponResponseSchema = z12.object({
+  success: z12.boolean().openapi({
+    description: "Whether the redemption was successful",
+    example: true
+  }),
+  message: z12.string().openapi({
+    description: "Human-readable message about the redemption result",
+    example: "Coupon redeemed successfully! You now have Pro access."
+  }),
+  expiresAt: z12.string().optional().openapi({
+    description: "When the offer expires (if successful)",
+    example: "2025-01-15T14:30:00.000Z"
+  })
+}).openapi("RedeemCouponResponse");
+var subscriptionStatusResponseSchema = z12.object({
+  userId: z12.string().openapi({
+    description: "User ID from Clerk",
+    example: "user_30Gbwrzto1VZvAHcGUm5NLQhpkp"
+  }),
+  plan: z12.string().openapi({
+    description: "Current subscription plan",
+    example: "pro_plus"
+  }),
+  planDisplayName: z12.string().openapi({
+    description: "Human-readable plan name",
+    example: "Pro Plus"
+  }),
+  features: z12.array(z12.string()).openapi({
+    description: "List of features available to the user",
+    example: ["unlimited_usage", "priority_support"]
+  }),
+  usage: z12.object({
+    executionCount: z12.number().openapi({
+      description: "Current monthly execution count",
+      example: 100
+    }),
+    executionLimit: z12.number().openapi({
+      description: "Current monthly execution limit",
+      example: 42
+    }),
+    creditLimit: z12.number().openapi({
+      description: "Monthly credit limit",
+      example: 100
+    }),
+    activeFlowLimit: z12.number().openapi({
+      description: "Current monthly active flow limit",
+      example: 2
+    }),
+    estimatedMonthlyCost: z12.number().openapi({
+      description: "Projected monthly cost based on current usage trend",
+      example: 14.19
+    }),
+    resetDate: z12.string().openapi({
+      description: "ISO date when usage resets",
+      example: "2025-02-01T00:00:00.000Z"
+    }),
+    tokenUsage: z12.array(
+      z12.object({
+        modelName: z12.string().openapi({
+          description: "Model name",
+          example: "gpt-4"
+        }),
+        inputTokens: z12.number().openapi({
+          description: "Input tokens used this month",
+          example: 1500
+        }),
+        outputTokens: z12.number().openapi({
+          description: "Output tokens used this month",
+          example: 750
+        }),
+        totalTokens: z12.number().openapi({
+          description: "Total tokens used this month",
+          example: 2250
+        })
+      })
+    ).openapi({
+      description: "Token usage breakdown by model for current month"
+    }),
+    serviceUsage: z12.array(ServiceUsageSchema).openapi({
+      description: "Service usage and cost breakdown for current month"
+    })
+  }),
+  isActive: z12.boolean().openapi({
+    description: "Whether the subscription is active",
+    example: true
+  }),
+  hackathonOffer: hackathonOfferSchema.optional().openapi({
+    description: "Active hackathon promotional offer information"
+  }),
+  specialOffer: specialOfferSchema.optional().openapi({
+    description: "Special offer from private metadata (takes precedence over hackathon offer)"
+  })
+}).openapi("SubscriptionStatusResponse");
+
+// src/milk-tea.ts
+import { z as z15 } from "zod";
+
+// src/ai-models.ts
+import { z as z13 } from "zod";
+var AvailableModels = z13.enum([
+  // OpenAI models
+  "openai/gpt-5",
+  "openai/gpt-5-mini",
+  "openai/gpt-5.1",
+  "openai/gpt-5.2",
+  // Google Gemini models
+  "google/gemini-2.5-pro",
+  "google/gemini-2.5-flash",
+  "google/gemini-2.5-flash-lite",
+  "google/gemini-2.5-flash-image-preview",
+  "google/gemini-3-pro-preview",
+  "google/gemini-3-pro-image-preview",
+  "google/gemini-3-flash-preview",
+  // Anthropic models
+  "anthropic/claude-sonnet-4-5",
+  "anthropic/claude-opus-4-5",
+  "anthropic/claude-haiku-4-5",
+  // OpenRouter models
+  "openrouter/x-ai/grok-code-fast-1",
+  "openrouter/z-ai/glm-4.6",
+  "openrouter/anthropic/claude-sonnet-4.5",
+  "openrouter/google/gemini-3-pro-preview",
+  "openrouter/morph/morph-v3-large",
+  "openrouter/x-ai/grok-4.1-fast",
+  "openrouter/openai/gpt-oss-120b",
+  "openrouter/deepseek/deepseek-chat-v3.1"
+]);
+
+// src/agent-memory.ts
+import { z as z14 } from "zod";
+var TOOL_CALL_TO_DISCARD = ["get-bubble-details-tool"];
+var ConversationMessageSchema = z14.object({
+  role: z14.enum(["user", "assistant", "tool"]).describe("The role of the message sender"),
+  content: z14.string().describe("The message content"),
+  toolCallId: z14.string().optional().describe("Tool call ID for tool messages"),
+  name: z14.string().optional().describe("Tool name for tool messages")
+});
+
+// src/milk-tea.ts
+var MilkTeaRequestSchema = z15.object({
+  userRequest: z15.string().min(1, "User request is required").describe("The user request or question about configuring the bubble"),
+  bubbleName: z15.string().min(1, "Bubble name is required").describe('The name of the bubble to configure (e.g., "email-tool")'),
+  bubbleSchema: z15.record(z15.unknown()).describe(
+    "The full schema/interface definition of the bubble including parameters and types"
+  ),
+  currentCode: z15.string().optional().describe("The current workflow code context for validation"),
+  availableCredentials: z15.array(z15.string()).default([]).describe("List of credential types available to the user"),
+  userName: z15.string().describe("Name of the user making the request"),
+  insertLocation: z15.string().optional().describe("Location in code where the snippet should be inserted"),
+  conversationHistory: z15.array(ConversationMessageSchema).optional().default([]).describe(
+    "Previous conversation messages for multi-turn interactions (frontend manages state)"
+  ),
+  model: AvailableModels.default("google/gemini-2.5-pro").describe(
+    "AI model to use for Milk Tea agent"
+  )
+});
+var MilkTeaResponseSchema = z15.object({
+  type: z15.enum(["code", "question", "reject"]).describe(
+    "Type of response: code (generated snippet), question (needs clarification), reject (infeasible request)"
+  ),
+  message: z15.string().describe(
+    "Human-readable message: explanation for code, question text, or rejection reason"
+  ),
+  snippet: z15.string().optional().describe(
+    'Generated TypeScript code snippet (only present when type is "code")'
+  ),
+  success: z15.boolean().describe("Whether the operation completed successfully"),
+  error: z15.string().optional().describe("Error message if the operation failed")
+});
+var MilkTeaAgentOutputSchema = z15.object({
+  type: z15.enum(["code", "question", "reject"]),
+  message: z15.string(),
+  snippet: z15.string().optional()
+});
+
+// src/pearl.ts
+import { z as z16 } from "zod";
+var PEARL_DEFAULT_MODEL = "openrouter/anthropic/claude-sonnet-4.5";
+var PearlRequestSchema = z16.object({
+  userRequest: z16.string().min(1, "User request is required").describe("The user request or question about building a workflow"),
+  currentCode: z16.string().optional().describe("The current workflow code for context and modification"),
+  userName: z16.string().describe("Name of the user making the request"),
+  availableVariables: z16.array(z16.any()).describe("List of available variables in the current code"),
+  conversationHistory: z16.array(ConversationMessageSchema).optional().default([]).describe(
+    "Previous conversation messages for multi-turn interactions (frontend manages state)"
+  ),
+  model: AvailableModels.default(PEARL_DEFAULT_MODEL).describe(
+    "AI model to use for Pearl agent"
+  ),
+  additionalContext: z16.string().optional().describe(
+    "Additional context information like timezone, user preferences, etc."
+  ),
+  uploadedFiles: z16.array(
+    z16.object({
+      name: z16.string().describe("File name"),
+      content: z16.string().describe(
+        "File content: base64 for images, plain text for text files"
+      ),
+      fileType: z16.enum(["image", "text"]).describe("Type of file: image (base64) or text (plain text)")
+    })
+  ).optional().default([]).describe(
+    "Files uploaded by the user: images as base64, text files as plain text"
+  )
+});
+var PearlResponseSchema = z16.object({
+  type: z16.enum(["code", "question", "answer", "reject"]).describe(
+    "Type of response: code (generated workflow), question (needs clarification), answer (provides information/guidance), reject (infeasible request)"
+  ),
+  message: z16.string().describe(
+    "Human-readable message: explanation for code, question text, or rejection reason"
+  ),
+  snippet: z16.string().optional().describe(
+    'Generated TypeScript code for complete workflow (only present when type is "code")'
+  ),
+  bubbleParameters: z16.record(z16.number(), ParsedBubbleWithInfoSchema).optional().describe(
+    'Parsed bubble parameters from the generated workflow (only present when type is "code")'
+  ),
+  inputSchema: z16.record(z16.unknown()).optional().describe(
+    'Input schema for the generated workflow (only present when type is "code")'
+  ),
+  requiredCredentials: z16.record(z16.string(), z16.array(z16.nativeEnum(CredentialType))).optional().describe(
+    'Required credentials for the bubbles in the workflow (only present when type is "code")'
+  ),
+  success: z16.boolean().describe("Whether the operation completed successfully"),
+  error: z16.string().optional().describe("Error message if the operation failed")
+});
+var PearlAgentOutputSchema = z16.object({
+  type: z16.enum(["code", "question", "answer", "reject", "text"]),
+  message: z16.string(),
+  snippet: z16.string().optional()
+});
+
+// src/rice.ts
+import { z as z17 } from "zod";
+
+// src/bubbleflow-generation-prompts.ts
+var RECOMMENDED_MODELS = {
+  BEST: "google/gemini-3-pro-preview",
+  BEST_ALT: "openai/gpt-5.2",
+  PRO: "google/gemini-3-flash-preview",
+  PRO_ALT: "anthropic/claude-sonnet-4-5",
+  FAST: "google/gemini-3-flash-preview",
+  FAST_ALT: "anthropic/claude-haiku-4-5",
+  LITE: "google/gemini-2.5-flash-lite",
+  IMAGE: "google/gemini-3-pro-image-preview"
+};
+
+// src/rice.ts
+var RICE_DEFAULT_MODEL = RECOMMENDED_MODELS.FAST;
+var RiceIssueTypeSchema = z17.enum(["setup", "workflow", "input"]).nullable();
+var RiceEvaluationResultSchema = z17.object({
+  working: z17.boolean().describe(
+    "Whether the workflow is functioning correctly (true if no errors and expected behavior)"
+  ),
+  issueType: RiceIssueTypeSchema.describe(
+    'Category of issue: "setup" (config/credentials), "workflow" (code logic), "input" (bad input data), or null if working'
+  ),
+  summary: z17.string().describe(
+    "Brief summary of the execution. If working: what happened and any external changes made. If not working: description of the issue."
+  ),
+  rating: z17.number().int().min(1).max(10).describe(
+    "Quality rating 1-10: 1-3=severe issues, 4-6=partial functionality, 7-8=working with minor issues, 9-10=excellent"
+  )
+});
+var RiceRequestSchema = z17.object({
+  executionLogs: z17.array(z17.unknown()).describe("StreamingLogEvent[] from execution"),
+  workflowCode: z17.string().describe("The original workflow code that was executed"),
+  executionId: z17.number().describe("ID of the execution being evaluated"),
+  bubbleFlowId: z17.number().describe("ID of the BubbleFlow being evaluated"),
+  model: AvailableModels.optional().default(RICE_DEFAULT_MODEL).describe("AI model to use for Rice evaluation")
+});
+var RiceResponseSchema = z17.object({
+  success: z17.boolean().describe("Whether the evaluation completed successfully"),
+  evaluation: RiceEvaluationResultSchema.optional().describe(
+    "Evaluation result (only present if success=true)"
+  ),
+  error: z17.string().optional().describe("Error message if the evaluation failed")
+});
+
+// src/cron-utils.ts
+function parseCronExpression(cronString) {
+  const parts = cronString.trim().split(/\s+/);
+  if (parts.length !== 5) {
+    throw new Error(
+      `Invalid cron expression: expected 5 fields, got ${parts.length}`
+    );
+  }
+  const [minute, hour, dayOfMonth, month, dayOfWeek] = parts;
+  return {
+    minute,
+    hour,
+    dayOfMonth,
+    month,
+    dayOfWeek,
+    original: cronString
+  };
+}
+function validateCronExpression(cronString) {
+  try {
+    const expr = parseCronExpression(cronString);
+    const validations = [
+      validateCronField(expr.minute, 0, 59, "minute"),
+      validateCronField(expr.hour, 0, 23, "hour"),
+      validateCronField(expr.dayOfMonth, 1, 31, "day of month"),
+      validateCronField(expr.month, 1, 12, "month"),
+      validateCronField(expr.dayOfWeek, 0, 6, "day of week")
+    ];
+    for (const validation of validations) {
+      if (!validation.valid) {
+        return validation;
+      }
+    }
+    return { valid: true };
+  } catch (error) {
+    return {
+      valid: false,
+      error: error instanceof Error ? error.message : "Invalid cron expression"
+    };
+  }
+}
+function validateCronField(field, min, max, fieldName) {
+  if (field === "*") return { valid: true };
+  if (field.startsWith("*/")) {
+    const step = parseInt(field.substring(2), 10);
+    if (isNaN(step) || step <= 0) {
+      return {
+        valid: false,
+        error: `Invalid step value in ${fieldName}: ${field}`
+      };
+    }
+    return { valid: true };
+  }
+  if (field.includes("-")) {
+    const [start, end] = field.split("-").map((v) => parseInt(v, 10));
+    if (isNaN(start) || isNaN(end) || start < min || end > max || start > end) {
+      return {
+        valid: false,
+        error: `Invalid range in ${fieldName}: ${field} (must be ${min}-${max})`
+      };
+    }
+    return { valid: true };
+  }
+  if (field.includes(",")) {
+    const values = field.split(",").map((v) => parseInt(v.trim(), 10));
+    for (const val of values) {
+      if (isNaN(val) || val < min || val > max) {
+        return {
+          valid: false,
+          error: `Invalid value in ${fieldName} list: ${val} (must be ${min}-${max})`
+        };
+      }
+    }
+    return { valid: true };
+  }
+  const value = parseInt(field, 10);
+  if (isNaN(value) || value < min || value > max) {
+    return {
+      valid: false,
+      error: `Invalid ${fieldName}: ${field} (must be ${min}-${max})`
+    };
+  }
+  return { valid: true };
+}
+function describeCronExpression(cronString) {
+  try {
+    const expr = parseCronExpression(cronString);
+    if (cronString === "* * * * *") return "Every minute";
+    if (cronString === "0 * * * *") return "Every hour";
+    if (cronString === "0 0 * * *") return "Daily at midnight";
+    if (cronString === "0 0 * * 0") return "Weekly on Sunday at midnight";
+    if (cronString === "0 0 1 * *") return "Monthly on the 1st at midnight";
+    if (cronString === "0 0 1 1 *") return "Yearly on January 1st at midnight";
+    if (expr.minute.startsWith("*/")) {
+      const step = expr.minute.substring(2);
+      return `Every ${step} minute${step === "1" ? "" : "s"}`;
+    }
+    if (expr.hour.startsWith("*/") && expr.minute === "0") {
+      const step = expr.hour.substring(2);
+      return `Every ${step} hour${step === "1" ? "" : "s"}`;
+    }
+    if (expr.dayOfWeek === "1-5" && expr.hour === "9" && expr.minute === "0") {
+      return "Every weekday at 9:00 AM";
+    }
+    let description = "At ";
+    if (expr.minute !== "*" && expr.hour !== "*") {
+      const hour = parseInt(expr.hour, 10);
+      const minute = parseInt(expr.minute, 10);
+      const ampm = hour >= 12 ? "PM" : "AM";
+      const hour12 = hour % 12 || 12;
+      description += `${hour12}:${minute.toString().padStart(2, "0")} ${ampm}`;
+    } else if (expr.minute !== "*") {
+      description += `minute ${expr.minute}`;
+    } else if (expr.hour !== "*") {
+      description += `hour ${expr.hour}`;
+    }
+    if (expr.dayOfMonth !== "*") {
+      description += ` on day ${expr.dayOfMonth}`;
+    }
+    if (expr.dayOfWeek !== "*") {
+      const days = [
+        "Sunday",
+        "Monday",
+        "Tuesday",
+        "Wednesday",
+        "Thursday",
+        "Friday",
+        "Saturday"
+      ];
+      if (expr.dayOfWeek.includes("-")) {
+        const [start, end] = expr.dayOfWeek.split("-").map((v) => parseInt(v, 10));
+        description += ` on ${days[start]} through ${days[end]}`;
+      } else {
+        const day = parseInt(expr.dayOfWeek, 10);
+        description += ` on ${days[day]}`;
+      }
+    }
+    if (expr.month !== "*") {
+      const months = [
+        "January",
+        "February",
+        "March",
+        "April",
+        "May",
+        "June",
+        "July",
+        "August",
+        "September",
+        "October",
+        "November",
+        "December"
+      ];
+      const month = parseInt(expr.month, 10);
+      description += ` in ${months[month - 1]}`;
+    }
+    return description;
+  } catch (error) {
+    return "Invalid cron expression";
+  }
+}
+function getCronScheduleInfo(cronString) {
+  const validation = validateCronExpression(cronString);
+  if (!validation.valid) {
+    return {
+      expression: parseCronExpression(
+        cronString.split(/\s+/).length === 5 ? cronString : "0 0 * * *"
+      ),
+      description: "Invalid cron expression",
+      isValid: false,
+      error: validation.error
+    };
+  }
+  return {
+    expression: parseCronExpression(cronString),
+    description: describeCronExpression(cronString),
+    isValid: true
+  };
+}
+
+// src/trigger.ts
+var BUBBLE_TRIGGER_EVENTS = {
+  "slack/bot_mentioned": true,
+  "schedule/cron": true,
+  "webhook/http": true
+};
+function isValidBubbleTriggerEvent(eventType) {
+  return eventType in BUBBLE_TRIGGER_EVENTS;
+}
+
+// src/storage-utils.ts
+function prepareForStorage(value, options) {
+  const maxBytes = options?.maxBytes ?? 1024 * 1024;
+  const previewBytes = options?.previewBytes ?? 4096;
+  try {
+    const json = JSON.stringify(value);
+    const sizeBytes = typeof TextEncoder !== "undefined" ? new TextEncoder().encode(json).length : globalThis.Buffer?.byteLength?.(json, "utf8") ?? json.length;
+    if (sizeBytes > maxBytes) {
+      console.warn(
+        `[prepareForStorage] Size ${sizeBytes} > ${maxBytes}. Storing preview only.`
+      );
+      const previewBuffer = json.slice(0, previewBytes) + "....truncated due to size limit";
+      return {
+        truncated: true,
+        preview: previewBuffer,
+        sizeBytes
+      };
+    }
+    return {
+      truncated: false,
+      preview: value,
+      sizeBytes: 0
+    };
+  } catch (_err) {
+    console.warn(
+      "[prepareForStorage] Failed to serialize value for size check. Storing preview only."
+    );
+    return {
+      truncated: true,
+      preview: "",
+      sizeBytes: 0
+    };
+  }
+}
+function cleanUpObjectForDisplayAndStorage(obj, maxBytes = 1024 * 1024) {
+  const storageResult = prepareForStorage(obj, { maxBytes });
+  if (storageResult.truncated) {
+    return storageResult.preview;
+  }
+  return obj;
+}
+
+// src/param-utils.ts
+function sanitizeParams(params) {
+  return Object.fromEntries(
+    Object.entries(params).filter(([key]) => !key.startsWith("credentials"))
+  );
+}
+
+// src/error-enhancer.ts
+function enhanceErrorMessage(errorMessage) {
+  let enhanced = errorMessage;
+  const triggerRegistryPattern = /does not satisfy the constraint 'keyof BubbleTriggerEventRegistry'/;
+  if (triggerRegistryPattern.test(enhanced)) {
+    const availableKeys = Object.keys(BUBBLE_TRIGGER_EVENTS);
+    const hint = `
+Available trigger event types: ${availableKeys.map((k) => `'${k}'`).join(", ")}`;
+    enhanced = enhanced + hint;
+  }
+  const keyofTriggerPattern = /Type '([^']+)' does not satisfy the constraint 'keyof BubbleTriggerEventRegistry'/;
+  if (keyofTriggerPattern.test(enhanced) && !enhanced.includes("Available trigger event types")) {
+    const availableKeys = Object.keys(BUBBLE_TRIGGER_EVENTS);
+    const hint = `
+Available trigger event types: ${availableKeys.map((k) => `'${k}'`).join(", ")}`;
+    enhanced = enhanced + hint;
+  }
+  const bubbleErrorPattern = /BubbleError/;
+  if (bubbleErrorPattern.test(enhanced)) {
+    const hint = `
+BubbleLogger.error() method signature:
+- this.logger?.error(message: string, error?: BubbleError, metadata?: Partial<LogMetadata>)
+
+IMPORTANT: The second parameter must be a BubbleError instance, NOT a string!
+
+\u274C INCORRECT: this.logger?.error("msg1", "msg2")
+\u274C INCORRECT: this.logger?.error(msg1, msg2) // where msg2 is a string
+
+\u2705 CORRECT: this.logger?.error("Error message")
+\u2705 CORRECT: this.logger?.error("Error message", bubbleError)
+\u2705 CORRECT: this.logger?.error("Error message", bubbleError, { variableId: 1 })
+
+BubbleError minimal interface:
+- message: string (from Error)
+- variableId?: number
+- bubbleName?: string
+
+Creating a BubbleError:
+- new BubbleError("Error message", { variableId?: number, bubbleName?: string })
+- new BubbleValidationError("Validation failed", { variableId?: number, bubbleName?: string, validationErrors?: string[] })
+- new BubbleExecutionError("Execution failed", { variableId?: number, bubbleName?: string, executionPhase?: 'instantiation' | 'execution' | 'validation' })
+
+LogMetadata minimal interface (for metadata parameter):
+- variableId?: number
+- bubbleName?: string
+- lineNumber?: number
+- additionalData?: Record<string, unknown>
+
+Example usage:
+- this.logger?.error("Bubble execution failed", new BubbleError("Details", { variableId: 1, bubbleName: "MyBubble" }))
+- this.logger?.error("Error occurred", undefined, { variableId: 1, additionalData: { custom: "data" } })`;
+    enhanced = enhanced + hint;
+  }
+  const logMetadataPropertyPattern = /'(\w+)' does not exist in type '(?:Partial<)?LogMetadata(?:>)?'/;
+  const logMetadataMatch = enhanced.match(logMetadataPropertyPattern);
+  if (logMetadataMatch) {
+    const [, propertyName] = logMetadataMatch;
+    const hint = `
+LogMetadata does not support '${propertyName}'. Available properties:
+- additionalData?: Record<string, unknown>`;
+    enhanced = enhanced + hint;
+  }
+  const logMetadataTypePattern = /LogMetadata/;
+  if (logMetadataTypePattern.test(enhanced) && !enhanced.includes("Available properties:")) {
+    const hint = `
+LogMetadata interface properties:
+- additionalData?: Record<string, unknown> (optional)
+
+To add custom data, use the additionalData property.`;
+    enhanced = enhanced + hint;
+  }
+  const noExportedMemberPattern = /Module '([^']+)' has no exported member '(\w+)'/;
+  const noExportedMemberMatch = enhanced.match(noExportedMemberPattern);
+  if (noExportedMemberMatch) {
+    const [, moduleName, memberName] = noExportedMemberMatch;
+    const hint = `
+'${memberName}' is not exported from '${moduleName}'. Please remove it from your import statement or check the module's exports for the correct name.`;
+    enhanced = enhanced + hint;
+  }
+  return enhanced;
+}
+
+// src/hash-utils.ts
+function hashToVariableId(input) {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = hash * 16777619 >>> 0;
+  }
+  const mapped = 1e5 + hash % 9e5;
+  return mapped;
+}
+function buildCallSiteKey(methodName, invocationIndex) {
+  return `${methodName}#${invocationIndex}`;
+}
+export {
+  AssistantMessageSchema,
+  AvailableModels,
+  BROWSER_SESSION_PROVIDERS,
+  BUBBLE_CREDENTIAL_OPTIONS,
+  BUBBLE_NAMES_WITH_CONTEXT_INJECTION,
+  BUBBLE_TRIGGER_EVENTS,
+  BubbleDependencySpecSchema,
+  BubbleNodeTypeSchema,
+  BubbleParameterSchema,
+  BubbleParameterType,
+  BubbleParameterTypeSchema,
+  BubbleWorkflowNodeSchema,
+  COFFEE_DEFAULT_MODEL,
+  COFFEE_MAX_ITERATIONS,
+  COFFEE_MAX_QUESTIONS,
+  CREDENTIAL_CONFIGURATION_MAP,
+  CREDENTIAL_ENV_MAP,
+  CREDENTIAL_TYPE_CONFIG,
+  ClarificationChoiceSchema,
+  ClarificationQuestionSchema,
+  ClarificationRequestMessageSchema,
+  ClarificationResponseMessageSchema,
+  CodeBlockWorkflowNodeSchema,
+  CoffeeAgentOutputSchema,
+  CoffeeClarificationEventSchema,
+  CoffeeContextAnswerSchema,
+  CoffeeContextEventSchema,
+  CoffeeContextRequestInfoSchema,
+  CoffeeMessageSchema,
+  CoffeePlanEventSchema,
+  CoffeeRequestExternalContextEventSchema,
+  CoffeeRequestSchema,
+  CoffeeResponseSchema,
+  ContextRequestMessageSchema,
+  ContextResponseMessageSchema,
+  ControlFlowWorkflowNodeSchema,
+  ConversationMessageSchema,
+  CredentialType,
+  DependencyGraphNodeSchema,
+  ExecutionSummarySchema,
+  FunctionCallWorkflowNodeSchema,
+  GenerationResultSchema,
+  LocationSchema,
+  MilkTeaAgentOutputSchema,
+  MilkTeaRequestSchema,
+  MilkTeaResponseSchema,
+  MockDataGenerator,
+  OAUTH_PROVIDERS,
+  OPTIONAL_CREDENTIALS,
+  PEARL_DEFAULT_MODEL,
+  ParallelExecutionWorkflowNodeSchema,
+  ParsedBubbleSchema,
+  ParsedBubbleWithInfoSchema,
+  ParsedWorkflowSchema,
+  PearlAgentOutputSchema,
+  PearlRequestSchema,
+  PearlResponseSchema,
+  PlanApprovalMessageSchema,
+  PlanMessageSchema,
+  PlanStepSchema,
+  RECOMMENDED_MODELS,
+  RICE_DEFAULT_MODEL,
+  ReturnWorkflowNodeSchema,
+  RiceEvaluationResultSchema,
+  RiceIssueTypeSchema,
+  RiceRequestSchema,
+  RiceResponseSchema,
+  SYSTEM_CREDENTIALS,
+  ServiceUsageSchema,
+  SystemMessageSchema,
+  TOOL_CALL_TO_DISCARD,
+  ToolResultMessageSchema,
+  TransformationFunctionWorkflowNodeSchema,
+  TryCatchWorkflowNodeSchema,
+  UserMessageSchema,
+  VariableDeclarationBlockNodeSchema,
+  WorkflowNodeSchema,
+  WorkflowNodeTypeSchema,
+  activateBubbleFlowResponseSchema,
+  browserbaseSessionCompleteRequestSchema,
+  browserbaseSessionCompleteResponseSchema,
+  browserbaseSessionCreateRequestSchema,
+  browserbaseSessionCreateResponseSchema,
+  browserbaseSessionReopenRequestSchema,
+  browserbaseSessionReopenResponseSchema,
+  bubbleFlowDetailsResponseSchema,
+  bubbleFlowExecutionDetailSchema,
+  bubbleFlowExecutionSchema,
+  bubbleFlowListItemSchema,
+  bubbleFlowListResponseSchema,
+  bubbleFlowTemplateResponseSchema,
+  buildCallSiteKey,
+  cleanUpObjectForDisplayAndStorage,
+  createBubbleFlowResponseSchema,
+  createBubbleFlowSchema,
+  createCredentialResponseSchema,
+  createCredentialSchema,
+  createEmptyBubbleFlowResponseSchema,
+  createEmptyBubbleFlowSchema,
+  credentialResponseSchema,
+  databaseMetadataSchema,
+  describeCronExpression,
+  enhanceErrorMessage,
+  errorResponseSchema,
+  executeBubbleFlowResponseSchema,
+  executeBubbleFlowSchema,
+  generateBubbleFlowCodeResponseSchema,
+  generateBubbleFlowCodeSchema,
+  generateBubbleFlowTemplateSchema,
+  generateCredentialsSummary,
+  generateDocumentGenerationTemplateSchema,
+  getBrowserSessionProvider,
+  getCronScheduleInfo,
+  getOAuthProvider,
+  getScopeDescriptions,
+  hackathonOfferSchema,
+  hashToVariableId,
+  isBrowserSessionCredential,
+  isOAuthCredential,
+  isValidBubbleTriggerEvent,
+  joinWaitlistResponseSchema,
+  joinWaitlistSchema,
+  listBubbleFlowExecutionsResponseSchema,
+  oauthCallbackRequestSchema,
+  oauthInitiateRequestSchema,
+  oauthInitiateResponseSchema,
+  oauthRevokeResponseSchema,
+  oauthTokenRefreshResponseSchema,
+  parseCronExpression,
+  prepareForStorage,
+  redeemCouponRequestSchema,
+  redeemCouponResponseSchema,
+  sanitizeParams,
+  slackUrlVerificationResponseSchema,
+  slackUrlVerificationSchema,
+  specialOfferSchema,
+  subscriptionStatusResponseSchema,
+  successMessageResponseSchema,
+  updateBubbleFlowNameSchema,
+  updateBubbleFlowParametersSchema,
+  updateCredentialResponseSchema,
+  updateCredentialSchema,
+  validateBubbleFlowCodeResponseSchema,
+  validateBubbleFlowCodeSchema,
+  validateCronExpression,
+  webhookExecutionResponseSchema,
+  webhookResponseSchema
+};
 //# sourceMappingURL=index.js.map