wdevs/amcs
5
0
Fork 0
Code Issues 10 Pull Requests Actions Packages Projects Releases 1 Wiki Activity

test(tools): add unit tests for error handling functions

Browse Source 
* Implement tests for error functions like errRequiredField, errInvalidField, and errEntityNotFound.
* Ensure proper metadata is returned for various error scenarios.
* Validate error handling in CRM, Files, and other tools.
* Introduce tests for parsing stored file IDs and UUIDs.
* Enhance coverage for helper functions related to project resolution and session management.
This commit is contained in:
Hein
2026-03-31 15:10:07 +02:00
parent acd780ac9c
commit f41c512f36
54 changed files with 1937 additions and 365 deletions
Download Patch File Download Diff File Expand all files Collapse all files

591
internal/mcpserver/server.go
View File

@@ -3,7 +3,6 @@ package mcpserver
import (
"log/slog"
"net/http"
"time"
"github.com/modelcontextprotocol/go-sdk/mcp"
@@ -12,6 +11,7 @@ import (
)
type ToolSet struct {
Version *tools.VersionTool
Capture *tools.CaptureTool
Search *tools.SearchTool
List *tools.ListTool
@@ -37,355 +37,480 @@ type ToolSet struct {
Skills *tools.SkillsTool
}
func New(cfg config.MCPConfig, logger *slog.Logger, toolSet ToolSet) http.Handler {
func New(cfg config.MCPConfig, logger *slog.Logger, toolSet ToolSet, onSessionClosed func(string)) (http.Handler, error) {
server := mcp.NewServer(&mcp.Implementation{
Name: cfg.ServerName,
Version: cfg.Version,
}, nil)
addTool(server, logger, &mcp.Tool{
for _, register := range []func(*mcp.Server, *slog.Logger, ToolSet) error{
registerSystemTools,
registerThoughtTools,
registerProjectTools,
registerFileTools,
registerMaintenanceTools,
registerHouseholdTools,
registerCalendarTools,
registerMealTools,
registerCRMTools,
registerSkillTools,
} {
if err := register(server, logger, toolSet); err != nil {
return nil, err
}
}
opts := &mcp.StreamableHTTPOptions{
JSONResponse: true,
SessionTimeout: cfg.SessionTimeout,
}
if onSessionClosed != nil {
opts.EventStore = newCleanupEventStore(mcp.NewMemoryEventStore(nil), onSessionClosed)
}
return mcp.NewStreamableHTTPHandler(func(*http.Request) *mcp.Server {
return server
}, opts), nil
}
func registerSystemTools(server *mcp.Server, logger *slog.Logger, toolSet ToolSet) error {
if err := addTool(server, logger, &mcp.Tool{
Name: "get_version_info",
Description: "Return the server build version information, including version, tag name, commit, and build date.",
}, toolSet.Version.GetInfo); err != nil {
return err
}
return nil
}
func registerThoughtTools(server *mcp.Server, logger *slog.Logger, toolSet ToolSet) error {
if err := addTool(server, logger, &mcp.Tool{
Name: "capture_thought",
Description: "Store a thought with generated embeddings and extracted metadata.",
}, toolSet.Capture.Handle)
addTool(server, logger, &mcp.Tool{
}, toolSet.Capture.Handle); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "search_thoughts",
Description: "Search stored thoughts by semantic similarity.",
}, toolSet.Search.Handle)
addTool(server, logger, &mcp.Tool{
}, toolSet.Search.Handle); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "list_thoughts",
Description: "List recent thoughts with optional metadata filters.",
}, toolSet.List.Handle)
addTool(server, logger, &mcp.Tool{
}, toolSet.List.Handle); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "thought_stats",
Description: "Get counts and top metadata buckets across stored thoughts.",
}, toolSet.Stats.Handle)
addTool(server, logger, &mcp.Tool{
}, toolSet.Stats.Handle); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "get_thought",
Description: "Retrieve a full thought by id.",
}, toolSet.Get.Handle)
addTool(server, logger, &mcp.Tool{
}, toolSet.Get.Handle); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "update_thought",
Description: "Update thought content or merge metadata.",
}, toolSet.Update.Handle)
addTool(server, logger, &mcp.Tool{
}, toolSet.Update.Handle); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "delete_thought",
Description: "Hard-delete a thought by id.",
}, toolSet.Delete.Handle)
addTool(server, logger, &mcp.Tool{
}, toolSet.Delete.Handle); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "archive_thought",
Description: "Archive a thought so it is hidden from default search and listing.",
}, toolSet.Archive.Handle)
addTool(server, logger, &mcp.Tool{
Name: "create_project",
Description: "Create a named project container for thoughts.",
}, toolSet.Projects.Create)
addTool(server, logger, &mcp.Tool{
Name: "list_projects",
Description: "List projects and their current thought counts.",
}, toolSet.Projects.List)
addTool(server, logger, &mcp.Tool{
Name: "set_active_project",
Description: "Set the active project for the current MCP session.",
}, toolSet.Projects.SetActive)
addTool(server, logger, &mcp.Tool{
Name: "get_active_project",
Description: "Return the active project for the current MCP session.",
}, toolSet.Projects.GetActive)
addTool(server, logger, &mcp.Tool{
Name: "get_project_context",
Description: "Get recent and semantic context for a project.",
}, toolSet.Context.Handle)
addTool(server, logger, &mcp.Tool{
Name: "recall_context",
Description: "Recall semantically relevant and recent context.",
}, toolSet.Recall.Handle)
addTool(server, logger, &mcp.Tool{
}, toolSet.Archive.Handle); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "summarize_thoughts",
Description: "Summarize a filtered or searched set of thoughts.",
}, toolSet.Summarize.Handle)
addTool(server, logger, &mcp.Tool{
}, toolSet.Summarize.Handle); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "recall_context",
Description: "Recall semantically relevant and recent context.",
}, toolSet.Recall.Handle); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "link_thoughts",
Description: "Create a typed relationship between two thoughts.",
}, toolSet.Links.Link)
addTool(server, logger, &mcp.Tool{
}, toolSet.Links.Link); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "related_thoughts",
Description: "Retrieve explicit links and semantic neighbors for a thought.",
}, toolSet.Links.Related)
}, toolSet.Links.Related); err != nil {
return err
}
return nil
}
func registerProjectTools(server *mcp.Server, logger *slog.Logger, toolSet ToolSet) error {
if err := addTool(server, logger, &mcp.Tool{
Name: "create_project",
Description: "Create a named project container for thoughts.",
}, toolSet.Projects.Create); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "list_projects",
Description: "List projects and their current thought counts.",
}, toolSet.Projects.List); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "set_active_project",
Description: "Set the active project for the current MCP session. Requires a stateful MCP client that reuses the same session across calls.",
}, toolSet.Projects.SetActive); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "get_active_project",
Description: "Return the active project for the current MCP session. If your client does not preserve MCP sessions, pass project explicitly to project-scoped tools instead.",
}, toolSet.Projects.GetActive); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "get_project_context",
Description: "Get recent and semantic context for a project. Uses the explicit project when provided, otherwise the active MCP session project.",
}, toolSet.Context.Handle); err != nil {
return err
}
return nil
}
func registerFileTools(server *mcp.Server, logger *slog.Logger, toolSet ToolSet) error {
server.AddResourceTemplate(&mcp.ResourceTemplate{
Name: "stored_file",
URITemplate: "amcs://files/{id}",
Description: "A stored file. Read a file's raw binary content by its id. Use load_file for metadata.",
}, toolSet.Files.ReadResource)
addTool(server, logger, &mcp.Tool{
if err := addTool(server, logger, &mcp.Tool{
Name: "upload_file",
Description: "Stage a file and get an amcs://files/{id} resource URI. Provide content_path (absolute server-side path, no size limit) or content_base64 (≤10 MB). Optionally link immediately with thought_id/project, or omit them and pass the returned URI to save_file later.",
}, toolSet.Files.Upload)
addTool(server, logger, &mcp.Tool{
}, toolSet.Files.Upload); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "save_file",
Description: "Store a file and optionally link it to a thought. Supply either content_base64 (≤10 MB) or content_uri (amcs://files/{id} from a prior upload_file or POST /files call). For files larger than 10 MB, use upload_file with content_path first.",
}, toolSet.Files.Save)
addTool(server, logger, &mcp.Tool{
}, toolSet.Files.Save); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "load_file",
Description: "Load a previously stored file by id and return its metadata and base64 content.",
}, toolSet.Files.Load)
addTool(server, logger, &mcp.Tool{
}, toolSet.Files.Load); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "list_files",
Description: "List stored files, optionally filtered by thought, project, or kind.",
}, toolSet.Files.List)
}, toolSet.Files.List); err != nil {
return err
}
return nil
}
addTool(server, logger, &mcp.Tool{
func registerMaintenanceTools(server *mcp.Server, logger *slog.Logger, toolSet ToolSet) error {
if err := addTool(server, logger, &mcp.Tool{
Name: "backfill_embeddings",
Description: "Generate missing embeddings for stored thoughts using the active embedding model.",
}, toolSet.Backfill.Handle)
addTool(server, logger, &mcp.Tool{
}, toolSet.Backfill.Handle); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "reparse_thought_metadata",
Description: "Re-extract and normalize metadata for stored thoughts from their content.",
}, toolSet.Reparse.Handle)
addTool(server, logger, &mcp.Tool{
}, toolSet.Reparse.Handle); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "retry_failed_metadata",
Description: "Retry metadata extraction for thoughts still marked pending or failed.",
}, toolSet.RetryMetadata.Handle)
// Household Knowledge
addTool(server, logger, &mcp.Tool{
Name: "add_household_item",
Description: "Store a household fact (paint color, appliance details, measurement, document, etc.).",
}, toolSet.Household.AddItem)
addTool(server, logger, &mcp.Tool{
Name: "search_household_items",
Description: "Search household items by name, category, or location.",
}, toolSet.Household.SearchItems)
addTool(server, logger, &mcp.Tool{
Name: "get_household_item",
Description: "Retrieve a household item by id.",
}, toolSet.Household.GetItem)
addTool(server, logger, &mcp.Tool{
Name: "add_vendor",
Description: "Add a service provider (plumber, electrician, landscaper, etc.).",
}, toolSet.Household.AddVendor)
addTool(server, logger, &mcp.Tool{
Name: "list_vendors",
Description: "List household service vendors, optionally filtered by service type.",
}, toolSet.Household.ListVendors)
// Home Maintenance
addTool(server, logger, &mcp.Tool{
}, toolSet.RetryMetadata.Handle); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "add_maintenance_task",
Description: "Create a recurring or one-time home maintenance task.",
}, toolSet.Maintenance.AddTask)
addTool(server, logger, &mcp.Tool{
}, toolSet.Maintenance.AddTask); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "log_maintenance",
Description: "Log completed maintenance work; automatically updates the task's next due date.",
}, toolSet.Maintenance.LogWork)
addTool(server, logger, &mcp.Tool{
}, toolSet.Maintenance.LogWork); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "get_upcoming_maintenance",
Description: "List maintenance tasks due within the next N days.",
}, toolSet.Maintenance.GetUpcoming)
addTool(server, logger, &mcp.Tool{
}, toolSet.Maintenance.GetUpcoming); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "search_maintenance_history",
Description: "Search the maintenance log by task name, category, or date range.",
}, toolSet.Maintenance.SearchHistory)
}, toolSet.Maintenance.SearchHistory); err != nil {
return err
}
return nil
}
// Family Calendar
addTool(server, logger, &mcp.Tool{
func registerHouseholdTools(server *mcp.Server, logger *slog.Logger, toolSet ToolSet) error {
if err := addTool(server, logger, &mcp.Tool{
Name: "add_household_item",
Description: "Store a household fact (paint color, appliance details, measurement, document, etc.).",
}, toolSet.Household.AddItem); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "search_household_items",
Description: "Search household items by name, category, or location.",
}, toolSet.Household.SearchItems); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "get_household_item",
Description: "Retrieve a household item by id.",
}, toolSet.Household.GetItem); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "add_vendor",
Description: "Add a service provider (plumber, electrician, landscaper, etc.).",
}, toolSet.Household.AddVendor); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "list_vendors",
Description: "List household service vendors, optionally filtered by service type.",
}, toolSet.Household.ListVendors); err != nil {
return err
}
return nil
}
func registerCalendarTools(server *mcp.Server, logger *slog.Logger, toolSet ToolSet) error {
if err := addTool(server, logger, &mcp.Tool{
Name: "add_family_member",
Description: "Add a family member to the household.",
}, toolSet.Calendar.AddMember)
addTool(server, logger, &mcp.Tool{
}, toolSet.Calendar.AddMember); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "list_family_members",
Description: "List all family members.",
}, toolSet.Calendar.ListMembers)
addTool(server, logger, &mcp.Tool{
}, toolSet.Calendar.ListMembers); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "add_activity",
Description: "Schedule a one-time or recurring family activity.",
}, toolSet.Calendar.AddActivity)
addTool(server, logger, &mcp.Tool{
}, toolSet.Calendar.AddActivity); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "get_week_schedule",
Description: "Get all activities scheduled for a given week.",
}, toolSet.Calendar.GetWeekSchedule)
addTool(server, logger, &mcp.Tool{
}, toolSet.Calendar.GetWeekSchedule); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "search_activities",
Description: "Search activities by title, type, or family member.",
}, toolSet.Calendar.SearchActivities)
addTool(server, logger, &mcp.Tool{
}, toolSet.Calendar.SearchActivities); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "add_important_date",
Description: "Track a birthday, anniversary, deadline, or other important date.",
}, toolSet.Calendar.AddImportantDate)
addTool(server, logger, &mcp.Tool{
}, toolSet.Calendar.AddImportantDate); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "get_upcoming_dates",
Description: "Get important dates coming up in the next N days.",
}, toolSet.Calendar.GetUpcomingDates)
}, toolSet.Calendar.GetUpcomingDates); err != nil {
return err
}
return nil
}
// Meal Planning
addTool(server, logger, &mcp.Tool{
func registerMealTools(server *mcp.Server, logger *slog.Logger, toolSet ToolSet) error {
if err := addTool(server, logger, &mcp.Tool{
Name: "add_recipe",
Description: "Save a recipe with ingredients and instructions.",
}, toolSet.Meals.AddRecipe)
addTool(server, logger, &mcp.Tool{
}, toolSet.Meals.AddRecipe); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "search_recipes",
Description: "Search recipes by name, cuisine, tags, or ingredient.",
}, toolSet.Meals.SearchRecipes)
addTool(server, logger, &mcp.Tool{
}, toolSet.Meals.SearchRecipes); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "update_recipe",
Description: "Update an existing recipe.",
}, toolSet.Meals.UpdateRecipe)
addTool(server, logger, &mcp.Tool{
}, toolSet.Meals.UpdateRecipe); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "create_meal_plan",
Description: "Set the meal plan for a week; replaces any existing plan for that week.",
}, toolSet.Meals.CreateMealPlan)
addTool(server, logger, &mcp.Tool{
}, toolSet.Meals.CreateMealPlan); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "get_meal_plan",
Description: "Get the meal plan for a given week.",
}, toolSet.Meals.GetMealPlan)
addTool(server, logger, &mcp.Tool{
}, toolSet.Meals.GetMealPlan); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "generate_shopping_list",
Description: "Auto-generate a shopping list from the meal plan for a given week.",
}, toolSet.Meals.GenerateShoppingList)
}, toolSet.Meals.GenerateShoppingList); err != nil {
return err
}
return nil
}
// Professional CRM
addTool(server, logger, &mcp.Tool{
func registerCRMTools(server *mcp.Server, logger *slog.Logger, toolSet ToolSet) error {
if err := addTool(server, logger, &mcp.Tool{
Name: "add_professional_contact",
Description: "Add a professional contact to the CRM.",
}, toolSet.CRM.AddContact)
addTool(server, logger, &mcp.Tool{
}, toolSet.CRM.AddContact); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "search_contacts",
Description: "Search professional contacts by name, company, title, notes, or tags.",
}, toolSet.CRM.SearchContacts)
addTool(server, logger, &mcp.Tool{
}, toolSet.CRM.SearchContacts); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "log_interaction",
Description: "Log an interaction with a professional contact.",
}, toolSet.CRM.LogInteraction)
addTool(server, logger, &mcp.Tool{
}, toolSet.CRM.LogInteraction); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "get_contact_history",
Description: "Get full history (interactions and opportunities) for a contact.",
}, toolSet.CRM.GetHistory)
addTool(server, logger, &mcp.Tool{
}, toolSet.CRM.GetHistory); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "create_opportunity",
Description: "Create a deal, project, or opportunity linked to a contact.",
}, toolSet.CRM.CreateOpportunity)
addTool(server, logger, &mcp.Tool{
}, toolSet.CRM.CreateOpportunity); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "get_follow_ups_due",
Description: "List contacts with a follow-up date due within the next N days.",
}, toolSet.CRM.GetFollowUpsDue)
addTool(server, logger, &mcp.Tool{
}, toolSet.CRM.GetFollowUpsDue); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "link_thought_to_contact",
Description: "Append a stored thought to a contact's notes.",
}, toolSet.CRM.LinkThought)
}, toolSet.CRM.LinkThought); err != nil {
return err
}
return nil
}
// Agent Skills
addTool(server, logger, &mcp.Tool{
func registerSkillTools(server *mcp.Server, logger *slog.Logger, toolSet ToolSet) error {
if err := addTool(server, logger, &mcp.Tool{
Name: "add_skill",
Description: "Store a reusable agent skill (behavioural instruction or capability prompt).",
}, toolSet.Skills.AddSkill)
addTool(server, logger, &mcp.Tool{
}, toolSet.Skills.AddSkill); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "remove_skill",
Description: "Delete an agent skill by id.",
}, toolSet.Skills.RemoveSkill)
addTool(server, logger, &mcp.Tool{
}, toolSet.Skills.RemoveSkill); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "list_skills",
Description: "List all agent skills, optionally filtered by tag.",
}, toolSet.Skills.ListSkills)
// Agent Guardrails
addTool(server, logger, &mcp.Tool{
}, toolSet.Skills.ListSkills); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "add_guardrail",
Description: "Store a reusable agent guardrail (constraint or safety rule).",
}, toolSet.Skills.AddGuardrail)
addTool(server, logger, &mcp.Tool{
}, toolSet.Skills.AddGuardrail); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "remove_guardrail",
Description: "Delete an agent guardrail by id.",
}, toolSet.Skills.RemoveGuardrail)
addTool(server, logger, &mcp.Tool{
}, toolSet.Skills.RemoveGuardrail); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "list_guardrails",
Description: "List all agent guardrails, optionally filtered by tag or severity.",
}, toolSet.Skills.ListGuardrails)
// Project Skills & Guardrails
addTool(server, logger, &mcp.Tool{
}, toolSet.Skills.ListGuardrails); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "add_project_skill",
Description: "Link an agent skill to a project.",
}, toolSet.Skills.AddProjectSkill)
addTool(server, logger, &mcp.Tool{
Description: "Link an agent skill to a project. Pass project explicitly when your client does not preserve MCP sessions.",
}, toolSet.Skills.AddProjectSkill); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "remove_project_skill",
Description: "Unlink an agent skill from a project.",
}, toolSet.Skills.RemoveProjectSkill)
addTool(server, logger, &mcp.Tool{
Description: "Unlink an agent skill from a project. Pass project explicitly when your client does not preserve MCP sessions.",
}, toolSet.Skills.RemoveProjectSkill); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "list_project_skills",
Description: "List all skills linked to a project. Call this at the start of a project session to load existing agent behaviour instructions before generating new ones.",
}, toolSet.Skills.ListProjectSkills)
addTool(server, logger, &mcp.Tool{
Description: "List all skills linked to a project. Call this at the start of a project session to load existing agent behaviour instructions before generating new ones. Pass project explicitly when your client does not preserve MCP sessions.",
}, toolSet.Skills.ListProjectSkills); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "add_project_guardrail",
Description: "Link an agent guardrail to a project.",
}, toolSet.Skills.AddProjectGuardrail)
addTool(server, logger, &mcp.Tool{
Description: "Link an agent guardrail to a project. Pass project explicitly when your client does not preserve MCP sessions.",
}, toolSet.Skills.AddProjectGuardrail); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "remove_project_guardrail",
Description: "Unlink an agent guardrail from a project.",
}, toolSet.Skills.RemoveProjectGuardrail)
addTool(server, logger, &mcp.Tool{
Description: "Unlink an agent guardrail from a project. Pass project explicitly when your client does not preserve MCP sessions.",
}, toolSet.Skills.RemoveProjectGuardrail); err != nil {
return err
}
if err := addTool(server, logger, &mcp.Tool{
Name: "list_project_guardrails",
Description: "List all guardrails linked to a project. Call this at the start of a project session to load existing agent constraints before generating new ones.",
}, toolSet.Skills.ListProjectGuardrails)
return mcp.NewStreamableHTTPHandler(func(*http.Request) *mcp.Server {
return server
}, &mcp.StreamableHTTPOptions{
JSONResponse: true,
SessionTimeout: 10 * time.Minute,
})
Description: "List all guardrails linked to a project. Call this at the start of a project session to load existing agent constraints before generating new ones. Pass project explicitly when your client does not preserve MCP sessions.",
}, toolSet.Skills.ListProjectGuardrails); err != nil {
return err
}
return nil
}