tools

var (
	MessageTool = &Tool{
		Tool: mcp.Tool{
			Name:        toolspec.MessageName,
			Description: toolspec.MessageDescription,
			Annotations: &mcp.ToolAnnotations{Title: "Message"},
			InputSchema: toolspec.MessageSchema(),
		},
		Type:  ToolTypeBuiltin,
		Group: GroupMessaging,
	}
	WebFetchTool = &Tool{
		Tool: mcp.Tool{
			Name:        toolspec.WebFetchName,
			Description: toolspec.WebFetchDescription,
			Annotations: &mcp.ToolAnnotations{Title: "Web Fetch"},
			InputSchema: toolspec.WebFetchSchema(),
		},
		Type:  ToolTypeBuiltin,
		Group: GroupWeb,
	}
	SessionStatusTool = &Tool{
		Tool: mcp.Tool{
			Name:        toolspec.SessionStatusName,
			Description: toolspec.SessionStatusDescription,
			Annotations: &mcp.ToolAnnotations{Title: "Session Status"},
			InputSchema: toolspec.SessionStatusSchema(),
		},
		Type:  ToolTypeBuiltin,
		Group: GroupStatus,
	}
	MemorySearchTool = &Tool{
		Tool: mcp.Tool{
			Name:        toolspec.MemorySearchName,
			Description: toolspec.MemorySearchDescription,
			Annotations: &mcp.ToolAnnotations{Title: "Memory Search"},
			InputSchema: toolspec.MemorySearchSchema(),
		},
		Type:  ToolTypeBuiltin,
		Group: GroupMemory,
	}
	MemoryGetTool = &Tool{
		Tool: mcp.Tool{
			Name:        toolspec.MemoryGetName,
			Description: toolspec.MemoryGetDescription,
			Annotations: &mcp.ToolAnnotations{Title: "Memory Get"},
			InputSchema: toolspec.MemoryGetSchema(),
		},
		Type:  ToolTypeBuiltin,
		Group: GroupMemory,
	}
	ImageTool = &Tool{
		Tool: mcp.Tool{
			Name:        toolspec.ImageName,
			Description: toolspec.ImageDescription,
			Annotations: &mcp.ToolAnnotations{Title: "Image"},
			InputSchema: toolspec.ImageSchema(),
		},
		Type:  ToolTypeBuiltin,
		Group: GroupMedia,
	}
	ImageGenerateTool = &Tool{
		Tool: mcp.Tool{
			Name:        toolspec.ImageGenerateName,
			Description: toolspec.ImageGenerateDescription,
			Annotations: &mcp.ToolAnnotations{Title: "Image Generate"},
			InputSchema: toolspec.ImageGenerateSchema(),
		},
		Type:  ToolTypeBuiltin,
		Group: GroupMedia,
	}
	TTSTool = &Tool{
		Tool: mcp.Tool{
			Name:        toolspec.TTSName,
			Description: toolspec.TTSDescription,
			Annotations: &mcp.ToolAnnotations{Title: "TTS"},
			InputSchema: toolspec.TTSSchema(),
		},
		Type:  ToolTypeBuiltin,
		Group: GroupMedia,
	}
	GravatarFetchTool = &Tool{
		Tool: mcp.Tool{
			Name:        toolspec.GravatarFetchName,
			Description: toolspec.GravatarFetchDescription,
			Annotations: &mcp.ToolAnnotations{Title: "Gravatar Fetch"},
			InputSchema: toolspec.GravatarFetchSchema(),
		},
		Type:  ToolTypeBuiltin,
		Group: GroupOpenClaw,
	}
	GravatarSetTool = &Tool{
		Tool: mcp.Tool{
			Name:        toolspec.GravatarSetName,
			Description: toolspec.GravatarSetDescription,
			Annotations: &mcp.ToolAnnotations{Title: "Gravatar Set"},
			InputSchema: toolspec.GravatarSetSchema(),
		},
		Type:  ToolTypeBuiltin,
		Group: GroupOpenClaw,
	}
)

