Tool Chaos

function cruelTool<T extends { execute: (...args: any[]) => any }>(
  tool: T,
  options?: CruelChaosOptions
): WrappedTool<T>

function cruelTools<T extends Record<string, unknown>>(
  tools: T,
  options?: CruelChaosOptions
): WrappedTools<T>

// Simplified implementation
function cruelTool(tool, options) {
  return {
    ...tool,
    execute: async (...args) => {
      // Check for failure
      if (chance(options.toolFailure)) {
        options.onChaos?.({ type: 'toolFailure' })
        throw new Error('Tool execution failed')
      }
      
      // Check for timeout
      if (chance(options.toolTimeout)) {
        options.onChaos?.({ type: 'toolTimeout' })
        await new Promise(() => {})  // Never resolves
      }
      
      // Add delay
      const ms = getDelay(options.delay)
      if (ms > 0) await sleep(ms)
      
      // Execute original
      return tool.execute(...args)
    },
  }
}

import { openai } from '@ai-sdk/openai'
import { generateText, tool } from 'ai'
import { cruelModel, cruelTools } from 'cruel/ai-sdk'
import { z } from 'zod'

// Chaos at model level
const model = cruelModel(openai('gpt-4'), {
  rateLimit: 0.15,
  delay: [100, 300],
})

// Chaos at tool level
const tools = cruelTools(
  {
    weather: tool({
      description: 'Get weather',
      inputSchema: z.object({ city: z.string() }),
      execute: async ({ city }) => `${city}: 22C`,
    }),
  },
  {
    toolFailure: 0.2,
    delay: [50, 150],
  }
)

const result = await generateText({
  model,
  tools,
  prompt: 'What is the weather in Paris?',
  maxRetries: 3,
})

// Now you test:
// 1. Model failures (rate limits, etc.)
// 2. Tool failures (execution errors)
// 3. Combined scenarios

import { openai } from '@ai-sdk/openai'
import { generateText, tool } from 'ai'
import { cruelModel, cruelTools, presets } from 'cruel/ai-sdk'
import { z } from 'zod'

// Simulate realistic failures
const model = cruelModel(openai('gpt-4'), presets.unstable)

const tools = cruelTools(
  {
    database: tool({
      description: 'Query database',
      inputSchema: z.object({ query: z.string() }),
      execute: async ({ query }) => {
        // Actual database call
        return await db.query(query)
      },
    }),
    
    api: tool({
      description: 'Call external API',
      inputSchema: z.object({ endpoint: z.string() }),
      execute: async ({ endpoint }) => {
        // Actual API call
        return await fetch(`https://api.example.com/${endpoint}`)
      },
    }),
  },
  {
    toolFailure: 0.15,   // 15% failure (network issues, etc.)
    toolTimeout: 0.05,   // 5% timeout
    delay: [100, 500],   // Network latency
    
    onChaos: (event) => {
      console.error(`Tool ${event.type} detected`)
      sendAlert(`Tool chaos: ${event.type}`)
    },
  }
)

try {
  const result = await generateText({
    model,
    tools,
    prompt: 'Get user data from database and enrich with API',
    maxRetries: 3,
  })
  
  console.log('Success:', result.text)
} catch (error) {
  console.error('Failed after retries:', error)
}

import { cruelTools } from 'cruel/ai-sdk'

let toolCalls = 0
let toolFailures = 0
let toolTimeouts = 0

const tools = cruelTools(myTools, {
  toolFailure: 0.2,
  toolTimeout: 0.1,
  
  onChaos: (event) => {
    if (event.type === 'toolFailure') {
      toolFailures++
    }
    if (event.type === 'toolTimeout') {
      toolTimeouts++
    }
  },
})

// Wrap tool execution to count calls
for (const [name, tool] of Object.entries(tools)) {
  const original = tool.execute
  tool.execute = async (...args) => {
    toolCalls++
    return original(...args)
  }
}

// Run tests
await runTestSuite(tools)

console.log(`Tool calls: ${toolCalls}`)
console.log(`Failures: ${toolFailures} (${(toolFailures/toolCalls*100).toFixed(1)}%)`)
console.log(`Timeouts: ${toolTimeouts} (${(toolTimeouts/toolCalls*100).toFixed(1)}%)`)

import { cruelTools, presets } from 'cruel/ai-sdk'

// presets.nightmare includes:
// - toolFailure: 0.1
// - toolTimeout: 0

// presets.apocalypse includes:
// - toolFailure: 0.2
// - toolTimeout: 0.1

const tools = cruelTools(myTools, {
  ...presets.nightmare,
  onChaos: (event) => console.log(event.type),
})

import { cruelTool } from 'cruel/ai-sdk'

const customTool = {
  name: 'calculator',
  execute: async (a: number, b: number) => a + b,
}

const chaosTool = cruelTool(customTool, {
  toolFailure: 0.1,
  delay: [10, 50],
})

// Works!
const result = await chaosTool.execute(2, 3)

const notATool = { foo: 'bar' }
const wrapped = cruelTool(notATool, { toolFailure: 0.1 })
// wrapped === notATool (unchanged)

import type { CruelChaosOptions } from 'cruel/ai-sdk'
import { cruelTool, cruelTools } from 'cruel/ai-sdk'

type MyTool = {
  execute: (arg: string) => Promise<number>
}

const tool: MyTool = {
  execute: async (arg) => arg.length,
}

// Type-safe wrapping
const wrapped = cruelTool(tool, { toolFailure: 0.1 })
// typeof wrapped.execute === (arg: string) => Promise<number>

// Works with tool objects
const tools = {
  a: { execute: async () => 1 },
  b: { execute: async () => 2 },
  c: { notATool: true },  // Ignored
}

const wrappedTools = cruelTools(tools, { toolFailure: 0.1 })
// wrappedTools.a.execute: () => Promise<number>
// wrappedTools.b.execute: () => Promise<number>
// wrappedTools.c: { notATool: true }