@contractspec/lib.contracts 1.62.0 → 1.63.0

package/dist/node/integrations/providers/index.js

@@ -1,2317 +0,0 @@
-import { createRequire } from "node:module";
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
-var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-// src/registry-utils.ts
-var exports_registry_utils = {};
-__export(exports_registry_utils, {
-  groupByToArray: () => groupByToArray,
-  groupByMultiple: () => groupByMultiple,
-  groupBy: () => groupBy,
-  getUniqueTags: () => getUniqueTags,
-  getUniqueOwners: () => getUniqueOwners,
-  getUniqueDomains: () => getUniqueDomains,
-  filterBy: () => filterBy,
-  GroupingStrategies: () => GroupingStrategies
-});
-function filterBy(items, filter) {
-  return items.filter((item) => {
-    if (filter.tags?.length) {
-      const hasMatchingTag = filter.tags.some((tag) => item.meta.tags?.includes(tag));
-      if (!hasMatchingTag)
-        return false;
-    }
-    if (filter.owners?.length) {
-      const hasMatchingOwner = filter.owners.some((owner) => item.meta.owners?.includes(owner));
-      if (!hasMatchingOwner)
-        return false;
-    }
-    if (filter.stability?.length) {
-      if (!filter.stability.includes(item.meta.stability ?? "stable")) {
-        return false;
-      }
-    }
-    if (filter.domain) {
-      const itemDomain = GroupingStrategies.byDomain(item);
-      if (itemDomain !== filter.domain)
-        return false;
-    }
-    if (filter.keyPattern) {
-      const name = item.meta.key ?? item.meta.key ?? "";
-      const pattern = filter.keyPattern.replace(/\*/g, ".*").replace(/\?/g, ".");
-      const regex = new RegExp(`^${pattern}$`, "i");
-      if (!regex.test(name))
-        return false;
-    }
-    return true;
-  });
-}
-function groupBy(items, keyFn) {
-  const groups = new Map;
-  for (const item of items) {
-    const key = keyFn(item);
-    const existing = groups.get(key);
-    if (existing) {
-      existing.push(item);
-    } else {
-      groups.set(key, [item]);
-    }
-  }
-  return groups;
-}
-function groupByToArray(items, keyFn) {
-  const map = groupBy(items, keyFn);
-  return Array.from(map.entries()).map(([key, items2]) => ({ key, items: items2 }));
-}
-function groupByMultiple(items, keysFn) {
-  const groups = new Map;
-  for (const item of items) {
-    const keys = keysFn(item);
-    for (const key of keys) {
-      const existing = groups.get(key);
-      if (existing) {
-        existing.push(item);
-      } else {
-        groups.set(key, [item]);
-      }
-    }
-  }
-  return groups;
-}
-function getUniqueTags(items) {
-  const tags = new Set;
-  for (const item of items) {
-    for (const tag of item.meta.tags ?? []) {
-      tags.add(tag);
-    }
-  }
-  return Array.from(tags).sort();
-}
-function getUniqueOwners(items) {
-  const owners = new Set;
-  for (const item of items) {
-    for (const owner of item.meta.owners ?? []) {
-      owners.add(owner);
-    }
-  }
-  return Array.from(owners).sort();
-}
-function getUniqueDomains(items) {
-  const domains = new Set;
-  for (const item of items) {
-    domains.add(GroupingStrategies.byDomain(item));
-  }
-  return Array.from(domains).sort();
-}
-var GroupingStrategies;
-var init_registry_utils = __esm(() => {
-  GroupingStrategies = {
-    byTag: (item) => item.meta.tags?.[0] ?? "untagged",
-    byAllTags: (item) => item.meta.tags?.length ? item.meta.tags : ["untagged"],
-    byOwner: (item) => item.meta.owners?.[0] ?? "unowned",
-    byDomain: (item) => {
-      const name = item.meta.key ?? item.meta.key ?? "";
-      return name.split(".")[0] ?? "default";
-    },
-    byStability: (item) => item.meta.stability ?? "stable",
-    byUrlPath: (level) => (item) => {
-      if (!item.path)
-        return "root";
-      const segments = item.path.split("/").filter(Boolean);
-      return segments.slice(0, level).join("/") || "root";
-    }
-  };
-});
-
-// src/ownership.ts
-var StabilityEnum = {
-  Idea: "idea",
-  InCreation: "in_creation",
-  Experimental: "experimental",
-  Beta: "beta",
-  Stable: "stable",
-  Deprecated: "deprecated"
-};
-var OwnersEnum = {
-  PlatformCore: "platform.core",
-  PlatformSigil: "platform.sigil",
-  PlatformMarketplace: "platform.marketplace",
-  PlatformMessaging: "platform.messaging",
-  PlatformContent: "platform.content",
-  PlatformFeatureFlags: "platform.featureflags",
-  PlatformFinance: "platform.finance"
-};
-var Owners = OwnersEnum;
-var TagsEnum = {
-  Spots: "spots",
-  Collectivity: "collectivity",
-  Marketplace: "marketplace",
-  Sellers: "sellers",
-  Auth: "auth",
-  Login: "login",
-  Signup: "signup",
-  Guide: "guide",
-  Docs: "docs",
-  I18n: "i18n",
-  Incident: "incident",
-  Automation: "automation",
-  Hygiene: "hygiene"
-};
-var Tags = TagsEnum;
-
-// src/registry.ts
-init_registry_utils();
-import { compareVersions } from "compare-versions";
-var keyOfSpecContract = (spec) => `${spec.meta.key}.v${spec.meta.version}`;
-
-class SpecContractRegistry {
-  contractType;
-  items = new Map;
-  constructor(contractType, items) {
-    this.contractType = contractType;
-    if (items) {
-      items.forEach((p) => this.register(p));
-    }
-  }
-  register(p) {
-    const key = keyOfSpecContract(p);
-    if (this.items.has(key))
-      throw new Error(`Duplicate contract \`${this.contractType}\` ${key}`);
-    this.items.set(key, p);
-    return this;
-  }
-  count() {
-    return this.items.size;
-  }
-  list() {
-    return [...this.items.values()];
-  }
-  get(key, version) {
-    if (version != null)
-      return this.items.get(`${key}.v${version}`);
-    let candidate;
-    for (const [k, p] of this.items.entries()) {
-      if (!k.startsWith(`${key}.v`))
-        continue;
-      if (!candidate || compareVersions(p.meta.version, candidate.meta.version) > 0) {
-        candidate = p;
-      }
-    }
-    return candidate;
-  }
-  has(key, version) {
-    return !!this.get(key, version);
-  }
-  filter(criteria) {
-    return filterBy(this.list(), criteria);
-  }
-  listByTag(tag) {
-    return this.list().filter((p) => p.meta.tags?.includes(tag));
-  }
-  listByOwner(owner) {
-    return this.list().filter((p) => p.meta.owners?.includes(owner));
-  }
-  groupBy(keyFn) {
-    return groupBy(this.list(), keyFn);
-  }
-  getUniqueTags() {
-    return getUniqueTags(this.list());
-  }
-}
-
-// src/integrations/spec.ts
-var integrationKey = (meta) => `${meta.key}.v${meta.version}`;
-
-class IntegrationSpecRegistry extends SpecContractRegistry {
-  constructor(items) {
-    super("integration", items);
-  }
-  getByCategory(category) {
-    return this.list().filter((spec) => spec.meta.category === category);
-  }
-}
-function makeIntegrationSpecKey(meta) {
-  return integrationKey(meta);
-}
-var defineIntegration = (spec) => spec;
-// src/integrations/providers/stripe.ts
-var stripeIntegrationSpec = defineIntegration({
-  meta: {
-    key: "payments.stripe",
-    version: "1.0.0",
-    category: "payments",
-    title: "Stripe Payments",
-    description: "Stripe integration for payment processing, charges, and payouts.",
-    domain: "payments",
-    owners: ["platform.payments"],
-    tags: ["payments", "psp"],
-    stability: StabilityEnum.Stable
-  },
-  supportedModes: ["managed", "byok"],
-  capabilities: {
-    provides: [{ key: "payments.psp", version: "1.0.0" }],
-    requires: [
-      {
-        key: "platform.webhooks",
-        optional: true,
-        reason: "Recommended for reliable event ingestion"
-      }
-    ]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        accountId: {
-          type: "string",
-          description: "Connected account ID when using Stripe Connect (BYOK)."
-        },
-        region: {
-          type: "string",
-          description: "Optional Stripe region or data residency hint."
-        }
-      }
-    },
-    example: {
-      accountId: "acct_123",
-      region: "us-east-1"
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["apiKey", "webhookSecret"],
-      properties: {
-        apiKey: {
-          type: "string",
-          description: "Stripe secret API key (sk_live_... or sk_test_...)."
-        },
-        webhookSecret: {
-          type: "string",
-          description: "Signing secret for webhook verification."
-        }
-      }
-    },
-    example: {
-      apiKey: "sk_live_***",
-      webhookSecret: "whsec_***"
-    }
-  },
-  healthCheck: {
-    method: "ping",
-    timeoutMs: 5000
-  },
-  docsUrl: "https://stripe.com/docs/api",
-  constraints: {
-    rateLimit: {
-      rpm: 1000,
-      rph: 20000
-    }
-  },
-  byokSetup: {
-    setupInstructions: "Create a restricted Stripe API key with write access to Charges and provide a webhook signing secret.",
-    requiredScopes: ["charges:write", "customers:read"]
-  }
-});
-function registerStripeIntegration(registry) {
-  return registry.register(stripeIntegrationSpec);
-}
-
-// src/integrations/providers/postmark.ts
-var postmarkIntegrationSpec = defineIntegration({
-  meta: {
-    key: "email.postmark",
-    version: "1.0.0",
-    category: "email",
-    title: "Postmark Transactional Email",
-    description: "Postmark integration for transactional email delivery.",
-    domain: "communications",
-    owners: ["platform.messaging"],
-    tags: ["email", "transactional"],
-    stability: StabilityEnum.Stable
-  },
-  supportedModes: ["managed", "byok"],
-  capabilities: {
-    provides: [{ key: "email.transactional", version: "1.0.0" }],
-    requires: [
-      {
-        key: "platform.webhooks",
-        optional: true,
-        reason: "Optional for inbound bounce handling"
-      }
-    ]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        messageStream: {
-          type: "string",
-          description: "Optional message stream identifier (e.g., transactional)."
-        },
-        fromEmail: {
-          type: "string",
-          description: "Default From address used for outbound messages."
-        }
-      }
-    },
-    example: {
-      messageStream: "outbound",
-      fromEmail: "notifications@example.com"
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["serverToken"],
-      properties: {
-        serverToken: {
-          type: "string",
-          description: "Server token for the Postmark account."
-        }
-      }
-    },
-    example: {
-      serverToken: "server-***"
-    }
-  },
-  healthCheck: {
-    method: "ping",
-    timeoutMs: 3000
-  },
-  docsUrl: "https://postmarkapp.com/developer",
-  constraints: {
-    rateLimit: {
-      rpm: 500
-    }
-  },
-  byokSetup: {
-    setupInstructions: "Create a Postmark server token with outbound send permissions and configure allowed from addresses."
-  }
-});
-function registerPostmarkIntegration(registry) {
-  return registry.register(postmarkIntegrationSpec);
-}
-
-// src/integrations/providers/qdrant.ts
-var qdrantIntegrationSpec = defineIntegration({
-  meta: {
-    key: "vectordb.qdrant",
-    version: "1.0.0",
-    category: "vector-db",
-    title: "Qdrant Vector Database",
-    description: "Qdrant integration for vector search and embeddings storage.",
-    domain: "ai",
-    owners: ["platform.ai"],
-    tags: ["vector-db", "search"],
-    stability: StabilityEnum.Experimental
-  },
-  supportedModes: ["managed", "byok"],
-  capabilities: {
-    provides: [
-      { key: "vector-db.search", version: "1.0.0" },
-      { key: "vector-db.storage", version: "1.0.0" }
-    ],
-    requires: [
-      {
-        key: "ai.embeddings",
-        optional: true,
-        reason: "Required if vectors are generated via hosted embedding services"
-      }
-    ]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        apiUrl: {
-          type: "string",
-          description: "Base URL for the Qdrant instance (e.g., https://qdrant.example.com)."
-        },
-        collectionPrefix: {
-          type: "string",
-          description: "Prefix applied to all collection names for this tenant."
-        }
-      }
-    },
-    example: {
-      apiUrl: "https://qdrant.example.com",
-      collectionPrefix: "tenant_"
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        apiKey: {
-          type: "string",
-          description: "API key or token when authentication is enabled."
-        }
-      }
-    },
-    example: {
-      apiKey: "qdrant-api-key"
-    }
-  },
-  healthCheck: {
-    method: "ping",
-    timeoutMs: 4000
-  },
-  docsUrl: "https://qdrant.tech/documentation/quick-start/",
-  constraints: {
-    quotas: {
-      collections: 100,
-      pointsPerCollection: 1e6
-    }
-  },
-  byokSetup: {
-    setupInstructions: "Provide the HTTPS endpoint of your Qdrant cluster and generate an API key with read/write access to the collections that will be managed."
-  }
-});
-function registerQdrantIntegration(registry) {
-  return registry.register(qdrantIntegrationSpec);
-}
-
-// src/integrations/providers/supabase-vector.ts
-var supabaseVectorIntegrationSpec = defineIntegration({
-  meta: {
-    key: "vectordb.supabase",
-    version: "1.0.0",
-    category: "vector-db",
-    title: "Supabase Vector Database (pgvector)",
-    description: "Supabase integration for embedding storage and vector similarity search using pgvector.",
-    domain: "ai",
-    owners: ["platform.ai"],
-    tags: ["vector-db", "supabase", "pgvector"],
-    stability: StabilityEnum.Beta
-  },
-  supportedModes: ["managed", "byok"],
-  capabilities: {
-    provides: [
-      { key: "vector-db.search", version: "1.0.0" },
-      { key: "vector-db.storage", version: "1.0.0" }
-    ],
-    requires: [
-      {
-        key: "ai.embeddings",
-        optional: true,
-        reason: "Required when vectors are generated by a hosted embedding provider."
-      }
-    ]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        schema: {
-          type: "string",
-          description: "Schema name containing the pgvector table (default: public)."
-        },
-        table: {
-          type: "string",
-          description: "Table used to store vectors and metadata (default: contractspec_vectors)."
-        },
-        createTableIfMissing: {
-          type: "boolean",
-          description: "Automatically create pgvector extension and table when first writing vectors."
-        },
-        distanceMetric: {
-          type: "string",
-          enum: ["cosine", "l2", "inner_product"],
-          description: "Distance metric used for nearest-neighbor search."
-        }
-      }
-    },
-    example: {
-      schema: "public",
-      table: "contractspec_vectors",
-      createTableIfMissing: true,
-      distanceMetric: "cosine"
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["databaseUrl"],
-      properties: {
-        databaseUrl: {
-          type: "string",
-          description: "Supabase Postgres connection string with privileges to read/write vector rows."
-        }
-      }
-    },
-    example: {
-      databaseUrl: "postgresql://postgres.[project-ref]:password@aws-0-region.pooler.supabase.com:6543/postgres"
-    }
-  },
-  healthCheck: {
-    method: "ping",
-    timeoutMs: 5000
-  },
-  docsUrl: "https://supabase.com/docs/guides/ai/vector-columns",
-  byokSetup: {
-    setupInstructions: "Create or reuse a Supabase project, enable pgvector, and provide a Postgres connection string with read/write access to the target vector table."
-  }
-});
-function registerSupabaseVectorIntegration(registry) {
-  return registry.register(supabaseVectorIntegrationSpec);
-}
-
-// src/integrations/providers/supabase-postgres.ts
-var supabasePostgresIntegrationSpec = defineIntegration({
-  meta: {
-    key: "database.supabase",
-    version: "1.0.0",
-    category: "database",
-    title: "Supabase Postgres",
-    description: "Supabase Postgres integration for SQL query execution and transactional workloads.",
-    domain: "infrastructure",
-    owners: ["platform.infrastructure"],
-    tags: ["database", "postgres", "supabase"],
-    stability: StabilityEnum.Beta
-  },
-  supportedModes: ["managed", "byok"],
-  capabilities: {
-    provides: [{ key: "database.sql", version: "1.0.0" }]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        maxConnections: {
-          type: "number",
-          description: "Optional connection pool size when opening a Postgres client to Supabase."
-        },
-        sslMode: {
-          type: "string",
-          enum: ["require", "allow", "prefer"],
-          description: "TLS mode used by the Postgres client."
-        }
-      }
-    },
-    example: {
-      maxConnections: 10,
-      sslMode: "require"
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["databaseUrl"],
-      properties: {
-        databaseUrl: {
-          type: "string",
-          description: "Supabase Postgres connection string (transaction or session pooler endpoint)."
-        }
-      }
-    },
-    example: {
-      databaseUrl: "postgresql://postgres.[project-ref]:password@aws-0-region.pooler.supabase.com:6543/postgres"
-    }
-  },
-  healthCheck: {
-    method: "ping",
-    timeoutMs: 5000
-  },
-  docsUrl: "https://supabase.com/docs/guides/database/connecting-to-postgres",
-  byokSetup: {
-    setupInstructions: "Create or reuse a Supabase project and provide a Postgres connection string with permissions aligned to your workload."
-  }
-});
-function registerSupabasePostgresIntegration(registry) {
-  return registry.register(supabasePostgresIntegrationSpec);
-}
-
-// src/integrations/providers/mistral.ts
-var mistralIntegrationSpec = defineIntegration({
-  meta: {
-    key: "ai-llm.mistral",
-    version: "1.0.0",
-    category: "ai-llm",
-    title: "Mistral Large Language Model",
-    description: "Mistral integration providing chat completions and embedding generation.",
-    domain: "ai",
-    owners: ["platform.ai"],
-    tags: ["ai", "llm", "embeddings"],
-    stability: StabilityEnum.Experimental
-  },
-  supportedModes: ["managed", "byok"],
-  capabilities: {
-    provides: [
-      { key: "ai.chat", version: "1.0.0" },
-      { key: "ai.embeddings", version: "1.0.0" }
-    ]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        model: {
-          type: "string",
-          description: "Default chat completion model (e.g., mistral-large-latest)."
-        },
-        embeddingModel: {
-          type: "string",
-          description: "Embedding model identifier."
-        }
-      }
-    },
-    example: {
-      model: "mistral-large-latest",
-      embeddingModel: "mistral-embed"
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["apiKey"],
-      properties: {
-        apiKey: {
-          type: "string",
-          description: "Mistral API key with access to chat and embeddings endpoints."
-        }
-      }
-    },
-    example: {
-      apiKey: "mistral-***"
-    }
-  },
-  healthCheck: {
-    method: "custom",
-    timeoutMs: 5000
-  },
-  docsUrl: "https://docs.mistral.ai/platform/endpoints",
-  constraints: {
-    rateLimit: {
-      rpm: 600
-    }
-  },
-  byokSetup: {
-    setupInstructions: "Generate an API key within the Mistral console and ensure the selected models are enabled for the account."
-  }
-});
-function registerMistralIntegration(registry) {
-  return registry.register(mistralIntegrationSpec);
-}
-
-// src/integrations/providers/elevenlabs.ts
-var elevenLabsIntegrationSpec = defineIntegration({
-  meta: {
-    key: "ai-voice.elevenlabs",
-    version: "1.0.0",
-    category: "ai-voice",
-    title: "ElevenLabs Text-to-Speech",
-    description: "ElevenLabs integration for neural voice synthesis and voice catalog access.",
-    domain: "ai",
-    owners: ["platform.ai"],
-    tags: ["voice", "tts"],
-    stability: StabilityEnum.Beta
-  },
-  supportedModes: ["managed", "byok"],
-  capabilities: {
-    provides: [{ key: "ai.voice.synthesis", version: "1.0.0" }]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        defaultVoiceId: {
-          type: "string",
-          description: "Optional default voice identifier for synthesis requests."
-        }
-      }
-    },
-    example: {
-      defaultVoiceId: "pNInz6obpgDQGcFmaJgB"
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["apiKey"],
-      properties: {
-        apiKey: {
-          type: "string",
-          description: "ElevenLabs API key with text-to-speech permissions."
-        }
-      }
-    },
-    example: {
-      apiKey: "eleven-***"
-    }
-  },
-  healthCheck: {
-    method: "custom",
-    timeoutMs: 4000
-  },
-  docsUrl: "https://elevenlabs.io/docs/api-reference/text-to-speech",
-  constraints: {
-    rateLimit: {
-      rpm: 120
-    }
-  },
-  byokSetup: {
-    setupInstructions: "Create an ElevenLabs API key and ensure the desired voices are accessible to the key scope."
-  }
-});
-function registerElevenLabsIntegration(registry) {
-  return registry.register(elevenLabsIntegrationSpec);
-}
-
-// src/integrations/providers/gradium.ts
-var gradiumIntegrationSpec = defineIntegration({
-  meta: {
-    key: "ai-voice.gradium",
-    version: "1.0.0",
-    category: "ai-voice",
-    title: "Gradium Text-to-Speech",
-    description: "Gradium integration for low-latency voice synthesis and voice catalog access.",
-    domain: "ai",
-    owners: ["platform.ai"],
-    tags: ["voice", "tts", "realtime"],
-    stability: StabilityEnum.Experimental
-  },
-  supportedModes: ["byok"],
-  capabilities: {
-    provides: [{ key: "ai.voice.synthesis", version: "1.0.0" }]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        defaultVoiceId: {
-          type: "string",
-          description: "Optional default voice identifier used for synthesis."
-        },
-        region: {
-          type: "string",
-          enum: ["eu", "us"],
-          description: "Gradium region used by the SDK (eu or us)."
-        },
-        baseUrl: {
-          type: "string",
-          description: "Optional API base URL override for private routing or proxies."
-        },
-        timeoutMs: {
-          type: "number",
-          description: "Optional request timeout in milliseconds."
-        },
-        outputFormat: {
-          type: "string",
-          enum: [
-            "wav",
-            "pcm",
-            "opus",
-            "ulaw_8000",
-            "alaw_8000",
-            "pcm_16000",
-            "pcm_24000"
-          ],
-          description: "Optional default output format used when no format is specified."
-        }
-      }
-    },
-    example: {
-      defaultVoiceId: "YTpq7expH9539ERJ",
-      region: "eu",
-      timeoutMs: 15000,
-      outputFormat: "wav"
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["apiKey"],
-      properties: {
-        apiKey: {
-          type: "string",
-          description: "Gradium API key with TTS access."
-        }
-      }
-    },
-    example: {
-      apiKey: "gd_***"
-    }
-  },
-  healthCheck: {
-    method: "custom",
-    timeoutMs: 5000
-  },
-  docsUrl: "https://gradium.ai/api_docs.html",
-  byokSetup: {
-    setupInstructions: "Create a Gradium API key, select the target region, and store credentials in your tenant secret provider."
-  }
-});
-function registerGradiumIntegration(registry) {
-  return registry.register(gradiumIntegrationSpec);
-}
-
-// src/integrations/providers/fal.ts
-var falIntegrationSpec = defineIntegration({
-  meta: {
-    key: "ai-voice.fal",
-    version: "1.0.0",
-    category: "ai-voice",
-    title: "Fal Chatterbox Text-to-Speech",
-    description: "Fal integration for voice synthesis using Chatterbox text-to-speech models.",
-    domain: "ai",
-    owners: ["platform.ai"],
-    tags: ["voice", "tts", "chatterbox"],
-    stability: StabilityEnum.Experimental
-  },
-  supportedModes: ["byok"],
-  capabilities: {
-    provides: [{ key: "ai.voice.synthesis", version: "1.0.0" }]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        modelId: {
-          type: "string",
-          description: "Fal model endpoint identifier (e.g. fal-ai/chatterbox/text-to-speech)."
-        },
-        defaultVoiceUrl: {
-          type: "string",
-          description: "Optional reference audio URL used as default voice conditioning input."
-        },
-        defaultExaggeration: {
-          type: "number",
-          minimum: 0,
-          maximum: 1,
-          description: "Optional default exaggeration value for speech output."
-        },
-        defaultTemperature: {
-          type: "number",
-          minimum: 0.05,
-          maximum: 2,
-          description: "Optional default temperature for synthesis requests."
-        },
-        defaultCfg: {
-          type: "number",
-          minimum: 0.1,
-          maximum: 1,
-          description: "Optional default cfg value for synthesis requests."
-        },
-        pollIntervalMs: {
-          type: "number",
-          description: "Optional queue polling interval in milliseconds."
-        }
-      }
-    },
-    example: {
-      modelId: "fal-ai/chatterbox/text-to-speech",
-      defaultVoiceUrl: "https://storage.googleapis.com/chatterbox-demo-samples/prompts/male_rickmorty.mp3",
-      defaultExaggeration: 0.25,
-      defaultTemperature: 0.7,
-      defaultCfg: 0.5,
-      pollIntervalMs: 1000
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["apiKey"],
-      properties: {
-        apiKey: {
-          type: "string",
-          description: "Fal API key (FAL_KEY)."
-        }
-      }
-    },
-    example: {
-      apiKey: "key-id:key-secret"
-    }
-  },
-  healthCheck: {
-    method: "custom",
-    timeoutMs: 7000
-  },
-  docsUrl: "https://fal.ai/models/fal-ai/chatterbox/text-to-speech/api",
-  byokSetup: {
-    setupInstructions: "Create a Fal API key and configure the desired voice model endpoint before connecting tenants."
-  }
-});
-function registerFalIntegration(registry) {
-  return registry.register(falIntegrationSpec);
-}
-
-// src/integrations/providers/gmail.ts
-var gmailIntegrationSpec = defineIntegration({
-  meta: {
-    key: "email.gmail",
-    version: "1.0.0",
-    category: "email",
-    title: "Google Gmail API",
-    description: "Gmail integration supporting inbound thread ingestion and outbound transactional email.",
-    domain: "communications",
-    owners: ["platform.messaging"],
-    tags: ["email", "gmail"],
-    stability: StabilityEnum.Beta
-  },
-  supportedModes: ["managed", "byok"],
-  capabilities: {
-    provides: [
-      { key: "email.inbound", version: "1.0.0" },
-      { key: "email.outbound", version: "1.0.0" }
-    ]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        labelIds: {
-          type: "array",
-          items: { type: "string" },
-          description: "Optional list of label IDs to scope inbound sync."
-        },
-        includeSpamTrash: {
-          type: "boolean",
-          description: "Whether to include spam or trash messages during sync."
-        }
-      }
-    },
-    example: {
-      labelIds: ["INBOX"],
-      includeSpamTrash: false
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["clientId", "clientSecret", "refreshToken"],
-      properties: {
-        clientId: {
-          type: "string",
-          description: "OAuth client ID for the Google Cloud project."
-        },
-        clientSecret: {
-          type: "string",
-          description: "OAuth client secret for the Google Cloud project."
-        },
-        refreshToken: {
-          type: "string",
-          description: "OAuth refresh token for delegated Gmail access."
-        },
-        redirectUri: {
-          type: "string",
-          description: "Optional redirect URI used when issuing the refresh token."
-        }
-      }
-    },
-    example: {
-      clientId: "xxx.apps.googleusercontent.com",
-      clientSecret: "secret",
-      refreshToken: "refresh-token"
-    }
-  },
-  healthCheck: {
-    method: "custom",
-    timeoutMs: 4000
-  },
-  docsUrl: "https://developers.google.com/gmail/api",
-  constraints: {
-    rateLimit: {
-      rpm: 600
-    }
-  },
-  byokSetup: {
-    setupInstructions: "Create an OAuth consent screen and credentials within Google Cloud Console, then authorize the Gmail scopes and store the resulting refresh token."
-  }
-});
-function registerGmailIntegration(registry) {
-  return registry.register(gmailIntegrationSpec);
-}
-
-// src/integrations/providers/google-calendar.ts
-var googleCalendarIntegrationSpec = defineIntegration({
-  meta: {
-    key: "calendar.google",
-    version: "1.0.0",
-    category: "calendar",
-    title: "Google Calendar API",
-    description: "Google Calendar integration for event creation, updates, and scheduling automations.",
-    domain: "productivity",
-    owners: ["platform.messaging"],
-    tags: ["calendar", "google"],
-    stability: StabilityEnum.Beta
-  },
-  supportedModes: ["managed", "byok"],
-  capabilities: {
-    provides: [{ key: "calendar.events", version: "1.0.0" }]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        calendarId: {
-          type: "string",
-          description: "Default calendar identifier (defaults to primary)."
-        }
-      }
-    },
-    example: {
-      calendarId: "primary"
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["clientEmail", "privateKey"],
-      properties: {
-        clientEmail: {
-          type: "string",
-          description: "Service account client email."
-        },
-        privateKey: {
-          type: "string",
-          description: "Service account private key."
-        },
-        projectId: {
-          type: "string",
-          description: "Google Cloud project ID."
-        }
-      }
-    },
-    example: {
-      clientEmail: "svc-calendar@example.iam.gserviceaccount.com",
-      privateKey: "-----BEGIN PRIVATE KEY-----...",
-      projectId: "calendar-project"
-    }
-  },
-  healthCheck: {
-    method: "custom",
-    timeoutMs: 4000
-  },
-  docsUrl: "https://developers.google.com/calendar/api",
-  constraints: {},
-  byokSetup: {
-    setupInstructions: "Create a Google service account with Calendar access and share the target calendars with the service account email."
-  }
-});
-function registerGoogleCalendarIntegration(registry) {
-  return registry.register(googleCalendarIntegrationSpec);
-}
-
-// src/integrations/providers/twilio-sms.ts
-var twilioSmsIntegrationSpec = defineIntegration({
-  meta: {
-    key: "sms.twilio",
-    version: "1.0.0",
-    category: "sms",
-    title: "Twilio Messaging",
-    description: "Twilio SMS integration for transactional and notification messaging.",
-    domain: "communications",
-    owners: ["platform.messaging"],
-    tags: ["sms", "messaging"],
-    stability: StabilityEnum.Stable
-  },
-  supportedModes: ["managed", "byok"],
-  capabilities: {
-    provides: [{ key: "sms.outbound", version: "1.0.0" }]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        fromNumber: {
-          type: "string",
-          description: "Default Twilio phone number used as sender."
-        }
-      }
-    },
-    example: {
-      fromNumber: "+15551234567"
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["accountSid", "authToken"],
-      properties: {
-        accountSid: {
-          type: "string",
-          description: "Twilio Account SID."
-        },
-        authToken: {
-          type: "string",
-          description: "Twilio Auth Token."
-        }
-      }
-    },
-    example: {
-      accountSid: "ACxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
-      authToken: "auth-token"
-    }
-  },
-  healthCheck: {
-    method: "custom",
-    timeoutMs: 3000
-  },
-  docsUrl: "https://www.twilio.com/docs/sms/api",
-  constraints: {
-    rateLimit: {
-      rpm: 200
-    }
-  },
-  byokSetup: {
-    setupInstructions: "Provide a Twilio account SID, auth token, and verify the outbound sending numbers used by the integration."
-  }
-});
-function registerTwilioSmsIntegration(registry) {
-  return registry.register(twilioSmsIntegrationSpec);
-}
-
-// src/integrations/providers/gcs-storage.ts
-var gcsStorageIntegrationSpec = defineIntegration({
-  meta: {
-    key: "storage.gcs",
-    version: "1.0.0",
-    category: "storage",
-    title: "Google Cloud Storage Buckets",
-    description: "Google Cloud Storage integration for object storage and retrieval.",
-    domain: "infrastructure",
-    owners: ["platform.infrastructure"],
-    tags: ["storage", "gcs", "google-cloud"],
-    stability: StabilityEnum.Beta
-  },
-  supportedModes: ["managed", "byok"],
-  capabilities: {
-    provides: [{ key: "storage.objects", version: "1.0.0" }]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      required: ["bucket"],
-      properties: {
-        bucket: {
-          type: "string",
-          description: "Primary bucket name used for storing objects."
-        },
-        prefix: {
-          type: "string",
-          description: "Optional prefix applied to object keys."
-        }
-      }
-    },
-    example: {
-      bucket: "pfo-tenant-assets",
-      prefix: "documents/"
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        type: {
-          type: "string",
-          description: "Service account type field from Google credentials JSON (if provided)."
-        },
-        client_email: { type: "string" },
-        private_key: { type: "string" },
-        project_id: { type: "string" }
-      }
-    },
-    example: {
-      type: "service_account",
-      client_email: "svc-account@example.iam.gserviceaccount.com",
-      private_key: "-----BEGIN PRIVATE KEY-----...",
-      project_id: "example-project"
-    }
-  },
-  healthCheck: {
-    method: "ping",
-    timeoutMs: 4000
-  },
-  docsUrl: "https://cloud.google.com/storage/docs/apis",
-  constraints: {
-    quotas: {
-      storageGb: 5120
-    }
-  },
-  byokSetup: {
-    setupInstructions: "Create a Google Cloud service account with Storage Object Admin role and upload the JSON credentials to the secret store."
-  }
-});
-function registerGcsStorageIntegration(registry) {
-  return registry.register(gcsStorageIntegrationSpec);
-}
-
-// src/integrations/providers/powens.ts
-var powensIntegrationSpec = defineIntegration({
-  meta: {
-    key: "openbanking.powens",
-    version: "1.0.0",
-    category: "open-banking",
-    title: "Powens Open Banking (Read)",
-    description: "Read-only Open Banking integration powered by Powens, exposing accounts, transactions, and balances.",
-    domain: "finance",
-    owners: ["platform.finance"],
-    tags: ["open-banking", "powens", "finance"],
-    stability: StabilityEnum.Experimental
-  },
-  supportedModes: ["byok"],
-  capabilities: {
-    provides: [
-      { key: "openbanking.accounts.read", version: "1.0.0" },
-      { key: "openbanking.transactions.read", version: "1.0.0" },
-      { key: "openbanking.balances.read", version: "1.0.0" }
-    ]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      required: ["environment"],
-      properties: {
-        environment: {
-          type: "string",
-          enum: ["sandbox", "production"],
-          description: "Powens environment to target. Sandbox uses Powens test API base URL, production uses live endpoints."
-        },
-        baseUrl: {
-          type: "string",
-          description: "Optional override for the Powens API base URL. Defaults to Powens environment defaults."
-        },
-        region: {
-          type: "string",
-          description: "Optional Powens region identifier when targeting a specific data residency cluster."
-        },
-        pollingIntervalMs: {
-          type: "number",
-          description: "Optional custom polling interval in milliseconds for background sync jobs (defaults to platform standard)."
-        }
-      }
-    },
-    example: {
-      environment: "sandbox",
-      baseUrl: "https://api-sandbox.powens.com/v2",
-      region: "eu-west-1",
-      pollingIntervalMs: 300000
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["clientId", "clientSecret"],
-      properties: {
-        clientId: {
-          type: "string",
-          description: "Powens OAuth client identifier obtained from the Powens Console (BYOK project)."
-        },
-        clientSecret: {
-          type: "string",
-          description: "Powens OAuth client secret used to exchange for access tokens."
-        },
-        apiKey: {
-          type: "string",
-          description: "Optional Powens API key (if the tenant project exposes a dedicated API token)."
-        },
-        webhookSecret: {
-          type: "string",
-          description: "Optional webhook signing secret used to verify Powens webhook payloads."
-        }
-      }
-    },
-    example: {
-      clientId: "powens-client-id",
-      clientSecret: "powens-client-secret",
-      apiKey: "powens-api-key",
-      webhookSecret: "powens-webhook-secret"
-    }
-  },
-  healthCheck: {
-    method: "ping",
-    timeoutMs: 8000
-  },
-  docsUrl: "https://docs.powens.com/",
-  constraints: {
-    rateLimit: {
-      rph: 1e4,
-      rpm: 600
-    }
-  },
-  byokSetup: {
-    setupInstructions: "Create a Powens BYOK project, generate OAuth credentials, and optionally configure webhook delivery for account/transaction updates.",
-    requiredScopes: ["accounts:read", "transactions:read", "balances:read"]
-  }
-});
-function registerPowensIntegration(registry) {
-  return registry.register(powensIntegrationSpec);
-}
-
-// src/integrations/providers/posthog.ts
-var posthogIntegrationSpec = defineIntegration({
-  meta: {
-    key: "analytics.posthog",
-    version: "1.1.0",
-    category: "analytics",
-    title: "PostHog",
-    description: "PostHog integration for product analytics, feature flags, HogQL queries, and LLM analytics with evaluations.",
-    domain: "analytics",
-    owners: ["@platform.integrations"],
-    tags: ["analytics", "posthog", "llm", "ai"],
-    stability: StabilityEnum.Beta
-  },
-  supportedModes: ["managed", "byok"],
-  capabilities: {
-    provides: [
-      { key: "analytics.events", version: "1.0.0" },
-      { key: "analytics.feature-flags", version: "1.0.0" },
-      { key: "analytics.query", version: "1.0.0" },
-      { key: "analytics.events.read", version: "1.0.0" },
-      { key: "analytics.persons", version: "1.0.0" },
-      { key: "analytics.insights", version: "1.0.0" },
-      { key: "analytics.cohorts", version: "1.0.0" },
-      { key: "analytics.annotations", version: "1.0.0" },
-      { key: "analytics.llm-tracing", version: "1.0.0" },
-      { key: "analytics.llm-evaluations", version: "1.0.0" }
-    ]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        host: {
-          type: "string",
-          description: "PostHog host (e.g., https://app.posthog.com or self-hosted URL)."
-        },
-        projectId: {
-          type: "string",
-          description: "PostHog project ID for API queries."
-        },
-        mcpUrl: {
-          type: "string",
-          description: "Optional MCP endpoint URL for PostHog tools."
-        }
-      }
-    },
-    example: {
-      host: "https://app.posthog.com",
-      projectId: "12345"
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["personalApiKey"],
-      properties: {
-        personalApiKey: {
-          type: "string",
-          description: "PostHog personal API key (required for API reads/writes)."
-        },
-        projectApiKey: {
-          type: "string",
-          description: "PostHog project API key (required for capture/ingest events)."
-        }
-      }
-    },
-    example: {
-      personalApiKey: "phx_personal_api_key",
-      projectApiKey: "phc_project_api_key"
-    }
-  },
-  healthCheck: {
-    method: "custom",
-    timeoutMs: 5000
-  },
-  docsUrl: "https://posthog.com/docs",
-  byokSetup: {
-    setupInstructions: "Generate a PostHog personal API key for read/write operations and a project API key for event capture."
-  }
-});
-function registerPosthogIntegration(registry) {
-  return registry.register(posthogIntegrationSpec);
-}
-
-// src/integrations/providers/posthog-llm-telemetry.ts
-var posthogLLMTelemetrySpec = {
-  meta: {
-    key: "analytics.posthog.llm",
-    version: "1.0.0",
-    title: "PostHog LLM Analytics Telemetry",
-    description: "Telemetry events for PostHog LLM Analytics: generation tracing, token usage, and evaluation-ready metadata.",
-    domain: "analytics",
-    owners: ["@platform.integrations"],
-    tags: ["analytics", "posthog", "llm", "ai", "telemetry"],
-    stability: StabilityEnum.Beta
-  },
-  events: [
-    {
-      key: "posthog.llm.generation",
-      version: "1.0.0",
-      semantics: {
-        who: "AI agent or LLM consumer",
-        what: "Captures an LLM generation call with full observability metadata",
-        why: "Enable LLM performance monitoring, cost tracking, and automated quality evaluations via PostHog"
-      },
-      properties: {
-        $ai_model: {
-          type: "string",
-          required: true,
-          description: "The LLM model identifier (e.g., gpt-4o, claude-sonnet-4-20250514)"
-        },
-        $ai_provider: {
-          type: "string",
-          required: true,
-          description: "The LLM provider (e.g., openai, anthropic, contractspec)"
-        },
-        $ai_latency: {
-          type: "number",
-          required: false,
-          description: "LLM call latency in seconds"
-        },
-        $ai_input_tokens: {
-          type: "number",
-          required: false,
-          description: "Number of input/prompt tokens consumed"
-        },
-        $ai_output_tokens: {
-          type: "number",
-          required: false,
-          description: "Number of output/completion tokens generated"
-        },
-        $ai_total_cost_usd: {
-          type: "number",
-          required: false,
-          description: "Total cost in USD (input + output)"
-        },
-        $ai_is_error: {
-          type: "boolean",
-          required: false,
-          description: "Whether the generation resulted in an error"
-        },
-        $ai_trace_id: {
-          type: "string",
-          required: false,
-          description: "Trace ID for grouping related generations"
-        },
-        $ai_stream: {
-          type: "boolean",
-          required: false,
-          description: "Whether the response was streamed"
-        },
-        $ai_time_to_first_token: {
-          type: "number",
-          required: false,
-          description: "Time to first token in seconds (streaming only)"
-        },
-        $ai_tools: {
-          type: "json",
-          required: false,
-          description: "Tools/functions available to the LLM"
-        },
-        $ai_input: {
-          type: "json",
-          required: false,
-          pii: true,
-          redact: true,
-          description: "Messages sent to the LLM (may contain PII)"
-        },
-        $ai_output_choices: {
-          type: "json",
-          required: false,
-          pii: true,
-          redact: true,
-          description: "Response choices from the LLM (may contain PII)"
-        },
-        contractspec_operation: {
-          type: "string",
-          required: false,
-          description: "ContractSpec operation name"
-        },
-        contractspec_version: {
-          type: "string",
-          required: false,
-          description: "ContractSpec operation version"
-        },
-        contractspec_agent_id: {
-          type: "string",
-          required: false,
-          description: "ContractSpec agent identifier"
-        },
-        contractspec_finish_reason: {
-          type: "string",
-          required: false,
-          description: "AI SDK finish reason (stop, tool-calls, error, etc.)"
-        },
-        contractspec_tool_count: {
-          type: "number",
-          required: false,
-          description: "Number of tool calls made in this step"
-        }
-      },
-      privacy: "internal",
-      tags: ["llm", "generation", "posthog"]
-    }
-  ],
-  config: {
-    defaultRetentionDays: 90,
-    defaultSamplingRate: 1,
-    providers: [
-      {
-        type: "posthog",
-        config: {
-          eventName: "$ai_generation",
-          enableEvaluations: true,
-          evaluationTemplates: [
-            "relevance",
-            "helpfulness",
-            "jailbreak",
-            "hallucination",
-            "toxicity"
-          ]
-        }
-      }
-    ]
-  }
-};
-var POSTHOG_LLM_PII_FIELDS = [
-  "$ai_input",
-  "$ai_output_choices"
-];
-var POSTHOG_LLM_TELEMETRY_EVENTS = {
-  generation: "$ai_generation",
-  span: "$ai_span",
-  evaluation: "$ai_evaluation"
-};
-var POSTHOG_EVALUATION_TEMPLATES = {
-  relevance: "relevance",
-  helpfulness: "helpfulness",
-  jailbreak: "jailbreak",
-  hallucination: "hallucination",
-  toxicity: "toxicity"
-};
-function redactPostHogLLMTelemetryPayload(payload) {
-  const redacted = { ...payload };
-  for (const field of POSTHOG_LLM_PII_FIELDS) {
-    if (field in redacted) {
-      redacted[field] = "[REDACTED]";
-    }
-  }
-  return redacted;
-}
-
-// src/integrations/providers/linear.ts
-var linearIntegrationSpec = defineIntegration({
-  meta: {
-    key: "project-management.linear",
-    version: "1.0.0",
-    category: "project-management",
-    title: "Linear",
-    description: "Linear integration for issue tracking and project management workflows.",
-    domain: "productivity",
-    owners: ["@platform.integrations"],
-    tags: ["project-management", "linear"],
-    stability: StabilityEnum.Beta
-  },
-  supportedModes: ["managed", "byok"],
-  capabilities: {
-    provides: [{ key: "project-management.work-items", version: "1.0.0" }]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      required: ["teamId"],
-      properties: {
-        teamId: {
-          type: "string",
-          description: "Linear team ID that owns created issues."
-        },
-        projectId: {
-          type: "string",
-          description: "Optional default project ID for new issues."
-        },
-        stateId: {
-          type: "string",
-          description: "Optional default workflow state ID."
-        },
-        assigneeId: {
-          type: "string",
-          description: "Optional default assignee ID."
-        },
-        labelIds: {
-          type: "array",
-          items: { type: "string" },
-          description: "Optional label IDs applied to each issue."
-        },
-        tagLabelMap: {
-          type: "object",
-          additionalProperties: { type: "string" },
-          description: "Optional mapping of tags to Linear label IDs (tag -> labelId)."
-        }
-      }
-    },
-    example: {
-      teamId: "team_123",
-      projectId: "proj_456",
-      labelIds: ["label_1", "label_2"]
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["apiKey"],
-      properties: {
-        apiKey: {
-          type: "string",
-          description: "Linear API key (personal or service token)."
-        }
-      }
-    },
-    example: {
-      apiKey: "lin_api_key"
-    }
-  },
-  healthCheck: {
-    method: "custom",
-    timeoutMs: 4000
-  },
-  docsUrl: "https://developers.linear.app",
-  constraints: {},
-  byokSetup: {
-    setupInstructions: "Create a Linear API key with issue:write permission and store it as a secret."
-  }
-});
-function registerLinearIntegration(registry) {
-  return registry.register(linearIntegrationSpec);
-}
-
-// src/integrations/providers/jira.ts
-var jiraIntegrationSpec = defineIntegration({
-  meta: {
-    key: "project-management.jira",
-    version: "1.0.0",
-    category: "project-management",
-    title: "Jira Cloud",
-    description: "Jira Cloud integration for creating and tracking work items.",
-    domain: "productivity",
-    owners: ["@platform.integrations"],
-    tags: ["project-management", "jira"],
-    stability: StabilityEnum.Beta
-  },
-  supportedModes: ["managed", "byok"],
-  capabilities: {
-    provides: [{ key: "project-management.work-items", version: "1.0.0" }]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      required: ["siteUrl"],
-      properties: {
-        siteUrl: {
-          type: "string",
-          description: "Jira Cloud site URL (e.g., https://acme.atlassian.net)."
-        },
-        projectKey: {
-          type: "string",
-          description: "Default Jira project key for new issues."
-        },
-        issueType: {
-          type: "string",
-          description: "Default Jira issue type (e.g., Task, Story)."
-        },
-        defaultLabels: {
-          type: "array",
-          items: { type: "string" },
-          description: "Labels applied to each issue by default."
-        },
-        issueTypeMap: {
-          type: "object",
-          additionalProperties: { type: "string" },
-          description: "Optional mapping from work item types to Jira issue types."
-        }
-      }
-    },
-    example: {
-      siteUrl: "https://acme.atlassian.net",
-      projectKey: "PM",
-      issueType: "Task"
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["email", "apiToken"],
-      properties: {
-        email: {
-          type: "string",
-          description: "Jira account email used for API token auth."
-        },
-        apiToken: {
-          type: "string",
-          description: "Jira Cloud API token for the account."
-        }
-      }
-    },
-    example: {
-      email: "user@acme.com",
-      apiToken: "jira_api_token"
-    }
-  },
-  healthCheck: {
-    method: "custom",
-    timeoutMs: 4000
-  },
-  docsUrl: "https://developer.atlassian.com/cloud/jira/platform/rest/v3/intro/",
-  constraints: {},
-  byokSetup: {
-    setupInstructions: "Create a Jira API token and store it with the associated account email."
-  }
-});
-function registerJiraIntegration(registry) {
-  return registry.register(jiraIntegrationSpec);
-}
-
-// src/integrations/providers/notion.ts
-var notionIntegrationSpec = defineIntegration({
-  meta: {
-    key: "project-management.notion",
-    version: "1.0.0",
-    category: "project-management",
-    title: "Notion",
-    description: "Notion integration for creating shared project summaries and task entries.",
-    domain: "productivity",
-    owners: ["@platform.integrations"],
-    tags: ["project-management", "notion"],
-    stability: StabilityEnum.Beta
-  },
-  supportedModes: ["managed", "byok"],
-  capabilities: {
-    provides: [{ key: "project-management.work-items", version: "1.0.0" }]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        databaseId: {
-          type: "string",
-          description: "Optional Notion database ID to store tasks."
-        },
-        summaryParentPageId: {
-          type: "string",
-          description: "Optional parent page ID for summary pages."
-        },
-        titleProperty: {
-          type: "string",
-          description: 'Database title property name (defaults to "Name").'
-        },
-        statusProperty: {
-          type: "string",
-          description: "Database status/select property name."
-        },
-        priorityProperty: {
-          type: "string",
-          description: "Database priority/select property name."
-        },
-        tagsProperty: {
-          type: "string",
-          description: "Database multi-select tags property name."
-        },
-        dueDateProperty: {
-          type: "string",
-          description: "Database date property name for due dates."
-        },
-        descriptionProperty: {
-          type: "string",
-          description: "Database rich-text property for descriptions."
-        }
-      }
-    },
-    example: {
-      databaseId: "xxxxxxxxxxxxxxxx",
-      summaryParentPageId: "yyyyyyyyyyyyyyyy",
-      titleProperty: "Name",
-      statusProperty: "Status"
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["apiKey"],
-      properties: {
-        apiKey: {
-          type: "string",
-          description: "Notion integration secret token."
-        }
-      }
-    },
-    example: {
-      apiKey: "secret_notion_token"
-    }
-  },
-  healthCheck: {
-    method: "custom",
-    timeoutMs: 4000
-  },
-  docsUrl: "https://developers.notion.com",
-  constraints: {},
-  byokSetup: {
-    setupInstructions: "Create a Notion internal integration, share the target database/page with it, and store the secret token."
-  }
-});
-function registerNotionIntegration(registry) {
-  return registry.register(notionIntegrationSpec);
-}
-
-// src/integrations/providers/granola.ts
-var granolaIntegrationSpec = defineIntegration({
-  meta: {
-    key: "meeting-recorder.granola",
-    version: "1.0.0",
-    category: "meeting-recorder",
-    title: "Granola Meeting Notes",
-    description: "Granola meeting notes and transcripts via Enterprise API or MCP transport.",
-    domain: "productivity",
-    owners: ["platform.integrations"],
-    tags: ["meeting-recorder", "granola", "transcripts"],
-    stability: StabilityEnum.Experimental
-  },
-  supportedModes: ["byok"],
-  capabilities: {
-    provides: [
-      { key: "meeting-recorder.meetings.read", version: "1.0.0" },
-      { key: "meeting-recorder.transcripts.read", version: "1.0.0" }
-    ]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        baseUrl: {
-          type: "string",
-          description: "Optional override for the Granola API base URL. Defaults to https://public-api.granola.ai for API transport."
-        },
-        transport: {
-          type: "string",
-          enum: ["api", "mcp"],
-          description: "Transport mode for Granola integration. Use api for Enterprise API or mcp for broader MCP access."
-        },
-        mcpUrl: {
-          type: "string",
-          description: "Optional override for Granola MCP URL. Defaults to https://mcp.granola.ai/mcp."
-        },
-        mcpHeaders: {
-          type: "object",
-          additionalProperties: { type: "string" },
-          description: "Optional static headers for MCP gateway/proxy setups."
-        },
-        pageSize: {
-          type: "number",
-          description: "Page size for listing notes (maximum 30 per Granola API)."
-        }
-      }
-    },
-    example: {
-      transport: "mcp",
-      mcpUrl: "https://mcp.granola.ai/mcp",
-      pageSize: 10
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        apiKey: {
-          type: "string",
-          description: "Granola API key used as a Bearer token for Enterprise API requests (transport=api)."
-        },
-        mcpAccessToken: {
-          type: "string",
-          description: "Optional bearer token for MCP proxy/gateway auth (transport=mcp)."
-        }
-      }
-    },
-    example: {
-      mcpAccessToken: "granola-mcp-***"
-    }
-  },
-  healthCheck: {
-    method: "list",
-    timeoutMs: 8000
-  },
-  docsUrl: "https://docs.granola.ai/help-center/sharing/integrations/mcp",
-  byokSetup: {
-    setupInstructions: "Use Granola MCP for browser OAuth access, or configure an Enterprise API key for REST transport."
-  }
-});
-function registerGranolaIntegration(registry) {
-  return registry.register(granolaIntegrationSpec);
-}
-
-// src/integrations/providers/tldv.ts
-var tldvIntegrationSpec = defineIntegration({
-  meta: {
-    key: "meeting-recorder.tldv",
-    version: "1.0.0",
-    category: "meeting-recorder",
-    title: "tl;dv Meeting Recorder",
-    description: "tl;dv Public API for meeting recordings, transcripts, and webhook events.",
-    domain: "productivity",
-    owners: ["platform.integrations"],
-    tags: ["meeting-recorder", "tldv", "transcripts"],
-    stability: StabilityEnum.Experimental
-  },
-  supportedModes: ["byok"],
-  capabilities: {
-    provides: [
-      { key: "meeting-recorder.meetings.read", version: "1.0.0" },
-      { key: "meeting-recorder.transcripts.read", version: "1.0.0" },
-      { key: "meeting-recorder.webhooks", version: "1.0.0" }
-    ]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        baseUrl: {
-          type: "string",
-          description: "Optional override for the tl;dv API base URL. Defaults to https://pasta.tldv.io/v1alpha1."
-        },
-        webhookUrl: {
-          type: "string",
-          description: "Webhook destination URL configured in tl;dv settings (MeetingReady/TranscriptReady)."
-        },
-        webhookEvents: {
-          type: "array",
-          items: { type: "string" },
-          description: "Webhook triggers to enable (MeetingReady, TranscriptReady)."
-        },
-        webhookScope: {
-          type: "string",
-          description: "Webhook scope to configure (user, team, or organization)."
-        }
-      }
-    },
-    example: {
-      baseUrl: "https://pasta.tldv.io/v1alpha1",
-      webhookUrl: "https://example.com/webhooks/tldv",
-      webhookEvents: ["MeetingReady", "TranscriptReady"],
-      webhookScope: "team"
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["apiKey"],
-      properties: {
-        apiKey: {
-          type: "string",
-          description: "tl;dv API key used in the x-api-key header for API requests."
-        },
-        webhookSecret: {
-          type: "string",
-          description: "Optional shared secret for webhook verification if configured in your environment."
-        }
-      }
-    },
-    example: {
-      apiKey: "tldv-***",
-      webhookSecret: "tldv-webhook-secret"
-    }
-  },
-  healthCheck: {
-    method: "ping",
-    timeoutMs: 6000
-  },
-  docsUrl: "https://doc.tldv.io/index.html",
-  byokSetup: {
-    setupInstructions: "Generate a tl;dv API key and optionally configure MeetingReady/TranscriptReady webhooks."
-  }
-});
-function registerTldvIntegration(registry) {
-  return registry.register(tldvIntegrationSpec);
-}
-
-// src/integrations/providers/fireflies.ts
-var firefliesIntegrationSpec = defineIntegration({
-  meta: {
-    key: "meeting-recorder.fireflies",
-    version: "1.0.0",
-    category: "meeting-recorder",
-    title: "Fireflies.ai Meeting Recorder",
-    description: "Fireflies GraphQL API for meeting transcripts, metadata, and webhook events.",
-    domain: "productivity",
-    owners: ["platform.integrations"],
-    tags: ["meeting-recorder", "fireflies", "transcripts"],
-    stability: StabilityEnum.Experimental
-  },
-  supportedModes: ["byok"],
-  capabilities: {
-    provides: [
-      { key: "meeting-recorder.meetings.read", version: "1.0.0" },
-      { key: "meeting-recorder.transcripts.read", version: "1.0.0" },
-      { key: "meeting-recorder.webhooks", version: "1.0.0" }
-    ]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        baseUrl: {
-          type: "string",
-          description: "Optional override for the Fireflies GraphQL endpoint. Defaults to https://api.fireflies.ai/graphql."
-        },
-        webhookUrl: {
-          type: "string",
-          description: "Webhook destination URL configured in Fireflies developer settings."
-        },
-        webhookEvents: {
-          type: "array",
-          items: { type: "string" },
-          description: "Webhook events to subscribe to (e.g., Transcription completed)."
-        },
-        transcriptsPageSize: {
-          type: "number",
-          description: "Number of transcripts to request per GraphQL query."
-        }
-      }
-    },
-    example: {
-      baseUrl: "https://api.fireflies.ai/graphql",
-      webhookUrl: "https://example.com/webhooks/fireflies",
-      webhookEvents: ["Transcription completed"],
-      transcriptsPageSize: 25
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["apiKey"],
-      properties: {
-        apiKey: {
-          type: "string",
-          description: "Fireflies API key for GraphQL requests."
-        },
-        webhookSecret: {
-          type: "string",
-          description: "Optional webhook secret used to verify x-hub-signature HMAC payloads."
-        }
-      }
-    },
-    example: {
-      apiKey: "fireflies-***",
-      webhookSecret: "fireflies-webhook-secret"
-    }
-  },
-  healthCheck: {
-    method: "custom",
-    timeoutMs: 6000
-  },
-  docsUrl: "https://docs.fireflies.ai/getting-started/introduction",
-  byokSetup: {
-    setupInstructions: "Create a Fireflies API key and optionally configure webhook settings in Developer Settings."
-  }
-});
-function registerFirefliesIntegration(registry) {
-  return registry.register(firefliesIntegrationSpec);
-}
-
-// src/integrations/providers/fathom.ts
-var fathomIntegrationSpec = defineIntegration({
-  meta: {
-    key: "meeting-recorder.fathom",
-    version: "1.0.0",
-    category: "meeting-recorder",
-    title: "Fathom Meeting Recorder",
-    description: "Fathom External API for meetings, transcripts, and webhook events.",
-    domain: "productivity",
-    owners: ["platform.integrations"],
-    tags: ["meeting-recorder", "fathom", "transcripts"],
-    stability: StabilityEnum.Experimental
-  },
-  supportedModes: ["byok"],
-  capabilities: {
-    provides: [
-      { key: "meeting-recorder.meetings.read", version: "1.0.0" },
-      { key: "meeting-recorder.transcripts.read", version: "1.0.0" },
-      { key: "meeting-recorder.webhooks", version: "1.0.0" }
-    ]
-  },
-  configSchema: {
-    schema: {
-      type: "object",
-      properties: {
-        baseUrl: {
-          type: "string",
-          description: "Optional override for the Fathom API base URL. Defaults to https://api.fathom.ai/external/v1."
-        },
-        webhookUrl: {
-          type: "string",
-          description: "Webhook destination URL used when registering Fathom webhooks."
-        },
-        includeTranscript: {
-          type: "boolean",
-          description: "Include transcript data in Fathom webhook payloads."
-        },
-        includeSummary: {
-          type: "boolean",
-          description: "Include summary data in Fathom webhook payloads."
-        },
-        includeActionItems: {
-          type: "boolean",
-          description: "Include action items in Fathom webhook payloads."
-        },
-        includeCrmMatches: {
-          type: "boolean",
-          description: "Include CRM matches in Fathom webhook payloads."
-        },
-        triggeredFor: {
-          type: "array",
-          items: { type: "string" },
-          description: "Recording scopes to trigger webhooks for (e.g., my_recordings)."
-        }
-      }
-    },
-    example: {
-      baseUrl: "https://api.fathom.ai/external/v1",
-      webhookUrl: "https://example.com/webhooks/fathom",
-      includeTranscript: true,
-      includeSummary: true,
-      includeActionItems: false,
-      includeCrmMatches: false,
-      triggeredFor: ["my_recordings"]
-    }
-  },
-  secretSchema: {
-    schema: {
-      type: "object",
-      required: ["apiKey"],
-      properties: {
-        apiKey: {
-          type: "string",
-          description: "Fathom API key used in the X-Api-Key header."
-        },
-        webhookSecret: {
-          type: "string",
-          description: "Optional webhook secret used to verify Fathom webhook signatures."
-        }
-      }
-    },
-    example: {
-      apiKey: "fathom-***",
-      webhookSecret: "whsec_***"
-    }
-  },
-  healthCheck: {
-    method: "list",
-    timeoutMs: 8000
-  },
-  docsUrl: "https://developers.fathom.ai/",
-  constraints: {
-    rateLimit: {
-      rpm: 60
-    }
-  },
-  byokSetup: {
-    setupInstructions: "Generate an API key in Fathom settings and optionally configure webhooks for meeting content readiness."
-  }
-});
-function registerFathomIntegration(registry) {
-  return registry.register(fathomIntegrationSpec);
-}
-// src/integrations/providers/registry.ts
-function createDefaultIntegrationSpecRegistry() {
-  const registry = new IntegrationSpecRegistry;
-  registerStripeIntegration(registry);
-  registerPostmarkIntegration(registry);
-  registerQdrantIntegration(registry);
-  registerSupabaseVectorIntegration(registry);
-  registerSupabasePostgresIntegration(registry);
-  registerMistralIntegration(registry);
-  registerElevenLabsIntegration(registry);
-  registerGradiumIntegration(registry);
-  registerFalIntegration(registry);
-  registerGmailIntegration(registry);
-  registerGoogleCalendarIntegration(registry);
-  registerPosthogIntegration(registry);
-  registerTwilioSmsIntegration(registry);
-  registerGcsStorageIntegration(registry);
-  registerPowensIntegration(registry);
-  registerLinearIntegration(registry);
-  registerJiraIntegration(registry);
-  registerNotionIntegration(registry);
-  registerGranolaIntegration(registry);
-  registerTldvIntegration(registry);
-  registerFirefliesIntegration(registry);
-  registerFathomIntegration(registry);
-  return registry;
-}
-export {
-  twilioSmsIntegrationSpec,
-  tldvIntegrationSpec,
-  supabaseVectorIntegrationSpec,
-  supabasePostgresIntegrationSpec,
-  stripeIntegrationSpec,
-  registerTwilioSmsIntegration,
-  registerTldvIntegration,
-  registerSupabaseVectorIntegration,
-  registerSupabasePostgresIntegration,
-  registerStripeIntegration,
-  registerQdrantIntegration,
-  registerPowensIntegration,
-  registerPostmarkIntegration,
-  registerPosthogIntegration,
-  registerNotionIntegration,
-  registerMistralIntegration,
-  registerLinearIntegration,
-  registerJiraIntegration,
-  registerGranolaIntegration,
-  registerGradiumIntegration,
-  registerGoogleCalendarIntegration,
-  registerGmailIntegration,
-  registerGcsStorageIntegration,
-  registerFirefliesIntegration,
-  registerFathomIntegration,
-  registerFalIntegration,
-  registerElevenLabsIntegration,
-  redactPostHogLLMTelemetryPayload,
-  qdrantIntegrationSpec,
-  powensIntegrationSpec,
-  postmarkIntegrationSpec,
-  posthogLLMTelemetrySpec,
-  posthogIntegrationSpec,
-  notionIntegrationSpec,
-  mistralIntegrationSpec,
-  linearIntegrationSpec,
-  jiraIntegrationSpec,
-  granolaIntegrationSpec,
-  gradiumIntegrationSpec,
-  googleCalendarIntegrationSpec,
-  gmailIntegrationSpec,
-  gcsStorageIntegrationSpec,
-  firefliesIntegrationSpec,
-  fathomIntegrationSpec,
-  falIntegrationSpec,
-  elevenLabsIntegrationSpec,
-  createDefaultIntegrationSpecRegistry,
-  POSTHOG_LLM_TELEMETRY_EVENTS,
-  POSTHOG_LLM_PII_FIELDS,
-  POSTHOG_EVALUATION_TEMPLATES
-};