@jaypie/dynamodb 0.2.0 → 0.3.0

package/dist/cjs/mcp/index.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
-var mcp = require('@jaypie/vocabulary/mcp');
-var vocabulary = require('@jaypie/vocabulary');
+var mcp = require('@jaypie/fabric/mcp');
+var fabric = require('@jaypie/fabric');
 var clientDynamodb = require('@aws-sdk/client-dynamodb');
 var libDynamodb = require('@aws-sdk/lib-dynamodb');
 var errors = require('@jaypie/errors');
@@ -77,11 +77,11 @@ function isInitialized() {
     return docClient !== null && tableName !== null;
 }
 
-// Re-export shared constants from vocabulary
+// Re-export shared constants from fabric
 // GSI names (derived from DEFAULT_INDEXES)
 const INDEX_ALIAS = "indexAlias";
 const INDEX_CLASS = "indexClass";
-const INDEX_OU = "indexOu";
+const INDEX_SCOPE = "indexScope";
 const INDEX_TYPE = "indexType";
 const INDEX_XID = "indexXid";
 
@@ -89,53 +89,53 @@ const INDEX_XID = "indexXid";
 // Key Builders
 // =============================================================================
 /**
- * Build the indexOu key for hierarchical queries
- * @param ou - The organizational unit (APEX or "{parent.model}#{parent.id}")
+ * Build the indexScope key for hierarchical queries
+ * @param scope - The scope (APEX or "{parent.model}#{parent.id}")
  * @param model - The entity model name
- * @returns Composite key: "{ou}#{model}"
+ * @returns Composite key: "{scope}#{model}"
  */
-function buildIndexOu(ou, model) {
-    return `${ou}${vocabulary.SEPARATOR}${model}`;
+function buildIndexScope(scope, model) {
+    return `${scope}${fabric.SEPARATOR}${model}`;
 }
 /**
  * Build the indexAlias key for human-friendly lookups
- * @param ou - The organizational unit
+ * @param scope - The scope
  * @param model - The entity model name
  * @param alias - The human-friendly alias
- * @returns Composite key: "{ou}#{model}#{alias}"
+ * @returns Composite key: "{scope}#{model}#{alias}"
  */
-function buildIndexAlias(ou, model, alias) {
-    return `${ou}${vocabulary.SEPARATOR}${model}${vocabulary.SEPARATOR}${alias}`;
+function buildIndexAlias(scope, model, alias) {
+    return `${scope}${fabric.SEPARATOR}${model}${fabric.SEPARATOR}${alias}`;
 }
 /**
  * Build the indexClass key for category filtering
- * @param ou - The organizational unit
+ * @param scope - The scope
  * @param model - The entity model name
  * @param recordClass - The category classification
- * @returns Composite key: "{ou}#{model}#{class}"
+ * @returns Composite key: "{scope}#{model}#{class}"
  */
-function buildIndexClass(ou, model, recordClass) {
-    return `${ou}${vocabulary.SEPARATOR}${model}${vocabulary.SEPARATOR}${recordClass}`;
+function buildIndexClass(scope, model, recordClass) {
+    return `${scope}${fabric.SEPARATOR}${model}${fabric.SEPARATOR}${recordClass}`;
 }
 /**
  * Build the indexType key for type filtering
- * @param ou - The organizational unit
+ * @param scope - The scope
  * @param model - The entity model name
  * @param type - The type classification
- * @returns Composite key: "{ou}#{model}#{type}"
+ * @returns Composite key: "{scope}#{model}#{type}"
  */
-function buildIndexType(ou, model, type) {
-    return `${ou}${vocabulary.SEPARATOR}${model}${vocabulary.SEPARATOR}${type}`;
+function buildIndexType(scope, model, type) {
+    return `${scope}${fabric.SEPARATOR}${model}${fabric.SEPARATOR}${type}`;
 }
 /**
  * Build the indexXid key for external ID lookups
- * @param ou - The organizational unit
+ * @param scope - The scope
  * @param model - The entity model name
  * @param xid - The external ID
- * @returns Composite key: "{ou}#{model}#{xid}"
+ * @returns Composite key: "{scope}#{model}#{xid}"
  */
-function buildIndexXid(ou, model, xid) {
-    return `${ou}${vocabulary.SEPARATOR}${model}${vocabulary.SEPARATOR}${xid}`;
+function buildIndexXid(scope, model, xid) {
+    return `${scope}${fabric.SEPARATOR}${model}${fabric.SEPARATOR}${xid}`;
 }
 /**
  * Auto-populate GSI index keys on an entity
@@ -143,7 +143,7 @@ function buildIndexXid(ou, model, xid) {
  * Uses the model's registered indexes (from vocabulary registry) or
  * DEFAULT_INDEXES if no custom indexes are registered.
  *
- * - indexOu is always populated from ou + model
+ * - indexScope is always populated from scope + model
  * - indexAlias is populated only when alias is present
  * - indexClass is populated only when class is present
  * - indexType is populated only when type is present
@@ -154,9 +154,9 @@ function buildIndexXid(ou, model, xid) {
  * @returns The entity with populated index keys
  */
 function indexEntity(entity, suffix = "") {
-    const indexes = vocabulary.getModelIndexes(entity.model);
-    // Cast through unknown to bridge the type gap between StorableEntity and IndexableEntity
-    return vocabulary.populateIndexKeys(entity, indexes, suffix);
+    const indexes = fabric.getModelIndexes(entity.model);
+    // Cast through unknown to bridge the type gap between StorableEntity and IndexableModel
+    return fabric.populateIndexKeys(entity, indexes, suffix);
 }
 
 /**
@@ -166,20 +166,20 @@ function calculateEntitySuffix(entity) {
     const hasArchived = Boolean(entity.archivedAt);
     const hasDeleted = Boolean(entity.deletedAt);
     if (hasArchived && hasDeleted) {
-        return vocabulary.ARCHIVED_SUFFIX + vocabulary.DELETED_SUFFIX;
+        return fabric.ARCHIVED_SUFFIX + fabric.DELETED_SUFFIX;
     }
     if (hasArchived) {
-        return vocabulary.ARCHIVED_SUFFIX;
+        return fabric.ARCHIVED_SUFFIX;
     }
     if (hasDeleted) {
-        return vocabulary.DELETED_SUFFIX;
+        return fabric.DELETED_SUFFIX;
     }
     return "";
 }
 /**
  * Get a single entity by primary key
  */
-const getEntity = vocabulary.serviceHandler({
+const getEntity = fabric.fabricService({
     alias: "getEntity",
     description: "Get a single entity by primary key",
     input: {
@@ -201,7 +201,7 @@ const getEntity = vocabulary.serviceHandler({
  * Put (create or replace) an entity
  * Auto-populates GSI index keys via indexEntity
  *
- * Note: This is a regular async function (not serviceHandler) because it accepts
+ * Note: This is a regular async function (not fabricService) because it accepts
  * complex StorableEntity objects that can't be coerced by vocabulary's type system.
  */
 async function putEntity({ entity, }) {
@@ -220,7 +220,7 @@ async function putEntity({ entity, }) {
  * Update an existing entity
  * Auto-populates GSI index keys and sets updatedAt
  *
- * Note: This is a regular async function (not serviceHandler) because it accepts
+ * Note: This is a regular async function (not fabricService) because it accepts
  * complex StorableEntity objects that can't be coerced by vocabulary's type system.
  */
 async function updateEntity({ entity, }) {
@@ -242,7 +242,7 @@ async function updateEntity({ entity, }) {
  * Soft delete an entity by setting deletedAt timestamp
  * Re-indexes with appropriate suffix based on archived/deleted state
  */
-const deleteEntity = vocabulary.serviceHandler({
+const deleteEntity = fabric.fabricService({
     alias: "deleteEntity",
     description: "Soft delete an entity (sets deletedAt timestamp)",
     input: {
@@ -279,7 +279,7 @@ const deleteEntity = vocabulary.serviceHandler({
  * Archive an entity by setting archivedAt timestamp
  * Re-indexes with appropriate suffix based on archived/deleted state
  */
-const archiveEntity = vocabulary.serviceHandler({
+const archiveEntity = fabric.fabricService({
     alias: "archiveEntity",
     description: "Archive an entity (sets archivedAt timestamp)",
     input: {
@@ -316,7 +316,7 @@ const archiveEntity = vocabulary.serviceHandler({
  * Hard delete an entity (permanently removes from table)
  * Use with caution - prefer deleteEntity for soft delete
  */
-const destroyEntity = vocabulary.serviceHandler({
+const destroyEntity = fabric.fabricService({
     alias: "destroyEntity",
     description: "Hard delete an entity (permanently removes from table)",
     input: {
@@ -341,13 +341,13 @@ const destroyEntity = vocabulary.serviceHandler({
  */
 function calculateSuffix({ archived, deleted, }) {
     if (archived && deleted) {
-        return vocabulary.ARCHIVED_SUFFIX + vocabulary.DELETED_SUFFIX;
+        return fabric.ARCHIVED_SUFFIX + fabric.DELETED_SUFFIX;
     }
     if (archived) {
-        return vocabulary.ARCHIVED_SUFFIX;
+        return fabric.ARCHIVED_SUFFIX;
     }
     if (deleted) {
-        return vocabulary.DELETED_SUFFIX;
+        return fabric.DELETED_SUFFIX;
     }
     return "";
 }
@@ -379,16 +379,16 @@ async function executeQuery(indexName, keyValue, options = {}) {
     };
 }
 /**
- * Query entities by organizational unit (parent hierarchy)
- * Uses indexOu GSI
+ * Query entities by scope (parent hierarchy)
+ * Uses indexScope GSI
  *
- * Note: This is a regular async function (not serviceHandler) because it accepts
+ * Note: This is a regular async function (not fabricService) because it accepts
  * complex startKey objects that can't be coerced by vocabulary's type system.
  */
-async function queryByOu({ archived = false, ascending = false, deleted = false, limit, model, ou, startKey, }) {
+async function queryByScope({ archived = false, ascending = false, deleted = false, limit, model, scope, startKey, }) {
     const suffix = calculateSuffix({ archived, deleted });
-    const keyValue = buildIndexOu(ou, model) + suffix;
-    return executeQuery(INDEX_OU, keyValue, {
+    const keyValue = buildIndexScope(scope, model) + suffix;
+    return executeQuery(INDEX_SCOPE, keyValue, {
         ascending,
         limit,
         startKey,
@@ -398,7 +398,7 @@ async function queryByOu({ archived = false, ascending = false, deleted = false,
  * Query a single entity by human-friendly alias
  * Uses indexAlias GSI
  */
-const queryByAlias = vocabulary.serviceHandler({
+const queryByAlias = fabric.fabricService({
     alias: "queryByAlias",
     description: "Query a single entity by human-friendly alias",
     input: {
@@ -416,16 +416,19 @@ const queryByAlias = vocabulary.serviceHandler({
             description: "Query deleted entities instead of active ones",
         },
         model: { type: String, description: "Entity model name" },
-        ou: { type: String, description: "Organizational unit (@ for root)" },
+        scope: { type: String, description: "Scope (@ for root)" },
     },
-    service: async ({ alias, archived, deleted, model, ou, }) => {
+    service: async ({ alias, archived, deleted, model, scope, }) => {
         const aliasStr = alias;
         const archivedBool = archived;
         const deletedBool = deleted;
         const modelStr = model;
-        const ouStr = ou;
-        const suffix = calculateSuffix({ archived: archivedBool, deleted: deletedBool });
-        const keyValue = buildIndexAlias(ouStr, modelStr, aliasStr) + suffix;
+        const scopeStr = scope;
+        const suffix = calculateSuffix({
+            archived: archivedBool,
+            deleted: deletedBool,
+        });
+        const keyValue = buildIndexAlias(scopeStr, modelStr, aliasStr) + suffix;
         const result = await executeQuery(INDEX_ALIAS, keyValue, {
             limit: 1,
         });
@@ -436,12 +439,12 @@ const queryByAlias = vocabulary.serviceHandler({
  * Query entities by category classification
  * Uses indexClass GSI
  *
- * Note: This is a regular async function (not serviceHandler) because it accepts
+ * Note: This is a regular async function (not fabricService) because it accepts
  * complex startKey objects that can't be coerced by vocabulary's type system.
  */
-async function queryByClass({ archived = false, ascending = false, deleted = false, limit, model, ou, recordClass, startKey, }) {
+async function queryByClass({ archived = false, ascending = false, deleted = false, limit, model, scope, recordClass, startKey, }) {
     const suffix = calculateSuffix({ archived, deleted });
-    const keyValue = buildIndexClass(ou, model, recordClass) + suffix;
+    const keyValue = buildIndexClass(scope, model, recordClass) + suffix;
     return executeQuery(INDEX_CLASS, keyValue, {
         ascending,
         limit,
@@ -452,12 +455,12 @@ async function queryByClass({ archived = false, ascending = false, deleted = fal
  * Query entities by type classification
  * Uses indexType GSI
  *
- * Note: This is a regular async function (not serviceHandler) because it accepts
+ * Note: This is a regular async function (not fabricService) because it accepts
  * complex startKey objects that can't be coerced by vocabulary's type system.
  */
-async function queryByType({ archived = false, ascending = false, deleted = false, limit, model, ou, startKey, type, }) {
+async function queryByType({ archived = false, ascending = false, deleted = false, limit, model, scope, startKey, type, }) {
     const suffix = calculateSuffix({ archived, deleted });
-    const keyValue = buildIndexType(ou, model, type) + suffix;
+    const keyValue = buildIndexType(scope, model, type) + suffix;
     return executeQuery(INDEX_TYPE, keyValue, {
         ascending,
         limit,
@@ -468,7 +471,7 @@ async function queryByType({ archived = false, ascending = false, deleted = fals
  * Query a single entity by external ID
  * Uses indexXid GSI
  */
-const queryByXid = vocabulary.serviceHandler({
+const queryByXid = fabric.fabricService({
     alias: "queryByXid",
     description: "Query a single entity by external ID",
     input: {
@@ -485,17 +488,20 @@ const queryByXid = vocabulary.serviceHandler({
             description: "Query deleted entities instead of active ones",
         },
         model: { type: String, description: "Entity model name" },
-        ou: { type: String, description: "Organizational unit (@ for root)" },
+        scope: { type: String, description: "Scope (@ for root)" },
         xid: { type: String, description: "External ID" },
     },
-    service: async ({ archived, deleted, model, ou, xid, }) => {
+    service: async ({ archived, deleted, model, scope, xid, }) => {
         const archivedBool = archived;
         const deletedBool = deleted;
         const modelStr = model;
-        const ouStr = ou;
+        const scopeStr = scope;
         const xidStr = xid;
-        const suffix = calculateSuffix({ archived: archivedBool, deleted: deletedBool });
-        const keyValue = buildIndexXid(ouStr, modelStr, xidStr) + suffix;
+        const suffix = calculateSuffix({
+            archived: archivedBool,
+            deleted: deletedBool,
+        });
+        const keyValue = buildIndexXid(scopeStr, modelStr, xidStr) + suffix;
         const result = await executeQuery(INDEX_XID, keyValue, {
             limit: 1,
         });
@@ -524,12 +530,12 @@ function generateIndexName(pk) {
 function collectAllIndexes() {
     const indexMap = new Map();
     // Add DEFAULT_INDEXES first
-    for (const index of vocabulary.DEFAULT_INDEXES) {
+    for (const index of fabric.DEFAULT_INDEXES) {
         const name = index.name ?? generateIndexName(index.pk);
         indexMap.set(name, { ...index, name });
     }
     // Add registered model indexes (will not overwrite if name already exists)
-    for (const index of vocabulary.getAllRegisteredIndexes()) {
+    for (const index of fabric.getAllRegisteredIndexes()) {
         const name = index.name ?? generateIndexName(index.pk);
         if (!indexMap.has(name)) {
             indexMap.set(name, { ...index, name });
@@ -616,7 +622,7 @@ function createTableParams(tableName, billingMode) {
 /**
  * Create DynamoDB table with Jaypie GSI schema
  */
-const createTableHandler = vocabulary.serviceHandler({
+const createTableHandler = fabric.fabricService({
     alias: "dynamodb_create_table",
     description: "Create DynamoDB table with Jaypie GSI schema",
     input: {
@@ -680,7 +686,7 @@ const DEFAULT_TABLE_NAME = "jaypie-local";
 /**
  * Generate docker-compose.yml for local DynamoDB development
  */
-const dockerComposeHandler = vocabulary.serviceHandler({
+const dockerComposeHandler = fabric.fabricService({
     alias: "dynamodb_generate_docker_compose",
     description: "Generate docker-compose.yml for local DynamoDB development",
     input: {
@@ -778,7 +784,7 @@ function ensureInitialized() {
 /**
  * Check DynamoDB connection status and configuration
  */
-const statusHandler = vocabulary.serviceHandler({
+const statusHandler = fabric.fabricService({
     alias: "dynamodb_status",
     description: "Check DynamoDB connection status and configuration",
     service: async () => {
@@ -809,12 +815,12 @@ function wrapWithInit(handler) {
     return wrapped;
 }
 // MCP-specific serviceHandler wrappers for functions with complex inputs
-// Note: These wrap the regular async functions to make them work with registerMcpTool
+// Note: These wrap the regular async functions to make them work with fabricMcp
 /**
  * MCP wrapper for putEntity
  * Accepts entity JSON directly from LLM
  */
-const mcpPutEntity = vocabulary.serviceHandler({
+const mcpPutEntity = fabric.fabricService({
     alias: "dynamodb_put",
     description: "Create or replace an entity in DynamoDB (auto-indexes GSI keys)",
     input: {
@@ -822,10 +828,18 @@ const mcpPutEntity = vocabulary.serviceHandler({
         id: { type: String, description: "Entity ID (sort key)" },
         model: { type: String, description: "Entity model name (partition key)" },
         name: { type: String, description: "Entity name" },
-        ou: { type: String, description: "Organizational unit (@ for root)" },
+        scope: { type: String, description: "Scope (@ for root)" },
         // Optional fields
-        alias: { type: String, required: false, description: "Human-friendly alias" },
-        class: { type: String, required: false, description: "Category classification" },
+        alias: {
+            type: String,
+            required: false,
+            description: "Human-friendly alias",
+        },
+        class: {
+            type: String,
+            required: false,
+            description: "Category classification",
+        },
         type: { type: String, required: false, description: "Type classification" },
         xid: { type: String, required: false, description: "External ID" },
     },
@@ -838,7 +852,7 @@ const mcpPutEntity = vocabulary.serviceHandler({
             id: input.id,
             model: input.model,
             name: input.name,
-            ou: input.ou,
+            scope: input.scope,
             sequence: Date.now(),
             type: input.type,
             updatedAt: now,
@@ -851,7 +865,7 @@ const mcpPutEntity = vocabulary.serviceHandler({
  * MCP wrapper for updateEntity
  * Accepts entity JSON directly from LLM
  */
-const mcpUpdateEntity = vocabulary.serviceHandler({
+const mcpUpdateEntity = fabric.fabricService({
     alias: "dynamodb_update",
     description: "Update an entity in DynamoDB (sets updatedAt, re-indexes GSI keys)",
     input: {
@@ -860,9 +874,17 @@ const mcpUpdateEntity = vocabulary.serviceHandler({
         model: { type: String, description: "Entity model name (partition key)" },
         // Fields that can be updated
         name: { type: String, required: false, description: "Entity name" },
-        ou: { type: String, required: false, description: "Organizational unit" },
-        alias: { type: String, required: false, description: "Human-friendly alias" },
-        class: { type: String, required: false, description: "Category classification" },
+        scope: { type: String, required: false, description: "Scope" },
+        alias: {
+            type: String,
+            required: false,
+            description: "Human-friendly alias",
+        },
+        class: {
+            type: String,
+            required: false,
+            description: "Category classification",
+        },
         type: { type: String, required: false, description: "Type classification" },
         xid: { type: String, required: false, description: "External ID" },
     },
@@ -881,7 +903,7 @@ const mcpUpdateEntity = vocabulary.serviceHandler({
             ...(input.alias !== undefined && { alias: input.alias }),
             ...(input.class !== undefined && { class: input.class }),
             ...(input.name !== undefined && { name: input.name }),
-            ...(input.ou !== undefined && { ou: input.ou }),
+            ...(input.scope !== undefined && { scope: input.scope }),
             ...(input.type !== undefined && { type: input.type }),
             ...(input.xid !== undefined && { xid: input.xid }),
         };
@@ -889,15 +911,15 @@ const mcpUpdateEntity = vocabulary.serviceHandler({
     },
 });
 /**
- * MCP wrapper for queryByOu
+ * MCP wrapper for queryByScope
  * Note: Pagination via startKey is not exposed to MCP; use limit instead
  */
-const mcpQueryByOu = vocabulary.serviceHandler({
-    alias: "dynamodb_query_ou",
-    description: "Query entities by organizational unit (parent hierarchy)",
+const mcpQueryByScope = fabric.fabricService({
+    alias: "dynamodb_query_scope",
+    description: "Query entities by scope (parent hierarchy)",
     input: {
         model: { type: String, description: "Entity model name" },
-        ou: { type: String, description: "Organizational unit (@ for root)" },
+        scope: { type: String, description: "Scope (@ for root)" },
         archived: {
             type: Boolean,
             default: false,
@@ -923,13 +945,13 @@ const mcpQueryByOu = vocabulary.serviceHandler({
         },
     },
     service: async (input) => {
-        return queryByOu({
+        return queryByScope({
             archived: input.archived,
             ascending: input.ascending,
             deleted: input.deleted,
             limit: input.limit,
             model: input.model,
-            ou: input.ou,
+            scope: input.scope,
         });
     },
 });
@@ -937,12 +959,12 @@ const mcpQueryByOu = vocabulary.serviceHandler({
  * MCP wrapper for queryByClass
  * Note: Pagination via startKey is not exposed to MCP; use limit instead
  */
-const mcpQueryByClass = vocabulary.serviceHandler({
+const mcpQueryByClass = fabric.fabricService({
     alias: "dynamodb_query_class",
     description: "Query entities by category classification",
     input: {
         model: { type: String, description: "Entity model name" },
-        ou: { type: String, description: "Organizational unit (@ for root)" },
+        scope: { type: String, description: "Scope (@ for root)" },
         recordClass: { type: String, description: "Category classification" },
         archived: {
             type: Boolean,
@@ -975,7 +997,7 @@ const mcpQueryByClass = vocabulary.serviceHandler({
             deleted: input.deleted,
             limit: input.limit,
             model: input.model,
-            ou: input.ou,
+            scope: input.scope,
             recordClass: input.recordClass,
         });
     },
@@ -984,12 +1006,12 @@ const mcpQueryByClass = vocabulary.serviceHandler({
  * MCP wrapper for queryByType
  * Note: Pagination via startKey is not exposed to MCP; use limit instead
  */
-const mcpQueryByType = vocabulary.serviceHandler({
+const mcpQueryByType = fabric.fabricService({
     alias: "dynamodb_query_type",
     description: "Query entities by type classification",
     input: {
         model: { type: String, description: "Entity model name" },
-        ou: { type: String, description: "Organizational unit (@ for root)" },
+        scope: { type: String, description: "Scope (@ for root)" },
         type: { type: String, description: "Type classification" },
         archived: {
             type: Boolean,
@@ -1022,7 +1044,7 @@ const mcpQueryByType = vocabulary.serviceHandler({
             deleted: input.deleted,
             limit: input.limit,
             model: input.model,
-            ou: input.ou,
+            scope: input.scope,
             type: input.type,
         });
     },
@@ -1034,80 +1056,80 @@ function registerDynamoDbTools(config) {
     const { includeAdmin = true, server } = config;
     const tools = [];
     // Entity operations
-    mcp.registerMcpTool({
-        handler: wrapWithInit(getEntity),
+    mcp.fabricMcp({
+        service: wrapWithInit(getEntity),
         name: "dynamodb_get",
         server,
     });
     tools.push("dynamodb_get");
-    mcp.registerMcpTool({
-        handler: wrapWithInit(mcpPutEntity),
+    mcp.fabricMcp({
+        service: wrapWithInit(mcpPutEntity),
         name: "dynamodb_put",
         server,
     });
     tools.push("dynamodb_put");
-    mcp.registerMcpTool({
-        handler: wrapWithInit(mcpUpdateEntity),
+    mcp.fabricMcp({
+        service: wrapWithInit(mcpUpdateEntity),
         name: "dynamodb_update",
         server,
     });
     tools.push("dynamodb_update");
-    mcp.registerMcpTool({
-        handler: wrapWithInit(deleteEntity),
+    mcp.fabricMcp({
+        service: wrapWithInit(deleteEntity),
         name: "dynamodb_delete",
         server,
     });
     tools.push("dynamodb_delete");
-    mcp.registerMcpTool({
-        handler: wrapWithInit(archiveEntity),
+    mcp.fabricMcp({
+        service: wrapWithInit(archiveEntity),
         name: "dynamodb_archive",
         server,
     });
     tools.push("dynamodb_archive");
-    mcp.registerMcpTool({
-        handler: wrapWithInit(destroyEntity),
+    mcp.fabricMcp({
+        service: wrapWithInit(destroyEntity),
         name: "dynamodb_destroy",
         server,
     });
     tools.push("dynamodb_destroy");
     // Query operations
-    mcp.registerMcpTool({
-        handler: wrapWithInit(mcpQueryByOu),
-        name: "dynamodb_query_ou",
+    mcp.fabricMcp({
+        service: wrapWithInit(mcpQueryByScope),
+        name: "dynamodb_query_scope",
         server,
     });
-    tools.push("dynamodb_query_ou");
-    mcp.registerMcpTool({
-        handler: wrapWithInit(queryByAlias),
+    tools.push("dynamodb_query_scope");
+    mcp.fabricMcp({
+        service: wrapWithInit(queryByAlias),
         name: "dynamodb_query_alias",
         server,
     });
     tools.push("dynamodb_query_alias");
-    mcp.registerMcpTool({
-        handler: wrapWithInit(mcpQueryByClass),
+    mcp.fabricMcp({
+        service: wrapWithInit(mcpQueryByClass),
         name: "dynamodb_query_class",
         server,
     });
     tools.push("dynamodb_query_class");
-    mcp.registerMcpTool({
-        handler: wrapWithInit(mcpQueryByType),
+    mcp.fabricMcp({
+        service: wrapWithInit(mcpQueryByType),
         name: "dynamodb_query_type",
         server,
     });
     tools.push("dynamodb_query_type");
-    mcp.registerMcpTool({
-        handler: wrapWithInit(queryByXid),
+    mcp.fabricMcp({
+        service: wrapWithInit(queryByXid),
         name: "dynamodb_query_xid",
         server,
     });
     tools.push("dynamodb_query_xid");
     // Admin tools (MCP-only)
     if (includeAdmin) {
-        mcp.registerMcpTool({ handler: statusHandler, server });
+        mcp.fabricMcp({ service: statusHandler, server });
         tools.push("dynamodb_status");
-        mcp.registerMcpTool({ handler: createTableHandler, server });
+        mcp.fabricMcp({ service: createTableHandler, server });
         tools.push("dynamodb_create_table");
-        mcp.registerMcpTool({ handler: dockerComposeHandler, server });
+        mcp.fabricMcp({ service: dockerComposeHandler, server });
         tools.push("dynamodb_generate_docker_compose");
     }
     return { tools };