Code Execution Tool

resp, err := model.NewResponses(
    context.Background(),
    &responses.Request{
        Instructions: utils.Ptr("You are a personal math tutor. When asked a math question, write and run code using the python tool to answer the question."),
        Input: responses.InputUnion{
            OfString: utils.Ptr("I need to solve the equation 3x + 11 = 14. Can you help me?"),
        },
        Tools: []responses.ToolUnion{
            {
                OfCodeExecution: &responses.CodeExecutionTool{},
            },
        },
    },
)

Tools: []responses.ToolUnion{
    {
        OfCodeExecution: &responses.CodeExecutionTool{
            Container: &responses.CodeExecutionToolContainerUnion{
                ContainerConfig: &responses.CodeExecutionToolContainerConfig{
                    Type:        "auto",
                    MemoryLimit: "4g",
                    FileIds:     []string{}, // Optional: attach files to the container
                },
            },
        },
    },
},

Tools: []responses.ToolUnion{
    {
        OfCodeExecution: &responses.CodeExecutionTool{
            Container: &responses.CodeExecutionToolContainerUnion{
                ContainerID: utils.Ptr("container_abc123"),
            },
        },
    },
},

import (
    "context"
    "fmt"
    "github.com/curaious/uno/pkg/llm/responses"
    "github.com/curaious/uno/internal/utils"
)

func main() {
    // ... client and model initialization ...

    resp, err := model.NewResponses(context.Background(), &responses.Request{
        Instructions: utils.Ptr("You are a helpful assistant that can run code."),
        Input: responses.InputUnion{
            OfString: utils.Ptr("Calculate 15 * 23"),
        },
        Tools: []responses.ToolUnion{
            {
                OfCodeExecution: &responses.CodeExecutionTool{},
            },
        },
        Parameters: responses.Parameters{
            Include: []responses.Includable{
                responses.IncludableCodeInterpreterCallOutputs,
            },
        },
    })
    if err != nil {
        panic(err)
    }

    // Process the response
    for _, output := range resp.Output {
        if output.OfCodeInterpreterCall != nil {
            codeCall := output.OfCodeInterpreterCall
            
            fmt.Printf("Code Interpreter ID: %s\n", codeCall.ID)
            fmt.Printf("Status: %s\n", codeCall.Status)
            fmt.Printf("Code:\n%s\n", codeCall.Code)
            fmt.Printf("Container ID: %s\n", codeCall.ContainerID)
            
            // Process outputs
            for _, output := range codeCall.Outputs {
                if output.Type == "logs" {
                    fmt.Printf("Output:\n%s\n", output.Logs)
                }
            }
        }
    }
}

import (
    "context"
    "fmt"
    "github.com/curaious/uno/pkg/llm/responses"
    "github.com/curaious/uno/internal/utils"
)

func main() {
    // ... client and model initialization ...

    stream, err := model.NewStreamingResponses(context.Background(), &responses.Request{
        Instructions: utils.Ptr("You are a personal math tutor. When asked a math question, write and run code using the python tool to answer the question."),
        Input: responses.InputUnion{
            OfInputMessageList: responses.InputMessageList{
                {
                    OfEasyInput: &responses.EasyMessage{
                        Role: constants.RoleUser,
                        Content: responses.EasyInputContentUnion{
                            OfString: utils.Ptr("I need to solve the equation 3x + 11 = 14. Can you help me?"),
                        },
                    },
                },
            },
        },
        Tools: []responses.ToolUnion{
            {
                OfCodeExecution: &responses.CodeExecutionTool{
                    Container: &responses.CodeExecutionToolContainerUnion{
                        ContainerConfig: &responses.CodeExecutionToolContainerConfig{
                            Type:        "auto",
                            MemoryLimit: "4g",
                        },
                    },
                },
            },
        },
        Parameters: responses.Parameters{
            Stream: utils.Ptr(true),
            Include: []responses.Includable{
                responses.IncludableCodeInterpreterCallOutputs,
            },
        },
    })
    if err != nil {
        panic(err)
    }

    for chunk := range stream {
        // Check for code execution progress
        if chunk.OfCodeInterpreterCallInProgress != nil {
            fmt.Println("Code execution started...")
        }
        
        // Code is being written incrementally
        if chunk.OfCodeInterpreterCallCodeDelta != nil {
            delta := chunk.OfCodeInterpreterCallCodeDelta
            if delta.Delta != nil {
                fmt.Print(*delta.Delta) // Print code as it's being written
            }
        }
        
        // Code writing is complete
        if chunk.OfCodeInterpreterCallCodeDone != nil {
            done := chunk.OfCodeInterpreterCallCodeDone
            if done.Code != nil {
                fmt.Printf("\n\nComplete code:\n%s\n", *done.Code)
            }
        }
        
        // Code is being executed
        if chunk.OfCodeInterpreterCallInterpreting != nil {
            fmt.Println("Executing code...")
        }
        
        // Code execution is complete
        if chunk.OfCodeInterpreterCallCompleted != nil {
            fmt.Println("Code execution completed!")
        }
        
        // Check for completed output items
        if chunk.OfOutputItemDone != nil {
            item := chunk.OfOutputItemDone.Item
            if item.Type == "code_interpreter_call" {
                fmt.Printf("Final code:\n%s\n", item.Code)
                fmt.Printf("Outputs:\n%v\n", item.Outputs)
            }
        }
    }
}

Parameters: responses.Parameters{
    Include: []responses.Includable{
        responses.IncludableCodeInterpreterCallOutputs,
    },
},