> ## Documentation Index
> Fetch the complete documentation index at: https://docs.sudoapp.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# AI Router

> Create AI responses with various models and parameters

AI responses are the core functionality of the Sudo platform, allowing you to generate chat completions from a wide variety of models including GPT, Claude, Gemini, and more.

## Basic Usage

### Simple AI Response

<CodeGroup dropdown>
  ```typescript TypeScript theme={null}
  import { Sudo } from "sudo-ai";

  const sudo = new Sudo({
    serverURL: "https://sudoapp.dev/api",
    apiKey: process.env.SUDO_API_KEY ?? "",
  });

  async function simpleResponse() {
    const response = await sudo.router.create({
      model: "claude-sonnet-4-20250514",
      messages: [
        { role: "user", content: "Hello! How are you?" }
      ]
    });
    
    console.log(response.choices[0].message.content);
  }

  simpleResponse();
  ```

  ```python Python theme={null}
  import os
  from sudo import Sudo

  with Sudo(
      server_url="https://sudoapp.dev/api",
      api_key=os.getenv("SUDO_API_KEY"),
  ) as client:
      response = client.router.create(
          model="claude-sonnet-4-20250514",
          messages=[
              {"role": "user", "content": "Hello! How are you?"}
          ]
      )
      
      print(response.choices[0].message.content)
  ```
</CodeGroup>

### Conversation with System Message

<CodeGroup dropdown>
  ```typescript TypeScript theme={null}
  import { Sudo } from "sudo-ai";

  const sudo = new Sudo({
    serverURL: "https://sudoapp.dev/api",
    apiKey: process.env.SUDO_API_KEY ?? "",
  });

  async function conversationWithSystem() {
    const response = await sudo.router.create({
      model: "gpt-4o",
      messages: [
        {
          role: "system", 
          content: "You are a helpful programming assistant specialized in TypeScript."
        },
        {
          role: "user", 
          content: "How do I create a type-safe object from two arrays?"
        }
      ]
    });
    
    console.log(response.choices[0].message.content);
  }

  conversationWithSystem();
  ```

  ```python Python theme={null}
  import os
  from sudo import Sudo

  with Sudo(
      server_url="https://sudoapp.dev/api",
      api_key=os.getenv("SUDO_API_KEY"),
  ) as client:
      response = client.router.create(
          model="gpt-4o",
          messages=[
              {
                  "role": "system", 
                  "content": "You are a helpful programming assistant specialized in Python."
              },
              {
                  "role": "user", 
                  "content": "How do I create a dictionary from two lists?"
              }
          ]
      )
      
      print(response.choices[0].message.content)
  ```
</CodeGroup>

### Multi-turn Conversation

<CodeGroup dropdown>
  ```typescript TypeScript theme={null}
  import { Sudo } from "sudo-ai";
  import * as readline from 'readline';

  const sudo = new Sudo({
    serverURL: "https://sudoapp.dev/api",
    apiKey: process.env.SUDO_API_KEY ?? "",
  });

  async function chatConversation() {
    // Conversation history
    const messages = [
      { role: "system", content: "You are a helpful assistant." }
    ];
    
    const rl = readline.createInterface({
      input: process.stdin,
      output: process.stdout
    });
    
    const askQuestion = (query: string): Promise<string> =>
      new Promise(resolve => rl.question(query, resolve));
    
    console.log("Chat started! Type 'quit' or 'exit' to end.");
    
    while (true) {
      try {
        // Get user input
        const userInput = await askQuestion("You: ");
        if (userInput.toLowerCase() === 'quit' || userInput.toLowerCase() === 'exit') {
          break;
        }
        
        // Add user message
        messages.push({ role: "user", content: userInput });
        
        // Get AI response
        const response = await sudo.router.create({
          model: "claude-sonnet-4-20250514",
          messages: messages
        });
        
        const aiMessage = response.choices[0].message.content;
        console.log(`AI: ${aiMessage}`);
        
        // Add AI response to conversation history
        messages.push({ role: "assistant", content: aiMessage });
        
      } catch (error) {
        console.error("Error:", error);
      }
    }
    
    rl.close();
  }

  chatConversation();
  ```

  ```python Python theme={null}
  import os
  from sudo import Sudo

  def chat_conversation():
      with Sudo(
          server_url="https://sudoapp.dev/api",
          api_key=os.getenv("SUDO_API_KEY"),
      ) as client:
          # Conversation history
          messages = [
              {"role": "system", "content": "You are a helpful assistant."}
          ]
          
          while True:
              # Get user input
              user_input = input("You: ")
              if user_input.lower() in ['quit', 'exit']:
                  break
              
              # Add user message
              messages.append({"role": "user", "content": user_input})
              
              # Get AI response
              response = client.router.create(
                  model="claude-sonnet-4-20250514",
                  messages=messages
              )
              
              ai_message = response.choices[0].message.content
              print(f"AI: {ai_message}")
              
              # Add AI response to conversation history
              messages.append({"role": "assistant", "content": ai_message})

  chat_conversation()
  ```
