CRUD operations allow you to store, retrieve, update, and delete OpenAI Chat Completions for analysis, caching, and model improvement.

​
Storing Completions

​
Basic Storage

TypeScript
import { Sudo } from "sudo-ai";

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

async function basicStorage() {
  try {
    // Create and store a completion
    const response = await sudo.router.create({
      model: "gpt-4o",
      messages: [
        { role: "user", content: "Explain machine learning" }
      ],
      store: true,  // Enable storage
      metadata: {
        userId: "user_123",
        topic: "education",
        session: "learning_session_1"
      }
    });
    
    const completionId = response.id;
    console.log(`Stored completion with ID: ${completionId}`);
    console.log(`Response: ${response.choices[0].message.content}`);
  } catch (error) {
    console.error("Storage error:", error);
  }
}

basicStorage();

​
Retrieving Completions

​
List Stored Completions

TypeScript
import { Sudo } from "sudo-ai";

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

async function listStoredCompletions() {
  try {
    // List all stored completions
    const completions = await sudo.router.listChatCompletions({
      limit: 10,
      order: "desc"  // Most recent first
    });
    
    console.log(`Found ${completions.data.length} stored completions:`);
    completions.data.forEach(completion => {
      console.log(`- ID: ${completion.id}`);
      console.log(`  Model: ${completion.model}`);
      console.log(`  Created: ${completion.created}`);
      if (completion.metadata) {
        console.log(`  Metadata: ${JSON.stringify(completion.metadata)}`);
      }
    });
  } catch (error) {
    console.error("List completions error:", error);
  }
}

listStoredCompletions();

​
Filter by Metadata

TypeScript
import { Sudo } from "sudo-ai";

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

async function filterByMetadata() {
  try {
    // Filter completions by metadata
    const completions = await sudo.router.listChatCompletions({
      metadata: {
        userId: "user_123",
        topic: "education"
      },
      limit: 5
    });
    
    console.log("Education-related completions:");
    completions.data.forEach(completion => {
      console.log(`- ${completion.id}: ${completion.model}`);
    });
  } catch (error) {
    console.error("Filter by metadata error:", error);
  }
}

filterByMetadata();

​
Get Specific Completion

TypeScript
import { Sudo } from "sudo-ai";

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

async function getCompletionDetails(completionId: string) {
  try {
    // Get completion metadata
    const completion = await sudo.router.getChatCompletion(completionId);
    
    // Get completion messages
    const messages = await sudo.router.getChatCompletionMessages(completionId);
    
    return {
      completion,
      messages
    };
  } catch (error) {
    console.error("Get completion details error:", error);
    return null;
  }
}

// Usage
async function completionDetailsExample() {
  const completionId = "chatcmpl-abc123";  // Replace with actual ID
  const details = await getCompletionDetails(completionId);
  
  if (details) {
    console.log(`Completion ID: ${details.completion.id}`);
    console.log(`Model: ${details.completion.model}`);
    console.log(`Created: ${details.completion.created}`);
    console.log("\nMessages:");
    details.messages.data.forEach(message => {
      console.log(`- ${message.role}: ${message.content}`);
    });
  }
}

completionDetailsExample();

​
Updating Completions

​
Update Metadata

TypeScript
import { Sudo } from "sudo-ai";

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

async function updateCompletionMetadata(completionId: string, newMetadata: Record<string, any>) {
  try {
    const updatedCompletion = await sudo.router.updateChatCompletion({
      completionId: completionId,
      metadata: newMetadata
    });
    
    return updatedCompletion;
  } catch (error) {
    console.error("Update completion metadata error:", error);
    return null;
  }
}

// Example: Add rating and feedback
async function updateMetadataExample() {
  const newMetadata = {
    userId: "user_123",
    topic: "education", 
    rating: "5",
    feedback: "very_helpful",
    reviewed: "true"
  };

  const updated = await updateCompletionMetadata("chatcmpl-abc123", newMetadata);
  if (updated) {
    console.log(`Updated completion ${updated.id}`);
    console.log(`New metadata: ${JSON.stringify(updated.metadata)}`);
  }
}

updateMetadataExample();

​
Deleting Completions

​
Delete Single Completion

TypeScript
import { Sudo } from "sudo-ai";

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

async function deleteCompletion(completionId: string) {
  try {
    const result = await sudo.router.deleteChatCompletion(completionId);
    return result;
  } catch (error) {
    console.error("Delete completion error:", error);
    return null;
  }
}

// Delete a completion
async function deleteCompletionExample() {
  const result = await deleteCompletion("chatcmpl-abc123");
  if (result) {
    console.log(`Deletion result: ${JSON.stringify(result)}`);
  }
}

deleteCompletionExample();
CRUD operations are only available for completions created with store=True. This feature is designed for OpenAI API compatibility and works with both Python and TypeScript SDKs.

​
Summary

The Sudo SDK provides comprehensive functionality for building AI-powered applications in both Python and TypeScript:
  • System Endpoints: Monitor API health and discover available models
  • Chat Completion: Generate responses from various AI models with extensive customization
  • Streaming: Real-time response generation for interactive applications
  • Tool Calling: Enable AI models to execute functions and interact with external systems
  • Structured Output: Generate validated JSON responses for reliable data extraction
  • Image Input: Process images and multimodal content with vision-capable models
  • Reasoning: Access advanced reasoning capabilities for complex problem-solving
  • CRUD Operations: Manage stored completions for analysis and improvement
Both SDKs are designed for production use with comprehensive error handling, async support, and best practices built-in. Start with basic chat completions and gradually add advanced features as needed. Resources: