@lssm/lib.contracts-integrations 9.0.1

package/dist/integrations/providers/storage.d.ts

@@ -0,0 +1,65 @@
+export interface StorageObjectMetadata {
+    bucket: string;
+    key: string;
+    sizeBytes?: number;
+    contentType?: string;
+    etag?: string;
+    checksum?: string;
+    lastModified?: Date;
+    metadata?: Record<string, string>;
+}
+export type StorageObjectBody = {
+    data: Uint8Array;
+    stream?: never;
+} | {
+    data?: never;
+    stream: AsyncIterable<Uint8Array>;
+};
+export type GetObjectResult = StorageObjectMetadata & StorageObjectBody;
+export interface PutObjectInput {
+    bucket: string;
+    key: string;
+    data: Uint8Array | ArrayBuffer;
+    contentType?: string;
+    metadata?: Record<string, string>;
+    makePublic?: boolean;
+}
+export interface DeleteObjectInput {
+    bucket: string;
+    key: string;
+}
+export interface SignedUrlOptions {
+    bucket: string;
+    key: string;
+    expiresInSeconds: number;
+    method?: 'GET' | 'PUT';
+    contentType?: string;
+}
+export interface ListObjectsQuery {
+    bucket: string;
+    prefix?: string;
+    maxResults?: number;
+    pageToken?: string;
+}
+export interface ListObjectsResult {
+    objects: StorageObjectMetadata[];
+    nextPageToken?: string;
+}
+export interface ObjectStorageProvider {
+    putObject(input: PutObjectInput): Promise<StorageObjectMetadata>;
+    getObject(input: DeleteObjectInput): Promise<GetObjectResult | null>;
+    deleteObject(input: DeleteObjectInput): Promise<void>;
+    generateSignedUrl(options: SignedUrlOptions): Promise<{
+        url: string;
+        expiresAt: Date;
+    }>;
+    listObjects(query: ListObjectsQuery): Promise<ListObjectsResult>;
+}
+/** Additive read-only capability; cancellation applies while acquiring and consuming object bytes. */
+export interface StorageObjectReadInput extends DeleteObjectInput {
+    readonly signal?: AbortSignal;
+}
+/** Narrow readers expose no upload, delete, listing or signed-URL authority. */
+export interface ObjectStorageReadProvider {
+    getObject(input: StorageObjectReadInput): Promise<GetObjectResult | null>;
+}

package/dist/integrations/providers/storage.js

@@ -0,0 +1 @@
+// @bun

package/dist/integrations/providers/strava.d.ts

@@ -0,0 +1,3 @@
+import { type IntegrationSpecRegistry } from '../spec.js';
+export declare const stravaIntegrationSpec: import("..").IntegrationSpec;
+export declare function registerStravaIntegration(registry: IntegrationSpecRegistry): IntegrationSpecRegistry;

package/dist/integrations/providers/strava.js

@@ -0,0 +1,2 @@
+// @bun
+import{StabilityEnum as g}from"@lssm/lib.contracts-spec/ownership";import{SpecContractRegistry as s}from"@lssm/lib.contracts-spec/registry";var p=(e)=>`${e.key}.v${e.version}`;class c extends s{constructor(e){super("integration",e)}getByCategory(e){return this.list().filter((t)=>t.meta.category===e)}}function u(e){return p(e)}var i=(e)=>e;var o=["official-api","official-mcp","aggregator-api","aggregator-mcp","unofficial"],l=[{key:"health.activities.read",version:"1.0.0"},{key:"health.workouts.read",version:"1.0.0"},{key:"health.sleep.read",version:"1.0.0"},{key:"health.biometrics.read",version:"1.0.0"}],d=[{type:"rest"},{type:"mcp",transport:"http"},{type:"webhook",inbound:{signatureHeader:"x-webhook-signature",signingAlgorithm:"hmac-sha256"}}],n=[{type:"oauth2",grantType:"authorization_code",tokenUrl:"",scopes:[]},{type:"api-key"},{type:"bearer"},{type:"basic"}];function a(e){let t=e.supportedAuthMethods??y(e);return i({meta:{key:e.key,version:"1.0.0",category:"health",title:e.title,description:e.description,domain:"health",owners:["platform.integrations"],tags:["health","wearables",...e.tags],stability:e.stability??g.Experimental},supportedModes:e.supportedModes??["managed","byok"],transports:e.transports??d,preferredTransport:"rest",supportedAuthMethods:t,capabilities:{provides:e.capabilities??[...l]},configSchema:{schema:{type:"object",properties:{apiBaseUrl:{type:"string",description:"Optional API base URL override for provider-specific regional or partner endpoints."},mcpUrl:{type:"string",description:"Optional MCP endpoint URL for provider tool transport."},oauthTokenUrl:{type:"string",description:"Optional OAuth token endpoint override used for access-token refresh flows."},defaultTransport:{type:"string",enum:[...o],description:"Preferred transport strategy used before fallbacks are attempted."},strategyOrder:{type:"array",items:{type:"string",enum:[...o]},description:"Ordered transport fallback strategy. Defaults to official API -> official MCP -> aggregator API -> aggregator MCP -> unofficial."},allowUnofficial:{type:"boolean",description:"Must be true to allow unofficial/automation connectors as fallback."},unofficialAllowList:{type:"array",items:{type:"string"},description:"Optional allowlist of provider keys allowed to use unofficial connectors."}}},example:{defaultTransport:e.defaultTransport??"official-api",strategyOrder:[...o],allowUnofficial:!1,unofficialAllowList:[]}},secretSchema:{schema:{type:"object",properties:{apiKey:{type:"string"},accessToken:{type:"string"},refreshToken:{type:"string"},tokenExpiresAt:{type:"string"},clientId:{type:"string"},clientSecret:{type:"string"},mcpAccessToken:{type:"string"},username:{type:"string"},password:{type:"string"}}},example:{apiKey:"provider-api-key",accessToken:"oauth-access-token",refreshToken:"oauth-refresh-token"}},healthCheck:{method:"list",timeoutMs:1e4},docsUrl:e.docsUrl,byokSetup:{setupInstructions:e.byokSetupInstructions??"Create provider credentials, set allowed scopes, and store credentials in secret provider.",requiredScopes:e.byokScopes,keyRotationSupported:!1,quotaTrackingSupported:!1}})}function y(e){if(e.oauthTokenUrl){let t=e.oauthTokenUrl;return n.map((r)=>{if(r.type==="oauth2")return{...r,tokenUrl:t,scopes:e.byokScopes??[]};return r})}return[...n]}var f=a({key:"health.strava",title:"Strava",description:"Strava integration for activities, workouts, and athlete biometrics.",docsUrl:"https://developers.strava.com/",tags:["strava","official-api"],byokScopes:["read","activity:read_all"]});function T(e){return e.register(f)}export{T as registerStravaIntegration,f as stravaIntegrationSpec};

