services-as-software 0.1.0

package/README.md

@@ -0,0 +1,303 @@
+# services-as-software
+
+Define services with objectives, key results, and various pricing models for the agentic services architecture.
+
+## Installation
+
+```bash
+npm install services-as-software
+# or
+yarn add services-as-software
+# or
+pnpm add services-as-software
+```
+
+## Overview
+
+The `services-as-software` package enables defining services with clear objectives, measurable key results, and support for multiple pricing models. It allows Functions, Workflows, and Agents to be offered as Services with appropriate pricing and business models.
+
+## Usage
+
+### Basic Service Definition
+
+```typescript
+import { Service } from 'services-as-software'
+
+const myService = Service({
+  name: 'Content Generation Service',
+  description: 'AI-powered content generation for marketing teams',
+  objective: {
+    description: 'Provide high-quality content generation that increases marketing efficiency',
+    keyResults: [],
+  },
+  keyResults: [
+    {
+      description: 'Reduce content creation time',
+      target: 50,
+      currentValue: 0,
+      unit: 'percent',
+    },
+    {
+      description: 'Maintain content quality score',
+      target: 8,
+      currentValue: 0,
+      unit: 'rating',
+    },
+  ],
+  pricing: {
+    model: 'cost-based',
+    costBase: 10,
+    fixedCosts: 5,
+    variableCosts: 2,
+  },
+  implementation: {
+    type: 'function',
+    id: 'content-generator-123',
+  },
+})
+
+// Register the service
+const registeredService = await myService.register()
+
+// Calculate price
+const price = myService.calculatePrice({ quantity: 5 })
+
+// Track progress towards key results
+myService.trackProgress({
+  'Reduce content creation time': 30,
+  'Maintain content quality score': 9,
+})
+
+// Check if objective is achieved
+const achieved = myService.isObjectiveAchieved()
+```
+
+### Pricing Models
+
+The package supports four pricing models:
+
+#### 1. Cost-based Pricing
+
+```typescript
+const service = Service({
+  // ...other properties
+  pricing: {
+    model: 'cost-based',
+    costBase: 100,
+    fixedCosts: 50,
+    variableCosts: 10,
+  },
+})
+
+// Calculate price for 5 units
+const price = service.calculatePrice({ quantity: 5 }) // 200 (100 + 50 + 10*5)
+```
+
+#### 2. Margin-based Pricing
+
+```typescript
+const service = Service({
+  // ...other properties
+  pricing: {
+    model: 'margin-based',
+    costBase: 100,
+    marginPercentage: 20,
+  },
+})
+
+// Calculate price for 2 units
+const price = service.calculatePrice({ quantity: 2 }) // 240 (100*2 + 20% margin)
+```
+
+#### 3. Activity-based Pricing
+
+```typescript
+const service = Service({
+  // ...other properties
+  pricing: {
+    model: 'activity-based',
+    activities: [
+      { name: 'research', rate: 50 },
+      { name: 'writing', rate: 100 },
+      { name: 'editing', rate: 30 },
+    ],
+  },
+})
+
+// Calculate price based on activities performed
+const price = service.calculatePrice({
+  activities: {
+    research: 2,
+    writing: 1,
+    editing: 3,
+  },
+}) // 290 (50*2 + 100*1 + 30*3)
+```
+
+#### 4. Outcome-based Pricing
+
+```typescript
+const service = Service({
+  // ...other properties
+  pricing: {
+    model: 'outcome-based',
+    outcomes: [
+      { metric: 'conversion-rate', targetValue: 5, price: 500 },
+      { metric: 'engagement', targetValue: 10000, price: 300 },
+    ],
+  },
+})
+
+// Calculate price based on achieved outcomes
+const price = service.calculatePrice({
+  outcomes: {
+    'conversion-rate': 6.5,
+    engagement: 8000,
+  },
+}) // 500 (only conversion-rate target was met)
+```
+
+### Offering Functions as Services
+
+```typescript
+import { Service } from 'services-as-software'
+
+const functionAsService = Service({
+  name: 'Text Summarization',
+  objective: {
+    description: 'Provide accurate text summarization',
+    keyResults: [],
+  },
+  keyResults: [
+    {
+      description: 'Summarization accuracy',
+      target: 90,
+      unit: 'percent',
+    },
+  ],
+  pricing: {
+    model: 'cost-based',
+    costBase: 5,
+    variableCosts: 0.01,
+  },
+  implementation: {
+    type: 'function',
+    id: 'text-summarizer-function',
+  },
+})
+```
+
+### Offering Workflows as Services
+
+```typescript
+import { Service } from 'services-as-software'
+
+const workflowAsService = Service({
+  name: 'Content Production Pipeline',
+  objective: {
+    description: 'End-to-end content production',
+    keyResults: [],
+  },
+  keyResults: [
+    {
+      description: 'Average production time',
+      target: 24,
+      unit: 'hours',
+    },
+  ],
+  pricing: {
+    model: 'activity-based',
+    activities: [
+      { name: 'research', rate: 100 },
+      { name: 'writing', rate: 200 },
+      { name: 'editing', rate: 50 },
+      { name: 'publishing', rate: 30 },
+    ],
+  },
+  implementation: {
+    type: 'workflow',
+    id: 'content-production-workflow',
+  },
+})
+```
+
+### Offering Agents as Services
+
+```typescript
+import { Service } from 'services-as-software'
+
+const agentAsService = Service({
+  name: 'Customer Support Agent',
+  objective: {
+    description: 'Provide excellent customer support',
+    keyResults: [],
+  },
+  keyResults: [
+    {
+      description: 'Customer satisfaction score',
+      target: 4.5,
+      unit: 'rating',
+    },
+    {
+      description: 'First response time',
+      target: 5,
+      unit: 'minutes',
+    },
+  ],
+  pricing: {
+    model: 'outcome-based',
+    outcomes: [
+      { metric: 'resolution-rate', targetValue: 95, price: 1000 },
+      { metric: 'satisfaction-score', targetValue: 4.8, price: 500 },
+    ],
+  },
+  implementation: {
+    type: 'agent',
+    id: 'customer-support-agent',
+  },
+})
+```
+
+## API Reference
+
+### Service Function
+
+```typescript
+function Service(definition: ServiceDefinition): ServiceObject
+```
+
+Creates a service with the given definition.
+
+### ServiceDefinition
+
+```typescript
+interface ServiceDefinition {
+  name: string
+  description?: string
+  objective: Objective
+  keyResults: KeyResult[]
+  pricing: ServicePricing
+  implementation: ImplementationDetails
+  metadata?: Record<string, any>
+}
+```
+
+### Pricing Models
+
+```typescript
+type PricingModel = 'cost-based' | 'margin-based' | 'activity-based' | 'outcome-based'
+
+type ServicePricing = CostBasedPricing | MarginBasedPricing | ActivityBasedPricing | OutcomeBasedPricing
+```
+
+## Integration with Existing Services
+
+The `services-as-software` package is designed to work with the existing services ecosystem:
+
+- Integrates with the `services.do` SDK for service registration
+- Extends the business model concepts from `Business-as-Code`
+- Compatible with Functions, Workflows, and Agents collections
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,216 @@
+import { Objective as Objective$1, KeyResult as KeyResult$1 } from 'business-as-code';
+
+/**
+ * Pricing model types for services
+ */
+type PricingModel = 'cost-based' | 'margin-based' | 'activity-based' | 'outcome-based';
+/**
+ * Cost-based pricing configuration
+ */
+interface CostBasedPricing {
+    model: 'cost-based';
+    costBase: number;
+    fixedCosts?: number;
+    variableCosts?: number;
+}
+/**
+ * Margin-based pricing configuration
+ */
+interface MarginBasedPricing {
+    model: 'margin-based';
+    costBase: number;
+    marginPercentage: number;
+}
+/**
+ * Activity-based pricing configuration
+ */
+interface ActivityBasedPricing {
+    model: 'activity-based';
+    activities: {
+        name: string;
+        description?: string;
+        rate: number;
+    }[];
+}
+/**
+ * Outcome-based pricing configuration
+ */
+interface OutcomeBasedPricing {
+    model: 'outcome-based';
+    outcomes: {
+        metric: string;
+        description?: string;
+        targetValue: number;
+        price: number;
+        unit?: string;
+    }[];
+}
+/**
+ * Union type for all pricing configurations
+ */
+type ServicePricing = CostBasedPricing | MarginBasedPricing | ActivityBasedPricing | OutcomeBasedPricing;
+/**
+ * Implementation types for services
+ */
+type ImplementationType = 'function' | 'workflow' | 'agent';
+/**
+ * Implementation details for a service
+ */
+interface ImplementationDetails {
+    type: ImplementationType;
+    id: string;
+    version?: string;
+    configuration?: Record<string, any>;
+}
+/**
+ * Service definition with business model aspects
+ */
+interface ServiceDefinition {
+    /**
+     * Service name
+     */
+    name: string;
+    /**
+     * Service description
+     */
+    description?: string;
+    /**
+     * Service objective
+     */
+    objective: Objective$1;
+    /**
+     * Key results for measuring service success
+     */
+    keyResults: KeyResult$1[];
+    /**
+     * Service pricing model
+     */
+    pricing: ServicePricing;
+    /**
+     * Implementation details
+     */
+    implementation: ImplementationDetails;
+    /**
+     * Additional metadata
+     */
+    metadata?: Record<string, any>;
+}
+/**
+ * Registered service with additional properties
+ */
+interface RegisteredService extends ServiceDefinition {
+    /**
+     * Unique service identifier
+     */
+    id: string;
+    /**
+     * Service status
+     */
+    status: 'active' | 'inactive' | 'degraded';
+    /**
+     * Service endpoint URL
+     */
+    endpoint: string;
+    /**
+     * Creation timestamp
+     */
+    createdAt: string;
+    /**
+     * Last update timestamp
+     */
+    updatedAt: string;
+}
+
+interface Objective {
+    description: string;
+    keyResults: string[] | KeyResult[];
+}
+interface KeyResult {
+    description: string;
+    target?: number;
+    currentValue?: number;
+    unit?: string;
+    dueDate?: Date;
+}
+
+/**
+ * Calculate price for cost-based pricing model
+ * @param pricing Cost-based pricing configuration
+ * @param quantity Number of units
+ * @returns Calculated price
+ */
+declare function calculateCostBasedPrice(pricing: CostBasedPricing, quantity?: number): number;
+/**
+ * Calculate price for margin-based pricing model
+ * @param pricing Margin-based pricing configuration
+ * @param quantity Number of units
+ * @returns Calculated price
+ */
+declare function calculateMarginBasedPrice(pricing: MarginBasedPricing, quantity?: number): number;
+/**
+ * Calculate price for activity-based pricing model
+ * @param pricing Activity-based pricing configuration
+ * @param activities Record of activity names and their quantities
+ * @returns Calculated price
+ */
+declare function calculateActivityBasedPrice(pricing: ActivityBasedPricing, activities: Record<string, number>): number;
+/**
+ * Calculate price for outcome-based pricing model
+ * @param pricing Outcome-based pricing configuration
+ * @param outcomes Record of metric names and their achieved values
+ * @returns Calculated price
+ */
+declare function calculateOutcomeBasedPrice(pricing: OutcomeBasedPricing, outcomes: Record<string, number>): number;
+/**
+ * Calculate price based on the pricing model
+ * @param pricing Service pricing configuration
+ * @param params Additional parameters for price calculation
+ * @returns Calculated price
+ */
+declare function calculatePrice(pricing: ServicePricing, params?: {
+    quantity?: number;
+    activities?: Record<string, number>;
+    outcomes?: Record<string, number>;
+}): number;
+
+/**
+ * Create a service with objectives, key results, and pricing models
+ * @param definition Service definition
+ * @returns Service object with additional methods
+ */
+declare function Service(definition: ServiceDefinition): {
+    /**
+     * Calculate the price for this service
+     * @param params Parameters for price calculation
+     * @returns Calculated price
+     */
+    calculatePrice(params?: Parameters<typeof calculatePrice>[1]): number;
+    /**
+     * Register the service with the service registry
+     * @param options Optional configuration for service registration
+     * @returns Promise resolving to the registered service
+     */
+    register(options?: {
+        apiKey?: string;
+        baseUrl?: string;
+    }): Promise<RegisteredService>;
+    /**
+     * Track progress towards key results
+     * @param results Record of key result updates
+     */
+    trackProgress(results: Record<string, number>): void;
+    /**
+     * Check if all key results have been achieved
+     * @returns Whether all key results have been achieved
+     */
+    isObjectiveAchieved(): boolean;
+    name: string;
+    description?: string;
+    objective: Objective;
+    keyResults: KeyResult[];
+    pricing: ServicePricing;
+    implementation: ImplementationDetails;
+    metadata?: Record<string, any>;
+};
+
+export { type ActivityBasedPricing, type CostBasedPricing, type ImplementationDetails, type ImplementationType, type MarginBasedPricing, type OutcomeBasedPricing, type PricingModel, type RegisteredService, Service, type ServiceDefinition, type ServicePricing, calculateActivityBasedPrice, calculateCostBasedPrice, calculateMarginBasedPrice, calculateOutcomeBasedPrice, calculatePrice };

