Tool Calling

// Define a function tool
getWeatherTool := responses.ToolUnion{
    OfFunction: &responses.FunctionTool{
        Name:        "get_current_weather",
        Description: utils.Ptr("Get the current weather in a given location"),
        Parameters: map[string]any{
            "type": "object",
            "properties": map[string]any{
                "location": map[string]any{
                    "type":        "string",
                    "description": "The city and state, e.g. San Francisco, CA",
                },
                "unit": map[string]any{
                    "type": "string",
                    "enum": []string{"celsius", "fahrenheit"},
                },
            },
            "required": []string{"location"},
        },
    },
}

resp, err := model.NewResponses(ctx, &responses.Request{
    Input: responses.InputUnion{
        OfString: utils.Ptr("What's the weather like in Paris?"),
    },
    Tools: []responses.ToolUnion{getWeatherTool},
})

for _, output := range resp.Output {
    // Check if the output item is a function call
    if output.OfFunctionCall != nil {
        fnCall := output.OfFunctionCall
        fmt.Printf("Model requested tool: %s\n", fnCall.Name)
        fmt.Printf("Arguments: %s\n", fnCall.Arguments)
        
        // Execute your local logic here...
    }
}

import (
    "fmt"
    "github.com/hastekit/hastekit-sdk-go/pkg/gateway/llm/responses"
)

// ... request initialization with Tools ...

stream, err := model.NewStreamingResponses(ctx, request)
if err != nil {
    panic(err)
}

for chunk := range stream {
    // Detect when an output item is completed
    if chunk.ChunkType() == "response.output_item.done" {
        item := chunk.OfOutputItemDone.Item
        
        // Check if the completed item is a function call
        if item.Type == "function_call" {
            fmt.Printf("Model requested tool: %s\n", *item.Name)
            fmt.Printf("Arguments: %s\n", *item.Arguments)
            
            // Execute your local logic here...
        }
    }
}

resp, err := model.NewResponses(ctx, &responses.Request{
    Input: responses.InputUnion{
        OfInputMessageList: responses.InputMessageList{
            // ... original user message ...
            // ... original tool call request from model ...
            {
                OfFunctionCallOutput: &responses.FunctionCallOutputMessage{
                    CallID: "call_123", // Must match the ID from the request
                    Output: responses.FunctionCallOutputContentUnion{
                        OfString: utils.Ptr(`{"temperature": 22, "condition": "Sunny"}`),
                    },
                },
            },
        },
    },
})