</CodeGroup>

## Parameters and Configuration

### Temperature and Randomness

<CodeGroup dropdown>
  ```typescript TypeScript theme={null}
  import { Sudo } from "sudo-ai";

  const sudo = new Sudo({
    serverURL: "https://sudoapp.dev/api",
    apiKey: process.env.SUDO_API_KEY ?? "",
  });

  async function temperatureExamples() {
    // Deterministic output (low temperature)
    const deterministic = await sudo.router.create({
      model: "gpt-4o",
      messages: [{ role: "user", content: "Explain quantum computing" }],
      temperature: 0.1  // Very focused, consistent responses
    });
    
    // Creative output (high temperature)
    const creative = await sudo.router.create({
      model: "gpt-4o",
      messages: [{ role: "user", content: "Write a creative story" }],
      temperature: 0.9  // More random and creative
    });
    
    console.log("Deterministic:", deterministic.choices[0].message.content.substring(0, 100));
    console.log("Creative:", creative.choices[0].message.content.substring(0, 100));
  }

  temperatureExamples();
  ```

  ```python Python theme={null}
  import os
  from sudo import Sudo

  with Sudo(
      server_url="https://sudoapp.dev/api",
      api_key=os.getenv("SUDO_API_KEY"),
  ) as client:
      # Deterministic output (low temperature)
      deterministic = client.router.create(
          model="gpt-4o",
          messages=[{"role": "user", "content": "Explain quantum computing"}],
          temperature=0.1  # Very focused, consistent responses
      )
      
      # Creative output (high temperature)
      creative = client.router.create(
          model="gpt-4o",
          messages=[{"role": "user", "content": "Write a creative story"}],
          temperature=0.9  # More random and creative
      )
      
      print("Deterministic:", deterministic.choices[0].message.content[:100])
      print("Creative:", creative.choices[0].message.content[:100])
  ```
</CodeGroup>

### Token Limits

<CodeGroup dropdown>
  ```typescript TypeScript theme={null}
  import { Sudo } from "sudo-ai";

  const sudo = new Sudo({
    serverURL: "https://sudoapp.dev/api",
    apiKey: process.env.SUDO_API_KEY ?? "",
  });

  async function tokenLimitsExample() {
    const response = await sudo.router.create({
      model: "gpt-4o",
      messages: [{ role: "user", content: "Write a summary of machine learning" }],
      maxCompletionTokens: 150  // Limit response length
    });
    
    console.log(`Tokens used: ${response.usage.totalTokens}`);
    console.log(`Response: ${response.choices[0].message.content}`);
  }

  tokenLimitsExample();
  ```

  ```python Python theme={null}
  import os
  from sudo import Sudo

  with Sudo(
      server_url="https://sudoapp.dev/api",
      api_key=os.getenv("SUDO_API_KEY"),
  ) as client:
      response = client.router.create(
          model="gpt-4o",
          messages=[{"role": "user", "content": "Write a summary of machine learning"}],
          max_completion_tokens=150  # Limit response length
      )
      
      print(f"Tokens used: {response.usage.total_tokens}")
      print(f"Response: {response.choices[0].message.content}")
  ```
