Complete Examples

const blogGeneratorService = {
  name: 'AI Blog Post Generator',
  type: $.ServiceType.ContentGeneration,
  stages: ['keyword-research', 'topic-selection', 'outline-creation', 'content-writing', 'seo-optimization', 'image-generation', 'quality-assurance'],
  pricing: {
    model: 'tiered',
    tiers: [
      { name: 'basic', price: 29, wordCount: 800, images: 1 },
      { name: 'standard', price: 49, wordCount: 1500, images: 3 },
      { name: 'premium', price: 99, wordCount: 2500, images: 5 },
    ],
  },
}

const analysisService = {
  name: 'Sales Data Analyzer',
  type: $.ServiceType.DataAnalysis,
  analyses: ['trend-analysis', 'anomaly-detection', 'predictive-modeling', 'customer-segmentation', 'revenue-forecasting'],
  pricing: {
    model: 'per-analysis',
    rate: 25.0,
    currency: 'USD',
  },
}

const invoiceAutomationService = {
  name: 'Automated Invoice Processor',
  type: $.ServiceType.Automation,
  workflow: ['invoice-receipt', 'data-extraction', 'validation', 'po-matching', 'approval-routing', 'payment-scheduling', 'accounting-integration'],
  pricing: {
    model: 'per-invoice',
    tiers: [
      { min: 0, max: 100, rate: 2.0 },
      { min: 101, max: 500, rate: 1.5 },
      { min: 501, max: Infinity, rate: 1.0 },
    ],
  },
}

const crmSyncService = {
  name: 'Universal CRM Synchronizer',
  type: $.ServiceType.Integration,
  platforms: ['salesforce', 'hubspot', 'pipedrive', 'zoho', 'dynamics'],
  pricing: {
    model: 'subscription',
    tiers: [
      {
        name: 'starter',
        price: 99,
        recordLimit: 10000,
        syncFrequency: 'hourly',
      },
      {
        name: 'professional',
        price: 299,
        recordLimit: 100000,
        syncFrequency: 'real-time',
      },
      {
        name: 'enterprise',
        price: 999,
        recordLimit: Infinity,
        syncFrequency: 'real-time',
        customMappings: true,
      },
    ],
  },
}

import $, { ai, db, on, send } from 'sdk.do'

const blogGeneratorService = await $.Service.create({
  name: 'AI Blog Post Generator',
  type: $.ServiceType.ContentGeneration,

  workflow: ['keyword-research', 'topic-selection', 'outline-creation', 'content-writing', 'seo-optimization', 'image-generation', 'quality-assurance'],

  pricing: {
    model: 'per-post',
    tiers: [
      { name: 'basic', price: 29, length: 800, images: 1 },
      { name: 'standard', price: 49, length: 1500, images: 3 },
      { name: 'premium', price: 99, length: 2500, images: 5, research: 'deep' },
    ],
  },
})

