// Code function - deterministic validation
async function validateInvoice(invoice: Invoice): Promise<ValidationResult> {
  const errors: string[] = []

  if (!invoice.amount || invoice.amount <= 0) {
    errors.push('Invoice amount must be positive')
  }

  if (!invoice.customerId) {
    errors.push('Customer ID is required')
  }

  if (!invoice.dueDate || invoice.dueDate < new Date()) {
    errors.push('Due date must be in the future')
  }

  return {
    valid: errors.length === 0,
    errors
  }
}

// Code function - transform data structure
async function transformInvoiceToPayment(invoice: Invoice): Promise<PaymentIntent> {
  return {
    amount: invoice.amount,
    currency: invoice.currency || 'usd',
    customer: invoice.customerId,
    description: `Payment for Invoice ${invoice.id}`,
    metadata: {
      invoiceId: invoice.id,
      invoiceNumber: invoice.number
    }
  }
}

// Code function - external API call
async function sendToAccounting(invoice: Invoice): Promise<void> {
  await fetch('https://accounting-api.example.com/invoices', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.ACCOUNTING_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(invoice)
  })
}

// Generative function - create product description
async function generateProductDescription(product: Product): Promise<string> {
  const prompt = `
Generate a compelling product description for:

Name: ${product.name}
Category: ${product.category}
Features: ${product.features.join(', ')}
Target audience: ${product.targetAudience}

Write 2-3 paragraphs that highlight benefits and use cases.
`

  const response = await anthropic.messages.create({
    model: 'claude-sonnet-4-5',
    max_tokens: 500,
    messages: [{ role: 'user', content: prompt }]
  })

  return response.content[0].text
}

// Generative function - classify support ticket
async function classifyTicket(ticket: SupportTicket): Promise<TicketCategory> {
  const prompt = `
Classify this support ticket into one category:
- billing
- technical
- feature_request
- bug_report
- other

Ticket: ${ticket.description}

Respond with just the category name.
`

  const response = await openai.chat.completions.create({
    model: 'gpt-4',
    messages: [{ role: 'user', content: prompt }],
    temperature: 0
  })

  return response.choices[0].message.content as TicketCategory
}

// Generative function - extract structured data
async function extractInvoiceData(ocrText: string): Promise<InvoiceData> {
  const prompt = `
Extract invoice data from this OCR text and return as JSON:

${ocrText}

Return JSON with these fields:
- invoiceNumber: string
- amount: number
- currency: string
- dueDate: string (ISO format)
- vendorName: string
`

  const response = await anthropic.messages.create({
    model: 'claude-sonnet-4-5',
    messages: [{ role: 'user', content: prompt }]
  })

  return JSON.parse(response.content[0].text)
}

// Agentic function - multi-step research
async function researchCompetitor(company: string, agent: Agent): Promise<CompetitorReport> {
  const task: Task = {
    type: 'research',
    description: `Research ${company} and provide a competitive analysis`,
    context: {
      company,
      focusAreas: ['products', 'pricing', 'market_position', 'recent_news']
    }
  }

  // Agent autonomously:
  // 1. Plans the research approach
  // 2. Searches the web for information
  // 3. Visits and analyzes competitor websites
  // 4. Synthesizes findings into a report
  const result = await agent.do(task)

  return result.data as CompetitorReport
}

// Agentic function - analyze codebase
async function analyzeCodeQuality(repo: Repository, agent: Agent): Promise<QualityReport> {
  const task: Task = {
    type: 'analysis',
    description: 'Analyze code quality and provide recommendations',
    context: {
      repoUrl: repo.url,
      language: repo.primaryLanguage,
      focusAreas: ['architecture', 'testing', 'documentation', 'performance']
    }
  }

  // Agent autonomously:
  // 1. Clones repository
  // 2. Analyzes code structure
  // 3. Runs static analysis tools
  // 4. Reviews test coverage
  // 5. Generates comprehensive report
  const result = await agent.do(task)

  return result.data as QualityReport
}

// Agentic function - complete complex workflow
async function createFeatureImplementation(
  feature: FeatureRequest,
  agent: Agent
): Promise<Implementation> {
  const task: Task = {
    type: 'implementation',
    description: `Create implementation plan and code for: ${feature.title}`,
    context: {
      requirements: feature.requirements,
      codebase: feature.codebaseContext,
      constraints: feature.constraints
    }
  }

  // Agent autonomously:
  // 1. Analyzes requirements
  // 2. Reviews existing codebase
  // 3. Designs solution architecture
  // 4. Writes implementation code
  // 5. Creates tests
  // 6. Generates documentation
  const result = await agent.do(task)

  return result.data as Implementation
}

// Human function - approve invoice
async function approveInvoice(invoice: Invoice, human: Human): Promise<ApprovalResult> {
  const task: HumanTask = {
    type: 'approval',
    assignee: human,
    description: `Approve invoice ${invoice.number} for ${invoice.amount}`,
    data: invoice,
    ui: {
      type: 'slack',
      template: 'invoice-approval'
    }
  }

  // Creates task, notifies human via Slack
  // Human reviews and clicks approve/reject
  const result = await human.do(task)

  return result.data as ApprovalResult
}

