@fluentcommerce/fluent-mcp-extn 0.2.0 → 0.3.0

package/dist/entity-registry.js

@@ -286,6 +286,7 @@ const ENTITY_REGISTRY = {
             'context is a plain String ("RETAILER"), NOT { contextType: "RETAILER" }',
             "contextId is a separate Int field, not combined with context",
             "For large JSON values, use lobValue instead of value (lobType: LOB)",
+            'For Mystique manifest settings (fc.mystique.*), set valueType:"JSON" — LOB type breaks manifest parsing silently',
         ],
         hasRef: false,
         retailerScoped: false,

package/dist/fluent-client.js

@@ -140,6 +140,36 @@ export class FluentClientAdapter {
             return FluentClientAdapter.unwrapResponse(response);
         });
     }
+    /**
+     * Fetch a workflow definition by name from the REST API.
+     * GET /api/v4.1/workflow/{retailerId}/{entityType}::{entitySubtype}/
+     * Optionally fetch a specific version:
+     * GET /api/v4.1/workflow/{retailerId}/{entityType}::{entitySubtype}/{version}
+     * Read-only — safe to retry.
+     */
+    async getWorkflow(retailerId, entityType, entitySubtype, version) {
+        const requestClient = this.requireRequestClient("Workflow REST API");
+        const workflowName = `${entityType}::${entitySubtype}`;
+        const path = version
+            ? `/api/v4.1/workflow/${retailerId}/${workflowName}/${version}`
+            : `/api/v4.1/workflow/${retailerId}/${workflowName}/`;
+        return this.execute("getWorkflow", async () => {
+            const response = await requestClient.request(path, { method: "GET" });
+            return FluentClientAdapter.unwrapResponse(response);
+        });
+    }
+    /**
+     * List all workflows for a retailer from the REST API.
+     * GET /api/v4.1/workflow?retailerId={retailerId}
+     * Read-only — safe to retry.
+     */
+    async listWorkflows(retailerId) {
+        const requestClient = this.requireRequestClient("Workflow REST API");
+        return this.execute("listWorkflows", async () => {
+            const response = await requestClient.request(`/api/v4.1/workflow?retailerId=${retailerId}&count=200`, { method: "GET" });
+            return FluentClientAdapter.unwrapResponse(response);
+        });
+    }
     /**
      * Query Prometheus metrics via GraphQL metricInstant / metricRange queries.
      * The Fluent platform does NOT expose raw Prometheus REST endpoints
@@ -149,19 +179,19 @@ export class FluentClientAdapter {
     async queryPrometheus(payload) {
         const isRange = payload.type === "range";
         const query = isRange
-            ? `query MetricRange($query: String!, $start: DateTime!, $end: DateTime!, $step: String!) {
-          metricRange(query: $query, start: $start, end: $end, step: $step) {
-            status
-            data { resultType result { metric values } }
-            errorType error warnings
-          }
+            ? `query MetricRange($query: String!, $start: DateTime!, $end: DateTime!, $step: String!) {
+          metricRange(query: $query, start: $start, end: $end, step: $step) {
+            status
+            data { resultType result { metric values } }
+            errorType error warnings
+          }
         }`
-            : `query MetricInstant($query: String!${payload.time ? ", $time: DateTime" : ""}) {
-          metricInstant(query: $query${payload.time ? ", time: $time" : ""}) {
-            status
-            data { resultType result { metric value } }
-            errorType error warnings
-          }
+            : `query MetricInstant($query: String!${payload.time ? ", $time: DateTime" : ""}) {
+          metricInstant(query: $query${payload.time ? ", time: $time" : ""}) {
+            status
+            data { resultType result { metric value } }
+            errorType error warnings
+          }
         }`;
         const variables = { query: payload.query };
         if (isRange) {

package/dist/settings-tools.js

@@ -5,6 +5,8 @@
  * settings that workflows depend on (webhook URLs, feature flags, thresholds).
  */
 import { z } from "zod";