</CodeGroup>

### Frequency and Presence Penalties

<CodeGroup dropdown>
  ```typescript TypeScript theme={null}
  import { Sudo } from "sudo-ai";

  const sudo = new Sudo({
    serverURL: "https://sudoapp.dev/api",
    apiKey: process.env.SUDO_API_KEY ?? "",
  });

  async function penaltiesExample() {
    const response = await sudo.router.create({
      model: "gpt-4o",
      messages: [{ role: "user", content: "List programming languages" }],
      frequencyPenalty: 0.5,  // Reduce repetition of frequent words
      presencePenalty: 0.5    // Encourage diverse vocabulary
    });
    
    console.log(response.choices[0].message.content);
  }

  penaltiesExample();
  ```

  ```python Python theme={null}
  import os
  from sudo import Sudo

  with Sudo(
      server_url="https://sudoapp.dev/api",
      api_key=os.getenv("SUDO_API_KEY"),
  ) as client:
      response = client.router.create(
          model="gpt-4o",
          messages=[{"role": "user", "content": "List programming languages"}],
          frequency_penalty=0.5,  # Reduce repetition of frequent words
          presence_penalty=0.5    # Encourage diverse vocabulary
      )
      
      print(response.choices[0].message.content)
  ```
</CodeGroup>

### Stop Sequences

<CodeGroup dropdown>
  ```typescript TypeScript theme={null}
  import { Sudo } from "sudo-ai";

  const sudo = new Sudo({
    serverURL: "https://sudoapp.dev/api",
    apiKey: process.env.SUDO_API_KEY ?? "",
  });

  async function stopSequencesExample() {
    const response = await sudo.router.create({
      model: "gpt-4o",
      messages: [{ role: "user", content: "Count from 1 to 10" }],
      stop: ["5", "---"]  // Stop generation at these sequences
    });
    
    console.log(response.choices[0].message.content);
  }

  stopSequencesExample();
  ```

  ```python Python theme={null}
  import os
  from sudo import Sudo

  with Sudo(
      server_url="https://sudoapp.dev/api",
      api_key=os.getenv("SUDO_API_KEY"),
  ) as client:
      response = client.router.create(
          model="gpt-4o",
          messages=[{"role": "user", "content": "Count from 1 to 10"}],
          stop=["5", "---"]  # Stop generation at these sequences
      )
      
      print(response.choices[0].message.content)
  ```
</CodeGroup>

## Response Format Options

### Multiple Choices

<CodeGroup dropdown>
  ```typescript TypeScript theme={null}
  import { Sudo } from "sudo-ai";

  const sudo = new Sudo({
    serverURL: "https://sudoapp.dev/api",
    apiKey: process.env.SUDO_API_KEY ?? "",
  });

  async function multipleChoicesExample() {
    const response = await sudo.router.create({
      model: "gpt-4o",
      messages: [{ role: "user", content: "Give me a creative business idea" }],
      n: 3  // Generate 3 different responses
    });
    
    response.choices.forEach((choice, index) => {
      console.log(`Idea ${index + 1}: ${choice.message.content}`);
      console.log("-".repeat(50));
    });
  }

  multipleChoicesExample();
  ```

  ```python Python theme={null}
  import os
  from sudo import Sudo

  with Sudo(
      server_url="https://sudoapp.dev/api",
      api_key=os.getenv("SUDO_API_KEY"),
  ) as client:
      response = client.router.create(
          model="gpt-4o",
          messages=[{"role": "user", "content": "Give me a creative business idea"}],
          n=3  # Generate 3 different responses
      )
      
      for i, choice in enumerate(response.choices, 1):
          print(f"Idea {i}: {choice.message.content}")
          print("-" * 50)
  ```
