Get Model

func (r *ModelService) Get(
    ctx context.Context,
    modelID string,
    opts ...option.RequestOption,
) (*Model, error)

package main

import (
    "context"
    "fmt"
    "log"

    dedalus "github.com/dedalus-labs/dedalus-sdk-go"
    "github.com/dedalus-labs/dedalus-sdk-go/option"
)

func main() {
    client := dedalus.NewClient(
        option.WithAPIKey("your-api-key"),
    )

    ctx := context.Background()
    
    model, err := client.Models.Get(ctx, "openai/gpt-4")
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Model: %s\n", model.ID)
    fmt.Printf("Provider: %s\n", model.Provider)
    fmt.Printf("Display Name: %s\n", model.DisplayName)
    fmt.Printf("Description: %s\n", model.Description)
}

model, err := client.Models.Get(ctx, "anthropic/claude-3-5-sonnet-20241022")
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Model: %s\n\n", model.ID)
fmt.Println("Capabilities:")

if model.Capabilities.Text {
    fmt.Println("  ✓ Text generation")
}
if model.Capabilities.Vision {
    fmt.Println("  ✓ Vision (image understanding)")
}
if model.Capabilities.Audio {
    fmt.Println("  ✓ Audio processing")
}
if model.Capabilities.Tools {
    fmt.Println("  ✓ Function/tool calling")
}
if model.Capabilities.Streaming {
    fmt.Println("  ✓ Streaming responses")
}
if model.Capabilities.StructuredOutput {
    fmt.Println("  ✓ Structured JSON output")
}

model, err := client.Models.Get(ctx, "google/gemini-1.5-pro")
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Model: %s\n", model.ID)
fmt.Printf("Input Token Limit: %d\n", model.Capabilities.InputTokenLimit)
fmt.Printf("Output Token Limit: %d\n", model.Capabilities.OutputTokenLimit)

// Calculate total context window
totalTokens := model.Capabilities.InputTokenLimit + model.Capabilities.OutputTokenLimit
fmt.Printf("Total Context: %d tokens\n", totalTokens)

model, err := client.Models.Get(ctx, "openai/gpt-4")
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Model: %s\n\n", model.ID)
fmt.Println("Default Parameters:")

if model.Defaults.Temperature > 0 {
    fmt.Printf("  Temperature: %.2f\n", model.Defaults.Temperature)
}
if model.Defaults.TopP > 0 {
    fmt.Printf("  Top P: %.2f\n", model.Defaults.TopP)
}
if model.Defaults.TopK > 0 {
    fmt.Printf("  Top K: %d\n", model.Defaults.TopK)
}
if model.Defaults.MaxOutputTokens > 0 {
    fmt.Printf("  Max Output Tokens: %d\n", model.Defaults.MaxOutputTokens)
}

func validateModel(client *dedalus.Client, modelID string) error {
    ctx := context.Background()
    
    _, err := client.Models.Get(ctx, modelID)
    if err != nil {
        return fmt.Errorf("model %s not found or not accessible: %w", modelID, err)
    }
    
    return nil
}

// Usage
err := validateModel(client, "openai/gpt-4")
if err != nil {
    log.Fatal(err)
}
fmt.Println("Model is valid and accessible")

modelIDs := []string{
    "openai/gpt-4",
    "anthropic/claude-3-5-sonnet-20241022",
    "google/gemini-1.5-pro",
}

fmt.Println("Model Comparison:\n")

for _, modelID := range modelIDs {
    model, err := client.Models.Get(ctx, modelID)
    if err != nil {
        log.Printf("Error fetching %s: %v\n", modelID, err)
        continue
    }

    fmt.Printf("%s:\n", model.ID)
    fmt.Printf("  Provider: %s\n", model.Provider)
    fmt.Printf("  Input Limit: %d tokens\n", model.Capabilities.InputTokenLimit)
    fmt.Printf("  Output Limit: %d tokens\n", model.Capabilities.OutputTokenLimit)
    fmt.Printf("  Vision: %v\n", model.Capabilities.Vision)
    fmt.Printf("  Tools: %v\n", model.Capabilities.Tools)
    fmt.Println()
}

model, err := client.Models.Get(ctx, "openai/gpt-4")
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Model: %s\n\n", model.ID)

if len(model.ProviderInfo) > 0 {
    fmt.Println("Provider-Specific Information:")
    for key, value := range model.ProviderInfo {
        fmt.Printf("  %s: %v\n", key, value)
    }
}

if len(model.ProviderDeclaredGenerationMethods) > 0 {
    fmt.Println("\nGeneration Methods:")
    for _, method := range model.ProviderDeclaredGenerationMethods {
        fmt.Printf("  - %s\n", method)
    }
}

func isModelSuitableForTask(client *dedalus.Client, modelID string, requireVision bool, requireTools bool) (bool, error) {
    ctx := context.Background()
    
    model, err := client.Models.Get(ctx, modelID)
    if err != nil {
        return false, err
    }

    if requireVision && !model.Capabilities.Vision {
        return false, nil
    }

    if requireTools && !model.Capabilities.Tools {
        return false, nil
    }

    return true, nil
}

// Usage
suitable, err := isModelSuitableForTask(
    client,
    "openai/gpt-4",
    true,  // requires vision
    true,  // requires tools
)

if err != nil {
    log.Fatal(err)
}

if suitable {
    fmt.Println("Model is suitable for the task")
} else {
    fmt.Println("Model does not meet requirements")
}