on.ServiceRequest.created, async (request) => {
  if (request.serviceId !== blogGeneratorService.id) return

  const tier = request.inputs.tier || 'standard'
  const config = blogGeneratorService.pricing.tiers.find((t) => t.name === tier)

  try {
    // 1. Keyword Research
    const keywords = await ai.research({
      model: 'gpt-5',
      topic: request.inputs.topic,
      industry: request.inputs.industry,
      intent: 'informational',
      count: 10,
    })

    // 2. Select Best Topics
    const topicAnalysis = await ai.analyze({
      model: 'gpt-5',
      keywords,
      criteria: ['search-volume', 'competition', 'relevance'],
      selectTop: 1,
    })

    // 3. Create Outline
    const outline = await ai.generate({
      model: 'gpt-5',
      type: 'blog-outline',
      context: {
        topic: topicAnalysis.selectedTopic,
        keywords: keywords.primary,
        targetLength: config.length,
        audience: request.inputs.audience,
      },
    })

    // 4. Write Content
    const content = await ai.generate({
      model: 'gpt-5',
      type: 'blog-post',
      context: {
        outline: outline.sections,
        keywords: keywords.primary,
        tone: request.inputs.tone || 'professional',
        length: config.length,
      },
      quality: {
        minReadability: 60,
        keywordDensity: { min: 0.01, max: 0.03 },
        uniqueness: 0.95,
      },
    })

    // 5. SEO Optimization
    const seo = await ai.optimize({
      model: 'gpt-5',
      content: content.text,
      keywords: keywords.primary,
      optimizations: ['meta-description', 'title-tag', 'header-hierarchy', 'internal-links', 'keyword-placement'],
    })

    // 6. Generate Images
    const images = []
    if (config.images > 0) {
      const imagePrompts = await ai.generate({
        model: 'gpt-5',
        type: 'image-prompts',
        context: { content: content.text, count: config.images },
      })

      for (const prompt of imagePrompts) {
        const image = await ai.generateImage({
          model: 'dalle-3',
          prompt: prompt.text,
          style: 'professional',
          aspectRatio: '16:9',
        })
        images.push(image)
      }
    }

    // 7. Quality Check
    const quality = await ai.evaluate({
      content: seo.optimizedContent,
      criteria: {
        readability: { min: 60 },
        seoScore: { min: 80 },
        grammar: { maxErrors: 3 },
        plagiarism: { maxSimilarity: 0.05 },
      },
    })

    if (quality.passed) {
      // Deliver complete package
      send.ServiceResult.deliver, {
        requestId: request.id,
        outputs: {
          post: {
            title: seo.title,
            content: seo.optimizedContent,
            excerpt: content.excerpt,
            images,
            seo: {
              metaDescription: seo.metaDescription,
              keywords: keywords.primary,
              slug: seo.slug,
            },
          },
          analytics: {
            wordCount: content.wordCount,
            readingTime: Math.ceil(content.wordCount / 200),
            seoScore: seo.score,
            readabilityScore: quality.readability,
          },
          research: {
            keywords: keywords.all,
            competitorAnalysis: keywords.competition,
          },
        },
        format: 'markdown',
      })

      // Bill for service
      send.Payment.charge, {
        customerId: request.customerId,
        amount: config.price,
        description: `Blog Post (${tier} tier) - ${seo.title}`,
      })
    } else {
      // Quality check failed, improve content
      const improved = await ai.improve({
        content: seo.optimizedContent,
        issues: quality.issues,
      })

      // Deliver improved version
      // ... (similar to above)
    }
  } catch (error) {
    send.ServiceRequest.fail, {
      requestId: request.id,
      error: error.message,
    })
  }
})

const productDescriptionService = await $.Service.create({
  name: 'E-commerce Product Description Writer',
  type: $.ServiceType.ContentGeneration,

  pricing: {
    model: 'per-product',
    base: 5.0,
    variables: {
      length: { short: 1.0, medium: 1.5, long: 2.0 },
      language: { additional: 3.0 },
    },
  },
})

on.ServiceRequest.created, async (request) => {
  if (request.serviceId !== productDescriptionService.id) return

  const product = request.inputs.product

  // Analyze product
  const analysis = await ai.analyze({
    model: 'gpt-5',
    data: {
      category: product.category,
      features: product.features,
      specifications: product.specs,
      images: product.images,
    },
    extract: ['key-benefits', 'unique-selling-points', 'target-audience'],
  })

  // Generate description
  const description = await ai.generate({
    model: 'gpt-5',
    type: 'product-description',
    context: {
      productName: product.name,
      analysis,
      tone: 'persuasive',
      length: request.inputs.length || 'medium',
      keywords: product.targetKeywords,
    },
  })

  // Generate variations for A/B testing
  const variations = await Promise.all([
    ai.generate({
      model: 'gpt-5',
      type: 'product-description',
      context: { ...description, style: 'features-focused' },
    }),
    ai.generate({
      model: 'gpt-5',
      type: 'product-description',
      context: { ...description, style: 'benefits-focused' },
    }),
    ai.generate({
      model: 'gpt-5',
      type: 'product-description',
      context: { ...description, style: 'story-driven' },
    }),
  ])

  // Translate if requested
  let translations = {}
  if (request.inputs.languages) {
    for (const lang of request.inputs.languages) {
      translations[lang] = await ai.translate({
        text: description.text,
        to: lang,
        preserveFormatting: true,
      })
    }
  }

  // Calculate price
  const lengthMultiplier = productDescriptionService.pricing.variables.length[request.inputs.length || 'medium']
  const translationCost = Object.keys(translations).length * productDescriptionService.pricing.variables.language.additional

  const total = productDescriptionService.pricing.base * lengthMultiplier + translationCost

  // Deliver
  send.ServiceResult.deliver, {
    requestId: request.id,
    outputs: {
      primary: description.text,
      variations: variations.map((v) => v.text),
      translations,
      seo: {
        title: description.seoTitle,
        metaDescription: description.metaDescription,
      },
      bullets: description.keyFeatures,
    },
  })

  send.Payment.charge, {
    customerId: request.customerId,
    amount: total,
    breakdown: {
      base: productDescriptionService.pricing.base * lengthMultiplier,
      translations: translationCost,
    },
  })
})