</CodeGroup>

### Log Probabilities

<CodeGroup dropdown>
  ```typescript TypeScript theme={null}
  import { Sudo } from "sudo-ai";

  const sudo = new Sudo({
    serverURL: "https://sudoapp.dev/api",
    apiKey: process.env.SUDO_API_KEY ?? "",
  });

  async function logProbsExample() {
    const response = await sudo.router.create({
      model: "gpt-4o",
      messages: [{ role: "user", content: "The capital of France is" }],
      logprobs: true,
      topLogprobs: 3  // Show top 3 token probabilities
    });
    
    const choice = response.choices[0];
    if (choice.logprobs) {
      choice.logprobs.content.forEach(tokenInfo => {
        console.log(`Token: ${tokenInfo.token}`);
        console.log(`Probability: ${tokenInfo.logprob}`);
        console.log("Top alternatives:");
        tokenInfo.topLogprobs.forEach(alt => {
          console.log(`  ${alt.token}: ${alt.logprob}`);
        });
      });
    }
  }

  logProbsExample();
  ```

  ```python Python theme={null}
  import os
  from sudo import Sudo

  with Sudo(
      server_url="https://sudoapp.dev/api",
      api_key=os.getenv("SUDO_API_KEY"),
  ) as client:
      response = client.router.create(
          model="gpt-4o",
          messages=[{"role": "user", "content": "The capital of France is"}],
          logprobs=True,
          top_logprobs=3  # Show top 3 token probabilities
      )
      
      choice = response.choices[0]
      if choice.logprobs:
          for token_info in choice.logprobs.content:
              print(f"Token: {token_info.token}")
              print(f"Probability: {token_info.logprob}")
              print("Top alternatives:")
              for alt in token_info.top_logprobs:
                  print(f"  {alt.token}: {alt.logprob}")
  ```
</CodeGroup>

## Metadata and Storage

### Adding Metadata

<CodeGroup dropdown>
  ```typescript TypeScript theme={null}
  import { Sudo } from "sudo-ai";

  const sudo = new Sudo({
    serverURL: "https://sudoapp.dev/api",
    apiKey: process.env.SUDO_API_KEY ?? "",
  });

  async function metadataExample() {
    const response = await sudo.router.create({
      model: "gpt-4o",
      messages: [{ role: "user", content: "Explain TypeScript decorators" }],
      metadata: {
        userId: "user_123",
        sessionId: "session_456",
        feature: "code_explanation",
        version: "1.0"
      },
      store: true  // Store for later retrieval (OpenAI compatible)
    });
    
    console.log(`Completion ID: ${response.id}`);
    console.log(`Response: ${response.choices[0].message.content}`);
  }

  metadataExample();
  ```

  ```python Python theme={null}
  import os
  from sudo import Sudo

  with Sudo(
      server_url="https://sudoapp.dev/api",
      api_key=os.getenv("SUDO_API_KEY"),
  ) as client:
      response = client.router.create(
          model="gpt-4o",
          messages=[{"role": "user", "content": "Explain Python decorators"}],
          metadata={
              "user_id": "user_123",
              "session_id": "session_456",
              "feature": "code_explanation",
              "version": "1.0"
          },
          store=True  # Store for later retrieval (OpenAI compatible)
      )
      
      print(f"Completion ID: {response.id}")
      print(f"Response: {response.choices[0].message.content}")
  ```
</CodeGroup>

## Async Usage

### Basic Async