var (
	ReadTool = newUnavailableBuiltinTool(unavailableBuiltinToolSpec{
		name:        toolspec.ReadName,
		description: toolspec.ReadDescription,
		title:       "Read",
		inputSchema: toolspec.ReadSchema(),
	})
	WriteTool = newUnavailableBuiltinTool(unavailableBuiltinToolSpec{
		name:        toolspec.WriteName,
		description: toolspec.WriteDescription,
		title:       "Write",
		inputSchema: toolspec.WriteSchema(),
	})
	EditTool = newUnavailableBuiltinTool(unavailableBuiltinToolSpec{
		name:        toolspec.EditName,
		description: toolspec.EditDescription,
		title:       "Edit",
		inputSchema: toolspec.EditSchema(),
	})
)

var AgentsListTool = &Tool{
	Tool: mcp.Tool{
		Name:        "agents_list",
		Description: "List agent ids you can target with sessions_spawn (based on allowlists).",
		Annotations: &mcp.ToolAnnotations{Title: "Agents List"},
		InputSchema: toolspec.EmptyObjectSchema(),
	},
	Type:  ToolTypeBuiltin,
	Group: GroupSessions,
}

var ApplyPatchTool = newUnavailableBuiltinTool(unavailableBuiltinToolSpec{
	name:        toolspec.ApplyPatchName,
	description: toolspec.ApplyPatchDescription,
	title:       "Apply Patch",
	inputSchema: toolspec.ApplyPatchSchema(),
})

var BeeperDocsTool = newConnectorOnlyTool(
	toolspec.BeeperDocsName,
	toolspec.BeeperDocsDescription,
	"Beeper Docs",
	toolspec.BeeperDocsSchema(),
)

var BeeperSendFeedbackTool = newConnectorOnlyTool(
	toolspec.BeeperSendFeedbackName,
	toolspec.BeeperSendFeedbackDescription,
	"Beeper Send Feedback",
	toolspec.BeeperSendFeedbackSchema(),
)

var Calculator = &Tool{
	Tool: mcp.Tool{
		Name:        toolspec.CalculatorName,
		Description: toolspec.CalculatorDescription,
		Annotations: &mcp.ToolAnnotations{Title: "Calculator"},
		InputSchema: toolspec.CalculatorSchema(),
	},
	Type:    ToolTypeBuiltin,
	Group:   GroupCalc,
	Execute: executeCalculator,
}

var CreateAgentTool = &Tool{
	Tool: mcp.Tool{
		Name:        "create_agent",
		Description: "Create a new AI agent with custom configuration",
		Annotations: &mcp.ToolAnnotations{Title: "Create Agent"},
		InputSchema: toolspec.ObjectSchema(map[string]any{
			"name":          toolspec.StringProperty("Display name for the agent"),
			"description":   toolspec.StringProperty("Brief description of what the agent does"),
			"model":         toolspec.StringProperty("Model ID to use (e.g., 'anthropic/claude-sonnet-4.5'). Leave empty for default."),
			"system_prompt": toolspec.StringProperty("Custom system prompt for the agent"),
			"tools":         toolPolicySchema(),
			"subagents":     subagentSchema(),
		}, "name"),
	},
	Type:  ToolTypeBuiltin,
	Group: GroupBuilder,
}

var CronTool = &Tool{
	Tool: mcp.Tool{
		Name:        toolspec.CronName,
		Description: toolspec.CronDescription,
		Annotations: &mcp.ToolAnnotations{Title: "Scheduler"},
		InputSchema: toolspec.CronSchema(),
	},
	Type:  ToolTypeBuiltin,
	Group: GroupOpenClaw,
}

var DeleteAgentTool = &Tool{
	Tool: mcp.Tool{
		Name:        "delete_agent",
		Description: "Delete a custom agent (preset agents cannot be deleted)",
		Annotations: &mcp.ToolAnnotations{Title: "Delete Agent"},
		InputSchema: toolspec.ObjectSchema(map[string]any{
			"agent_id": toolspec.StringProperty("ID of the agent to delete"),
		}, "agent_id"),
	},
	Type:  ToolTypeBuiltin,
	Group: GroupBuilder,
}

var EditAgentTool = &Tool{
	Tool: mcp.Tool{
		Name:        "edit_agent",
		Description: "Modify an existing custom agent's configuration",
		Annotations: &mcp.ToolAnnotations{Title: "Edit Agent"},
		InputSchema: toolspec.ObjectSchema(map[string]any{
			"agent_id":      toolspec.StringProperty("ID of the agent to edit"),
			"name":          toolspec.StringProperty("New display name"),
			"description":   toolspec.StringProperty("New description"),
			"model":         toolspec.StringProperty("New model ID"),
			"system_prompt": toolspec.StringProperty("New system prompt"),
			"tools":         toolPolicySchema(),
			"subagents":     subagentSchema(),
		}, "agent_id"),
	},
	Type:  ToolTypeBuiltin,
	Group: GroupBuilder,
}

var ForkAgentTool = &Tool{
	Tool: mcp.Tool{
		Name:        "fork_agent",
		Description: "Create a copy of an existing agent as a new custom agent",
		Annotations: &mcp.ToolAnnotations{Title: "Fork Agent"},
		InputSchema: toolspec.ObjectSchema(map[string]any{
			"source_id": toolspec.StringProperty("ID of the agent to copy"),
			"new_name":  toolspec.StringProperty("Name for the new agent (defaults to '[Original Name] (Fork)')"),
		}, "source_id"),
	},
	Type:  ToolTypeBuiltin,
	Group: GroupBuilder,
}

var ListAgentsTool = &Tool{
	Tool: mcp.Tool{
		Name:        "list_agents",
		Description: "List all available agents (both preset and custom)",
		Annotations: &mcp.ToolAnnotations{Title: "List Agents"},
		InputSchema: toolspec.EmptyObjectSchema(),
	},
	Type:  ToolTypeBuiltin,
	Group: GroupBuilder,
}

var ListModelsTool = &Tool{
	Tool: mcp.Tool{
		Name:        "list_models",
		Description: "List all available AI models",
		Annotations: &mcp.ToolAnnotations{Title: "List Models"},
		InputSchema: toolspec.EmptyObjectSchema(),
	},
	Type:  ToolTypeBuiltin,
	Group: GroupSessions,
}

var ModifyRoomTool = &Tool{
	Tool: mcp.Tool{
		Name:        "modify_room",
		Description: "Modify an existing room's configuration",
		Annotations: &mcp.ToolAnnotations{Title: "Modify Room"},
		InputSchema: toolspec.ObjectSchema(map[string]any{
			"room_id":       toolspec.StringProperty("ID of the room to modify"),
			"name":          toolspec.StringProperty("New display name for the room"),
			"agent_id":      toolspec.StringProperty("New agent ID to assign to this room"),
			"system_prompt": toolspec.StringProperty("New system prompt override for this room"),
		}, "room_id"),
	},
	Type:  ToolTypeBuiltin,
	Group: GroupSessions,
}

var RunInternalCommandTool = &Tool{
	Tool: mcp.Tool{
		Name:        "run_internal_command",
		Description: "Run an internal !ai command in a target room",
		Annotations: &mcp.ToolAnnotations{Title: "Run Internal Command"},
		InputSchema: toolspec.ObjectSchema(map[string]any{
			"command": toolspec.StringProperty("The !ai command to run (with or without prefix)"),
			"room_id": toolspec.StringProperty("Optional target room ID (defaults to the current room)"),
		}, "command"),
	},
	Type:  ToolTypeBuiltin,
	Group: GroupBuilder,
}

