@vly-ai/integrations 0.5.2

package/README.md

@@ -0,0 +1,245 @@
+# vly-integrations
+
+First-order integrations for AI, email, and payments with automatic usage billing through Vly deployment tokens. Built on the AI SDK for reliable, type-safe AI Gateway integration.
+
+## Installation
+
+```bash
+npm install vly-integrations
+# or
+yarn add vly-integrations
+# or
+pnpm add vly-integrations
+```
+
+No additional dependencies required! Built with fetch and AI SDK.
+
+## Usage
+
+```typescript
+import { createVlyIntegrations } from 'vly-integrations';
+
+const vly = createVlyIntegrations({
+  deploymentToken: process.env.VLY_INTEGRATION_KEY,  // Uses VLY_INTEGRATION_KEY env var
+  debug: false // optional
+});
+
+// AI Completions via AI Gateway - supports any Vercel AI Gateway model
+const completion = await vly.ai.completion({
+  model: 'gpt-5', // Or any model supported by Vercel AI Gateway
+  messages: [
+    { role: 'system', content: 'You are a helpful assistant.' },
+    { role: 'user', content: 'Hello!' }
+  ],
+  temperature: 0.7,
+  maxTokens: 150
+});
+
+// Streaming completions
+await vly.ai.streamCompletion({
+  model: 'claude-opus-4-1',
+  messages: [{ role: 'user', content: 'Tell me a story...' }]
+}, (chunk) => {
+  process.stdout.write(chunk); // Real-time streaming
+});
+
+// Send Email
+const emailResult = await vly.email.send({
+  to: 'user@example.com',
+  subject: 'Welcome!',
+  html: '<h1>Welcome to our service!</h1>',
+  text: 'Welcome to our service!'
+});
+
+// Create Payment Intent
+const paymentIntent = await vly.payments.createPaymentIntent({
+  amount: 2000, // $20.00 in cents
+  currency: 'usd',
+  description: 'Premium subscription',
+  customer: {
+    email: 'customer@example.com'
+  }
+});
+```
+
+## AI Gateway Integration
+
+Powered by the AI SDK with OpenAI-compatible provider for https://ai-gateway.vly.ai
+
+### Supported Models
+
+The vly-integrations package supports **all models available through the Vercel AI Gateway**. This includes but is not limited to:
+
+- **OpenAI Models**: GPT-5, GPT-5 Mini, GPT-5 Nano, GPT-4, GPT-3.5, etc.
+- **Anthropic Claude**: Claude 4 Opus, Claude 4 Sonnet, Claude 3.7, Claude 3.5, Haiku, etc.
+- **Google Models**: Gemini Pro, Gemini Flash, Gemini Ultra, etc.
+- **Meta Models**: Llama models and variants
+- **Mistral Models**: Mistral Large, Medium, Small, etc.
+- **DeepSeek Models**: DeepSeek R1, DeepSeek Thinking, DeepSeek Coder, etc.
+- **Qwen Models**: Qwen Coder and other variants
+- **And many more...**
+
+Simply pass any model identifier supported by the Vercel AI Gateway to the `model` parameter.
+
+### Direct AI SDK Access
+
+For advanced usage, access the AI SDK provider directly:
+
+```typescript
+import { generateText, streamText } from 'ai';
+
+// Get the provider
+const provider = vly.ai.getProvider();
+const model = provider('gpt-5');
+
+// Use with AI SDK directly
+const result = await generateText({
+  model,
+  messages: [{ role: 'user', content: 'Hello!' }]
+});
+
+// Or streaming
+const stream = await streamText({
+  model,
+  messages: [{ role: 'user', content: 'Tell me a story' }]
+});
+
+for await (const delta of stream.textStream) {
+  process.stdout.write(delta);
+}
+```
+
+## API Reference
+
+### AI Integration
+
+```typescript
+// Create completion
+vly.ai.completion(request: AICompletionRequest): Promise<ApiResponse<AICompletionResponse>>
+
+// Stream completion
+vly.ai.streamCompletion(
+  request: AICompletionRequest,
+  onChunk: (chunk: string) => void
+): Promise<ApiResponse<AICompletionResponse>>
+
+// Get AI SDK provider for direct usage
+vly.ai.getProvider(): OpenAICompatibleProvider
+
+// Generate embeddings (limited support)
+vly.ai.embeddings(input: string | string[]): Promise<ApiResponse<{embeddings: number[][]}>>
+```
+
+### Email Integration
+
+```typescript
+// Send single email
+vly.email.send(email: EmailRequest): Promise<ApiResponse<EmailResponse>>
+
+// Send batch emails
+vly.email.sendBatch(emails: EmailRequest[]): Promise<ApiResponse<EmailResponse[]>>
+
+// Get email status
+vly.email.getStatus(emailId: string): Promise<ApiResponse<EmailResponse>>
+
+// Domain management
+vly.email.verifyDomain(domain: string): Promise<ApiResponse>
+vly.email.listDomains(): Promise<ApiResponse>
+```
+
+### Payments Integration
+
+```typescript
+// Payment Intents
+vly.payments.createPaymentIntent(intent: PaymentIntent): Promise<ApiResponse<PaymentIntentResponse>>
+vly.payments.confirmPaymentIntent(intentId: string, paymentMethodId: string): Promise<ApiResponse>
+vly.payments.getPaymentIntent(intentId: string): Promise<ApiResponse>
+vly.payments.cancelPaymentIntent(intentId: string): Promise<ApiResponse>
+
+// Subscriptions
+vly.payments.createSubscription(subscription: Subscription): Promise<ApiResponse<SubscriptionResponse>>
+vly.payments.updateSubscription(id: string, updates: Partial<Subscription>): Promise<ApiResponse>
+vly.payments.cancelSubscription(id: string, immediately?: boolean): Promise<ApiResponse>
+vly.payments.getSubscription(id: string): Promise<ApiResponse>
+vly.payments.listSubscriptions(customerId?: string): Promise<ApiResponse>
+
+// Checkout & Portal
+vly.payments.createCheckoutSession(session: CheckoutSession): Promise<ApiResponse>
+vly.payments.createCustomerPortal(session: CustomerPortalSession): Promise<ApiResponse>
+
+// Customer Management
+vly.payments.createCustomer(customer: Customer): Promise<ApiResponse>
+vly.payments.getCustomer(customerId: string): Promise<ApiResponse>
+vly.payments.updateCustomer(customerId: string, updates: CustomerUpdate): Promise<ApiResponse>
+
+// Payment Methods
+vly.payments.listPaymentMethods(customerId: string): Promise<ApiResponse>
+vly.payments.attachPaymentMethod(methodId: string, customerId: string): Promise<ApiResponse>
+vly.payments.detachPaymentMethod(methodId: string): Promise<ApiResponse>
+```
+
+## Error Handling
+
+All methods return an `ApiResponse` object with the following structure:
+
+```typescript
+interface ApiResponse<T> {
+  success: boolean;
+  data?: T;
+  error?: string;
+  usage?: {
+    credits: number;
+    operation: string;
+  };
+}
+```
+
+Example error handling:
+
+```typescript
+const result = await vly.ai.completion({ ... });
+
+if (result.success) {
+  console.log('Response:', result.data);
+  console.log('Credits used:', result.usage?.credits);
+} else {
+  console.error('Error:', result.error);
+}
+```
+
+## Configuration
+
+### Environment Variables
+
+```bash
+VLY_INTEGRATION_KEY=your_integration_key_here  # The key for authenticating with VLY
+VLY_DEBUG=true  # optional, enables debug logging
+```
+
+### Debug Mode
+
+Enable debug mode to see detailed logs:
+
+```typescript
+const vly = createVlyIntegrations({
+  deploymentToken: process.env.VLY_INTEGRATION_KEY,  // Note: parameter is 'deploymentToken' but env var is 'VLY_INTEGRATION_KEY'
+  debug: true
+});
+```
+
+## What's New in v0.2.0
+
+- ✅ **AI SDK Integration**: Now powered by `@ai-sdk/openai-compatible` for better reliability
+- ✅ **No more axios**: Replaced with built-in fetch for lighter weight
+- ✅ **New AI models**: Support for GPT-5, Claude 4, and Claude 3.7 models
+- ✅ **Direct AI SDK access**: Get the provider for advanced AI SDK usage
+- ✅ **Better streaming**: Improved streaming support with AI SDK
+- ✅ **Type safety**: Enhanced TypeScript support
+
+## Billing
+
+All API calls are automatically billed to your deployment based on usage. The billing happens transparently through your deployment token, and usage information is included in the API responses.
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,253 @@
+import * as _ai_sdk_openai_compatible from '@ai-sdk/openai-compatible';
+export { CoreMessage } from 'ai';
+
+interface VlyConfig {
+    deploymentToken: string;
+    debug?: boolean;
+}
+interface RequestOptions {
+    timeout?: number;
+    retries?: number;
+}
+interface ApiResponse<T = any> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    usage?: {
+        credits: number;
+        operation: string;
+    };
+}
+type AIModel = string;
+interface AICompletionRequest {
+    model?: AIModel;
+    messages: Array<{
+        role: 'system' | 'user' | 'assistant';
+        content: string;
+    }>;
+    temperature?: number;
+    maxTokens?: number;
+    stream?: boolean;
+}
+interface AICompletionResponse {
+    id: string;
+    choices: Array<{
+        message: {
+            role: string;
+            content: string;
+        };
+        finishReason: string;
+    }>;
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}
+interface EmailRequest {
+    to: string | string[];
+    from?: string;
+    subject: string;
+    html?: string;
+    text?: string;
+    attachments?: Array<{
+        filename: string;
+        content: string;
+        encoding?: string;
+    }>;
+    replyTo?: string;
+    cc?: string | string[];
+    bcc?: string | string[];
+}
+interface EmailResponse {
+    id: string;
+    status: 'sent' | 'queued' | 'failed';
+    messageId?: string;
+    error?: string;
+}
+interface PaymentIntent {
+    amount: number;
+    currency?: string;
+    description?: string;
+    metadata?: Record<string, any>;
+    customer?: {
+        email?: string;
+        name?: string;
+        id?: string;
+    };
+}
+interface PaymentIntentResponse {
+    id: string;
+    clientSecret: string;
+    amount: number;
+    currency: string;
+    status: 'requires_payment_method' | 'requires_confirmation' | 'succeeded' | 'processing' | 'canceled';
+    paymentMethodTypes: string[];
+}
+interface Subscription {
+    customerId: string;
+    priceId: string;
+    metadata?: Record<string, any>;
+    trialPeriodDays?: number;
+    cancelAtPeriodEnd?: boolean;
+}
+interface SubscriptionResponse {
+    id: string;
+    customerId: string;
+    status: 'active' | 'past_due' | 'canceled' | 'incomplete' | 'trialing';
+    currentPeriodEnd: string;
+    items: Array<{
+        id: string;
+        priceId: string;
+        quantity: number;
+    }>;
+}
+interface CustomerPortalSession {
+    customerId: string;
+    returnUrl?: string;
+}
+interface CustomerPortalResponse {
+    id: string;
+    url: string;
+    returnUrl?: string;
+    created: number;
+}
+
+declare class VlyAI {
+    private provider;
+    private config;
+    constructor(config: VlyConfig);
+    private getModel;
+    private mapMessages;
+    completion(request: AICompletionRequest, _options?: RequestOptions): Promise<ApiResponse<AICompletionResponse>>;
+    streamCompletion(request: AICompletionRequest, onChunk: (chunk: string) => void, _options?: RequestOptions): Promise<ApiResponse<AICompletionResponse>>;
+    embeddings(input: string | string[], _options?: RequestOptions & {
+        model?: string;
+    }): Promise<ApiResponse<{
+        embeddings: number[][];
+        usage: any;
+    }>>;
+    getProvider(): _ai_sdk_openai_compatible.OpenAICompatibleProvider<string, string, string, string>;
+}
+
+declare class VlyClient {
+    protected config: Required<VlyConfig>;
+    constructor(config: VlyConfig);
+    protected request<T = any>(endpoint: string, method: 'GET' | 'POST' | 'PUT' | 'DELETE', data?: any, options?: RequestOptions): Promise<ApiResponse<T>>;
+    protected log(message: string, data?: any): void;
+}
+
+declare class VlyEmail extends VlyClient {
+    send(email: EmailRequest, options?: RequestOptions): Promise<ApiResponse<EmailResponse>>;
+    sendBatch(emails: EmailRequest[], options?: RequestOptions): Promise<ApiResponse<EmailResponse[]>>;
+    getStatus(emailId: string, options?: RequestOptions): Promise<ApiResponse<EmailResponse>>;
+    verifyDomain(domain: string, options?: RequestOptions): Promise<ApiResponse<{
+        domain: string;
+        verified: boolean;
+        dnsRecords: Array<{
+            type: string;
+            name: string;
+            value: string;
+            verified: boolean;
+        }>;
+    }>>;
+    listDomains(options?: RequestOptions): Promise<ApiResponse<Array<{
+        domain: string;
+        verified: boolean;
+        createdAt: string;
+        verifiedAt?: string;
+    }>>>;
+}
+
+declare class VlyPayments extends VlyClient {
+    createPaymentIntent(intent: PaymentIntent, options?: RequestOptions): Promise<ApiResponse<PaymentIntentResponse>>;
+    confirmPaymentIntent(intentId: string, paymentMethodId: string, options?: RequestOptions): Promise<ApiResponse<PaymentIntentResponse>>;
+    getPaymentIntent(intentId: string, options?: RequestOptions): Promise<ApiResponse<PaymentIntentResponse>>;
+    cancelPaymentIntent(intentId: string, options?: RequestOptions): Promise<ApiResponse<PaymentIntentResponse>>;
+    createSubscription(subscription: Subscription, options?: RequestOptions): Promise<ApiResponse<SubscriptionResponse>>;
+    updateSubscription(subscriptionId: string, updates: Partial<Subscription>, options?: RequestOptions): Promise<ApiResponse<SubscriptionResponse>>;
+    cancelSubscription(subscriptionId: string, immediately?: boolean, options?: RequestOptions): Promise<ApiResponse<SubscriptionResponse>>;
+    getSubscription(subscriptionId: string, options?: RequestOptions): Promise<ApiResponse<SubscriptionResponse>>;
+    listSubscriptions(customerId?: string, options?: RequestOptions & {
+        limit?: number;
+        offset?: number;
+    }): Promise<ApiResponse<{
+        subscriptions: SubscriptionResponse[];
+        hasMore: boolean;
+        total: number;
+    }>>;
+    createCustomerPortal(session: CustomerPortalSession, options?: RequestOptions): Promise<ApiResponse<CustomerPortalResponse>>;
+    createCheckoutSession(session: {
+        customerId?: string;
+        customerEmail?: string;
+        lineItems: Array<{
+            priceId: string;
+            quantity: number;
+        }>;
+        mode: 'payment' | 'subscription';
+        successUrl: string;
+        cancelUrl: string;
+        metadata?: Record<string, any>;
+    }, options?: RequestOptions): Promise<ApiResponse<{
+        id: string;
+        url: string;
+    }>>;
+    createCustomer(customer: {
+        email: string;
+        name?: string;
+        metadata?: Record<string, any>;
+    }, options?: RequestOptions): Promise<ApiResponse<{
+        id: string;
+        email: string;
+        name?: string;
+        created: number;
+    }>>;
+    getCustomer(customerId: string, options?: RequestOptions): Promise<ApiResponse<{
+        id: string;
+        email: string;
+        name?: string;
+        created: number;
+        metadata?: Record<string, any>;
+    }>>;
+    updateCustomer(customerId: string, updates: {
+        email?: string;
+        name?: string;
+        metadata?: Record<string, any>;
+    }, options?: RequestOptions): Promise<ApiResponse<{
+        id: string;
+        email: string;
+        name?: string;
+        created: number;
+        metadata?: Record<string, any>;
+    }>>;
+    listPaymentMethods(customerId: string, options?: RequestOptions): Promise<ApiResponse<Array<{
+        id: string;
+        type: string;
+        card?: {
+            brand: string;
+            last4: string;
+            expMonth: number;
+            expYear: number;
+        };
+        created: number;
+    }>>>;
+    attachPaymentMethod(paymentMethodId: string, customerId: string, options?: RequestOptions): Promise<ApiResponse<{
+        id: string;
+        customerId: string;
+        attached: boolean;
+    }>>;
+    detachPaymentMethod(paymentMethodId: string, options?: RequestOptions): Promise<ApiResponse<{
+        id: string;
+        detached: boolean;
+    }>>;
+}
+
+declare class VlyIntegrations {
+    ai: VlyAI;
+    email: VlyEmail;
+    payments: VlyPayments;
+    constructor(config: VlyConfig);
+}
+declare function createVlyIntegrations(config: VlyConfig): VlyIntegrations;
+
+export { type AICompletionRequest, type AICompletionResponse, type AIModel, type ApiResponse, type CustomerPortalResponse, type CustomerPortalSession, type EmailRequest, type EmailResponse, type PaymentIntent, type PaymentIntentResponse, type RequestOptions, type Subscription, type SubscriptionResponse, VlyAI, type VlyConfig, VlyEmail, VlyIntegrations, VlyPayments, createVlyIntegrations };