services-as-software 2.0.2 → 2.1.1

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # services-as-software
 
+## 2.1.1
+
+### Patch Changes
+
+- Updated dependencies [6beb531]
+  - ai-functions@2.1.1
+  - ai-database@2.1.1
+  - digital-workers@2.1.1
+
+## 2.0.3
+
+### Patch Changes
+
+- Updated dependencies
+  - rpc.do@0.2.0
+  - ai-database@2.0.3
+  - ai-functions@2.0.3
+  - digital-workers@2.0.3
+
 ## 2.0.2
 
 ### Patch Changes

package/examples/client-usage.js

@@ -0,0 +1,68 @@
+/**
+ * Example: Using the Service Client
+ *
+ * This example demonstrates how to connect to a remote service using the Client
+ */
+import { Client, Provider, providers } from '../src/index.js';
+// Connect to a service using a direct URL
+const translationClient = Client({
+    url: 'https://api.example.com/translation',
+    auth: {
+        type: 'api-key',
+        credentials: {
+            apiKey: 'your-api-key-here',
+        },
+    },
+});
+// Use the client
+async function useDirectClient() {
+    const result = await translationClient.do('translate', {
+        text: 'Hello, world!',
+        to: 'es',
+    });
+    console.log('Translation:', result);
+    // Get a quote
+    const quote = await translationClient.quote({ text: 'Large document...', to: 'es' }, 1000);
+    console.log('Quote:', quote);
+    // Subscribe to a plan
+    const subscription = await translationClient.subscribe('pro');
+    console.log('Subscription:', subscription);
+}
+// Use a provider to access multiple services
+const awsProvider = providers.aws({
+    accessKeyId: 'your-access-key',
+    secretAccessKey: 'your-secret-key',
+    region: 'us-east-1',
+});
+async function useProvider() {
+    // Get the translate service from AWS
+    const translate = awsProvider.service('translate');
+    const result = await translate.do('translate', {
+        text: 'Hello, world!',
+        sourceLang: 'en',
+        targetLang: 'es',
+    });
+    console.log('AWS Translation:', result);
+}
+// Create a custom provider
+const customProvider = Provider({
+    name: 'My Company',
+    baseUrl: 'https://api.mycompany.com',
+    auth: {
+        type: 'jwt',
+        credentials: {
+            token: 'your-jwt-token',
+        },
+    },
+    services: ['translation', 'summarization', 'sentiment'],
+});
+async function useCustomProvider() {
+    const translation = customProvider.service('translation');
+    const result = await translation.do('translate', {
+        text: 'Hello',
+        to: 'fr',
+    });
+    console.log('Custom provider result:', result);
+}
+// Export examples
+export { useDirectClient, useProvider, useCustomProvider };

package/examples/translation-service.js

@@ -0,0 +1,214 @@
+/**
+ * Example: Translation Service
+ *
+ * This example demonstrates how to create a translation service with:
+ * - Multiple endpoints (translate, detect language)
+ * - Per-use pricing
+ * - Rate limiting
+ * - Usage tracking
+ */
+import { Service, Endpoint, POST, GET } from '../src/index.js';
+// Define the translation service
+const translationService = Service({
+    name: 'translation-service',
+    version: '1.0.0',
+    description: 'AI-powered translation service',
+    status: 'active',
+    // Default pricing for all endpoints
+    pricing: {
+        model: 'per-use',
+        pricePerUnit: 0.01, // $0.01 per character
+        currency: 'USD',
+        freeTier: {
+            units: 10000, // 10,000 free characters per month
+            resetInterval: 'monthly',
+        },
+    },
+    // Service endpoints
+    endpoints: [
+        POST({
+            name: 'translate',
+            description: 'Translate text between languages',
+            path: '/translate',
+            input: {
+                type: 'object',
+                properties: {
+                    text: { type: 'string', description: 'Text to translate' },
+                    from: { type: 'string', description: 'Source language code (optional)' },
+                    to: { type: 'string', description: 'Target language code' },
+                },
+                required: ['text', 'to'],
+                additionalProperties: false,
+            },
+            output: {
+                type: 'object',
+                properties: {
+                    translatedText: { type: 'string', description: 'Translated text' },
+                    sourceLanguage: { type: 'string', description: 'Detected or specified source language' },
+                    confidence: { type: 'number', description: 'Translation confidence (0-1)' },
+                },
+                required: ['translatedText', 'sourceLanguage', 'confidence'],
+                additionalProperties: false,
+            },
+            handler: async (input, context) => {
+                // Track usage for billing
+                if (context?.usage && context.customerId) {
+                    await context.usage.track({
+                        customerId: context.customerId,
+                        resource: 'translate',
+                        quantity: input.text.length, // Charge per character
+                        timestamp: new Date(),
+                    });
+                }
+                // In a real implementation, this would call an AI translation API
+                return {
+                    translatedText: `[Translated to ${input.to}] ${input.text}`,
+                    sourceLanguage: input.from || 'auto-detected',
+                    confidence: 0.95,
+                };
+            },
+            rateLimit: {
+                requests: 100,
+                window: 60000, // 100 requests per minute
+            },
+        }),
+        GET({
+            name: 'detect',
+            description: 'Detect the language of text',
+            path: '/detect',
+            input: {
+                type: 'object',
+                properties: {
+                    text: { type: 'string', description: 'Text to analyze' },
+                },
+                required: ['text'],
+                additionalProperties: false,
+            },
+            output: {
+                type: 'object',
+                properties: {
+                    language: { type: 'string', description: 'Detected language code' },
+                    confidence: { type: 'number', description: 'Detection confidence (0-1)' },
+                },
+                required: ['language', 'confidence'],
+                additionalProperties: false,
+            },
+            handler: async (input) => {
+                // Language detection logic
+                return {
+                    language: 'en',
+                    confidence: 0.98,
+                };
+            },
+            pricing: {
+                model: 'per-use',
+                pricePerUnit: 0.001, // $0.001 per detection (cheaper than translation)
+                currency: 'USD',
+            },
+        }),
+        Endpoint({
+            name: 'languages',
+            description: 'Get supported languages',
+            method: 'GET',
+            path: '/languages',
+            handler: async () => {
+                return {
+                    languages: [
+                        { code: 'en', name: 'English' },
+                        { code: 'es', name: 'Spanish' },
+                        { code: 'fr', name: 'French' },
+                        { code: 'de', name: 'German' },
+                        { code: 'ja', name: 'Japanese' },
+                        { code: 'zh', name: 'Chinese' },
+                    ],
+                };
+            },
+            requiresAuth: false, // Public endpoint
+        }),
+    ],
+    // Subscription plans
+    plans: [
+        {
+            id: 'starter',
+            name: 'Starter Plan',
+            description: 'For individual developers',
+            pricing: {
+                model: 'subscription',
+                basePrice: 9.99,
+                currency: 'USD',
+                interval: 'monthly',
+            },
+            entitlements: ['api-access', 'basic-support'],
+            features: [
+                '100,000 characters/month',
+                'Email support',
+                'Basic languages',
+            ],
+            limits: {
+                characters: 100000,
+            },
+        },
+        {
+            id: 'pro',
+            name: 'Pro Plan',
+            description: 'For growing businesses',
+            pricing: {
+                model: 'subscription',
+                basePrice: 49.99,
+                currency: 'USD',
+                interval: 'monthly',
+            },
+            entitlements: ['api-access', 'priority-support', 'advanced-features'],
+            features: [
+                '1,000,000 characters/month',
+                'Priority support',
+                'All languages',
+                'Custom models',
+            ],
+            limits: {
+                characters: 1000000,
+            },
+        },
+    ],
+    // KPIs
+    kpis: [
+        {
+            id: 'translations-per-day',
+            name: 'Translations per Day',
+            description: 'Number of translation requests processed daily',
+            calculate: async () => {
+                // In a real implementation, query the database
+                return 1247;
+            },
+            target: 1000,
+            unit: 'requests',
+        },
+        {
+            id: 'average-confidence',
+            name: 'Average Translation Confidence',
+            description: 'Average confidence score across all translations',
+            calculate: async () => {
+                return 0.94;
+            },
+            target: 0.95,
+            unit: 'score',
+        },
+    ],
+});
+// Example usage
+async function example() {
+    // Call the translate endpoint
+    const result = await translationService.call('translate', {
+        text: 'Hello, world!',
+        to: 'es',
+    });
+    console.log('Translation result:', result);
+    // Get KPIs
+    const kpis = await translationService.kpis();
+    console.log('KPIs:', kpis);
+    // Subscribe to a plan
+    const subscription = await translationService.subscribe('pro');
+    console.log('Subscription:', subscription);
+}
+// Export the service
+export { translationService };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "services-as-software",
-  "version": "2.0.2",
+  "version": "2.1.1",
   "description": "Primitives for building AI-powered services that operate as software",
   "type": "module",
   "main": "dist/index.js",