const invoiceAutomationService = await $.Service.create({
  name: 'Automated Invoice Processor',
  type: $.ServiceType.Automation,

  workflow: ['invoice-receipt', 'data-extraction', 'validation', 'po-matching', 'approval-routing', 'payment-scheduling', 'accounting-integration'],

  pricing: {
    model: 'per-invoice',
    base: 2.0,
    volume: [
      { min: 0, max: 100, rate: 2.0 },
      { min: 101, max: 500, rate: 1.5 },
      { min: 501, max: Infinity, rate: 1.0 },
    ],
  },
})

on.Invoice.received, async (invoice) => {
  try {
    // 1. Extract data using AI OCR
    const extracted = await ai.extract({
      model: 'gpt-5',
      document: invoice.file,
      schema: {
        vendorName: 'string',
        vendorAddress: 'address',
        invoiceNumber: 'string',
        invoiceDate: 'date',
        dueDate: 'date',
        poNumber: 'string',
        lineItems: [
          {
            description: 'string',
            quantity: 'number',
            unitPrice: 'currency',
            amount: 'currency',
          },
        ],
        subtotal: 'currency',
        tax: 'currency',
        total: 'currency',
        bankDetails: {
          accountName: 'string',
          accountNumber: 'string',
          routingNumber: 'string',
        },
      },
    })

    // 2. Validate extraction
    const validation = await validateInvoice(extracted)

    if (!validation.valid) {
      // Low confidence, send for human review
      send.HumanReview.create, {
        type: 'invoice-extraction',
        invoiceId: invoice.id,
        extracted,
        issues: validation.issues,
        priority: 'normal',
      })
      return
    }

    // 3. Match with purchase order
    const po = await db.findOne($.PurchaseOrder, {
      number: extracted.poNumber,
      vendorName: extracted.vendorName,
    })

    if (!po) {
      send.Invoice.flagForReview, {
        invoiceId: invoice.id,
        reason: 'No matching purchase order',
        extracted,
      })
      return
    }

    // 4. Validate against PO
    const poValidation = await validateAgainstPO(extracted, po)

    if (!poValidation.matches) {
      send.Invoice.flagForReview, {
        invoiceId: invoice.id,
        reason: 'Invoice does not match PO',
        differences: poValidation.differences,
        extracted,
        po,
      })
      return
    }

    // 5. Route for approval
    const approver = await determineApprover(extracted, po)

    if (extracted.total > approver.approvalLimit) {
      // Requires higher approval
      const seniorApprover = await getNextApprover(approver)

      send.Approval.request, {
        type: 'invoice',
        invoiceId: invoice.id,
        amount: extracted.total,
        approverId: seniorApprover.id,
        context: { extracted, po },
      })
    } else {
      // Auto-approve within limit
      send.Approval.autoApprove, {
        invoiceId: invoice.id,
        approverId: approver.id,
        reason: 'Within approval limit',
      })
    }

    // 6. Create accounting entries
    send.AccountingEntry.create, {
      type: 'accounts-payable',
      invoiceId: invoice.id,
      vendor: extracted.vendorName,
      amount: extracted.total,
      dueDate: extracted.dueDate,
      lineItems: extracted.lineItems.map((item) => ({
        account: mapToGLAccount(item.description),
        debit: item.amount,
      })),
    })

    // 7. Schedule payment
    const paymentDate = calculatePaymentDate(extracted.dueDate, po.paymentTerms)

    send.Payment.schedule, {
      payee: extracted.vendorName,
      amount: extracted.total,
      date: paymentDate,
      method: po.paymentMethod,
      bankDetails: extracted.bankDetails,
      reference: extracted.invoiceNumber,
    })

    // 8. Update inventory
    for (const item of extracted.lineItems) {
      if (item.sku) {
        send.Inventory.update, {
          sku: item.sku,
          quantity: { increment: item.quantity },
          location: po.deliveryLocation,
        })
      }
    }

    // Update invoice status
    await db.update(invoice, {
      status: 'processed',
      processedAt: new Date(),
      extractedData: extracted,
      purchaseOrder: po.id,
      paymentScheduled: paymentDate,
    })

    // Bill for service
    const monthlyVolume = await getMonthlyInvoiceCount(invoice.companyId)
    const tier = invoiceAutomationService.pricing.volume.find((t) => monthlyVolume >= t.min && monthlyVolume <= t.max)

    send.Payment.charge, {
      customerId: invoice.companyId,
      amount: tier.rate,
      description: `Invoice Processing - ${extracted.invoiceNumber}`,
    })
  } catch (error) {
    send.Invoice.processingFailed, {
      invoiceId: invoice.id,
      error: error.message,
    })
  }
})