<CodeGroup dropdown>
  ```typescript TypeScript theme={null}
  import { Sudo } from "sudo-ai";

  const sudo = new Sudo({
    serverURL: "https://sudoapp.dev/api",
    apiKey: process.env.SUDO_API_KEY ?? "",
  });

  async function asyncChat() {
    try {
      const response = await sudo.router.create({
        model: "claude-sonnet-4-20250514",
        messages: [{ role: "user", content: "Hello async world!" }]
      });
      
      return response.choices[0].message.content;
    } catch (error) {
      console.error("Error in async chat:", error);
      throw error;
    }
  }

  // Usage
  asyncChat()
    .then(result => console.log(result))
    .catch(error => console.error("Failed:", error));
  ```

  ```python Python theme={null}
  import asyncio
  import os
  from sudo import Sudo

  async def async_chat():
      async with Sudo(
          server_url="https://sudoapp.dev/api",
          api_key=os.getenv("SUDO_API_KEY"),
      ) as client:
          response = await client.router.create_async(
              model="claude-sonnet-4-20250514",
              messages=[{"role": "user", "content": "Hello async world!"}]
          )
          return response.choices[0].message.content

  # Run async function
  result = asyncio.run(async_chat())
  print(result)
  ```
</CodeGroup>

### Concurrent Requests

<CodeGroup dropdown>
  ```typescript TypeScript theme={null}
  import { Sudo } from "sudo-ai";

  const sudo = new Sudo({
    serverURL: "https://sudoapp.dev/api",
    apiKey: process.env.SUDO_API_KEY ?? "",
  });

  async function processMultipleQueries() {
    const queries = [
      "What is machine learning?",
      "Explain neural networks",
      "What is deep learning?",
      "How do transformers work?"
    ];
    
    try {
      // Process all queries concurrently
      const promises = queries.map(query =>
        sudo.router.create({
          model: "gpt-4o",
          messages: [{ role: "user", content: query }],
          maxCompletionTokens: 100
        })
      );
      
      const responses = await Promise.all(promises);
      
      // Display results
      responses.forEach((response, index) => {
        console.log(`Q: ${queries[index]}`);
        console.log(`A: ${response.choices[0].message.content}`);
        console.log(`Tokens: ${response.usage.totalTokens}`);
        console.log("---");
      });
      
    } catch (error) {
      console.error("Error processing queries:", error);
    }
  }

  processMultipleQueries();
  ```

  ```python Python theme={null}
  import asyncio
  import os
  from sudo import Sudo

  async def process_multiple_queries():
      async with Sudo(
          server_url="https://sudoapp.dev/api",
          api_key=os.getenv("SUDO_API_KEY"),
      ) as client:
          queries = [
              "What is machine learning?",
              "Explain neural networks", 
              "What is deep learning?",
              "How do transformers work?"
          ]
          
          # Create tasks for concurrent execution
          tasks = [
              client.router.create_async(
                  model="gpt-4o",
                  messages=[{"role": "user", "content": query}],
                  max_completion_tokens=100
              )
              for query in queries
          ]
          
          # Wait for all responses
          responses = await asyncio.gather(*tasks)
          
          # Display results
          for query, response in zip(queries, responses):
              print(f"Q: {query}")
              print(f"A: {response.choices[0].message.content}")
              print(f"Tokens: {response.usage.total_tokens}")
              print("---")

  # Run the async function
  asyncio.run(process_multiple_queries())
  ```
</CodeGroup>

## Error Handling

<CodeGroup dropdown>
  ```typescript TypeScript theme={null}
  import { Sudo } from "sudo-ai";
  import * as errors from "sudo-ai/models/errors";

  const sudo = new Sudo({
    serverURL: "https://sudoapp.dev/api",
    apiKey: process.env.SUDO_API_KEY ?? "",
  });

  async function errorHandlingExample() {
    try {
      const response = await sudo.router.create({
        model: "non-existent-model",  // This will cause an error
        messages: [{ role: "user", content: "Hello" }]
      });
      
      console.log(response.choices[0].message.content);
      
    } catch (error) {
      if (error instanceof errors.SudoError) {
        console.log(`SDK Error: ${error.message}`);
        console.log(`Status Code: ${error.statusCode}`);
        console.log(`Response Body: ${error.body}`);
        
        // Handle specific error types
        if (error instanceof errors.ErrorResponse) {
          console.log(`Error Details: ${error.data$.error}`);
        }
      } else {
        console.log(`Unexpected error: ${error}`);
      }
    }
  }

  errorHandlingExample();
  ```

  ```python Python theme={null}
  import os
  from sudo import Sudo, errors

  with Sudo(
      server_url="https://sudoapp.dev/api",
      api_key=os.getenv("SUDO_API_KEY"),
  ) as client:
      try:
          response = client.router.create(
              model="non-existent-model",  # This will cause an error
              messages=[{"role": "user", "content": "Hello"}]
          )
          print(response.choices[0].message.content)
          
      except errors.ErrorResponse as e:
          print(f"API Error: {e.message}")
          print(f"Status Code: {e.status_code}")
          print(f"Error Details: {e.data.error}")
      except errors.SudoError as e:
          print(f"SDK Error: {e.message}")
          print(f"Status Code: {e.status_code}")
      except Exception as e:
          print(f"Unexpected error: {str(e)}")
  ```