@@ -20,10 +20,9 @@
     "clean": "rm -rf dist"
   },
   "dependencies": {
-    "ai-database": "2.0.2",
-    "ai-functions": "2.0.2",
-    "digital-workers": "2.0.2",
-    "rpc.do": "^0.1.0"
+    "ai-database": "2.1.1",
+    "ai-functions": "2.1.1",
+    "digital-workers": "2.1.1"
   },
   "keywords": [
     "services",

package/src/client.js

@@ -0,0 +1,102 @@
+/**
+ * Service client for connecting to remote services
+ */
+/**
+ * Create a client to connect to a remote service
+ *
+ * @example
+ * ```ts
+ * const client = Client({
+ *   url: 'https://api.example.com/translation',
+ *   auth: {
+ *     type: 'api-key',
+ *     credentials: { apiKey: process.env.API_KEY },
+ *   },
+ * })
+ *
+ * const result = await client.do('translate', {
+ *   text: 'Hello world',
+ *   to: 'es',
+ * })
+ * ```
+ */
+export function Client(config) {
+    const baseUrl = config.url || '';
+    const headers = {
+        'Content-Type': 'application/json',
+        ...config.headers,
+    };
+    // Add auth headers
+    if (config.auth) {
+        switch (config.auth.type) {
+            case 'api-key':
+                headers['Authorization'] = `Bearer ${config.auth.credentials.apiKey || config.auth.credentials.token}`;
+                break;
+            case 'basic':
+                const basicAuth = Buffer.from(`${config.auth.credentials.username}:${config.auth.credentials.password}`).toString('base64');
+                headers['Authorization'] = `Basic ${basicAuth}`;
+                break;
+            case 'jwt':
+                headers['Authorization'] = `Bearer ${config.auth.credentials.token}`;
+                break;
+            // OAuth would require more complex flow
+        }
+    }
+    /**
+     * Make an HTTP request to the service
+     */
+    async function request(endpoint, body) {
+        const url = `${baseUrl}/${endpoint.replace(/^\//, '')}`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: body ? JSON.stringify(body) : undefined,
+            signal: config.timeout ? AbortSignal.timeout(config.timeout) : undefined,
+        });
+        if (!response.ok) {
+            throw new Error(`Service request failed: ${response.status} ${response.statusText}`);
+        }
+        return response.json();
+    }
+    return {
+        async ask(question, context) {
+            const result = await request('ask', { question, context });
+            return result.answer;
+        },
+        async deliver(orderId, results) {
+            await request('deliver', { orderId, results });
+        },
+        async do(action, input) {
+            return request('do', { action, input });
+        },
+        async generate(prompt, options) {
+            return request('generate', { prompt, options });
+        },
+        async is(value, type) {
+            const result = await request('is', { value, type });
+            return result.result;
+        },
+        async notify(notification) {
+            await request('notify', notification);
+        },
+        async order(product, quantity) {
+            return request('order', { product, quantity });
+        },
+        async quote(product, quantity) {
+            return request('quote', { product, quantity });
+        },
+        async subscribe(planId) {
+            return request('subscribe', { planId });
+        },
+        async entitlements() {
+            const result = await request('entitlements', {});
+            return result.entitlements;
+        },
+        async kpis() {
+            return request('kpis', {});
+        },
+        async okrs() {
+            return request('okrs', {});
+        },
+    };
+}

package/src/endpoint.js

@@ -0,0 +1,95 @@
+/**
+ * Endpoint helper for defining service endpoints
+ */
+/**
+ * Create an endpoint definition
+ *
+ * @example
+ * ```ts
+ * const translateEndpoint = Endpoint({
+ *   name: 'translate',
+ *   description: 'Translate text between languages',
+ *   method: 'POST',
+ *   path: '/translate',
+ *   input: {
+ *     type: 'object',
+ *     properties: {
+ *       text: { type: 'string', description: 'Text to translate' },
+ *       from: { type: 'string', description: 'Source language code' },
+ *       to: { type: 'string', description: 'Target language code' },
+ *     },
+ *     required: ['text', 'to'],
+ *     additionalProperties: false,
+ *   },
+ *   output: {
+ *     type: 'object',
+ *     properties: {
+ *       translatedText: { type: 'string' },
+ *       confidence: { type: 'number' },
+ *     },
+ *     required: ['translatedText'],
+ *     additionalProperties: false,
+ *   },
+ *   handler: async (input, context) => {
+ *     // Translation logic here
+ *     return {
+ *       translatedText: `Translated: ${input.text}`,
+ *       confidence: 0.95,
+ *     }
+ *   },
+ *   pricing: {
+ *     model: 'per-use',
+ *     pricePerUnit: 0.01,
+ *     currency: 'USD',
+ *   },
+ *   rateLimit: {
+ *     requests: 100,
+ *     window: 60000, // 1 minute
+ *   },
+ * })
+ * ```
+ */
+export function Endpoint(config) {
+    return {
+        name: config.name,
+        description: config.description,
+        method: config.method || 'POST',
+        path: config.path || `/${config.name}`,
+        input: config.input,
+        output: config.output,
+        handler: config.handler,
+        pricing: config.pricing,
+        rateLimit: config.rateLimit,
+        requiresAuth: config.requiresAuth !== false, // Default to true
+    };
+}
+/**
+ * Create a GET endpoint
+ */
+export function GET(config) {
+    return Endpoint({ ...config, method: 'GET' });
+}
+/**
+ * Create a POST endpoint
+ */
+export function POST(config) {
+    return Endpoint({ ...config, method: 'POST' });
+}
+/**
+ * Create a PUT endpoint
+ */
+export function PUT(config) {
+    return Endpoint({ ...config, method: 'PUT' });
+}
+/**
+ * Create a DELETE endpoint
+ */
+export function DELETE(config) {
+    return Endpoint({ ...config, method: 'DELETE' });
+}
+/**
+ * Create a PATCH endpoint
+ */
+export function PATCH(config) {
+    return Endpoint({ ...config, method: 'PATCH' });
+}