import { streamText } from 'ai';
import { createAnthropic } from '@ai-sdk/anthropic';

// Configure Anthropic provider (replace with your API key)
const anthropic = createAnthropic({
  apiKey: process.env.ANTHROPIC_API_KEY || 'your-api-key-here',
});

// Define a simple tool
const tools = {
  getData: {
    description: 'Fetches data based on a query',
    parameters: {
      type: 'object',
      properties: {
        query: { type: 'string' },
      },
      required: ['query'],
    },
    execute: async ({ query }) => {
      return `Data for: ${query}`;
    },
  },
};

// Sample system prompt
const systemPrompt = 'You are a helpful assistant that can fetch data using tools.';

// Function to simulate the chat stream
async function reproduceBug() {
  try {
    // Initial messages array with a user query
    const messages = [
      {
        role: 'user',
        content: 'Tell me something and fetch data about "example"',
      },
    ];

    // Start streaming with tool calling enabled
    const result = await streamText({
      model: anthropic('claude-3-5-sonnet-latest'),
      system: systemPrompt,
      messages,
      tools,
      maxSteps: 5,
    });

    // Process the stream (simulating tool call response)
    let toolCallDetected = false;
    const updatedMessages = [...messages];

    for await (const chunk of result.fullStream) {
      if (chunk.type === 'tool-call') {
        toolCallDetected = true;
        const toolCall = chunk.args;
        const toolResult = await tools.getData.execute({ query: toolCall.query });

        // Simulate Claude's behavior: Assistant message with empty text + tool call
        updatedMessages.push({
          role: 'assistant',
          content: [
            { type: 'text', text: '' }, // Empty text block causing the bug
            {
              type: 'tool_use',
              id: chunk.toolCallId,
              name: 'getData',
              input: { query: toolCall.query },
            },
          ],
        });

        // Add tool result message
        updatedMessages.push({
          role: 'user',
          content: [
            {
              type: 'tool_result',
              tool_call_id: chunk.toolCallId,
              content: toolResult,
            },
          ],
        });

        // Attempt to continue the stream with the tool result
        const continuedResult = await streamText({
          model: anthropic('claude-3-5-sonnet-latest'),
          system: systemPrompt,
          messages: updatedMessages,
          tools,
          maxSteps: 5,
        });

        for await (const nextChunk of continuedResult.fullStream) {
          console.log(nextChunk);
        }
      }
    }

    if (!toolCallDetected) {
      console.log('No tool call occurred.');
    }
  } catch (error) {
    console.error('Error in chat stream:', error);
    // Expected output: [AI_APICallError: messages: text content blocks must be non-empty]
  }
}

// Run the reproduction
reproduceBug();