How could I drop specific items from a generic GUI window spawned from a custom inventory?

Good job on thinking that there's a better solution.

Instead of hand-creating a GUI for every object, you should instead create a GUI (or perhaps a function that makes a GUI) that works for all of them. In each way an object can differ from another, you will need a variable. You could put these variables in game.ReplicatedStorage (ex the sword variables would go in a "WoodenSword" folder with StringValues and such), but easier to work with is a ModuleScript. You could try to use classes here, but if you don't know how, just use tables instead. Here's a sample ModuleScript to give you the idea:

--Resource Types
local ResourceManager = {}
local resources = {
	WoodSword = {
		Name = "Wooden Sword",
		Image = "",
		Model = game.ServerStorage.WoodenSwordModel,
		--Add any other information you want here, like "IsDroppable" or "IsWeapon", or "DamageAmount". You needn't have all these properties in every resource -- just make sure your code is okay with the value being nil. ex, if "DamageAmount" is nil, your code should simply not display the amount of damage it does (because it probably isn't a weapon).
	},
	["Object Type With Spaces"] = {
		Name = "(for example)",
		Image = "",
		Model = game.ServerStorage.etc,
	}
}
ResourceManager.Resources = resources --allow other scripts to access this table
--Note that each entry in Resources must be unique, since it's a dictionary. The Names don't have to be, but if you write a NameToData function, you'll have to think about what you want to do if there are multiple data types with the same name.
--example of ImageToData:
local function ResourceManager.ImageToData(image) --This only works if all images are unique. If not, this algorithm should be changed to support returning a list of items.
	for dataName, data in pairs(resources) do
		if data.Image == image then
			return data
		end
	end
end
--But if you regularly need to convert an image back to the data type it came from, you should cache the results in a table, or just make a table of all Image->Data types automatically. Let's also make it return lists of items that the image belongs to, instead of just a single item.
local imageToData = {}
for dataName, data in pairs(resources) do
	if data.Image then
		local t = imageToData[data.Image]
		if not t then
			t = {}
			imageToData[data.Image] = t
		end
		t[#t + 1] = data --same as "table.insert(t, data)"
	end
end
ResourceManager.ImageToData = imageToData
return ResourceManager

A note about the ImageToData: You could use it by saying ImageToData["linkAddress"]; you would get a list of items that that image could refer to (or nil if no object has that linkAddress as its image). I can't see how this is useful, but this concept may be useful for other fields. Your scripts should usually just store the type name ("WoodSword") or the data itself (Resources.WoodSword). Your scripts can get the data like this:

local ResourceManager = require(game.ReplicatedStorage.ResourceManager)
local woodSwordData = ResourceManager.Resources["WoodSword"] --for example

But note that you should only rare have to write out "WoodSword" in most of your code. ex, for your gui code, it should accept a function parameter or StringValue that will contain the ObjectType (which may happen to be WoodSword). Then the script can get the information it needs using the ResourceManager. You should have to say "WoodSword" specifically if you are generating a WoodSword or giving a player one (ex as a quest reward).

To aid in this, models lying in the workspace (that can be clicked on) should all have a StringValue describing its type (ex. "WoodSword").

So, in your gui code, probably the easiest is to put a StringValue as a child of the gui code (unless your gui code is in a ModuleScript and can then receive function arguments).

--In whatever creates a new gui script:
local s = Instance.new("StringValue")
s.Name = "ResourceType"
s.Value = objectType
s.Parent = guiScript

--As first lines of gui script:
local ResourceManager = require(game.ReplicatedStorage.ResourceManager)
local resourceType = script:WaitForChild("ResourceType").Value
local data = ResourceManager.Resources[resourceType]
--Use the data accordingly. ex, to get the image, use "data.Image".

However, it would be faster (in terms of performance and maybe in writing code) to put more of this stuff in ModuleScripts (which can be accessed by other scripts). ex, for your inventory slots, you might use an InventorySlots ModuleScript. It could have functions for adding/dropping/using/equipping items (it may have to work with other scripts to equip something, for instance). With ModuleScripts you don't need to use StringValues (though you may find it easier to do so in some cases).

ex, maybe when the player clicks on InventorySlot 2, you will send information to a different script saying "The player clickedon InventorySlot 2 -- display the options!". That script can request what objectType is in inventory slot #2 by asking the InventorySlots ModuleScript. It can then, if needed, get information about the type from the ResourceManager. It should then have all the information it needs to display "Equip", "Drop", "Use", etc. (well, it may need to ask for more information from other scripts, but hopefully you get the idea). In the end, your gui code need never contain the string "WoodSword".