Function Tools

type CustomTool struct {
	*agents.BaseTool
}

func NewCustomTool() *CustomTool {
	return &CustomTool{
		BaseTool: &agents.BaseTool{
			ToolUnion: responses.ToolUnion{
				OfFunction: &responses.FunctionTool{
					Name:        "get_user_name",
					Description: utils.Ptr("Returns the user's name"),
					Parameters: map[string]any{
						"type": "object",
						"properties": map[string]any{
							"user_id": map[string]any{
								"type":        "string",
								"description": "The user ID to look up",
							},
						},
						"required": []string{"user_id"},
					},
				},
			},
		},
	}
}

func (t *CustomTool) Execute(ctx context.Context, params *agents.ToolCall) (*agents.ToolCallResponse, error) {
    // Parse arguments
    args := map[string]interface{}{}
    if err := json.Unmarshal([]byte(params.Arguments), &args); err != nil {
        return nil, err
    }

    userID := args["user_id"].(string)
    
    // Your custom logic here
    userName := lookupUserName(userID)  // Example function
    
    // Return the result
    return &agents.ToolCallResponse{
        FunctionCallOutputMessage: &responses.FunctionCallOutputMessage{
            ID:     params.ID,
            CallID: params.CallID,
            Output: responses.FunctionCallOutputContentUnion{
                OfString: utils.Ptr(userName),
            },
        },
        StateUpdates: map[string]string{},
    }, nil
}

type UserArgs struct {
    UserID string `json:"user_id" jsonschema_description:"The user ID to look up"`
}

type UserName struct {
    Name string `json:"name"`
}

func getUserName(ctx context.Context, args UserArgs) (UserName, error) {
    return UserName{Name: lookupUserName(args.UserID)}, nil
}

userTool := hastekit.NewTool(getUserName,
    hastekit.WithName("get_user_name"), // optional; defaults to the function name
    hastekit.WithDescription[UserArgs, UserName]("Returns the user's name"),
)

func main() {
    // Create agent with tool
    agent := hastekit.NewAgent(&hastekit.AgentConfig{
        Name:        "Assistant",
        Instruction: hastekit.NewPrompt("You are a helpful assistant. Use the get_user_name tool to get the user's name and greet them."),
        LLM:         client.Model("OpenAI/gpt-4o-mini"),
        Tools: []hastekit.Tool{
            NewGetUserNameTool(),
        },
    })

    handle, err := agent.Execute(context.Background(), &agents.AgentInput{
        Message: history.Message{
            Messages: []responses.InputMessageUnion{
                responses.UserMessage("Hello! Can you get my name for user_id '123'?"),
            },
        },
    })
    if err != nil {
        log.Fatal(err)
    }
}