package/dist/index.js

@@ -0,0 +1,172 @@
+// src/pricing/index.ts
+function calculateCostBasedPrice(pricing, quantity = 1) {
+  const { costBase, fixedCosts = 0, variableCosts = 0 } = pricing;
+  return costBase + fixedCosts + variableCosts * quantity;
+}
+function calculateMarginBasedPrice(pricing, quantity = 1) {
+  const { costBase, marginPercentage } = pricing;
+  const cost = costBase * quantity;
+  const margin = cost * (marginPercentage / 100);
+  return cost + margin;
+}
+function calculateActivityBasedPrice(pricing, activities) {
+  return pricing.activities.reduce((total, activity) => {
+    const quantity = activities[activity.name] || 0;
+    return total + activity.rate * quantity;
+  }, 0);
+}
+function calculateOutcomeBasedPrice(pricing, outcomes) {
+  return pricing.outcomes.reduce((total, outcome) => {
+    const achievedValue = outcomes[outcome.metric] || 0;
+    if (achievedValue >= outcome.targetValue) {
+      return total + outcome.price;
+    }
+    return total;
+  }, 0);
+}
+function calculatePrice(pricing, params = {}) {
+  const { quantity = 1, activities = {}, outcomes = {} } = params;
+  switch (pricing.model) {
+    case "cost-based":
+      return calculateCostBasedPrice(pricing, quantity);
+    case "margin-based":
+      return calculateMarginBasedPrice(pricing, quantity);
+    case "activity-based":
+      return calculateActivityBasedPrice(pricing, activities);
+    case "outcome-based":
+      return calculateOutcomeBasedPrice(pricing, outcomes);
+    default:
+      throw new Error(`Unsupported pricing model: ${pricing.model}`);
+  }
+}
+
+// src/index.ts
+function Service(definition) {
+  validateServiceDefinition(definition);
+  const service = {
+    ...definition,
+    /**
+     * Calculate the price for this service
+     * @param params Parameters for price calculation
+     * @returns Calculated price
+     */
+    calculatePrice(params) {
+      return calculatePrice(definition.pricing, params);
+    },
+    /**
+     * Register the service with the service registry
+     * @param options Optional configuration for service registration
+     * @returns Promise resolving to the registered service
+     */
+    async register(options) {
+      try {
+        const { Services } = await import("services.do");
+        const services = new Services(options);
+        const serviceDefinition = {
+          name: definition.name,
+          description: definition.description,
+          endpoint: `https://api.services.do/implementations/${definition.implementation.type}/${definition.implementation.id}`,
+          version: definition.implementation.version,
+          metadata: {
+            ...definition.metadata,
+            objective: definition.objective,
+            keyResults: definition.keyResults,
+            pricing: definition.pricing,
+            implementation: definition.implementation
+          }
+        };
+        const registeredService = await services.register(serviceDefinition);
+        return {
+          ...definition,
+          id: registeredService.id,
+          status: registeredService.status,
+          endpoint: registeredService.endpoint,
+          createdAt: registeredService.createdAt,
+          updatedAt: registeredService.updatedAt
+        };
+      } catch (error) {
+        console.warn("Failed to register with services.do, using mock implementation", error);
+        return {
+          ...definition,
+          id: generateId(),
+          status: "active",
+          endpoint: `https://api.services.do/services/${generateId()}`,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+    },
+    /**
+     * Track progress towards key results
+     * @param results Record of key result updates
+     */
+    trackProgress(results) {
+      definition.keyResults.forEach((kr) => {
+        if (kr.description in results) {
+          kr.currentValue = results[kr.description];
+        }
+      });
+    },
+    /**
+     * Check if all key results have been achieved
+     * @returns Whether all key results have been achieved
+     */
+    isObjectiveAchieved() {
+      return definition.keyResults.every((kr) => kr.currentValue !== void 0 && kr.target !== void 0 && kr.currentValue >= kr.target);
+    }
+  };
+  return service;
+}
+function validateServiceDefinition(definition) {
+  const { name, objective, keyResults, pricing, implementation } = definition;
+  if (!name) {
+    throw new Error("Service name is required");
+  }
+  if (!objective || !objective.description) {
+    throw new Error("Service objective with description is required");
+  }
+  if (!keyResults || !Array.isArray(keyResults) || keyResults.length === 0) {
+    throw new Error("At least one key result is required");
+  }
+  if (!pricing || !pricing.model) {
+    throw new Error("Service pricing model is required");
+  }
+  if (!implementation || !implementation.type || !implementation.id) {
+    throw new Error("Service implementation details are required");
+  }
+  switch (pricing.model) {
+    case "cost-based":
+      if (pricing.costBase === void 0) {
+        throw new Error("Cost base is required for cost-based pricing");
+      }
+      break;
+    case "margin-based":
+      if (pricing.costBase === void 0 || pricing.marginPercentage === void 0) {
+        throw new Error("Cost base and margin percentage are required for margin-based pricing");
+      }
+      break;
+    case "activity-based":
+      if (!pricing.activities || !Array.isArray(pricing.activities) || pricing.activities.length === 0) {
+        throw new Error("At least one activity is required for activity-based pricing");
+      }
+      break;
+    case "outcome-based":
+      if (!pricing.outcomes || !Array.isArray(pricing.outcomes) || pricing.outcomes.length === 0) {
+        throw new Error("At least one outcome is required for outcome-based pricing");
+      }
+      break;
+    default:
+      throw new Error(`Unsupported pricing model: ${pricing.model}`);
+  }
+}
+function generateId() {
+  return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+}
+export {
+  Service,
+  calculateActivityBasedPrice,
+  calculateCostBasedPrice,
+  calculateMarginBasedPrice,
+  calculateOutcomeBasedPrice,
+  calculatePrice
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "services-as-software",
+  "version": "0.1.0",
+  "description": "Define services with objectives, key results, and various pricing models",
+  "keywords": [
+    "services",
+    "business",
+    "pricing",
+    "objectives",
+    "key results",
+    "agentic"
+  ],
+  "homepage": "https://mdx.org.ai",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts",
+    "dev": "tsup src/index.ts --format esm --dts --watch",
+    "lint": "eslint src --ext ts",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "apis.do": "0.1.0",
+    "services.do": "workspace:*"
+  },
+  "devDependencies": {
+    "business-as-code": "0.0.2",
+    "tsup": "^8.0.1",
+    "typescript": "^5.2.2",
+    "vitest": "^0.34.6"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/drivly/ai.git",
+    "directory": "pkgs/services-as-software"
+  },
+  "bugs": {
+    "url": "https://github.com/drivly/ai/issues"
+  },
+  "author": "Drivly",
+  "license": "MIT"
+}