// Approval workflow
on.Approval.granted, async (approval) => {
  if (approval.type !== 'invoice') return

  // Continue with payment
  const invoice = await db.findOne($.Invoice, { id: approval.invoiceId })

  send.Payment.execute, {
    invoiceId: invoice.id,
  })
})

const leadEnrichmentService = await $.Service.create({
  name: 'AI Lead Enricher',
  type: $.ServiceType.DataEnrichment,

  enrichmentLevels: {
    basic: {
      price: 0.25,
      includes: ['email-verification', 'company-info'],
    },
    standard: {
      price: 0.75,
      includes: ['basic', 'social-profiles', 'job-details', 'company-size'],
    },
    premium: {
      price: 1.5,
      includes: ['standard', 'technographics', 'intent-data', 'org-chart'],
    },
  },
})

on.ServiceRequest.created, async (request) => {
  if (request.serviceId !== leadEnrichmentService.id) return

  const level = request.inputs.level || 'standard'
  const config = leadEnrichmentService.enrichmentLevels[level]

  const enrichedLeads = []

  for (const lead of request.inputs.leads) {
    const enriched = { ...lead }

    try {
      // Email verification (all levels)
      enriched.email = await verifyEmail(lead.email)

      // Company info (all levels)
      if (lead.company || lead.domain) {
        enriched.company = await ai.research({
          model: 'gpt-5',
          query: lead.company || lead.domain,
          sources: ['linkedin', 'crunchbase', 'company-website'],
          extract: ['industry', 'size', 'revenue', 'location', 'description'],
        })
      }

      // Standard and Premium
      if (config.includes.includes('social-profiles')) {
        enriched.social = await findSocialProfiles(lead)

        if (enriched.social.linkedin) {
          enriched.jobDetails = await ai.extract({
            model: 'gpt-5',
            source: enriched.social.linkedin,
            schema: {
              title: 'string',
              seniority: 'string',
              department: 'string',
              startDate: 'date',
              previousRoles: ['string'],
            },
          })
        }
      }

      // Premium only
      if (config.includes.includes('technographics')) {
        enriched.technographics = await ai.research({
          model: 'gpt-5',
          company: enriched.company,
          extract: ['technologies-used', 'stack', 'tools'],
        })
      }

      if (config.includes.includes('intent-data')) {
        enriched.intent = await ai.analyze({
          model: 'gpt-5',
          sources: [enriched.social, enriched.company.recentNews],
          indicators: ['buying-signals', 'pain-points', 'interests'],
        })
      }

      if (config.includes.includes('org-chart')) {
        enriched.orgChart = await ai.research({
          model: 'gpt-5',
          company: enriched.company,
          findRelatedPeople: {
            relationship: ['reports-to', 'team-members', 'decision-makers'],
          },
        })
      }

      // Lead scoring
      enriched.score = await ai.score({
        model: 'gpt-5',
        lead: enriched,
        criteria: request.inputs.scoringCriteria || 'default',
        scale: 100,
      })

      enrichedLeads.push(enriched)
    } catch (error) {
      enrichedLeads.push({
        ...lead,
        enrichmentError: error.message,
      })
    }
  }

  // Deliver enriched leads
  send.ServiceResult.deliver, {
    requestId: request.id,
    outputs: {
      leads: enrichedLeads,
      summary: {
        total: request.inputs.leads.length,
        enriched: enrichedLeads.filter((l) => !l.enrichmentError).length,
        failed: enrichedLeads.filter((l) => l.enrichmentError).length,
        averageScore: calculateAverageScore(enrichedLeads),
      },
    },
  })

  // Bill for service
  const cost = request.inputs.leads.length * config.price

  send.Payment.charge, {
    customerId: request.customerId,
    amount: cost,
    description: `Lead Enrichment (${level}) - ${request.inputs.leads.length} leads`,
  })
})

const crmSyncService = await $.Service.create({
  name: 'Universal CRM Synchronizer',
  type: $.ServiceType.Integration,

  supportedPlatforms: ['salesforce', 'hubspot', 'pipedrive', 'zoho', 'dynamics'],

  pricing: {
    model: 'subscription',
    tiers: [
      {
        name: 'starter',
        price: 99,
        recordLimit: 10000,
        syncFrequency: 'hourly',
      },
      {
        name: 'professional',
        price: 299,
        recordLimit: 100000,
        syncFrequency: 'real-time',
      },
      {
        name: 'enterprise',
        price: 999,
        recordLimit: Infinity,
        syncFrequency: 'real-time',
        customMappings: true,
      },
    ],
  },
})