// Human function - review blog post
async function reviewBlogPost(post: BlogPost, reviewer: Human): Promise<ReviewResult> {
  const task: HumanTask = {
    type: 'review',
    assignee: reviewer,
    description: `Review blog post: ${post.title}`,
    data: {
      post,
      criteria: ['accuracy', 'tone', 'grammar', 'SEO']
    },
    ui: {
      type: 'web',
      template: 'content-review'
    }
  }

  // Opens web interface for human review
  // Reviewer provides feedback and approval
  const result = await reviewer.do(task)

  return result.data as ReviewResult
}

// Human function - make strategic decision
async function decidePricingStrategy(
  analysis: MarketAnalysis,
  executive: Human
): Promise<PricingDecision> {
  const task: HumanTask = {
    type: 'decision',
    assignee: executive,
    description: 'Review market analysis and decide pricing strategy',
    data: {
      analysis,
      options: ['premium', 'competitive', 'penetration'],
      context: 'Q1 2024 product launch'
    },
    ui: {
      type: 'web',
      template: 'strategic-decision'
    }
  }

  // Executive reviews analysis in web interface
  // Makes decision with rationale
  const result = await executive.do(task)

  return result.data as PricingDecision
}

// Same task, different UIs
const approvalTask = createHumanTask({
  type: 'approval',
  data: invoice
})

// Render to Slack
renderSlack(approvalTask) // Slack Block Kit with buttons

// Render to Email
renderEmail(approvalTask) // HTML email with action buttons

// Render to Web
renderHTML(approvalTask) // Rich web interface

interface Task {
  id: string
  type: string
  description: string
  context: any
  assignee?: Agent | Human
  status: 'pending' | 'in_progress' | 'completed' | 'failed'
  result?: Result
}

interface Result {
  success: boolean
  data: any
  error?: string
}

interface Worker {
  ask(prompt: string): Promise<Response>
  do(task: Task): Promise<Result>
}

async function processInvoice(invoice: Invoice): Promise<ProcessedInvoice> {
  // 1. Code function - validate
  const validation = await validateInvoice(invoice)
  if (!validation.valid) throw new Error('Invalid invoice')

  // 2. Generative function - extract data
  const extractedData = await extractInvoiceData(invoice.ocrText)

  // 3. Code function - transform
  const enrichedInvoice = await enrichInvoiceData(invoice, extractedData)

  // 4. Agentic or Human function - approve
  const approver = enrichedInvoice.amount > 10000
    ? humanApprover  // Human for high-value
    : agentApprover  // Agent for low-value

  const approval = await approveInvoice(enrichedInvoice, approver)

  if (!approval.approved) {
    throw new Error('Invoice not approved')
  }

  // 5. Code function - process payment
  const payment = await processPayment(enrichedInvoice)

  return { invoice: enrichedInvoice, payment, approval }
}

// Execute functions in sequence
async function processOrder(order: Order): Promise<ProcessedOrder> {
  const validated = await validateOrder(order)        // Code
  const enriched = await enrichOrderData(validated)   // Code
  const fraud = await checkFraud(enriched)            // Generative
  const approved = await approveOrder(enriched)       // Human
  const processed = await processPayment(approved)    // Code
  return processed
}

// Execute functions in parallel
async function analyzeCompetitors(competitors: string[]): Promise<Analysis[]> {
  const tasks = competitors.map(competitor =>
    researchCompetitor(competitor, agent)  // Agentic
  )
  return await Promise.all(tasks)
}

// Choose function based on conditions
async function handleSupport(ticket: SupportTicket): Promise<Resolution> {
  const category = await classifyTicket(ticket)  // Generative

  if (category === 'billing') {
    return await resolveBilling(ticket)      // Code
  } else if (category === 'technical') {
    return await debugIssue(ticket, agent)   // Agentic
  } else {
    return await escalateToHuman(ticket)     // Human
  }
}

Is the logic deterministic?
├─ Yes → Code function (ServiceAccount)
└─ No → Does it need language understanding/generation?
    ├─ Yes → Is it a single-turn generation?
    │   ├─ Yes → Generative function (Model)
    │   └─ No → Agentic function (Agent)
    └─ No → Does it require human judgment?
        ├─ Yes → Human function (Human)
        └─ No → Agentic function (Agent)

// Optimize by using cheaper functions when possible
async function processDocument(doc: Document): Promise<ProcessedDoc> {
  // Try Code function first (free)
  const parsed = await parseDocument(doc)

  // Use Generative only if needed (cheap)
  const classified = await classifyDocument(parsed)

  // Use Agentic for complex analysis (moderate cost)
  if (classified.needsDeepAnalysis) {
    return await analyzeDocument(parsed, agent)
  }

  // Only escalate to Human for exceptions (expensive)
  if (classified.requiresHumanReview) {
    return await reviewDocument(parsed, human)
  }

  return parsed
}