@fluentcommerce/fluent-mcp-extn 0.7.0 → 0.7.3

package/dist/tools.js

@@ -209,7 +209,7 @@ const SettingListedInputSchema = {
     additionalProperties: false,
 };
 const WORKFLOW_LISTED_SCHEMAS = {
-    "workflow.upload": {
+    "workflow_upload": {
         type: "object",
         properties: {
             workflow: {
@@ -234,7 +234,7 @@ const WORKFLOW_LISTED_SCHEMAS = {
         required: ["workflow"],
         additionalProperties: false,
     },
-    "workflow.diff": {
+    "workflow_diff": {
         type: "object",
         properties: {
             base: {
@@ -255,7 +255,7 @@ const WORKFLOW_LISTED_SCHEMAS = {
         required: ["base", "target"],
         additionalProperties: false,
     },
-    "workflow.simulate": {
+    "workflow_simulate": {
         type: "object",
         properties: {
             workflow: {
@@ -284,8 +284,8 @@ const WORKFLOW_LISTED_SCHEMAS = {
     },
 };
 const SETTING_LISTED_SCHEMAS = {
-    "setting.upsert": SettingListedInputSchema,
-    "setting.bulkUpsert": {
+    "setting_upsert": SettingListedInputSchema,
+    "setting_bulkUpsert": {
         type: "object",
         properties: {
             settings: {
@@ -303,152 +303,152 @@ const SETTING_LISTED_SCHEMAS = {
 export const TOOL_CATALOG = [
     // ---- config & health (no API) ------------------------------------------
     {
-        name: "config.validate",
+        name: "config_validate",
         description: "Run first: validates auth/base URL/retailer configuration and reports readiness for API tools.",
         schema: z.object({}),
         annotations: { title: "Validate Configuration", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     },
     {
-        name: "health.ping",
+        name: "health_ping",
         description: "Quick diagnostics: confirms SDK adapter connection and config readiness when calls fail.",
         schema: z.object({}),
         annotations: { title: "Health Ping", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
     },
     {
-        name: "time.resolveWindow",
+        name: "time_resolveWindow",
         description: "Resolve natural-language, shorthand, or datemath time phrases like 'last month', '1h30m', 'now-7d/d', or 'now-7d to now' into exact ISO from/to timestamps. Returns candidates instead of guessing when the phrase is ambiguous.",
         schema: ResolveTimeWindowInputSchema,
         annotations: { title: "Resolve Time Window", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     },
     // ---- event tools (from event-tools module) -----------------------------
     ...fromModule(EVENT_TOOL_DEFINITIONS, {
-        "event.build": EventBuildInputSchema,
-        "event.send": EventPublishInputSchema,
-        "event.get": EventGetInputSchema,
-        "event.list": EventListInputSchema,
-        "event.flowInspect": EventFlowInspectInputSchema,
+        "event_build": EventBuildInputSchema,
+        "event_send": EventPublishInputSchema,
+        "event_get": EventGetInputSchema,
+        "event_list": EventListInputSchema,
+        "event_flowInspect": EventFlowInspectInputSchema,
     }),
     // ---- metrics tools (from metrics-tools module) -------------------------
     ...fromModule(METRICS_TOOL_DEFINITIONS, {
-        "metrics.query": MetricsQueryInputSchema,
-        "metrics.topEvents": MetricsTopEventsInputSchema,
-        "metrics.healthCheck": MetricsHealthCheckInputSchema,
-        "metrics.sloReport": MetricsSloReportInputSchema,
-        "metrics.labelCatalog": MetricsLabelCatalogInputSchema,
-        "metrics.metricCatalog": MetricsMetricCatalogInputSchema,
-        "metrics.planQuery": MetricsPlanQueryInputSchema,
-        "metrics.snapshot": MetricsSnapshotInputSchema,
-        "metrics.compare": MetricsCompareInputSchema,
-        "metrics.mutationAudit": MetricsMutationAuditInputSchema,
+        "metrics_query": MetricsQueryInputSchema,
+        "metrics_topEvents": MetricsTopEventsInputSchema,
+        "metrics_healthCheck": MetricsHealthCheckInputSchema,
+        "metrics_sloReport": MetricsSloReportInputSchema,
+        "metrics_labelCatalog": MetricsLabelCatalogInputSchema,
+        "metrics_metricCatalog": MetricsMetricCatalogInputSchema,
+        "metrics_planQuery": MetricsPlanQueryInputSchema,
+        "metrics_snapshot": MetricsSnapshotInputSchema,
+        "metrics_compare": MetricsCompareInputSchema,
+        "metrics_mutationAudit": MetricsMutationAuditInputSchema,
     }),
-    // ---- workflow.transitions & plugin.list (inline) -----------------------
+    // ---- workflow_transitions & plugin_list (inline) -----------------------
     {
-        name: "workflow.transitions",
+        name: "workflow_transitions",
         description: [
             "Query available user actions (transitions) via POST /api/v4.1/transition.",
             "Requires flexType (e.g. ORDER::HD) — auto-derived from type+subtype when omitted.",
-            "Returns per-trigger summary of event names, required attributes, _attributeTemplate (ready for event.send), _predictions with target status + action classification + multi-step lookahead, and _recommended safest next action. Auto-fetches workflow when not cached.",
+            "Returns per-trigger summary of event names, required attributes, _attributeTemplate (ready for event_send), _predictions with target status + action classification + multi-step lookahead, and _recommended safest next action. Auto-fetches workflow when not cached.",
         ].join("\n"),
         schema: TransitionActionsInputSchema,
         annotations: { title: "Query Transitions", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
     },
     {
-        name: "plugin.list",
+        name: "plugin_list",
         description: "List registered orchestration rules with metadata. Optional name filter. Use keysOnly=true for lightweight key+count response.",
         schema: PluginListInputSchema,
         annotations: { title: "List Plugins", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
     },
-    // ---- graphql query tools (from graphql-query-tools module) -------------
+    // ---- graphql_query tools (from graphql_query-tools module) -------------
     ...fromModule(GRAPHQL_QUERY_TOOL_DEFINITIONS, {
-        "graphql.query": GraphQLQueryInputSchema,
-        "graphql.queryAll": GraphQLQueryAllInputSchema,
-        "graphql.batchMutate": GraphQLBatchMutateInputSchema,
-        "graphql.introspect": GraphQLIntrospectInputSchema,
+        "graphql_query": GraphQLQueryInputSchema,
+        "graphql_queryAll": GraphQLQueryAllInputSchema,
+        "graphql_batchMutate": GraphQLBatchMutateInputSchema,
+        "graphql_introspect": GraphQLIntrospectInputSchema,
     }),
     // ---- batch tools (from batch-tools module) -----------------------------
     ...fromModule(BATCH_TOOL_DEFINITIONS, {
-        "batch.create": BatchCreateInputSchema,
-        "batch.send": BatchSendInputSchema,
-        "batch.status": BatchStatusInputSchema,
-        "batch.batchStatus": BatchGetBatchStatusInputSchema,
-        "batch.results": BatchResultsInputSchema,
-        "batch.describePayload": BatchDescribePayloadInputSchema,
+        "batch_create": BatchCreateInputSchema,
+        "batch_send": BatchSendInputSchema,
+        "batch_status": BatchStatusInputSchema,
+        "batch_batchStatus": BatchGetBatchStatusInputSchema,
+        "batch_results": BatchResultsInputSchema,
+        "batch_describePayload": BatchDescribePayloadInputSchema,
     }),
     // ---- connection & webhook (inline) -------------------------------------
     {
-        name: "connection.test",
+        name: "connection_test",
         description: "End-to-end connectivity test. Authenticates and executes a 'me' query.",
         schema: z.object({}),
         annotations: { title: "Test Connection", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
     },
     {
-        name: "webhook.validate",
+        name: "webhook_validate",
         description: "Validate a webhook payload. Optionally verify signature with public key.",
         schema: WebhookValidateInputSchema,
         annotations: { title: "Validate Webhook", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     },
     // ---- connection management (multi-profile) --------------------------------
     {
-        name: "connection.list",
+        name: "connection_list",
         description: "List all loaded profiles with connection status, auth strategy, and which is the default.",
         schema: z.object({}),
         annotations: { title: "List Connections", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     },
     {
-        name: "connection.add",
+        name: "connection_add",
         description: "Register an additional connection from a CLI profile or explicit credentials.",
         schema: ConnectionAddInputSchema,
         annotations: { title: "Add Connection", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     },
     {
-        name: "connection.remove",
+        name: "connection_remove",
         description: "Remove a previously loaded profile. Cannot remove the current default profile.",
         schema: ConnectionRemoveInputSchema,
         annotations: { title: "Remove Connection", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     },
     {
-        name: "connection.switch",
+        name: "connection_switch",
         description: "Switch the default profile. Subsequent tool calls without an explicit profile parameter will use this profile.",
         schema: ConnectionSwitchInputSchema,
         annotations: { title: "Switch Default Connection", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     },
     // ---- sub-module tools (entity, workflow, setting, environment, test, graphql schema, cache) --
     ...fromModule(ENTITY_TOOL_DEFINITIONS, {
-        "entity.create": EntityCreateInputSchema,
-        "entity.update": EntityUpdateInputSchema,
-        "entity.get": EntityGetInputSchema,
-        "entity.planCreate": EntityPlanCreateInputSchema,
-        "entity.planUpdate": EntityPlanUpdateInputSchema,
+        "entity_create": EntityCreateInputSchema,
+        "entity_update": EntityUpdateInputSchema,
+        "entity_get": EntityGetInputSchema,
+        "entity_planCreate": EntityPlanCreateInputSchema,
+        "entity_planUpdate": EntityPlanUpdateInputSchema,
     }),
     ...fromModule(WORKFLOW_TOOL_DEFINITIONS, {
-        "workflow.get": WorkflowGetInputSchema,
-        "workflow.list": WorkflowListInputSchema,
-        "workflow.upload": WorkflowUploadInputSchema,
-        "workflow.diff": WorkflowDiffInputSchema,
-        "workflow.simulate": WorkflowSimulateInputSchema,
+        "workflow_get": WorkflowGetInputSchema,
+        "workflow_list": WorkflowListInputSchema,
+        "workflow_upload": WorkflowUploadInputSchema,
+        "workflow_diff": WorkflowDiffInputSchema,
+        "workflow_simulate": WorkflowSimulateInputSchema,
     }, WORKFLOW_LISTED_SCHEMAS),
     ...fromModule(SETTING_TOOL_DEFINITIONS, {
-        "setting.get": SettingGetInputSchema,
-        "setting.upsert": SettingUpsertInputSchema,
-        "setting.bulkUpsert": SettingBulkUpsertInputSchema,
+        "setting_get": SettingGetInputSchema,
+        "setting_upsert": SettingUpsertInputSchema,
+        "setting_bulkUpsert": SettingBulkUpsertInputSchema,
     }, SETTING_LISTED_SCHEMAS),
     ...fromModule(ENVIRONMENT_TOOL_DEFINITIONS, {
-        "environment.discover": EnvironmentDiscoverInputSchema,
-        "environment.validate": EnvironmentValidateInputSchema,
+        "environment_discover": EnvironmentDiscoverInputSchema,
+        "environment_validate": EnvironmentValidateInputSchema,
     }),
     ...fromModule(TEST_TOOL_DEFINITIONS, {
-        "test.assert": TestAssertInputSchema,
+        "test_assert": TestAssertInputSchema,
     }),
     ...fromModule(GRAPHQL_SCHEMA_TOOL_DEFINITIONS, {
-        "graphql.listRoots": ListRootsInputSchema,
-        "graphql.planOperation": PlanOperationInputSchema,
-        "graphql.buildQuery": BuildQueryInputSchema,
-        "graphql.validate": ValidateInputSchema,
-        "graphql.generateFull": GenerateFullInputSchema,
+        "graphql_listRoots": ListRootsInputSchema,
+        "graphql_planOperation": PlanOperationInputSchema,
+        "graphql_buildQuery": BuildQueryInputSchema,
+        "graphql_validate": ValidateInputSchema,
+        "graphql_generateFull": GenerateFullInputSchema,
     }),
     ...fromModule(CACHE_TOOL_DEFINITIONS, {
-        "cache.status": CacheStatusInputSchema,
-        "cache.clear": CacheClearInputSchema,
+        "cache_status": CacheStatusInputSchema,
+        "cache_clear": CacheClearInputSchema,
     }),
 ];
 // ---------------------------------------------------------------------------
@@ -707,14 +707,14 @@ export function buildActionPredictions(analysis, workflow) {
         }
     }
     if (!workflow) {
-        hints.push("Call workflow.get with this entity type+subtype to enable status predictions and action classification.");
+        hints.push("Call workflow_get with this entity type+subtype to enable status predictions and action classification.");
     }
     if (Object.keys(_attributeTemplate).length > 0) {
-        hints.push("Use _attributeTemplate values as the 'attributes' parameter in event.send or event.build.");
+        hints.push("Use _attributeTemplate values as the 'attributes' parameter in event_send or event_build.");
     }
     const terminalActions = predictions.filter((p) => p.classification === "terminal");
     if (terminalActions.length > 0) {
-        hints.push(`Terminal actions (no further workflow transitions): ${terminalActions.map((a) => a.eventName).join(", ")}. Use with caution.`);
+        hints.push(`Terminal actions (no further workflow_transitions): ${terminalActions.map((a) => a.eventName).join(", ")}. Use with caution.`);
     }
     const progressionActions = predictions.filter((p) => p.classification === "progression");
     if (progressionActions.length > 0 && progressionActions.length < predictions.length) {
@@ -830,7 +830,7 @@ export function getFilteredCatalog(filterOverride) {
     if (prefixes.length === 0)
         return TOOL_CATALOG;
     return TOOL_CATALOG.filter((t) => {
-        const category = t.name.split(".")[0].toLowerCase();
+        const category = t.name.split("_")[0].toLowerCase();
         return prefixes.includes(category);
     });
 }
@@ -867,28 +867,28 @@ function json(payload, isError = false, budget) {
 }
 function requireClient(ctx) {
     if (!ctx.client) {
-        throw new ToolError("CONFIG_ERROR", "SDK client is not available. Run config.validate and fix auth/base URL.");
+        throw new ToolError("CONFIG_ERROR", "SDK client is not available. Run config_validate and fix auth/base URL.");
     }
     return ctx.client;
 }
 /** Tools where selecting a profile has no effect. */
 const PROFILE_IRRELEVANT_TOOLS = new Set([
-    "time.resolveWindow",
-    "webhook.validate",
-    "connection.list",
-    "connection.add",
-    "connection.remove",
-    "connection.switch",
+    "time_resolveWindow",
+    "webhook_validate",
+    "connection_list",
+    "connection_add",
+    "connection_remove",
+    "connection_switch",
 ]);
 /**
  * Tools that should follow the selected profile's config/cache but do not need
  * an SDK client to do their work.
  */
 const PROFILE_CONFIG_ONLY_TOOLS = new Set([
-    "config.validate",
-    "cache.status",
-    "cache.clear",
-    "event.build",
+    "config_validate",
+    "cache_status",
+    "cache_clear",
+    "event_build",
 ]);
 const MCP_TOOL_INPUT_SCHEMA = z.object({}).passthrough().default({});
 function getLowLevelServer(server) {
@@ -977,7 +977,7 @@ export function getListedInputSchema(tool, registry) {
         const props = (normalized.properties ?? {});
         props.profile = {
             type: "string",
-            description: `Target profile (see connection.list). Default: ${registry.defaultName}`,
+            description: `Target profile (see connection_list). Default: ${registry.defaultName}`,
         };
         normalized.properties = props;
     }
@@ -1077,14 +1077,14 @@ async function handleToolCall(toolName, args, ctx) {
 }
 async function dispatchToolCall(toolName, args, ctx) {
     // ------- cache tools (no API) ----------------------------------------
-    if (toolName === "cache.status") {
+    if (toolName === "cache_status") {
         return json(handleCacheStatus(args, ctx.cache), false, ctx.responseBudget);
     }
-    if (toolName === "cache.clear") {
+    if (toolName === "cache_clear") {
         return json(handleCacheClear(args, ctx.cache), false, ctx.responseBudget);
     }
     // ------- config & health (no API) ------------------------------------
-    if (toolName === "config.validate") {
+    if (toolName === "config_validate") {
         const validation = validateConfig(ctx.config);
         return json({
             ok: true,
@@ -1093,7 +1093,7 @@ async function dispatchToolCall(toolName, args, ctx) {
             config: toSafeConfigSummary(ctx.config),
         });
     }
-    if (toolName === "health.ping") {
+    if (toolName === "health_ping") {
         const validation = validateConfig(ctx.config);
         return json({
             ok: true,
@@ -1104,11 +1104,11 @@ async function dispatchToolCall(toolName, args, ctx) {
             config: toSafeConfigSummary(ctx.config),
         });
     }
-    if (toolName === "time.resolveWindow") {
+    if (toolName === "time_resolveWindow") {
         return json(handleResolveTimeWindow(args), false, ctx.responseBudget);
     }
     // ------- connection management (multi-profile) -----------------------
-    if (toolName === "connection.list") {
+    if (toolName === "connection_list") {
         if (!ctx.registry) {
             return json({
                 ok: true,
@@ -1124,7 +1124,7 @@ async function dispatchToolCall(toolName, args, ctx) {
         }
         return json({ ok: true, profiles: ctx.registry.list() });
     }
-    if (toolName === "connection.add") {
+    if (toolName === "connection_add") {
         const parsed = ConnectionAddInputSchema.parse(args);
         if (!ctx.registry) {
             return json(toToolFailure(new ToolError("CONFIG_ERROR", "Multi-profile not enabled. Set FLUENT_ADDITIONAL_PROFILES or start with a FLUENT_PROFILE to enable the registry.")), true);
@@ -1136,7 +1136,7 @@ async function dispatchToolCall(toolName, args, ctx) {
         ctx.registry.add(name, params);
         return json({ ok: true, message: `Profile "${parsed.name}" registered (lazy init on first use).`, profiles: ctx.registry.list() });
     }
-    if (toolName === "connection.remove") {
+    if (toolName === "connection_remove") {
         const parsed = ConnectionRemoveInputSchema.parse(args);
         if (!ctx.registry) {
             return json(toToolFailure(new ToolError("CONFIG_ERROR", "Multi-profile not enabled.")), true);
@@ -1144,7 +1144,7 @@ async function dispatchToolCall(toolName, args, ctx) {
         ctx.registry.remove(parsed.name);
         return json({ ok: true, message: `Profile "${parsed.name}" removed.`, profiles: ctx.registry.list() });
     }
-    if (toolName === "connection.switch") {
+    if (toolName === "connection_switch") {
         const parsed = ConnectionSwitchInputSchema.parse(args);
         if (!ctx.registry) {
             return json(toToolFailure(new ToolError("CONFIG_ERROR", "Multi-profile not enabled.")), true);
@@ -1158,54 +1158,54 @@ async function dispatchToolCall(toolName, args, ctx) {
         return json({ ok: true, message: `Default profile switched to "${parsed.name}".`, profiles: ctx.registry.list() });
     }
     // ------- event tools (delegated to event-tools module) ---------------
-    if (toolName === "event.build") {
+    if (toolName === "event_build") {
         return json(await handleEventBuild(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "event.send") {
+    if (toolName === "event_send") {
         return json(await handleEventSend(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "event.get") {
+    if (toolName === "event_get") {
         return json(await handleEventGet(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "event.list") {
+    if (toolName === "event_list") {
         return json(await handleEventList(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "event.flowInspect") {
+    if (toolName === "event_flowInspect") {
         return json(await handleEventFlowInspect(args, ctx), false, ctx.responseBudget);
     }
     // ------- metrics tools (delegated to metrics-tools module) -----------
-    if (toolName === "metrics.query") {
+    if (toolName === "metrics_query") {
         return json(await handleMetricsQuery(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "metrics.healthCheck") {
+    if (toolName === "metrics_healthCheck") {
         return json(await handleMetricsHealthCheck(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "metrics.sloReport") {
+    if (toolName === "metrics_sloReport") {
         return json(await handleMetricsSloReport(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "metrics.labelCatalog") {
+    if (toolName === "metrics_labelCatalog") {
         return json(await handleMetricsLabelCatalog(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "metrics.metricCatalog") {
+    if (toolName === "metrics_metricCatalog") {
         return json(await handleMetricsMetricCatalog(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "metrics.planQuery") {
+    if (toolName === "metrics_planQuery") {
         return json(await handleMetricsPlanQuery(args), false, ctx.responseBudget);
     }
-    if (toolName === "metrics.topEvents") {
+    if (toolName === "metrics_topEvents") {
         return json(await handleMetricsTopEvents(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "metrics.snapshot") {
+    if (toolName === "metrics_snapshot") {
         return json(await handleMetricsSnapshot(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "metrics.compare") {
+    if (toolName === "metrics_compare") {
         return json(await handleMetricsCompare(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "metrics.mutationAudit") {
+    if (toolName === "metrics_mutationAudit") {
         return json(await handleMetricsMutationAudit(args, ctx), false, ctx.responseBudget);
     }
-    // ------- workflow.transitions (inline) --------------------------------
-    if (toolName === "workflow.transitions") {
+    // ------- workflow_transitions (inline) --------------------------------
+    if (toolName === "workflow_transitions") {
         const parsed = TransitionActionsInputSchema.parse(args);
         const client = requireClient(ctx);
         const payload = resolveTransitionRequest(parsed, ctx.config.retailerId);
@@ -1273,8 +1273,8 @@ async function dispatchToolCall(toolName, args, ctx) {
             ],
         }, false, ctx.responseBudget);
     }
-    // ------- plugin.list (inline) ----------------------------------------
-    if (toolName === "plugin.list") {
+    // ------- plugin_list (inline) ----------------------------------------
+    if (toolName === "plugin_list") {
         const client = requireClient(ctx);
         const parsed = PluginListInputSchema.parse(args);
         let rawPlugins = null;
@@ -1321,40 +1321,40 @@ async function dispatchToolCall(toolName, args, ctx) {
             ...(cacheMeta ? { _cache: cacheMeta } : {}),
         }, false, ctx.responseBudget);
     }
-    // ------- graphql query tools (delegated to graphql-query-tools module) --
-    if (toolName === "graphql.query") {
+    // ------- graphql_query tools (delegated to graphql_query-tools module) --
+    if (toolName === "graphql_query") {
         return json(await handleGraphQLQuery(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "graphql.queryAll") {
+    if (toolName === "graphql_queryAll") {
         return json(await handleGraphQLQueryAll(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "graphql.batchMutate") {
+    if (toolName === "graphql_batchMutate") {
         return json(await handleGraphQLBatchMutate(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "graphql.introspect") {
+    if (toolName === "graphql_introspect") {
         return json(await handleGraphQLIntrospect(args, ctx), false, ctx.responseBudget);
     }
     // ------- batch tools (delegated to batch-tools module) ---------------
-    if (toolName === "batch.create") {
+    if (toolName === "batch_create") {
         return json(await handleBatchCreate(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "batch.send") {
+    if (toolName === "batch_send") {
         return json(await handleBatchSend(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "batch.status") {
+    if (toolName === "batch_status") {
         return json(await handleBatchStatus(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "batch.batchStatus") {
+    if (toolName === "batch_batchStatus") {
         return json(await handleBatchBatchStatus(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "batch.results") {
+    if (toolName === "batch_results") {
         return json(await handleBatchResults(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "batch.describePayload") {
+    if (toolName === "batch_describePayload") {
         return json(await handleBatchDescribePayload(args, ctx), false, ctx.responseBudget);
     }
-    // ------- connection.test (inline) ------------------------------------
-    if (toolName === "connection.test") {
+    // ------- connection_test (inline) ------------------------------------
+    if (toolName === "connection_test") {
         const client = requireClient(ctx);
         const tester = new FluentConnectionTester(client.asGraphQLCapable(), {
             retailerId: ctx.config.retailerId ?? "unknown",
@@ -1369,8 +1369,8 @@ async function dispatchToolCall(toolName, args, ctx) {
                 : { error: result.error }),
         });
     }
-    // ------- webhook.validate (inline) -----------------------------------
-    if (toolName === "webhook.validate") {
+    // ------- webhook_validate (inline) -----------------------------------
+    if (toolName === "webhook_validate") {
         const parsed = WebhookValidateInputSchema.parse(args);
         const payload = parsed.payload;
         // Basic field validation
@@ -1474,72 +1474,72 @@ async function dispatchToolCall(toolName, args, ctx) {
         });
     }
     // ------- entity tools (delegated to entity-tools module) -------------
-    if (toolName === "entity.create") {
+    if (toolName === "entity_create") {
         return json(await handleEntityCreate(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "entity.update") {
+    if (toolName === "entity_update") {
         return json(await handleEntityUpdate(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "entity.get") {
+    if (toolName === "entity_get") {
         return json(await handleEntityGet(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "entity.planCreate") {
+    if (toolName === "entity_planCreate") {
         return json(handleEntityPlanCreate(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "entity.planUpdate") {
+    if (toolName === "entity_planUpdate") {
         return json(handleEntityPlanUpdate(args, ctx), false, ctx.responseBudget);
     }
     // ------- workflow tools (delegated to workflow-tools module) ----------
-    if (toolName === "workflow.get") {
+    if (toolName === "workflow_get") {
         return json(await handleWorkflowGet(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "workflow.list") {
+    if (toolName === "workflow_list") {
         return json(await handleWorkflowList(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "workflow.upload") {
+    if (toolName === "workflow_upload") {
         return json(await handleWorkflowUpload(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "workflow.diff") {
+    if (toolName === "workflow_diff") {
         return json(await handleWorkflowDiff(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "workflow.simulate") {
+    if (toolName === "workflow_simulate") {
         return json(await handleWorkflowSimulate(args, ctx), false, ctx.responseBudget);
     }
     // ------- setting tools (delegated to settings-tools module) ----------
-    if (toolName === "setting.get") {
+    if (toolName === "setting_get") {
         return json(await handleSettingGet(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "setting.upsert") {
+    if (toolName === "setting_upsert") {
         return json(await handleSettingUpsert(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "setting.bulkUpsert") {
+    if (toolName === "setting_bulkUpsert") {
         return json(await handleSettingBulkUpsert(args, ctx), false, ctx.responseBudget);
     }
     // ------- environment tools (delegated to environment-tools module) ---
-    if (toolName === "environment.discover") {
+    if (toolName === "environment_discover") {
         return json(await handleEnvironmentDiscover(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "environment.validate") {
+    if (toolName === "environment_validate") {
         return json(await handleEnvironmentValidate(args, ctx), false, ctx.responseBudget);
     }
     // ------- test tools (delegated to test-tools module) -----------------
-    if (toolName === "test.assert") {
+    if (toolName === "test_assert") {
         return json(await handleTestAssert(args, ctx), false, ctx.responseBudget);
     }
     // ------- graphql schema tools (delegated to graphql-schema-tools module) --
-    if (toolName === "graphql.listRoots") {
+    if (toolName === "graphql_listRoots") {
         return json(await handleListRoots(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "graphql.planOperation") {
+    if (toolName === "graphql_planOperation") {
         return json(await handlePlanOperation(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "graphql.buildQuery") {
+    if (toolName === "graphql_buildQuery") {
         return json(await handleBuildQuery(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "graphql.validate") {
+    if (toolName === "graphql_validate") {
         return json(await handleValidate(args, ctx), false, ctx.responseBudget);
     }
-    if (toolName === "graphql.generateFull") {
+    if (toolName === "graphql_generateFull") {
         return json(await handleGenerateFull(args, ctx), false, ctx.responseBudget);
     }
     throw new ToolError("VALIDATION_ERROR", `Unknown tool: ${toolName}`);
@@ -1564,5 +1564,10 @@ export function registerToolHandlers(server, ctx) {
             ...(tool.annotations ? { annotations: tool.annotations } : {}),
         })),
     }));
-    lowLevelServer.setRequestHandler(CallToolRequestSchema, async (request) => handleToolCall(request.params.name, request.params.arguments ?? {}, ctx));
+    lowLevelServer.setRequestHandler(CallToolRequestSchema, async (request) => {
+        // Normalize dot-notation names for backward compatibility with lenient clients
+        // that still send "health.ping" instead of "health_ping".
+        const toolName = request.params.name.replace(/\./g, "_");
+        return handleToolCall(toolName, request.params.arguments ?? {}, ctx);
+    });
 }