// Initial sync setup
on.Integration.created, async (integration) => {
  if (integration.serviceId !== crmSyncService.id) return

  // Fetch all existing records from external CRM
  const externalRecords = await fetchAllRecords(integration.platform, integration.credentials)

  // Map and import to internal system
  for (const record of externalRecords) {
    const mapped = await mapToInternal(record, integration.fieldMappings)

    const internal = await $.Contact.create(mapped)

    // Store mapping
    await db.create($.IntegrationMapping, {
      integrationId: integration.id,
      internalId: internal.id,
      externalId: record.id,
      type: 'contact',
      lastSynced: new Date(),
    })
  }

  // Mark integration as active
  await db.update(integration, {
    status: 'active',
    lastSync: new Date(),
    recordCount: externalRecords.length,
  })
})

// Sync internal changes to external
on.Contact.updated, async (contact) => {
  const integrations = await db.query($.Integration, {
    where: {
      businessId: contact.businessId,
      status: 'active',
    },
  })

  for (const integration of integrations) {
    const mapping = await db.findOne($.IntegrationMapping, {
      integrationId: integration.id,
      internalId: contact.id,
    })

    if (mapping) {
      // Update existing record
      const externalData = await mapToExternal(contact, integration.fieldMappings)

      await updateInCRM(integration.platform, integration.credentials, mapping.externalId, externalData)

      await db.update(mapping, {
        lastSynced: new Date(),
      })
    } else {
      // Create new record
      const externalData = await mapToExternal(contact, integration.fieldMappings)

      const externalRecord = await createInCRM(integration.platform, integration.credentials, externalData)

      await db.create($.IntegrationMapping, {
        integrationId: integration.id,
        internalId: contact.id,
        externalId: externalRecord.id,
        type: 'contact',
      })
    }
  }
})

// Periodic sync from external
setInterval(async () => {
  const integrations = await db.query($.Integration, {
    where: { status: 'active' },
  })

  for (const integration of integrations) {
    try {
      // Fetch updates since last sync
      const updates = await fetchUpdates(integration.platform, integration.credentials, integration.lastSync)

      for (const update of updates) {
        const mapping = await db.findOne($.IntegrationMapping, {
          integrationId: integration.id,
          externalId: update.id,
        })

        if (mapping) {
          // Update internal record
          const internalData = await mapToInternal(update, integration.fieldMappings)

          await db.update($.Contact, {
            where: { id: mapping.internalId },
            data: internalData,
          })

          await db.update(mapping, {
            lastSynced: new Date(),
          })
        } else {
          // Create new internal record
          const internalData = await mapToInternal(update, integration.fieldMappings)

          const internal = await $.Contact.create(internalData)

          await db.create($.IntegrationMapping, {
            integrationId: integration.id,
            internalId: internal.id,
            externalId: update.id,
            type: 'contact',
          })
        }
      }

      // Update last sync time
      await db.update(integration, {
        lastSync: new Date(),
      })
    } catch (error) {
      send.Alert.create, {
        severity: 'error',
        title: `CRM Sync Failed: ${integration.platform}`,
        error: error.message,
        integrationId: integration.id,
      })
    }
  }
}, 60000) // Every minute for real-time plans

// Validate inputs before execution
const validateInputs = (inputs, schema) => {
  const errors = []

  for (const [field, rules] of Object.entries(schema)) {
    if (rules.required && !inputs[field]) {
      errors.push(`${field} is required`)
    }
    // ... more validation
  }

  if (errors.length > 0) {
    throw new ValidationError(errors)
  }
}

// Retry with exponential backoff
const executeWithRetry = async (fn, maxRetries = 3) => {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn()
    } catch (error) {
      if (i === maxRetries - 1) throw error
      await delay(Math.pow(2, i) * 1000)
    }
  }
}

// Emit progress events
const execution = {
  async execute(steps) {
    for (let i = 0; i < steps.length; i++) {
      await this.emitProgress({
        step: i + 1,
        total: steps.length,
        percent: ((i + 1) / steps.length) * 100,
        message: steps[i].name,
      })
      await steps[i].execute()
    }
  },
}

// Track costs per execution
const trackCosts = async (execution) => {
  const costs = {
    aiTokens: execution.tokensUsed * 0.00001,
    storage: execution.storageUsed * 0.023,
    compute: execution.duration * 0.00001,
  }

  costs.total = Object.values(costs).reduce((a, b) => a + b, 0)

  await db.create($.CostRecord, {
    executionId: execution.id,
    costs,
    timestamp: new Date(),
  })
}