package/dist/integrations/providers/stripe.d.ts

@@ -0,0 +1,3 @@
+import { IntegrationSpecRegistry } from '../spec.js';
+export declare const stripeIntegrationSpec: import("..").IntegrationSpec;
+export declare function registerStripeIntegration(registry: IntegrationSpecRegistry): IntegrationSpecRegistry;

package/dist/integrations/providers/stripe.js

@@ -0,0 +1,2 @@
+// @bun
+import{StabilityEnum as a}from"@lssm/lib.contracts-spec/ownership";import{SpecContractRegistry as n}from"@lssm/lib.contracts-spec/registry";var i=(e)=>`${e.key}.v${e.version}`;class o extends n{constructor(e){super("integration",e)}getByCategory(e){return this.list().filter((r)=>r.meta.category===e)}}function c(e){return i(e)}var t=(e)=>e;var s=t({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:a.Stable},supportedModes:["managed","byok"],transports:[{type:"rest",baseUrl:"https://api.stripe.com",apiVersionHeader:"Stripe-Version"},{type:"webhook",inbound:{signatureHeader:"stripe-signature",signingAlgorithm:"hmac-sha256"}},{type:"sdk",packageName:"stripe",minVersion:"14.0.0"}],preferredTransport:"rest",supportedAuthMethods:[{type:"api-key",headerName:"Authorization",prefix:"Bearer "},{type:"oauth2",grantType:"authorization_code",authorizationUrl:"https://connect.stripe.com/oauth/authorize",tokenUrl:"https://connect.stripe.com/oauth/token",scopes:["read_write"]},{type:"webhook-signing",algorithm:"hmac-sha256",signatureHeader:"stripe-signature"}],versionPolicy:{currentVersion:"2026-07-29.dahlia",supportedVersions:[{version:"2026-07-29.dahlia",status:"stable"}],versionHeader:"Stripe-Version"},capabilities:{provides:[{key:"payments.psp",version:"1.0.0"},{key:"payments.customers",version:"1.0.0"},{key:"payments.payment-methods",version:"1.0.0"},{key:"payments.checkout",version:"1.0.0"},{key:"payments.subscriptions",version:"1.0.0"},{key:"payments.invoices",version:"1.0.0"},{key:"payments.disputes",version:"1.0.0"},{key:"payments.payouts",version:"1.0.0"},{key:"payments.marketplace",version:"1.0.0"},{key:"payments.webhooks",version:"1.0.0"}],requires:[{key:"platform.webhooks",optional:!0,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"],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. Provide a webhook signing secret when inbound events are enabled.",requiredScopes:["charges:write","customers:read"],keyRotationSupported:!0,quotaTrackingSupported:!1}});function h(e){return e.register(s)}export{h as registerStripeIntegration,s as stripeIntegrationSpec};

package/dist/integrations/providers/supabase-postgres.d.ts

@@ -0,0 +1,3 @@
+import { IntegrationSpecRegistry } from '../spec.js';
+export declare const supabasePostgresIntegrationSpec: import("..").IntegrationSpec;
+export declare function registerSupabasePostgresIntegration(registry: IntegrationSpecRegistry): IntegrationSpecRegistry;

package/dist/integrations/providers/supabase-postgres.js

@@ -0,0 +1,2 @@
+// @bun
+import{StabilityEnum as i}from"@lssm/lib.contracts-spec/ownership";import{SpecContractRegistry as n}from"@lssm/lib.contracts-spec/registry";var a=(e)=>`${e.key}.v${e.version}`;class o extends n{constructor(e){super("integration",e)}getByCategory(e){return this.list().filter((r)=>r.meta.category===e)}}function g(e){return a(e)}var t=(e)=>e;var s=t({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:i.Beta},supportedModes:["managed","byok"],transports:[{type:"rest"},{type:"sdk",packageName:"@supabase/supabase-js"}],preferredTransport:"rest",supportedAuthMethods:[{type:"api-key"},{type:"basic"}],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.",keyRotationSupported:!0,quotaTrackingSupported:!1}});function l(e){return e.register(s)}export{l as registerSupabasePostgresIntegration,s as supabasePostgresIntegrationSpec};

package/dist/integrations/providers/supabase-vector.d.ts

@@ -0,0 +1,3 @@
+import { IntegrationSpecRegistry } from '../spec.js';
+export declare const supabaseVectorIntegrationSpec: import("..").IntegrationSpec;
+export declare function registerSupabaseVectorIntegration(registry: IntegrationSpecRegistry): IntegrationSpecRegistry;

package/dist/integrations/providers/supabase-vector.js

@@ -0,0 +1,2 @@
+// @bun
+import{StabilityEnum as o}from"@lssm/lib.contracts-spec/ownership";import{SpecContractRegistry as a}from"@lssm/lib.contracts-spec/registry";var n=(e)=>`${e.key}.v${e.version}`;class i extends a{constructor(e){super("integration",e)}getByCategory(e){return this.list().filter((r)=>r.meta.category===e)}}function c(e){return n(e)}var t=(e)=>e;var s=t({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:o.Beta},supportedModes:["managed","byok"],transports:[{type:"rest"},{type:"sdk",packageName:"@supabase/supabase-js"}],preferredTransport:"rest",supportedAuthMethods:[{type:"api-key"},{type:"bearer"}],capabilities:{provides:[{key:"vector-db.search",version:"1.0.0"},{key:"vector-db.storage",version:"1.0.0"}],requires:[{key:"ai.embeddings",optional:!0,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:!0,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.",keyRotationSupported:!0,quotaTrackingSupported:!1}});function u(e){return e.register(s)}export{u as registerSupabaseVectorIntegration,s as supabaseVectorIntegrationSpec};

package/dist/integrations/providers/tavily.d.ts

@@ -0,0 +1,8 @@
+import { IntegrationSpecRegistry } from '../spec.js';
+export declare const tavilyIntegrationSpec: import("..").IntegrationSpec;
+/**
+ * Additive web-access contract. The original 1.0.0 metadata remains available
+ * through `tavilyIntegrationSpec` for callers that pinned its transport set.
+ */
+export declare const tavilyIntegrationSpecV1_1: import("..").IntegrationSpec;
+export declare function registerTavilyIntegration(registry: IntegrationSpecRegistry): IntegrationSpecRegistry;

package/dist/integrations/providers/tavily.js

@@ -0,0 +1,2 @@
+// @bun
+import{StabilityEnum as m}from"@lssm/lib.contracts-spec/ownership";import{SpecContractRegistry as c}from"@lssm/lib.contracts-spec/registry";var g=(e)=>`${e.key}.v${e.version}`;class l extends c{constructor(e){super("integration",e)}getByCategory(e){return this.list().filter((t)=>t.meta.category===e)}}function f(e){return g(e)}var o=(e)=>e;function i({unsupportedModeReason:e,configFields:t,secretFields:a,rotationSupported:p=!1,setupSteps:n}){let r={mode:"byok",validationStrategy:"byok-lifecycle",rotation:{supported:p}};if(t)r.configFields=t;if(a)r.secretFields=a;if(n)r.setupSteps=n;return{modes:{byok:r},exempt:!0,exemptionReason:e}}import{StabilityEnum as d}from"@lssm/lib.contracts-spec/ownership";function s(e){return o({meta:{key:e.key,version:e.version??"1.0.0",category:"custom",title:e.title,description:e.description,domain:"knowledge",owners:["platform.ai"],tags:["web-access",...e.tags],stability:d.Experimental},supportedModes:["byok"],credentialManifest:i({unsupportedModeReason:"Managed credentials are not shipped; tenants must supply provider-owned credentials through a SecretProvider.",secretFields:e.secretFields.map((t)=>({key:t})),rotationSupported:!1}),transports:e.transports,preferredTransport:e.preferredTransport,supportedAuthMethods:e.auth,capabilities:{provides:e.capabilities.map((t)=>({key:t,version:"1.0.0"}))},configSchema:{schema:{type:"object",properties:{baseUrl:{type:"string"},policyMode:{type:"string",enum:["governed","provider-pass-through","public-only"]},...e.configProperties}}},secretSchema:{schema:{type:"object",properties:Object.fromEntries(e.secretFields.map((t)=>[t,{type:"string"}]))},example:Object.fromEntries(e.secretFields.map((t)=>[t,"***"]))},healthCheck:{method:"custom",timeoutMs:5000},docsUrl:e.docsUrl,byokSetup:{setupInstructions:"Resolve provider credentials at execution time through SecretProvider; never persist credentials in integration config.",keyRotationSupported:!1,quotaTrackingSupported:!0}})}var y=o({meta:{key:"web-research.tavily",version:"1.0.0",category:"custom",title:"Tavily Search, Extract, Crawl, and Research",description:"Tavily integration for real-time search, extraction, crawling, mapping, and research through API, SDK, MCP, and OAuth-enabled remote MCP.",domain:"knowledge",owners:["platform.ai"],tags:["search","extract","crawl","research","mcp","oauth"],stability:m.Experimental},supportedModes:["byok"],credentialManifest:i({unsupportedModeReason:"Managed Tavily credentials are not declared because Tavily API/MCP access is currently tenant-owned API-key or OAuth-token setup; ContractSpec does not provide a shared managed Tavily tenant.",secretFields:[{key:"apiKey"},{key:"mcpAccessToken"}],rotationSupported:!1}),transports:[{type:"sdk",packageName:"@tavily/core",runtime:"universal"},{type:"rest",baseUrl:"https://api.tavily.com"},{type:"mcp",transport:"http",url:"https://mcp.tavily.com/mcp/"},{type:"mcp",transport:"stdio",command:"npx",args:["-y","@tavily/mcp"]}],preferredTransport:"sdk",supportedAuthMethods:[{type:"bearer",tokenField:"apiKey"},{type:"oauth2",grantType:"authorization_code",tokenUrl:"https://mcp.tavily.com/token",authorizationUrl:"https://mcp.tavily.com/authorize",scopes:["openid","offline_access"],pkce:!0}],capabilities:{provides:[{key:"web.search",version:"1.0.0"},{key:"web.extract",version:"1.0.0"},{key:"web.crawl",version:"1.0.0"},{key:"web.research",version:"1.0.0"},{key:"provider.mcp.tavily",version:"1.0.0"}]},configSchema:{schema:{type:"object",properties:{projectId:{type:"string"},baseUrl:{type:"string"},mcpUrl:{type:"string"},defaultSearchDepth:{type:"string",enum:["basic","advanced"]}}},example:{baseUrl:"https://api.tavily.com",mcpUrl:"https://mcp.tavily.com/mcp/",defaultSearchDepth:"basic"}},secretSchema:{schema:{type:"object",properties:{apiKey:{type:"string",description:"Tavily API key."},mcpAccessToken:{type:"string",description:"OAuth access token for Tavily remote MCP."}}},example:{apiKey:"tvly-***",mcpAccessToken:"oauth_***"}},healthCheck:{method:"custom",timeoutMs:5000},docsUrl:"https://docs.tavily.com/",byokSetup:{setupInstructions:"Use @tavily/core for API calls when available. For MCP, connect to the remote MCP URL with OAuth discovery or API-key auth, or run @tavily/mcp locally.",requiredScopes:["openid","offline_access"],keyRotationSupported:!1,quotaTrackingSupported:!0}}),h=s({key:"web-research.tavily",version:"1.1.0",title:"Tavily Web Access",description:"Tavily Search, Extract, Map, Crawl, Research, polling, SSE streaming, SDK, and native MCP access.",tags:["search","extract","map","crawl","research","sse","mcp"],transports:[{type:"sdk",packageName:"@tavily/core",minVersion:"0.7.7",runtime:"universal"},{type:"rest",baseUrl:"https://api.tavily.com"},{type:"sse",url:"https://api.tavily.com/research",discoveryOperationKey:"web-access.tavily.research.stream",resumeHeader:"Last-Event-ID"},{type:"mcp",transport:"http",url:"https://mcp.tavily.com/mcp/",toolPrefix:"tavily"},{type:"mcp",transport:"stdio",command:"npx",args:["-y","@tavily/mcp"],toolPrefix:"tavily"},{type:"mcp",transport:"stdio",command:"npx",args:["-y","tavily-mcp"],toolPrefix:"tavily"}],preferredTransport:"sdk",auth:[{type:"bearer",tokenField:"apiKey"},{type:"oauth2",grantType:"authorization_code",tokenUrl:"https://mcp.tavily.com/token",authorizationUrl:"https://mcp.tavily.com/authorize",scopes:["openid","offline_access"],pkce:!0}],secretFields:["apiKey","mcpAccessToken"],capabilities:["web.search","web.extract","web.map","web.crawl","web.research","provider.mcp.tavily"],docsUrl:"https://docs.tavily.com/documentation/api-reference/introduction"});function R(e){return e.register(y).register(h)}export{R as registerTavilyIntegration,y as tavilyIntegrationSpec,h as tavilyIntegrationSpecV1_1};

package/dist/integrations/providers/tldv.d.ts

@@ -0,0 +1,3 @@
+import { IntegrationSpecRegistry } from '../spec.js';
+export declare const tldvIntegrationSpec: import("..").IntegrationSpec;
+export declare function registerTldvIntegration(registry: IntegrationSpecRegistry): IntegrationSpecRegistry;

package/dist/integrations/providers/tldv.js

@@ -0,0 +1,2 @@
+// @bun
+import{StabilityEnum as c}from"@lssm/lib.contracts-spec/ownership";import{SpecContractRegistry as p}from"@lssm/lib.contracts-spec/registry";var g=(e)=>`${e.key}.v${e.version}`;class d extends p{constructor(e){super("integration",e)}getByCategory(e){return this.list().filter((t)=>t.meta.category===e)}}function m(e){return g(e)}var o=(e)=>e;function a({unsupportedModeReason:e,configFields:t,secretFields:n,rotationSupported:s=!1,setupSteps:i}){let r={mode:"byok",validationStrategy:"byok-lifecycle",rotation:{supported:s}};if(t)r.configFields=t;if(n)r.secretFields=n;if(i)r.setupSteps=i;return{modes:{byok:r},exempt:!0,exemptionReason:e}}var l=o({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:c.Experimental},supportedModes:["byok"],credentialManifest:a({unsupportedModeReason:"Managed tl;dv credentials are not declared because API and webhook access depend on tenant-owned tl;dv API keys and workspace configuration.",secretFields:[{key:"apiKey",required:!0},{key:"webhookSecret"}],rotationSupported:!1}),transports:[{type:"rest"},{type:"webhook",inbound:{signatureHeader:"x-tldv-signature",signingAlgorithm:"hmac-sha256"}}],preferredTransport:"rest",supportedAuthMethods:[{type:"api-key"},{type:"webhook-signing",algorithm:"hmac-sha256",signatureHeader:"x-tldv-signature"}],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.",keyRotationSupported:!1,quotaTrackingSupported:!1}});function v(e){return e.register(l)}export{v as registerTldvIntegration,l as tldvIntegrationSpec};

package/dist/integrations/providers/twilio-sms.d.ts

@@ -0,0 +1,3 @@
+import { IntegrationSpecRegistry } from '../spec.js';
+export declare const twilioSmsIntegrationSpec: import("..").IntegrationSpec;
+export declare function registerTwilioSmsIntegration(registry: IntegrationSpecRegistry): IntegrationSpecRegistry;

package/dist/integrations/providers/twilio-sms.js

@@ -0,0 +1,2 @@
+// @bun
+import{StabilityEnum as a}from"@lssm/lib.contracts-spec/ownership";import{SpecContractRegistry as r}from"@lssm/lib.contracts-spec/registry";var n=(t)=>`${t.key}.v${t.version}`;class o extends r{constructor(t){super("integration",t)}getByCategory(t){return this.list().filter((i)=>i.meta.category===t)}}function g(t){return n(t)}var e=(t)=>t;var s=e({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:a.Stable},supportedModes:["managed","byok"],transports:[{type:"rest",baseUrl:"https://api.twilio.com"},{type:"webhook",inbound:{signatureHeader:"x-twilio-signature",signingAlgorithm:"hmac-sha1"}},{type:"sdk",packageName:"twilio",minVersion:"5.0.0"}],preferredTransport:"rest",supportedAuthMethods:[{type:"basic"}],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.",keyRotationSupported:!0,quotaTrackingSupported:!1}});function l(t){return t.register(s)}export{l as registerTwilioSmsIntegration,s as twilioSmsIntegrationSpec};

package/dist/integrations/providers/vector-store.d.ts

@@ -0,0 +1,39 @@
+import type { EmbeddingVector } from './embedding.js';
+export interface VectorDocument {
+    id: string;
+    vector: EmbeddingVector;
+    payload?: Record<string, unknown>;
+    namespace?: string;
+    expiresAt?: Date;
+}
+export interface VectorUpsertRequest {
+    collection: string;
+    documents: VectorDocument[];
+    waitForSync?: boolean;
+}
+export interface VectorDeleteRequest {
+    collection: string;
+    ids: string[];
+    namespace?: string;
+}
+export interface VectorSearchQuery {
+    collection: string;
+    vector: EmbeddingVector;
+    topK: number;
+    namespace?: string;
+    filter?: Record<string, unknown>;
+    scoreThreshold?: number;
+    consistent?: boolean;
+}
+export interface VectorSearchResult {
+    id: string;
+    score: number;
+    payload?: Record<string, unknown>;
+    vector?: EmbeddingVector;
+    namespace?: string;
+}
+export interface VectorStoreProvider {
+    upsert(request: VectorUpsertRequest): Promise<void>;
+    search(query: VectorSearchQuery): Promise<VectorSearchResult[]>;
+    delete(request: VectorDeleteRequest): Promise<void>;
+}

package/dist/integrations/providers/vector-store.js

@@ -0,0 +1 @@
+// @bun

package/dist/integrations/providers/video.d.ts

@@ -0,0 +1,181 @@
+import type { VoiceTimingMap } from './voice-video-sync.js';
+export interface VideoFormatLandscape {
+    type: 'landscape';
+    width: 1920;
+    height: 1080;
+}
+export interface VideoFormatPortrait {
+    type: 'portrait';
+    width: 1080;
+    height: 1920;
+}
+export interface VideoFormatSquare {
+    type: 'square';
+    width: 1080;
+    height: 1080;
+}
+export interface VideoFormatCustom {
+    type: 'custom';
+    width: number;
+    height: number;
+}
+export type VideoFormat = VideoFormatLandscape | VideoFormatPortrait | VideoFormatSquare | VideoFormatCustom;
+export declare const VIDEO_FORMATS: {
+    landscape: {
+        readonly type: 'landscape';
+        readonly width: 1920;
+        readonly height: 1080;
+    };
+    portrait: {
+        readonly type: 'portrait';
+        readonly width: 1080;
+        readonly height: 1920;
+    };
+    square: {
+        readonly type: 'square';
+        readonly width: 1080;
+        readonly height: 1080;
+    };
+};
+export interface NarrationConfig {
+    enabled: boolean;
+    voiceId?: string;
+    language?: string;
+    style?: 'professional' | 'casual' | 'technical';
+}
+export interface VideoStyleOverrides {
+    /** Override brand primary color */
+    primaryColor?: string;
+    /** Override brand accent color */
+    accentColor?: string;
+    /** Background color or gradient CSS value */
+    background?: string;
+    /** Font family override */
+    fontFamily?: string;
+    /** Show watermark / logo */
+    showBranding?: boolean;
+    /** Dark mode */
+    darkMode?: boolean;
+}
+export interface VideoScene {
+    id: string;
+    /** Maps to a registered Remotion composition ID */
+    compositionId: string;
+    /** Input props passed to the Remotion composition */
+    props: Record<string, unknown>;
+    /** Duration in frames */
+    durationInFrames: number;
+    /** Optional narration text for this scene */
+    narrationText?: string;
+    /** Transition to next scene */
+    transition?: SceneTransition;
+}
+export type SceneTransitionType = 'fade' | 'slide-left' | 'slide-right' | 'wipe' | 'none';
+export interface SceneTransition {
+    type: SceneTransitionType;
+    durationInFrames: number;
+}
+export interface AudioTrack {
+    /** Audio data as Uint8Array (e.g., from VoiceProvider) */
+    data?: Uint8Array;
+    /** Or a URL/path to the audio file */
+    src?: string;
+    format: 'mp3' | 'wav' | 'ogg';
+    durationSeconds: number;
+    /** Volume 0-1 */
+    volume?: number;
+}
+export interface VideoProject {
+    id: string;
+    /** The scenes composing this video in order */
+    scenes: VideoScene[];
+    /** Total duration across all scenes */
+    totalDurationInFrames: number;
+    fps: number;
+    /** Video dimensions */
+    format: VideoFormat;
+    /** Audio tracks */
+    audio?: {
+        narration?: AudioTrack;
+        backgroundMusic?: AudioTrack;
+    };
+    /** Metadata for the rendered file */
+    metadata?: VideoProjectMetadata;
+    /** VTT subtitles generated from voice narration */
+    subtitles?: string;
+    /** Voice timing map for per-scene audio sync */
+    voiceTimingMap?: VoiceTimingMap;
+    /** Generated thumbnail image */
+    thumbnail?: {
+        prompt: string;
+        imageUrl?: string;
+    };
+}
+export interface VideoProjectMetadata {
+    title?: string;
+    description?: string;
+    tags?: string[];
+    createdAt?: string;
+}
+export type VideoCodec = 'h264' | 'h265' | 'vp8' | 'vp9';
+export type VideoOutputFormat = 'mp4' | 'webm' | 'gif';
+export interface RenderConfig {
+    /** Output codec */
+    codec?: VideoCodec;
+    /** Output container format */
+    outputFormat?: VideoOutputFormat;
+    /** Constant Rate Factor (quality). Lower = better. Default 18. */
+    crf?: number;
+    /** Output file path */
+    outputPath: string;
+    /** Generate additional format variants (square, portrait) */
+    autoVariants?: boolean;
+    /** Pixel format. Default 'yuv420p'. */
+    pixelFormat?: string;
+    /** Number of rendering threads. Default: CPU count. */
+    concurrency?: number;
+}
+export interface RenderResult {
+    outputPath: string;
+    format: VideoOutputFormat;
+    codec: VideoCodec;
+    durationSeconds: number;
+    fileSizeBytes: number;
+    dimensions: {
+        width: number;
+        height: number;
+    };
+    /** Additional format variants if autoVariants was true */
+    variants?: RenderResult[];
+}
+export interface VideoProvider {
+    /**
+     * Render a video project to a file.
+     * Implementations may use local Remotion renderer, Lambda, Cloud Run, etc.
+     */
+    render(project: VideoProject, config: RenderConfig): Promise<RenderResult>;
+    /**
+     * Get a still frame from a composition (useful for thumbnails).
+     */
+    renderStill?(compositionId: string, props: Record<string, unknown>, frame: number, format: VideoFormat): Promise<Uint8Array>;
+}
+export interface CompositionMeta {
+    id: string;
+    displayName: string;
+    description: string;
+    /** Default duration in frames */
+    defaultDurationInFrames: number;
+    fps: number;
+    /** Default dimensions */
+    defaultFormat: VideoFormat;
+    /** Schema of expected input props (for validation / UI generation) */
+    propsSchema?: Record<string, unknown>;
+    /** Tags for categorization */
+    tags?: string[];
+}
+export interface CompositionRegistry {
+    register(meta: CompositionMeta): void;
+    get(id: string): CompositionMeta | undefined;
+    list(): CompositionMeta[];
+    listByTag(tag: string): CompositionMeta[];
+}

package/dist/integrations/providers/video.js

@@ -0,0 +1,2 @@
+// @bun
+var e={landscape:{type:"landscape",width:1920,height:1080},portrait:{type:"portrait",width:1080,height:1920},square:{type:"square",width:1080,height:1080}};export{e as VIDEO_FORMATS};

package/dist/integrations/providers/voice-video-sync.d.ts

@@ -0,0 +1,29 @@
+import type { WordTiming } from './voice.js';
+/**
+ * Timing map produced by voice/tts, consumed by video-gen.
+ * Video-gen uses this to adjust scene durations to match voice.
+ */
+export interface VoiceTimingMap {
+    totalDurationMs: number;
+    segments: VoiceSegmentTiming[];
+    fps: number;
+}
+export interface VoiceSegmentTiming {
+    /** Matches a sceneId from video-gen's ScenePlan */
+    sceneId: string;
+    /** Voice audio duration for this segment in ms */
+    durationMs: number;
+    /** Equivalent duration in frames */
+    durationInFrames: number;
+    /** Recommended scene duration (voice + breathing room) */
+    recommendedSceneDurationInFrames: number;
+    wordTimings?: WordTiming[];
+}
+export interface VoicePacingDirective {
+    sceneId: string;
+    rate: number;
+    emphasis: 'reduced' | 'normal' | 'strong';
+    tone: 'neutral' | 'urgent' | 'excited' | 'calm' | 'authoritative';
+    leadingSilenceMs: number;
+    trailingSilenceMs: number;
+}

package/dist/integrations/providers/voice-video-sync.js

@@ -0,0 +1 @@
+// @bun

package/dist/integrations/providers/voice.d.ts

@@ -0,0 +1,180 @@
+export interface Voice {
+    id: string;
+    name: string;
+    description?: string;
+    language?: string;
+    gender?: 'male' | 'female' | 'neutral';
+    previewUrl?: string;
+    capabilities?: ('tts' | 'conversational')[];
+    metadata?: Record<string, string>;
+}
+export type AudioFormat = 'mp3' | 'wav' | 'ogg' | 'pcm' | 'opus';
+export interface AudioData {
+    data: Uint8Array;
+    format: AudioFormat;
+    sampleRateHz: number;
+    durationMs?: number;
+    channels?: 1 | 2;
+}
+export interface WordTiming {
+    word: string;
+    startMs: number;
+    endMs: number;
+    confidence?: number;
+}
+export interface TTSSynthesisInput {
+    text: string;
+    voiceId: string;
+    language?: string;
+    format?: AudioFormat;
+    sampleRateHz?: number;
+    /** Speech rate multiplier (0.5-2.0). Default 1.0 */
+    rate?: number;
+    /** Pitch adjustment in semitones (-12 to +12). Default 0 */
+    pitch?: number;
+    /** Emphasis level */
+    emphasis?: 'reduced' | 'normal' | 'strong';
+    /** Style (0-1, provider-specific) */
+    style?: number;
+    /** Stability (0-1, provider-specific) */
+    stability?: number;
+    /** SSML markup. Overrides text if set. */
+    ssml?: string;
+    metadata?: Record<string, string>;
+}
+export interface TTSSynthesisResult {
+    audio: AudioData;
+    wordTimings?: WordTiming[];
+    /** Provider may return revised/normalized text */
+    normalizedText?: string;
+}
+export interface TTSProvider {
+    synthesize(input: TTSSynthesisInput): Promise<TTSSynthesisResult>;
+    listVoices(): Promise<Voice[]>;
+}
+export interface STTRequestOptions {
+    language?: string;
+    diarize?: boolean;
+    speakerCount?: number;
+    wordTimestamps?: boolean;
+    timestampGranularities?: ('segment' | 'word')[];
+    vocabularyHints?: string[];
+    model?: string;
+    metadata?: Record<string, string>;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+/** Encoded media containers carry their own sample rate; callers must not invent one. */
+export interface STTMediaTranscriptionInput extends STTRequestOptions {
+    media: {
+        data: Uint8Array | Blob;
+        mediaType: 'audio/mpeg' | 'audio/wav' | 'audio/ogg' | 'audio/webm' | 'audio/mp4' | 'audio/flac';
+        durationMs?: number;
+    };
+}
+export interface STTTranscriptionInput extends STTRequestOptions {
+    audio: AudioData;
+}
+export interface TranscriptionSegment {
+    text: string;
+    startMs: number;
+    endMs: number;
+    speakerId?: string;
+    speakerName?: string;
+    confidence?: number;
+    wordTimings?: WordTiming[];
+}
+export interface STTTranscriptionResult {
+    /** Actual provider model identifier when returned. */
+    model?: string;
+    text: string;
+    segments: TranscriptionSegment[];
+    language: string;
+    durationMs: number;
+    speakers?: {
+        id: string;
+        name?: string;
+    }[];
+    wordTimings?: WordTiming[];
+}
+export interface STTProvider {
+    /** Optional encoded-media support; consumers must check capability explicitly. */
+    transcribeMedia?(input: STTMediaTranscriptionInput): Promise<STTTranscriptionResult>;
+    transcribe(input: STTTranscriptionInput): Promise<STTTranscriptionResult>;
+    /** Stream transcription (real-time audio input) */
+    transcribeStream?(audio: AsyncIterable<Uint8Array>, options?: Omit<STTTranscriptionInput, 'audio'>): AsyncIterable<TranscriptionSegment>;
+}
+export interface ConversationalSessionConfig {
+    voiceId: string;
+    language?: string;
+    systemPrompt?: string;
+    /** LLM model for response generation */
+    llmModel?: string;
+    /** Audio input format */
+    inputFormat?: AudioFormat;
+    /** Audio output format */
+    outputFormat?: AudioFormat;
+    /** Turn detection mode */
+    turnDetection?: 'server_vad' | 'push_to_talk';
+    /** Silence threshold in ms to detect end of turn */
+    silenceThresholdMs?: number;
+    /** Maximum session duration in seconds */
+    maxDurationSeconds?: number;
+    metadata?: Record<string, string>;
+}
+export type ConversationalEvent = {
+    type: 'session_started';
+    sessionId: string;
+} | {
+    type: 'user_speech_started';
+} | {
+    type: 'user_speech_ended';
+    transcript: string;
+} | {
+    type: 'agent_speech_started';
+    text: string;
+} | {
+    type: 'agent_audio';
+    audio: Uint8Array;
+} | {
+    type: 'agent_speech_ended';
+} | {
+    type: 'transcript';
+    role: 'user' | 'agent';
+    text: string;
+    timestamp: number;
+} | {
+    type: 'error';
+    error: Error;
+} | {
+    type: 'session_ended';
+    reason: string;
+    durationMs: number;
+};
+export interface ConversationalSession {
+    /** Send audio chunk from user */
+    sendAudio(chunk: Uint8Array): void;
+    /** Send text input (bypass STT) */
+    sendText(text: string): void;
+    /** Interrupt the agent's current speech */
+    interrupt(): void;
+    /** End the session */
+    close(): Promise<ConversationalSessionSummary>;
+    /** Event stream */
+    events: AsyncIterable<ConversationalEvent>;
+}
+export interface ConversationalSessionSummary {
+    sessionId: string;
+    durationMs: number;
+    turns: {
+        role: 'user' | 'agent';
+        text: string;
+        startMs: number;
+        endMs: number;
+    }[];
+    transcript: string;
+}
+export interface ConversationalProvider {
+    startSession(config: ConversationalSessionConfig): Promise<ConversationalSession>;
+    listVoices(): Promise<Voice[]>;
+}

package/dist/integrations/providers/voice.js

@@ -0,0 +1 @@
+// @bun

package/dist/integrations/providers/web-access-shared.d.ts

@@ -0,0 +1,18 @@
+import type { IntegrationAuthConfig } from '../auth.js';
+import { type IntegrationSpec } from '../spec.js';
+import type { IntegrationTransportConfig } from '../transport.js';
+export interface WebAccessIntegrationSpecInput {
+    key: string;
+    version?: string;
+    title: string;
+    description: string;
+    tags: string[];
+    transports: IntegrationTransportConfig[];
+    preferredTransport: IntegrationSpec['preferredTransport'];
+    auth: IntegrationAuthConfig[];
+    secretFields: string[];
+    capabilities: string[];
+    docsUrl: string;
+    configProperties?: Record<string, unknown>;
+}
+export declare function makeWebAccessIntegrationSpec(input: WebAccessIntegrationSpecInput): IntegrationSpec;