run-dmcp 0.1.0

package/dist/register/quests.js

@@ -0,0 +1,118 @@
+import { z } from "zod";
+import * as questTools from "../tools/quest.js";
+import { LIMITS } from "../utils/validation.js";
+import { ANNOTATIONS } from "../utils/tool-annotations.js";
+export function registerQuestTools(server) {
+    server.registerTool("create_quest", {
+        description: "Create a new quest. Call this whenever the player receives a mission, task, or goal - whether from an NPC, discovered through exploration, or self-initiated. Include clear objectives that can be tracked.",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            name: z.string().min(1).max(LIMITS.NAME_MAX).describe("Quest name"),
+            description: z.string().max(LIMITS.DESCRIPTION_MAX).describe("Quest description"),
+            objectives: z.array(z.object({
+                description: z.string().max(LIMITS.DESCRIPTION_MAX),
+                completed: z.boolean().optional(),
+                optional: z.boolean().optional(),
+            })).max(LIMITS.ARRAY_MAX).describe("Quest objectives"),
+            rewards: z.string().max(LIMITS.DESCRIPTION_MAX).optional().describe("Quest rewards"),
+        },
+        annotations: ANNOTATIONS.CREATE,
+    }, async (params) => {
+        const quest = questTools.createQuest({
+            ...params,
+            objectives: params.objectives.map((obj) => ({
+                description: obj.description,
+                completed: obj.completed ?? false,
+                optional: obj.optional,
+            })),
+        });
+        return {
+            content: [{ type: "text", text: JSON.stringify(quest, null, 2) }],
+        };
+    });
+    server.registerTool("get_quest", {
+        description: "Get quest details",
+        inputSchema: {
+            questId: z.string().max(100).describe("The quest ID"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ questId }) => {
+        const quest = questTools.getQuest(questId);
+        if (!quest) {
+            return {
+                content: [{ type: "text", text: "Quest not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(quest, null, 2) }],
+        };
+    });
+    server.registerTool("update_quest", {
+        description: "Update a quest",
+        inputSchema: {
+            questId: z.string().max(100).describe("The quest ID"),
+            name: z.string().max(LIMITS.NAME_MAX).optional().describe("New name"),
+            description: z.string().max(LIMITS.DESCRIPTION_MAX).optional().describe("New description"),
+            status: z.enum(["active", "completed", "failed", "abandoned"]).optional().describe("New status"),
+            rewards: z.string().max(LIMITS.DESCRIPTION_MAX).optional().describe("Updated rewards"),
+        },
+        annotations: ANNOTATIONS.UPDATE,
+    }, async ({ questId, ...updates }) => {
+        const quest = questTools.updateQuest(questId, updates);
+        if (!quest) {
+            return {
+                content: [{ type: "text", text: "Quest not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(quest, null, 2) }],
+        };
+    });
+    // ============================================================================
+    // MODIFY OBJECTIVES - CONSOLIDATED (replaces add_objective + complete_objective)
+    // ============================================================================
+    server.registerTool("modify_objectives", {
+        description: "Add new objectives and/or mark existing objectives as completed in a single call. Call this immediately when: (1) player completes a quest step, (2) new sub-tasks are discovered, (3) objectives change based on player choices.",
+        inputSchema: {
+            questId: z.string().max(100).describe("The quest ID"),
+            add: z.array(z.object({
+                description: z.string().max(LIMITS.DESCRIPTION_MAX).describe("Objective description"),
+                optional: z.boolean().optional().describe("Is this objective optional?"),
+            })).max(LIMITS.ARRAY_MAX).optional().describe("New objectives to add"),
+            complete: z.array(z.string().max(100)).max(LIMITS.ARRAY_MAX).optional().describe("Objective IDs to mark as completed"),
+        },
+        annotations: ANNOTATIONS.UPDATE,
+    }, async ({ questId, add, complete }) => {
+        if (!add?.length && !complete?.length) {
+            return {
+                content: [{ type: "text", text: "No objectives to add or complete" }],
+                isError: true,
+            };
+        }
+        const result = questTools.modifyObjectives(questId, { add, complete });
+        if (!result) {
+            return {
+                content: [{ type: "text", text: "Quest not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("list_quests", {
+        description: "List quests in a game",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            status: z.enum(["active", "completed", "failed", "abandoned"]).optional().describe("Filter by status"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ gameId, status }) => {
+        const quests = questTools.listQuests(gameId, status ? { status } : undefined);
+        return {
+            content: [{ type: "text", text: JSON.stringify(quests, null, 2) }],
+        };
+    });
+}

package/dist/register/relationships.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerRelationshipTools(server: McpServer): void;

package/dist/register/relationships.js

@@ -0,0 +1,147 @@
+import { z } from "zod";
+import * as relationshipTools from "../tools/relationship.js";
+import { LIMITS } from "../utils/validation.js";
+import { ANNOTATIONS } from "../utils/tool-annotations.js";
+export function registerRelationshipTools(server) {
+    server.registerTool("create_relationship", {
+        description: "Create a relationship between two entities (characters, factions, etc.). Call this when establishing NPC attitudes toward the player, alliances, enmities, or any significant social connection mentioned in narrative.",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            sourceId: z.string().max(100).describe("Source entity ID"),
+            sourceType: z.string().max(100).describe("Source entity type (e.g., 'character', 'faction')"),
+            targetId: z.string().max(100).describe("Target entity ID"),
+            targetType: z.string().max(100).describe("Target entity type"),
+            relationshipType: z.string().max(100).describe("Type of relationship (e.g., 'attitude', 'bond', 'rivalry', 'loyalty')"),
+            value: z.number().optional().describe("Initial value (-100 to 100, default: 0)"),
+            label: z.string().max(LIMITS.NAME_MAX).optional().describe("Descriptive label (e.g., 'friendly', 'hostile')"),
+            notes: z.string().max(LIMITS.DESCRIPTION_MAX).optional().describe("Notes about the relationship"),
+        },
+        annotations: ANNOTATIONS.CREATE,
+    }, async (params) => {
+        const relationship = relationshipTools.createRelationship(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(relationship, null, 2) }],
+        };
+    });
+    server.registerTool("get_relationship", {
+        description: "Get a relationship by ID",
+        inputSchema: {
+            relationshipId: z.string().max(100).describe("The relationship ID"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ relationshipId }) => {
+        const relationship = relationshipTools.getRelationship(relationshipId);
+        if (!relationship) {
+            return {
+                content: [{ type: "text", text: "Relationship not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(relationship, null, 2) }],
+        };
+    });
+    server.registerTool("get_relationship_between", {
+        description: "Get the relationship between two specific entities",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            sourceId: z.string().max(100).describe("Source entity ID"),
+            targetId: z.string().max(100).describe("Target entity ID"),
+            relationshipType: z.string().max(100).optional().describe("Filter by relationship type"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ gameId, sourceId, targetId, relationshipType }) => {
+        const relationship = relationshipTools.getRelationshipBetween(gameId, sourceId, targetId, relationshipType);
+        if (!relationship) {
+            return {
+                content: [{ type: "text", text: "No relationship found between these entities" }],
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(relationship, null, 2) }],
+        };
+    });
+    // ============================================================================
+    // UPDATE RELATIONSHIP VALUE - CONSOLIDATED (replaces update_relationship + modify_relationship)
+    // ============================================================================
+    server.registerTool("update_relationship_value", {
+        description: "Update a relationship value and/or metadata. Use mode 'delta' to change by amount with history logging, or 'set' to set absolute value. Call this after any interaction that would affect how characters feel about each other - helpful actions, betrayals, gifts, insults, etc.",
+        inputSchema: {
+            relationshipId: z.string().max(100).describe("The relationship ID"),
+            mode: z.enum(["delta", "set"]).describe("'delta' to change by amount, 'set' to set absolute value"),
+            value: z.number().describe("Value to add (delta mode) or set (set mode)"),
+            reason: z.string().max(LIMITS.DESCRIPTION_MAX).optional().describe("Reason for the change (logged to history)"),
+            minValue: z.number().optional().describe("Minimum bound"),
+            maxValue: z.number().optional().describe("Maximum bound"),
+            relationshipType: z.string().max(100).optional().describe("Update relationship type"),
+            label: z.string().max(LIMITS.NAME_MAX).nullable().optional().describe("Update label"),
+            notes: z.string().max(LIMITS.DESCRIPTION_MAX).optional().describe("Update notes"),
+        },
+        annotations: ANNOTATIONS.UPDATE,
+    }, async ({ relationshipId, mode, value, reason, minValue, maxValue, relationshipType, label, notes }) => {
+        const result = relationshipTools.updateRelationshipValue({
+            relationshipId,
+            mode,
+            value,
+            reason,
+            minValue,
+            maxValue,
+            relationshipType,
+            label,
+            notes,
+        });
+        if (!result) {
+            return {
+                content: [{ type: "text", text: "Relationship not found" }],
+                isError: true,
+            };
+        }
+        const suggestedLabel = relationshipTools.getRelationshipLabel(result.relationship.value);
+        return {
+            content: [{ type: "text", text: JSON.stringify({ ...result, suggestedLabel }, null, 2) }],
+        };
+    });
+    server.registerTool("delete_relationship", {
+        description: "Delete a relationship",
+        inputSchema: {
+            relationshipId: z.string().max(100).describe("The relationship ID"),
+        },
+        annotations: ANNOTATIONS.DESTRUCTIVE,
+    }, async ({ relationshipId }) => {
+        const success = relationshipTools.deleteRelationship(relationshipId);
+        return {
+            content: [{ type: "text", text: success ? "Relationship deleted" : "Relationship not found" }],
+            isError: !success,
+        };
+    });
+    server.registerTool("list_relationships", {
+        description: "List relationships with optional filters",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            entityId: z.string().max(100).optional().describe("Filter by entity (either source or target)"),
+            sourceId: z.string().max(100).optional().describe("Filter by source entity"),
+            targetId: z.string().max(100).optional().describe("Filter by target entity"),
+            relationshipType: z.string().max(100).optional().describe("Filter by relationship type"),
+            entityType: z.string().max(100).optional().describe("Filter by entity type"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ gameId, ...filter }) => {
+        const relationships = relationshipTools.listRelationships(gameId, filter);
+        return {
+            content: [{ type: "text", text: JSON.stringify(relationships, null, 2) }],
+        };
+    });
+    server.registerTool("get_relationship_history", {
+        description: "Get change history for a relationship",
+        inputSchema: {
+            relationshipId: z.string().max(100).describe("The relationship ID"),
+            limit: z.number().optional().describe("Maximum entries to return"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ relationshipId, limit }) => {
+        const history = relationshipTools.getRelationshipHistory(relationshipId, limit);
+        return {
+            content: [{ type: "text", text: JSON.stringify(history, null, 2) }],
+        };
+    });
+}

package/dist/register/resources.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerResourceTools(server: McpServer): void;

package/dist/register/resources.js

@@ -0,0 +1,277 @@
+import { z } from "zod";
+import * as resourceTools from "../tools/resource.js";
+import * as constraintTools from "../tools/constraint.js";
+import { LIMITS } from "../utils/validation.js";
+import { ANNOTATIONS } from "../utils/tool-annotations.js";
+import { errors, formatErrorResponse } from "../utils/errors.js";
+export function registerResourceTools(server) {
+    server.registerTool("create_resource", {
+        description: "Create a new resource (currency, reputation, counter, etc.)",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            ownerType: z.enum(["game", "character"]).describe("Owner type: 'game' for party/global resources, 'character' for personal resources"),
+            ownerId: z.string().max(100).optional().describe("Character ID if ownerType is 'character' (omit for game-level resources)"),
+            name: z.string().min(1).max(LIMITS.NAME_MAX).describe("Resource name (e.g., 'Gold', 'Sanity', 'Thieves Guild Reputation')"),
+            description: z.string().max(LIMITS.DESCRIPTION_MAX).optional().describe("Resource description"),
+            category: z.string().max(100).optional().describe("Category for grouping (e.g., 'currency', 'reputation', 'pool', 'counter')"),
+            value: z.number().optional().describe("Initial value (default: 0)"),
+            minValue: z.number().optional().describe("Minimum bound (null for unbounded)"),
+            maxValue: z.number().optional().describe("Maximum bound (null for unbounded)"),
+        },
+        annotations: ANNOTATIONS.CREATE,
+    }, async (params) => {
+        const resource = resourceTools.createResource(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(resource, null, 2) }],
+        };
+    });
+    server.registerTool("get_resource", {
+        description: "Get resource details",
+        inputSchema: {
+            resourceId: z.string().max(100).describe("The resource ID"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ resourceId }) => {
+        const resource = resourceTools.getResource(resourceId);
+        if (!resource) {
+            return {
+                content: [{ type: "text", text: "Resource not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(resource, null, 2) }],
+        };
+    });
+    server.registerTool("update_resource", {
+        description: "Update resource metadata (name, description, category, bounds)",
+        inputSchema: {
+            resourceId: z.string().max(100).describe("The resource ID"),
+            name: z.string().max(LIMITS.NAME_MAX).optional().describe("New name"),
+            description: z.string().max(LIMITS.DESCRIPTION_MAX).optional().describe("New description"),
+            category: z.string().max(100).nullable().optional().describe("New category (null to clear)"),
+            minValue: z.number().nullable().optional().describe("New minimum bound (null for unbounded)"),
+            maxValue: z.number().nullable().optional().describe("New maximum bound (null for unbounded)"),
+        },
+        annotations: ANNOTATIONS.UPDATE,
+    }, async ({ resourceId, ...updates }) => {
+        try {
+            const resource = resourceTools.updateResource(resourceId, updates);
+            if (!resource) {
+                return {
+                    content: [{ type: "text", text: "Resource not found" }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify(resource, null, 2) }],
+            };
+        }
+        catch (error) {
+            if (error instanceof constraintTools.ConstraintViolationError) {
+                return formatErrorResponse(errors.constraintViolation(error.resourceId, error.message));
+            }
+            return {
+                content: [{ type: "text", text: error.message }],
+                isError: true,
+            };
+        }
+    });
+    server.registerTool("delete_resource", {
+        description: "Delete a resource and its history",
+        inputSchema: {
+            resourceId: z.string().max(100).describe("The resource ID"),
+        },
+        annotations: ANNOTATIONS.DESTRUCTIVE,
+    }, async ({ resourceId }) => {
+        try {
+            const success = resourceTools.deleteResource(resourceId);
+            return {
+                content: [{ type: "text", text: success ? "Resource deleted" : "Resource not found" }],
+                isError: !success,
+            };
+        }
+        catch (error) {
+            if (error instanceof constraintTools.ConstraintViolationError) {
+                return formatErrorResponse(errors.constraintViolation(error.resourceId, error.message));
+            }
+            return {
+                content: [{ type: "text", text: error.message }],
+                isError: true,
+            };
+        }
+    });
+    server.registerTool("list_resources", {
+        description: "List resources in a game",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            ownerType: z.enum(["game", "character"]).optional().describe("Filter by owner type"),
+            ownerId: z.string().max(100).optional().describe("Filter by owner ID (for character resources)"),
+            category: z.string().max(100).optional().describe("Filter by category"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ gameId, ownerType, ownerId, category }) => {
+        const resources = resourceTools.listResources(gameId, { ownerType, ownerId, category });
+        return {
+            content: [{ type: "text", text: JSON.stringify(resources, null, 2) }],
+        };
+    });
+    // ============================================================================
+    // UPDATE RESOURCE VALUE - CONSOLIDATED (replaces modify_resource + set_resource)
+    // ============================================================================
+    server.registerTool("update_resource_value", {
+        description: "Update a resource's value. Use mode 'delta' to add/subtract, or 'set' to set an absolute value. Changes are logged to history.",
+        inputSchema: {
+            resourceId: z.string().max(100).describe("The resource ID"),
+            mode: z.enum(["delta", "set"]).describe("'delta' to add/subtract, 'set' to set absolute value"),
+            value: z.number().describe("Amount to add/subtract (for delta) or absolute value (for set)"),
+            reason: z.string().max(LIMITS.DESCRIPTION_MAX).optional().describe("Reason for the change (logged to history)"),
+        },
+        annotations: ANNOTATIONS.UPDATE,
+    }, async ({ resourceId, mode, value, reason }) => {
+        try {
+            const result = resourceTools.updateResourceValue({ resourceId, mode, value, reason });
+            if (!result) {
+                return {
+                    content: [{ type: "text", text: "Resource not found" }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            if (error instanceof constraintTools.ConstraintViolationError) {
+                return formatErrorResponse(errors.constraintViolation(error.resourceId, error.message));
+            }
+            return {
+                content: [{ type: "text", text: error.message }],
+                isError: true,
+            };
+        }
+    });
+    // ============================================================================
+    // TRANSFER RESOURCE VALUE - the only write path for a 'conserved' member
+    // ============================================================================
+    server.registerTool("transfer_resource_value", {
+        description: "Move an amount from one resource to another, atomically, keeping their combined total unchanged. " +
+            "This is the ONLY way to change the value of a resource that belongs to a declared 'conserved' constraint -- " +
+            "update_resource_value rejects direct writes to such resources because a single-resource write can't say " +
+            "where the offsetting change should come from. fromResourceId and toResourceId must both already be members " +
+            "of the SAME declared 'conserved' constraint (see declare_resource_constraint). amount must be >= 0; swap " +
+            "fromResourceId/toResourceId to reverse direction. Never clamps -- if either side would cross its own " +
+            "minValue/maxValue, the whole transfer is rejected rather than applying an uneven amount to each side.",
+        inputSchema: {
+            fromResourceId: z.string().max(100).describe("Resource to subtract the amount from"),
+            toResourceId: z.string().max(100).describe("Resource to add the amount to"),
+            amount: z.number().min(0).describe("Amount to move (must be >= 0)"),
+            reason: z.string().max(LIMITS.DESCRIPTION_MAX).optional().describe("Reason for the transfer (logged to history on both sides)"),
+        },
+        annotations: ANNOTATIONS.UPDATE,
+    }, async ({ fromResourceId, toResourceId, amount, reason }) => {
+        try {
+            const result = resourceTools.transferResourceValue({ fromResourceId, toResourceId, amount, reason });
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            if (error instanceof constraintTools.ConstraintViolationError) {
+                return formatErrorResponse(errors.constraintViolation(error.resourceId, error.message));
+            }
+            return {
+                content: [{ type: "text", text: error.message }],
+                isError: true,
+            };
+        }
+    });
+    server.registerTool("get_resource_history", {
+        description: "Get change history for a resource",
+        inputSchema: {
+            resourceId: z.string().max(100).describe("The resource ID"),
+            limit: z.number().optional().describe("Maximum number of entries to return"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ resourceId, limit }) => {
+        const history = resourceTools.getResourceHistory(resourceId, limit);
+        return {
+            content: [{ type: "text", text: JSON.stringify(history, null, 2) }],
+        };
+    });
+    // ============================================================================
+    // RESOURCE CONSTRAINTS - optional, server-enforced invariants (opt-in; a
+    // resource with no declared constraint is unaffected -- see src/tools/constraint.ts)
+    // ============================================================================
+    server.registerTool("declare_resource_constraint", {
+        description: "Declare a server-enforced invariant on one or more resources, so update_resource_value cannot write a value that violates it. " +
+            "'bounded': the resource must already have minValue and/or maxValue set (via create_resource/update_resource) -- once declared, writes outside those bounds are REJECTED instead of the default silent clamp. " +
+            "'monotonic': the resource's value may only move in one direction ('increasing' = never decreases, 'decreasing' = never increases); holding steady is always allowed. " +
+            "'conserved': declares a set of 2+ resources that must always sum to a fixed total -- the members' current values must already sum to `total` (this does not rewrite them to match). Once declared, update_resource_value REJECTS direct writes to any member (ambiguous -- it can't know where the offsetting change comes from); use transfer_resource_value to move value between two members of the set atomically instead. A resource can belong to at most one 'conserved' set at a time.",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            kind: z.enum(["bounded", "monotonic", "conserved"]).describe("Constraint kind"),
+            resourceId: z.string().max(100).optional().describe("Required for 'bounded' or 'monotonic': the resource to constrain"),
+            resourceIds: z.array(z.string().max(100)).optional().describe("Required for 'conserved': 2 or more resource IDs that must sum to `total`"),
+            direction: z.enum(["increasing", "decreasing"]).optional().describe("Required for 'monotonic': the only direction the value may move"),
+            total: z.number().optional().describe("Required for 'conserved': the fixed sum the resource set must maintain"),
+        },
+        annotations: ANNOTATIONS.CREATE,
+    }, async ({ gameId, kind, resourceId, resourceIds, direction, total }) => {
+        try {
+            let constraint;
+            if (kind === "bounded") {
+                if (!resourceId)
+                    throw new Error("resourceId is required for a 'bounded' constraint");
+                constraint = constraintTools.declareBoundedConstraint({ gameId, resourceId });
+            }
+            else if (kind === "monotonic") {
+                if (!resourceId || !direction) {
+                    throw new Error("resourceId and direction are required for a 'monotonic' constraint");
+                }
+                constraint = constraintTools.declareMonotonicConstraint({ gameId, resourceId, direction });
+            }
+            else {
+                if (!resourceIds || total === undefined) {
+                    throw new Error("resourceIds and total are required for a 'conserved' constraint");
+                }
+                constraint = constraintTools.declareConservedConstraint({ gameId, resourceIds, total });
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify(constraint, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: error.message }],
+                isError: true,
+            };
+        }
+    });
+    server.registerTool("list_resource_constraints", {
+        description: "List declared resource constraints for a game, optionally filtered to those governing one resource.",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            resourceId: z.string().max(100).optional().describe("Filter to constraints governing this resource"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ gameId, resourceId }) => {
+        const constraints = constraintTools.listConstraints(gameId, resourceId);
+        return {
+            content: [{ type: "text", text: JSON.stringify(constraints, null, 2) }],
+        };
+    });
+    server.registerTool("remove_resource_constraint", {
+        description: "Remove a declared resource constraint by id. The resource(s) it governed revert to unconstrained (default clamp) behavior.",
+        inputSchema: {
+            constraintId: z.string().max(100).describe("The constraint ID"),
+        },
+        annotations: ANNOTATIONS.DESTRUCTIVE,
+    }, async ({ constraintId }) => {
+        const success = constraintTools.removeConstraint(constraintId);
+        return {
+            content: [{ type: "text", text: success ? "Constraint removed" : "Constraint not found" }],
+            isError: !success,
+        };
+    });
+}

package/dist/register/secrets.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerSecretTools(server: McpServer): void;