</CodeGroup>

## Advanced Examples

### Chat Bot with Context Management

<CodeGroup dropdown>
  ```typescript TypeScript theme={null}
  import { Sudo } from "sudo-ai";
  import * as readline from 'readline';

  interface ChatResponse {
    response?: string;
    tokensUsed?: number;
    model?: string;
    error?: string;
  }

  class ChatBot {
    private sudo: Sudo;
    private model: string;
    private maxHistory: number;
    private conversationHistory: Array<{role: string; content: string}>;

    constructor(model: string = "claude-sonnet-4-20250514", maxHistory: number = 10) {
      this.sudo = new Sudo({
        serverURL: "https://sudoapp.dev/api",
        apiKey: process.env.SUDO_API_KEY ?? "",
      });
      this.model = model;
      this.maxHistory = maxHistory;
      this.conversationHistory = [
        {
          role: "system",
          content: `You are a helpful assistant. Current time: ${new Date().toISOString()}`
        }
      ];
    }

    async chat(message: string): Promise<ChatResponse> {
      try {
        // Add user message
        this.conversationHistory.push({ role: "user", content: message });

        // Trim history if too long
        if (this.conversationHistory.length > this.maxHistory) {
          // Keep system message and recent messages
          this.conversationHistory = [
            this.conversationHistory[0]  // System message
          ].concat(this.conversationHistory.slice(-(this.maxHistory - 1)));
        }

        const response = await this.sudo.router.create({
          model: this.model,
          messages: this.conversationHistory,
          temperature: 0.7
        });

        const aiResponse = response.choices[0].message.content;

        // Add AI response to history
        this.conversationHistory.push({ role: "assistant", content: aiResponse });

        return {
          response: aiResponse,
          tokensUsed: response.usage.totalTokens,
          model: response.model
        };

      } catch (error) {
        return { error: `Failed to get response: ${error}` };
      }
    }

    resetConversation(): void {
      // Reset the conversation history, keeping only the system message
      this.conversationHistory = [this.conversationHistory[0]];
    }

    getHistorySummary(): { totalMessages: number; userMessages: number; aiMessages: number } {
      const userMessages = this.conversationHistory.filter(m => m.role === "user").length;
      const aiMessages = this.conversationHistory.filter(m => m.role === "assistant").length;
      return {
        totalMessages: this.conversationHistory.length,
        userMessages,
        aiMessages
      };
    }
  }

  // Usage
  async function runChatBot() {
    const bot = new ChatBot();
    
    const rl = readline.createInterface({
      input: process.stdin,
      output: process.stdout
    });

    const askQuestion = (query: string): Promise<string> =>
      new Promise(resolve => rl.question(query, resolve));

    console.log("Chat started! Type 'quit', 'exit', 'reset', or 'summary'");

    while (true) {
      try {
        const userInput = await askQuestion("You: ");
        
        if (userInput.toLowerCase() === 'quit' || userInput.toLowerCase() === 'exit') {
          break;
        } else if (userInput.toLowerCase() === 'reset') {
          bot.resetConversation();
          console.log("Conversation reset!");
          continue;
        } else if (userInput.toLowerCase() === 'summary') {
          const summary = bot.getHistorySummary();
          console.log(`Conversation summary: ${JSON.stringify(summary)}`);
          continue;
        }

        const result = await bot.chat(userInput);
        if (result.error) {
          console.log(`Error: ${result.error}`);
        } else {
          console.log(`AI: ${result.response}`);
          console.log(`(Tokens: ${result.tokensUsed}, Model: ${result.model})`);
        }
      } catch (error) {
        console.error("Unexpected error:", error);
      }
    }

    rl.close();
  }

  runChatBot();
  ```

  ```python Python theme={null}
  import os
  from datetime import datetime
  from sudo import Sudo

  class ChatBot:
      def __init__(self, model="claude-sonnet-4-20250514", max_history=10):
          self.client = Sudo(
              server_url="https://sudoapp.dev/api",
              api_key=os.getenv("SUDO_API_KEY"),
          )
          self.model = model
          self.max_history = max_history
          self.conversation_history = [
              {
                  "role": "system", 
                  "content": f"You are a helpful assistant. Current time: {datetime.now()}"
              }
          ]
      
      def chat(self, message):
          """Send a message and get a response"""
          # Add user message
          self.conversation_history.append({"role": "user", "content": message})
          
          # Trim history if too long
          if len(self.conversation_history) > self.max_history:
              # Keep system message and recent messages
              self.conversation_history = [
                  self.conversation_history[0]  # System message
              ] + self.conversation_history[-(self.max_history-1):]
          
          try:
              response = self.client.router.create(
                  model=self.model,
                  messages=self.conversation_history,
                  temperature=0.7
              )
              
              ai_response = response.choices[0].message.content
              
              # Add AI response to history
              self.conversation_history.append({"role": "assistant", "content": ai_response})
              
              return {
                  "response": ai_response,
                  "tokens_used": response.usage.total_tokens,
                  "model": response.model
              }
              
          except Exception as e:
              return {"error": f"Failed to get response: {str(e)}"}
      
      def reset_conversation(self):
          """Reset the conversation history"""
          self.conversation_history = [self.conversation_history[0]]  # Keep system message
      
      def get_history_summary(self):
          """Get a summary of the conversation"""
          user_messages = len([m for m in self.conversation_history if m["role"] == "user"])
          ai_messages = len([m for m in self.conversation_history if m["role"] == "assistant"])
          return {
              "total_messages": len(self.conversation_history),
              "user_messages": user_messages,
              "ai_messages": ai_messages
          }

  # Usage
  bot = ChatBot()

  # Interactive chat
  while True:
      user_input = input("You: ")
      if user_input.lower() in ['quit', 'exit']:
          break
      elif user_input.lower() == 'reset':
          bot.reset_conversation()
          print("Conversation reset!")
          continue
      elif user_input.lower() == 'summary':
          summary = bot.get_history_summary()
          print(f"Conversation summary: {summary}")
          continue
      
      result = bot.chat(user_input)
      if "error" in result:
          print(f"Error: {result['error']}")
      else:
          print(f"AI: {result['response']}")
          print(f"(Tokens: {result['tokens_used']}, Model: {result['model']})")
  ```
</CodeGroup>

## Next Steps

Now that you understand AI responses:

1. **[Explore Streaming](/sdk/sudo-sdk/streaming)** - Add real-time streaming responses
2. **[Try Tool Calling](/sdk/sudo-sdk/tool-calling)** - Enable function calling capabilities
3. **[Structured Output](/sdk/sudo-sdk/structured-output)** - Generate JSON and structured data
4. **[Image Input](/sdk/sudo-sdk/image-input)** - Work with multimodal inputs

<Tip>
  Start with simple use cases and gradually add complexity. Use appropriate models for your needs - faster models for simple tasks, more capable models for complex reasoning. Both Python and TypeScript SDKs offer the same powerful capabilities with language-specific optimizations.
</Tip>