+import * as fs from "node:fs";
+import * as path from "node:path";
 import { ToolError } from "./errors.js";
 // ---------------------------------------------------------------------------
 // Input schemas
@@ -16,6 +18,11 @@ const SettingInputSchema = z.object({
         .string()
         .optional()
         .describe("Large object value (for JSON payloads > 4KB). Mutually exclusive with value."),
+    valueType: z
+        .enum(["STRING", "LOB", "JSON"])
+        .optional()
+        .describe('Explicit value type override. Use "JSON" for Mystique manifest settings (fc.mystique.*). ' +
+        'Defaults to "LOB" when lobValue is provided, "STRING" when value is provided.'),
     context: z
         .string()
         .min(1)
@@ -26,6 +33,34 @@ const SettingInputSchema = z.object({
         .optional()
         .describe("Context ID (e.g., retailer ID). Falls back to FLUENT_RETAILER_ID for RETAILER context."),
 });
+export const SettingGetInputSchema = z.object({
+    name: z
+        .string()
+        .min(1)
+        .describe('Setting name or pattern. Supports "%" wildcards (e.g., "fc.mystique.manifest.%" for all manifest settings).'),
+    context: z
+        .string()
+        .optional()
+        .describe('Filter by context: "ACCOUNT", "RETAILER". Omit for all contexts.'),
+    contextId: z
+        .number()
+        .int()
+        .optional()
+        .describe("Context ID. Falls back to FLUENT_RETAILER_ID for RETAILER context, 0 for ACCOUNT."),
+    outputFile: z
+        .string()
+        .optional()
+        .describe("Optional file path to save the setting value/lobValue. " +
+        "When provided, writes content to file and returns only metadata (name, context, valueType, size) — " +
+        "keeps large manifests/JSON out of the LLM context. Parent directories are created automatically."),
+    first: z
+        .number()
+        .int()
+        .min(1)
+        .max(100)
+        .default(10)
+        .describe("Max results to return (default: 10, max: 100)."),
+});
 export const SettingUpsertInputSchema = SettingInputSchema;
 export const SettingBulkUpsertInputSchema = z.object({
     settings: z
@@ -38,6 +73,57 @@ export const SettingBulkUpsertInputSchema = z.object({
 // Tool definitions (JSON Schema for MCP)
 // ---------------------------------------------------------------------------
 export const SETTING_TOOL_DEFINITIONS = [
+    {
+        name: "setting.get",
+        description: [
+            "Fetch one or more Fluent Commerce settings by name (supports % wildcards).",
+            "",
+            "Returns metadata inline (name, context, contextId, valueType).",
+            "For small settings, the value is returned inline.",
+            "For large settings (manifests, JSON > 4KB), use outputFile to save content",
+            "to a local file and keep it out of the LLM context.",
+            "",
+            "When outputFile is set AND exactly one setting matches:",
+            "  - Writes lobValue (or value) to the file",
+            "  - Returns metadata + file path + byte size (NOT the content)",
+            "",
+            "When outputFile is NOT set:",
+            "  - Returns full setting data inline (may be large for manifests)",
+            "",
+            "Examples:",
+            '  setting.get({ name: "fc.mystique.manifest.oms.fragment.ordermanagement" })',
+            '  setting.get({ name: "fc.mystique.manifest.%", context: "ACCOUNT" })',
+            '  setting.get({ name: "fc.mystique.manifest.oms", outputFile: "./manifest-backup.json" })',
+        ].join("\n"),
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "Setting name or pattern with % wildcards",
+                },
+                context: {
+                    type: "string",
+                    description: "Filter by context: ACCOUNT, RETAILER, etc.",
+                },
+                contextId: {
+                    type: "integer",
+                    description: "Context ID. Defaults to FLUENT_RETAILER_ID or 0.",
+                },
+                outputFile: {
+                    type: "string",
+                    description: "File path to save setting content. Returns metadata only (not content) when set.",
+                },
+                first: {
+                    type: "integer",
+                    description: "Max results (default: 10, max: 100)",
+                    default: 10,
+                },
+            },
+            required: ["name"],
+            additionalProperties: false,
+        },
+    },
     {
         name: "setting.upsert",
         description: [
@@ -50,6 +136,8 @@ export const SETTING_TOOL_DEFINITIONS = [
             '- context is a plain String ("RETAILER"), NOT an object',
             "- contextId is a separate Int field",
             "- For large JSON values (>4KB), use lobValue instead of value",
+            '- For Mystique manifest settings (fc.mystique.*), set valueType: "JSON"',
+            "  — without it, defaults to LOB which breaks manifest parsing",
             "- Returns created: true/false for audit trail",
             "",
             "CONTEXTS: RETAILER, ACCOUNT, LOCATION, NETWORK, AGENT, CUSTOMER",
@@ -69,6 +157,12 @@ export const SETTING_TOOL_DEFINITIONS = [
                     type: "string",
                     description: "Large object value (for JSON payloads > 4KB)",
                 },
+                valueType: {
+                    type: "string",
+                    enum: ["STRING", "LOB", "JSON"],
+                    description: 'Explicit value type. Use "JSON" for Mystique manifest settings (fc.mystique.*). ' +
+                        "Defaults to LOB when lobValue provided, STRING when value provided.",
+                },
                 context: {
                     type: "string",
                     description: 'Setting scope: RETAILER, ACCOUNT, LOCATION, NETWORK, AGENT, CUSTOMER',
@@ -103,6 +197,11 @@ export const SETTING_TOOL_DEFINITIONS = [
                             name: { type: "string" },
                             value: { type: "string" },
                             lobValue: { type: "string" },
+                            valueType: {
+                                type: "string",
+                                enum: ["STRING", "LOB", "JSON"],
+                                description: 'Explicit value type. Use "JSON" for manifest settings.',
+                            },
                             context: { type: "string" },
                             contextId: { type: "integer" },
                         },
@@ -179,10 +278,18 @@ async function createSetting(client, input) {
     };
     if (input.lobValue) {
         mutationInput.lobValue = input.lobValue;
-        mutationInput.valueType = "LOB";
     }
     else {
         mutationInput.value = input.value;
+    }
+    // Explicit valueType wins; otherwise default to LOB/STRING based on field used
+    if (input.valueType) {
+        mutationInput.valueType = input.valueType;
+    }
+    else if (input.lobValue) {
+        mutationInput.valueType = "LOB";
+    }
+    else {
         mutationInput.valueType = "STRING";
     }
     const mutation = `mutation CreateSetting($input: CreateSettingInput!) {
@@ -220,10 +327,18 @@ async function updateSetting(client, input) {
     };
     if (input.lobValue) {
         mutationInput.lobValue = input.lobValue;
-        mutationInput.valueType = "LOB";
     }
     else {
         mutationInput.value = input.value;
+    }
+    // Explicit valueType wins; otherwise default to LOB/STRING based on field used
+    if (input.valueType) {
+        mutationInput.valueType = input.valueType;
+    }
+    else if (input.lobValue) {
+        mutationInput.valueType = "LOB";
+    }
+    else {
         mutationInput.valueType = "STRING";
     }
     const mutation = `mutation UpdateSetting($input: UpdateSettingInput!) {
@@ -250,6 +365,151 @@ async function updateSetting(client, input) {
     }
     return setting;
 }
+/**
+ * Handle setting.get tool call.
+ * Fetches settings by name (with wildcard support) and optionally writes to file.
+ */
+export async function handleSettingGet(args, ctx) {
+    const parsed = SettingGetInputSchema.parse(args);
+    const client = requireSettingClient(ctx);
+    // Build variables — only include context/contextId if provided
+    const variables = {
+        name: [parsed.name],
+        first: parsed.first,
+    };
+    if (parsed.context) {
+        variables.context = [parsed.context];
+    }
+    if (parsed.contextId !== undefined) {
+        variables.contextId = [parsed.contextId];
+    }
+    else if (parsed.context === "RETAILER" && ctx.config.retailerId) {
+        variables.contextId = [Number(ctx.config.retailerId)];
+    }
+    else if (parsed.context === "ACCOUNT") {
+        variables.contextId = [0];
+    }
+    // Build query — include lobValue for full content
+    const query = `query GetSettings($name: [String!], $context: [String!], $contextId: [Int!], $first: Int) {
+  settings(name: $name, context: $context, contextId: $contextId, first: $first) {
+    edges {
+      node {
+        id
+        name
+        value
+        lobValue
+        context
+        contextId
+        valueType
+      }
+    }
+  }
+}`;
+    const response = await client.graphql({
+        query,
+        variables: variables,
+    });
+    const data = response?.data;
+    const connection = data?.settings;
+    const edges = (connection?.edges ?? []);
+    const settings = edges.map((e) => e.node);
+    if (settings.length === 0) {
+        return {
+            ok: true,
+            count: 0,
+            settings: [],
+            message: `No settings found matching "${parsed.name}"${parsed.context ? ` with context ${parsed.context}` : ""}.`,
+        };
+    }
+    // If outputFile is provided and exactly one setting matches, write to file
+    if (parsed.outputFile && settings.length === 1) {
+        const setting = settings[0];
+        const content = setting.lobValue ?? setting.value ?? "";
+        // Try to pretty-print JSON content
+        let fileContent = content;
+        try {
+            const parsed = JSON.parse(content);
+            fileContent = JSON.stringify(parsed, null, 2);
+        }
+        catch {
+            // Not JSON — write as-is
+        }
+        // Ensure parent directory exists
+        const dir = path.dirname(parsed.outputFile);
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(parsed.outputFile, fileContent, "utf-8");
+        return {
+            ok: true,
+            count: 1,
+            savedTo: parsed.outputFile,
+            sizeBytes: Buffer.byteLength(fileContent, "utf-8"),
+            setting: {
+                id: setting.id,
+                name: setting.name,
+                context: setting.context,
+                contextId: setting.contextId,
+                valueType: setting.valueType,
+            },
+            message: `Setting "${setting.name}" saved to ${parsed.outputFile} (${Buffer.byteLength(fileContent, "utf-8")} bytes). Content NOT included in response.`,
+        };
+    }
+    // If outputFile provided but multiple settings match, warn
+    if (parsed.outputFile && settings.length > 1) {
+        // Write each setting to a separate file in the outputFile directory
+        const outputDir = parsed.outputFile.endsWith(".json")
+            ? path.dirname(parsed.outputFile)
+            : parsed.outputFile;
+        fs.mkdirSync(outputDir, { recursive: true });
+        const savedFiles = [];
+        for (const setting of settings) {
+            const content = setting.lobValue ?? setting.value ?? "";
+            let fileContent = content;
+            try {
+                const p = JSON.parse(content);
+                fileContent = JSON.stringify(p, null, 2);
+            }
+            catch {
+                // Not JSON — write as-is
+            }
+            const safeName = setting.name.replace(/[^a-zA-Z0-9._-]/g, "_");
+            const filePath = path.join(outputDir, `${safeName}.json`);
+            fs.writeFileSync(filePath, fileContent, "utf-8");
+            savedFiles.push({
+                name: setting.name,
+                file: filePath,
+                sizeBytes: Buffer.byteLength(fileContent, "utf-8"),
+            });
+        }
+        return {
+            ok: true,
+            count: settings.length,
+            savedTo: outputDir,
+            files: savedFiles,
+            settings: settings.map((s) => ({
+                id: s.id,
+                name: s.name,
+                context: s.context,
+                contextId: s.contextId,
+                valueType: s.valueType,
+            })),
+            message: `${settings.length} settings saved to ${outputDir}/. Content NOT included in response.`,
+        };
+    }
+    // No outputFile — return everything inline
+    return {
+        ok: true,
+        count: settings.length,
+        settings: settings.map((s) => ({
+            id: s.id,
+            name: s.name,
+            value: s.value,
+            lobValue: s.lobValue,
+            context: s.context,
+            contextId: s.contextId,
+            valueType: s.valueType,
+        })),
+    };
+}
 /**
  * Handle setting.upsert tool call.
  */
@@ -259,37 +519,52 @@ export async function handleSettingUpsert(args, ctx) {
     const contextId = resolveContextId(parsed.context, parsed.contextId, ctx.config);
     // Check if setting already exists
     const existing = await findExistingSetting(client, parsed.name, parsed.context, contextId);
+    // Warn when manifest setting is used without explicit valueType: "JSON"
+    const isManifestSetting = parsed.name.startsWith("fc.mystique.manifest.");
+    const manifestWarning = isManifestSetting && parsed.valueType !== "JSON"
+        ? 'Manifest setting detected without valueType:"JSON". ' +
+            "Default LOB type will break Mystique manifest parsing. " +
+            'Set valueType:"JSON" for fc.mystique.* settings.'
+        : undefined;
     if (existing) {
         // Update
         const setting = await updateSetting(client, {
             id: existing.id,
             value: parsed.value,
             lobValue: parsed.lobValue,
+            valueType: parsed.valueType,
             context: parsed.context,
             contextId,
         });
-        return {
+        const result = {
             ok: true,
             created: false,
             updated: true,
             setting,
             previousValue: existing.value ?? existing.lobValue,
         };
+        if (manifestWarning)
+            result.warning = manifestWarning;
+        return result;
     }
     // Create
     const setting = await createSetting(client, {
         name: parsed.name,
         value: parsed.value,
         lobValue: parsed.lobValue,
+        valueType: parsed.valueType,
         context: parsed.context,
         contextId,
     });
-    return {
+    const result = {
         ok: true,
         created: true,
         updated: false,
         setting,
     };
+    if (manifestWarning)
+        result.warning = manifestWarning;
+    return result;
 }
 /**
  * Handle setting.bulkUpsert tool call.
@@ -310,6 +585,7 @@ export async function handleSettingBulkUpsert(args, ctx) {
                     id: existing.id,
                     value: setting.value,
                     lobValue: setting.lobValue,
+                    valueType: setting.valueType,
                     context: setting.context,
                     contextId,
                 });
@@ -321,6 +597,7 @@ export async function handleSettingBulkUpsert(args, ctx) {
                     name: setting.name,
                     value: setting.value,
                     lobValue: setting.lobValue,
+                    valueType: setting.valueType,
                     context: setting.context,
                     contextId,
                 });

package/dist/tools.js

@@ -6,8 +6,8 @@ import { buildEventPayload } from "./event-payload.js";
 import { ToolError, toToolFailure } from "./errors.js";
 // New tool modules
 import { ENTITY_TOOL_DEFINITIONS, handleEntityCreate, handleEntityUpdate, handleEntityGet, } from "./entity-tools.js";
-import { WORKFLOW_TOOL_DEFINITIONS, handleWorkflowUpload, handleWorkflowDiff, handleWorkflowSimulate, } from "./workflow-tools.js";
-import { SETTING_TOOL_DEFINITIONS, handleSettingUpsert, handleSettingBulkUpsert, } from "./settings-tools.js";
+import { WORKFLOW_TOOL_DEFINITIONS, handleWorkflowGet, handleWorkflowList, handleWorkflowUpload, handleWorkflowDiff, handleWorkflowSimulate, } from "./workflow-tools.js";
+import { SETTING_TOOL_DEFINITIONS, handleSettingGet, handleSettingUpsert, handleSettingBulkUpsert, } from "./settings-tools.js";
 import { ENVIRONMENT_TOOL_DEFINITIONS, handleEnvironmentDiscover, handleEnvironmentValidate, } from "./environment-tools.js";
 import { TEST_TOOL_DEFINITIONS, handleTestAssert, } from "./test-tools.js";
 import { shapeResponse, summarizeConnection, analyzeEvents, } from "./response-shaper.js";
@@ -128,6 +128,8 @@ const TransitionTriggerInputSchema = z.object({
     module: z.string().min(1).optional(),
     flexType: z.string().min(1).optional(),
     flexVersion: z.union([z.string().min(1), z.number().int()]).optional(),
+    entityId: z.string().min(1).optional(),
+    entityRef: z.string().min(1).optional(),
 });
 const TransitionActionsInputSchema = z.object({
     triggers: z.array(TransitionTriggerInputSchema).min(1),
@@ -193,6 +195,7 @@ const GraphQLBatchMutateInputSchema = z.object({
     inputs: z.array(z.record(z.string(), z.unknown())).min(1).max(50),
     returnFields: z.array(z.string()).optional(),
     operationName: z.string().optional(),
+    dryRun: z.boolean().default(false),
 });
 const GraphQLIntrospectInputSchema = z.object({
     type: z.string().optional(),
@@ -598,8 +601,16 @@ const TOOL_DEFINITIONS = [
             "INTEGRATION: The eventName from each userAction maps directly to event.send's \"name\" parameter.",
             "The attributes[] tell you what to include in event.send's \"attributes\" parameter.",
             "",
+            "CRITICAL: The Transition API requires `flexType` (e.g. ORDER::HD) to return results.",
+            "Without it the API silently returns empty `{response:[]}`. For some entity types",
+            "(e.g. CREDIT_MEMO) `flexVersion` is also required. When `type` and `subtype` are",
+            "provided but `flexType` is not, the tool auto-derives it as `TYPE::SUBTYPE`.",
+            "",
+            "BEST PRACTICE: Always provide `flexType` and `flexVersion` for reliable results.",
+            "Get these from the entity's `workflowRef` and `workflowVersion` fields via GraphQL.",
+            "",
             "EXAMPLE: Find available actions for an ORDER in CREATED status:",
-            "{ triggers: [{ type: \"ORDER\", subtype: \"HD\", status: \"CREATED\", retailerId: \"5\", flexType: \"ORDER::HD\" }] }",
+            "{ triggers: [{ type: \"ORDER\", subtype: \"HD\", status: \"CREATED\", retailerId: \"5\", flexType: \"ORDER::HD\", flexVersion: 4 }] }",
         ].join("\n"),
         inputSchema: {
             type: "object",
@@ -622,17 +633,19 @@ const TOOL_DEFINITIONS = [
                             },
                             module: {
                                 type: "string",
-                                description: "Filter by module (e.g. servicepoint, adminconsole). Case-sensitive.",
+                                description: "REQUIRED for results. App module name (e.g. adminconsole, oms, store, servicepoint). Without this, API silently returns empty userActions. Case-sensitive.",
                             },
                             flexType: {
                                 type: "string",
-                                description: "Workflow type (e.g. ORDER::HD, FULFILMENT::HD_WH).",
+                                description: "Workflow type (e.g. ORDER::HD, FULFILMENT::HD_WH). REQUIRED for API to return results. Auto-derived from type::subtype when omitted.",
                             },
                             flexVersion: {
                                 oneOf: [{ type: "integer" }, { type: "string" }],
-                                description: "Workflow version. Omit for latest.",
+                                description: "Workflow version. Strongly recommended — required for some entity types (e.g. CREDIT_MEMO). Get from entity's workflowVersion field.",
                             },
                             name: { type: "string", description: "Event name filter" },
+                            entityId: { type: "string", description: "Entity ID (strongly recommended — API may return empty without it)" },
+                            entityRef: { type: "string", description: "Entity ref (strongly recommended — API may return empty without it)" },
                         },
                         required: ["retailerId"],
                         additionalProperties: false,
@@ -888,6 +901,10 @@ const TOOL_DEFINITIONS = [
                     type: "string",
                     description: "Custom GraphQL operation name (default: Batch<MutationName>s).",
                 },
+                dryRun: {
+                    type: "boolean",
+                    description: "If true, builds and validates the mutation query without executing it. Returns the query, variables, and input count for review. Default: false.",
+                },
             },
             required: ["mutation", "inputs"],
             additionalProperties: false,
@@ -1253,7 +1270,14 @@ export function toEventQueryParams(input) {
     return params;
 }
 /**
- * Fill missing trigger.retailerId from runtime config and validate readiness.
+ * Fill missing trigger fields from runtime config and validate readiness.
+ *
+ * The Transition API requires `flexType` (e.g. "ORDER::HD") to return results.
+ * Without it the API silently returns `{"response":[]}`.  For some entity
+ * types (e.g. CREDIT_MEMO) `flexVersion` is also required.
+ *
+ * This function auto-derives `flexType` from `type`+`subtype` when both are
+ * present and `flexType` is not explicitly set.
  */
 export function resolveTransitionRequest(input, fallbackRetailerId) {
     const triggers = input.triggers.map((trigger, index) => {
@@ -1261,9 +1285,16 @@ export function resolveTransitionRequest(input, fallbackRetailerId) {
         if (!retailerId) {
             throw new ToolError("VALIDATION_ERROR", `triggers[${index}].retailerId is required. Set FLUENT_RETAILER_ID or pass retailerId per trigger.`);
         }
+        // Auto-derive flexType from type+subtype when not explicitly provided.
+        // The Transition API requires flexType to return user actions.
+        let flexType = trigger.flexType;
+        if (!flexType && trigger.type && trigger.subtype) {
+            flexType = `${trigger.type}::${trigger.subtype}`;
+        }
         return {
             ...trigger,
             retailerId,
+            ...(flexType ? { flexType } : {}),
         };
     });
     return { triggers };
@@ -2540,6 +2571,18 @@ export function registerToolHandlers(server, ctx) {
                 for (let i = 0; i < batchSize; i++) {
                     variables[`input${i + 1}`] = parsed.inputs[i];
                 }
+                // Dry-run: return query + variables without executing
+                if (parsed.dryRun) {
+                    return json({
+                        ok: true,
+                        dryRun: true,
+                        mutation: parsed.mutation,
+                        inputCount: batchSize,
+                        query,
+                        variables,
+                        note: "No API call made. Set dryRun=false to execute.",
+                    });
+                }
                 const gqlPayload = {
                     query,
                     variables: toSdkVariables(variables),
@@ -3195,6 +3238,16 @@ export function registerToolHandlers(server, ctx) {
                 const result = await handleEntityGet(args, ctx);
                 return json(result, false, ctx.responseBudget);
             }
+            // ------- workflow.get ---------------------------------------------------
+            if (toolName === "workflow.get") {
+                const result = await handleWorkflowGet(args, ctx);
+                return json(result, false, ctx.responseBudget);
+            }
+            // ------- workflow.list --------------------------------------------------
+            if (toolName === "workflow.list") {
+                const result = await handleWorkflowList(args, ctx);
+                return json(result, false, ctx.responseBudget);
+            }
             // ------- workflow.upload -----------------------------------------------
             if (toolName === "workflow.upload") {
                 const result = await handleWorkflowUpload(args, ctx);
@@ -3210,6 +3263,11 @@ export function registerToolHandlers(server, ctx) {
                 const result = await handleWorkflowSimulate(args, ctx);
                 return json(result, false, ctx.responseBudget);
             }
+            // ------- setting.get ---------------------------------------------------
+            if (toolName === "setting.get") {
+                const result = await handleSettingGet(args, ctx);
+                return json(result, false, ctx.responseBudget);
+            }
             // ------- setting.upsert ------------------------------------------------
             if (toolName === "setting.upsert") {
                 const result = await handleSettingUpsert(args, ctx);