var SessionsHistoryTool = &Tool{
	Tool: mcp.Tool{
		Name:        "sessions_history",
		Description: "Fetch message history for a session. Use the sessionKey from sessions_list.",
		Annotations: &mcp.ToolAnnotations{Title: "Session History"},
		InputSchema: toolspec.ObjectSchema(map[string]any{
			"sessionKey":   toolspec.StringProperty("Session identifier from sessions_list (preferred canonical target)"),
			"limit":        toolspec.NumberProperty("Maximum number of messages to return (default: 200)"),
			"includeTools": toolspec.BooleanProperty("Whether to include tool calls in the returned history"),
		}, "sessionKey"),
	},
	Type:  ToolTypeBuiltin,
	Group: GroupSessions,
}

var SessionsListTool = &Tool{
	Tool: mcp.Tool{
		Name:        "sessions_list",
		Description: "List sessions with optional filters and last messages.",
		Annotations: &mcp.ToolAnnotations{Title: "List Sessions"},
		InputSchema: toolspec.ObjectSchema(map[string]any{
			"kinds": map[string]any{
				"type":  "array",
				"items": map[string]any{"type": "string"},
			},
			"limit":         toolspec.NumberProperty("Maximum number of sessions to return (default: 50)"),
			"activeMinutes": toolspec.NumberProperty("Only include sessions active within this many minutes"),
			"messageLimit":  toolspec.NumberProperty("Include the last N messages for each session"),
		}),
	},
	Type:  ToolTypeBuiltin,
	Group: GroupSessions,
}

var SessionsSendTool = &Tool{
	Tool: mcp.Tool{
		Name:        "sessions_send",
		Description: "Send a message into another session. Prefer the sessionKey from sessions_list; label is fallback only.",
		Annotations: &mcp.ToolAnnotations{Title: "Send to Session"},
		InputSchema: toolspec.ObjectSchema(map[string]any{
			"sessionKey":     toolspec.StringProperty("Session identifier from sessions_list (preferred canonical target)"),
			"label":          toolspec.StringProperty("Session label fallback (can be ambiguous; sessionKey is preferred)"),
			"agentId":        toolspec.StringProperty("Agent id filter for label lookups"),
			"message":        toolspec.StringProperty("The message to send"),
			"timeoutSeconds": toolspec.NumberProperty("Optional timeout for the remote session"),
		}, "message"),
	},
	Type:  ToolTypeBuiltin,
	Group: GroupSessions,
}

var SessionsSpawnTool = &Tool{
	Tool: mcp.Tool{
		Name:        "sessions_spawn",
		Description: "Spawn a background sub-agent run in an isolated session and announce the result back to the requester chat.",
		Annotations: &mcp.ToolAnnotations{Title: "Spawn Session"},
		InputSchema: toolspec.ObjectSchema(map[string]any{
			"task":              toolspec.StringProperty("Task description for the sub-agent."),
			"label":             toolspec.StringProperty("Optional label for the sub-agent run."),
			"agentId":           toolspec.StringProperty("Agent ID override for the sub-agent run."),
			"model":             toolspec.StringProperty("Optional model override (provider/model)."),
			"thinking":          toolspec.StringProperty("Optional thinking level override."),
			"runTimeoutSeconds": toolspec.NumberProperty("Optional run timeout in seconds."),
			"cleanup": map[string]any{
				"type":        "string",
				"enum":        []string{"delete", "keep"},
				"description": "Cleanup policy for the spawned session.",
			},
		}, "task"),
	},
	Type:  ToolTypeBuiltin,
	Group: GroupSessions,
}

var WebSearch = &Tool{
	Tool: mcp.Tool{
		Name:        toolspec.WebSearchName,
		Description: toolspec.WebSearchDescription,
		Annotations: &mcp.ToolAnnotations{Title: "Web Search"},
		InputSchema: toolspec.WebSearchSchema(),
	},
	Type:    ToolTypeBuiltin,
	Group:   GroupSearch,
	Execute: executeWebSearch,
}