Quick Start Guide

# Install the .do SDK
npm install sdk.do

# Or with pnpm
pnpm add sdk.do

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

// Configure SDK
$.configure({
  apiKey: process.env.DO_API_KEY,
})

// Define service
const tweetThreadService = await $.Service.create({
  name: 'Tweet Thread Generator',
  description: 'Turn any topic into an engaging Twitter thread',
  type: $.ServiceType.ContentGeneration,

  input: {
    required: ['topic'],
    optional: ['tone', 'length'],
  },

  pricing: {
    model: 'per-thread',
    rate: 5.0,
  },
})

// Implement service logic
on($.ServiceRequest.created, async (request) => {
  if (request.serviceId !== tweetThreadService.id) return

  try {
    const { topic, tone = 'engaging', length = 5 } = request.inputs

    const thread = await ai.generate({
      model: 'gpt-5',
      prompt: `Create a ${length}-tweet thread about: ${topic}`,
      context: {
        tone,
        constraints: {
          tweetLength: 280,
          includeHashtags: true,
          includeCallToAction: true,
        },
      },
    })

    await send($.ServiceResult.deliver, {
      requestId: request.id,
      outputs: {
        thread: thread.tweets,
        hashtags: thread.hashtags,
        estimatedEngagement: thread.metrics.engagement,
      },
    })

    await send($.Payment.charge, {
      customerId: request.customerId,
      amount: tweetThreadService.pricing.rate,
      description: `Tweet Thread: ${topic}`,
    })
  } catch (error) {
    await send($.ServiceRequest.fail, {
      requestId: request.id,
      error: error.message,
    })
  }
})

// Start the service
console.log(`Tweet Thread Generator deployed: ${tweetThreadService.id}`)

# Using the CLI
do request tweet-thread-generator \
  --input topic="AI and the future of work" \
  --input length=10

# Or via API
curl -X POST https://api.do/services/tweet-thread-generator/requests \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": {
      "topic": "AI and the future of work",
      "length": 10
    }
  }'

// Add quality checks
const quality = await ai.evaluate({
  content: thread.tweets,
  criteria: {
    engagement: { min: 0.7 },
    clarity: { min: 0.8 },
    sentiment: { target: 'positive' },
  },
})

if (quality.score < 0.8) {
  thread = await ai.improve({
    content: thread.tweets,
    issues: quality.issues,
  })
}

// Add scheduling
await send($.Twitter.scheduleThread, {
  tweets: thread.tweets,
  schedule: request.inputs.publishTime,
  customerId: request.customerId,
})

// Add analytics
await send($.Analytics.track, {
  event: 'thread-generated',
  properties: {
    topic,
    length,
    engagement: thread.metrics.engagement,
  },
})

on($.ServiceRequest.created, async (request) => {
  // Check subscription
  const subscription = await db.findOne($.Subscription, {
    customerId: request.customerId,
    serviceId: tweetThreadService.id,
    status: 'active',
  })

  if (!subscription) {
    return await send($.ServiceRequest.reject, {
      requestId: request.id,
      reason: 'No active subscription',
    })
  }

  // Check usage limits
  const usage = await getUsageThisMonth(request.customerId)
  if (usage.threads >= subscription.limits.threads) {
    return await send($.ServiceRequest.reject, {
      requestId: request.id,
      reason: 'Monthly limit reached',
      upgrade: { required: true },
    })
  }

  // Continue with service execution...
})

on($.ServiceResult.delivered, async (result) => {
  const customer = await db.findOne($.Customer, {
    id: result.customerId,
  })

  if (customer.webhookUrl) {
    await fetch(customer.webhookUrl, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        event: 'service.result.delivered',
        serviceId: result.serviceId,
        requestId: result.requestId,
        outputs: result.outputs,
        timestamp: new Date().toISOString(),
      }),
    })
  }
})

on($.ServiceRequest.fail, async (failure) => {
  if (failure.retryable && failure.retryCount < 3) {
    // Wait before retrying
    await sleep(Math.pow(2, failure.retryCount) * 1000)

    // Retry the request
    await send($.ServiceRequest.create, {
      ...failure.originalRequest,
      retryCount: failure.retryCount + 1,
    })
  } else {
    // Final failure - notify customer
    await send($.Customer.notify, {
      customerId: failure.customerId,
      type: 'service-failed',
      message: `Service execution failed: ${failure.error}`,
    })
  }
})