@burdenoff/mcp-libs 2026.908.1 → 2026.908.2

package/dist/modules/fluidgrids/index.js

@@ -0,0 +1,2097 @@
+import { mcpToolName, mcpResourceUri, mcpPromptName, errorResult, jsonResult } from '../../chunk-BSNL65PZ.js';
+import { z } from 'zod';
+
+// src/modules/fluidgrids/operations.ts
+var LIST_WORKFLOWS = `
+  query ListWorkflows($input: ListWorkflowDefinitionsInput!) {
+    workflowDefinitions(input: $input) {
+      items {
+        id
+        workflowKey
+        name
+        description
+        version
+        status
+        category
+        tags
+        isActive
+        totalVersions
+        createdAt
+        updatedAt
+      }
+      total
+      hasMore
+    }
+  }
+`;
+var GET_WORKFLOW = `
+  query GetWorkflow($id: ID, $workflowKey: String, $version: String) {
+    workflowDefinition(id: $id, workflowKey: $workflowKey, version: $version) {
+      id
+      workflowKey
+      name
+      description
+      version
+      status
+      category
+      tags
+      icon
+      isActive
+      totalVersions
+      definitionJson
+      createdAt
+      updatedAt
+    }
+  }
+`;
+var GET_WORKFLOW_VERSIONS = `
+  query GetWorkflowVersions($workflowKey: String!) {
+    workflowVersions(workflowKey: $workflowKey) {
+      id
+      workflowKey
+      name
+      description
+      version
+      status
+      category
+      tags
+      icon
+      isActive
+      totalVersions
+      createdAt
+      updatedAt
+    }
+  }
+`;
+var LIST_RUNS = `
+  query ListRuns($input: ListWorkflowRunsInput!) {
+    workflowRuns(input: $input) {
+      items {
+        id
+        workflowId
+        workflowKey
+        version
+        status
+        startedAt
+        completedAt
+        duration
+        triggeredById
+        errorMessage
+        errorType
+        progress
+        totalNodes
+        completedNodes
+        failedNodes
+      }
+      total
+      hasMore
+    }
+  }
+`;
+var GET_RUN = `
+  query GetRun($id: ID!) {
+    workflowRun(id: $id) {
+      id
+      workflowId
+      workflowKey
+      version
+      status
+      startedAt
+      completedAt
+      duration
+      triggeredById
+      triggerData
+      triggerNodeId
+      errorMessage
+      errorType
+      progress
+      totalNodes
+      completedNodes
+      failedNodes
+      skippedNodes
+      nodeStates {
+        nodeId
+        nodeType
+        status
+        error
+        output
+      }
+    }
+  }
+`;
+var GET_RUN_LOGS = `
+  query GetRunLogs(
+    $runId: ID!
+    $nodeId: String
+    $minLevel: RunLogLevel
+    $limit: Int
+    $after: String
+    $search: String
+    $includeChildRuns: Boolean
+  ) {
+    workflowRunLogs(
+      runId: $runId
+      nodeId: $nodeId
+      minLevel: $minLevel
+      limit: $limit
+      after: $after
+      search: $search
+      includeChildRuns: $includeChildRuns
+    ) {
+      lines {
+        id
+        runId
+        nodeId
+        level
+        message
+        timestamp
+        data
+        attempt
+        phase
+        stream
+        truncated
+      }
+      hasMore
+      nextCursor
+      limitReached
+    }
+  }
+`;
+var LIST_NODES = `
+  query ListNodes(
+    $nodeType: String
+    $publishType: PublishType
+    $status: NodeConfigStatus
+    $pagination: WorkflowPaginationInput
+  ) {
+    nodeEndpointConfigs(
+      nodeType: $nodeType
+      publishType: $publishType
+      status: $status
+      pagination: $pagination
+    ) {
+      configs {
+        id
+        nodeType
+        nodeVersion
+        name
+        description
+        category
+        icon
+        logo
+        keywords
+        kind
+        author
+        publishType
+        status
+        isLatest
+        endpointUrl
+        operations
+        supportsAdapterMode
+        adapterOutputType
+        createdAt
+        updatedAt
+      }
+      pagination {
+        total
+        limit
+        offset
+        hasMore
+      }
+    }
+  }
+`;
+var GET_NODE = `
+  query GetNode($nodeType: String!, $nodeVersion: String!) {
+    nodeEndpointConfig(nodeType: $nodeType, nodeVersion: $nodeVersion) {
+      id
+      nodeType
+      nodeVersion
+      name
+      description
+      category
+      icon
+      logo
+      keywords
+      kind
+      author
+      publishType
+      status
+      isLatest
+      endpointUrl
+      operations
+      supportsAdapterMode
+      adapterOutputType
+      createdAt
+      updatedAt
+      healthCheckUrl
+      nodeAdapters
+    }
+  }
+`;
+var LIST_CREDENTIALS = `
+  query ListCredentials($filter: ConnectionFilterInput, $pagination: IntegrationsPaginationInput) {
+    getConnections(filter: $filter, pagination: $pagination) {
+      items {
+        id
+        name
+        description
+        status
+        providerId
+        provider {
+          id
+          key
+          name
+          category
+          authType
+          icon
+        }
+        credentialSource
+        externalAccountId
+        externalAccountName
+        externalAccountEmail
+        grantedScopes
+        lastUsedAt
+        lastHealthCheck
+        errorMessage
+        createdAt
+        updatedAt
+      }
+      total
+      hasMore
+    }
+  }
+`;
+var GET_CREDENTIAL = `
+  query GetCredential($id: ID!) {
+    getConnection(id: $id) {
+      id
+      name
+      description
+      status
+      providerId
+      provider {
+        id
+        key
+        name
+        description
+        category
+        authType
+        configSchema
+        availableScopes
+        defaultScopes
+        icon
+        docsUrl
+      }
+      config
+      metadata
+      credentialSource
+      externalAccountId
+      externalAccountName
+      externalAccountEmail
+      grantedScopes
+      lastUsedAt
+      lastHealthCheck
+      errorMessage
+      workspaceId
+      createdAt
+      updatedAt
+    }
+  }
+`;
+var LIST_CREDENTIAL_TYPES = `
+  query ListCredentialTypes($filter: ProviderFilterInput, $pagination: IntegrationsPaginationInput) {
+    getProviders(filter: $filter, pagination: $pagination) {
+      items {
+        id
+        key
+        name
+        description
+        category
+        authType
+        configSchema
+        availableScopes
+        defaultScopes
+        icon
+        docsUrl
+        isBuiltIn
+        isEnabled
+        connectionCount
+      }
+      total
+      hasMore
+    }
+  }
+`;
+var LIST_WEBHOOKS = `
+  query ListWebhooks($status: EventStatus, $workflowKey: String) {
+    eventRegistrations(status: $status, workflowKey: $workflowKey) {
+      id
+      name
+      description
+      workflowKey
+      triggerNodeId
+      eventSource
+      eventType
+      status
+      isActive
+      webhookUrl
+      webhookToken
+      validationMethod
+      signatureHeader
+      apiKeyHeader
+      payloadMapping
+      config
+      tags
+      totalTriggers
+      successfulTriggers
+      failedTriggers
+      lastTriggeredAt
+      createdAt
+      updatedAt
+    }
+  }
+`;
+var GET_WEBHOOK = `
+  query GetWebhook($id: ID!) {
+    eventRegistration(id: $id) {
+      id
+      name
+      description
+      workflowKey
+      triggerNodeId
+      eventSource
+      eventType
+      status
+      isActive
+      webhookUrl
+      webhookToken
+      validationMethod
+      signatureHeader
+      apiKeyHeader
+      payloadMapping
+      config
+      tags
+      totalTriggers
+      successfulTriggers
+      failedTriggers
+      lastTriggeredAt
+      createdAt
+      updatedAt
+      projectId
+      workspaceId
+      createdById
+    }
+  }
+`;
+var LIST_SCHEDULED_JOBS = `
+  query ListScheduledJobs($enabled: Boolean, $workflowKey: String, $pagination: WorkflowPaginationInput) {
+    workflowScheduledJobs(enabled: $enabled, workflowKey: $workflowKey, pagination: $pagination) {
+      jobs {
+      id
+      name
+      workflowKey
+      version
+      schedule
+      enabled
+      nextRun
+      lastRun
+      config
+      createdAt
+      updatedAt
+      }
+      pagination {
+        total
+        limit
+        offset
+        hasMore
+      }
+    }
+  }
+`;
+var GET_SCHEDULED_JOB = `
+  query GetScheduledJob($jobId: ID!) {
+    workflowScheduledJob(jobId: $jobId) {
+      id
+      name
+      workflowKey
+      version
+      schedule
+      enabled
+      nextRun
+      lastRun
+      config
+      createdAt
+      updatedAt
+      workspaceId
+    }
+  }
+`;
+var GET_DASHBOARD_SUMMARY = `
+  query DashboardSummary($projectId: String) {
+    dashboardSummary(projectId: $projectId) {
+      userId
+      username
+      workflowsCount
+      activeWorkflowsCount
+      archivedWorkflowsCount
+      runsCountTotal
+      runsCompletedCount
+      runsFailedCount
+      runsCancelledCount
+      runsPendingCount
+      runsRunningCount
+      runsWaitingCount
+      runsCompletedLast24h
+      runsFailedLast24h
+      runsCompletedLast7d
+      runsFailedLast7d
+      runsCompletedLast30d
+      runsFailedLast30d
+      totalNodesExecutedCount
+      workflowSuccessRate
+      avgWorkflowExecutionTimeSeconds
+      avgNodeExecutionTimeSeconds
+      recentRuns {
+        id
+        workflowKey
+        version
+        status
+        startedAt
+        completedAt
+        duration
+      }
+      recentWorkflows {
+        workflowKey
+        name
+        version
+        updatedAt
+      }
+      nodeUsageStats {
+        nodeType
+        totalExecutions
+        successCount
+        failureCount
+        avgExecutionTime
+      }
+    }
+  }
+`;
+var GET_USAGE_METRICS = `
+  query GetUsageMetrics($input: UsageQueryInput!) {
+    usageMetrics(input: $input) {
+      period
+      workflowMetrics {
+        totalRuns
+        successfulRuns
+        failedRuns
+        cancelledRuns
+        totalDurationSeconds
+        averageDurationSeconds
+        minDurationSeconds
+        maxDurationSeconds
+        medianDurationSeconds
+      }
+      nodeMetrics {
+        totalNodes
+        successfulNodes
+        failedNodes
+        skippedNodes
+        totalDurationSeconds
+        averageDurationSeconds
+        nodeTypeBreakdown
+      }
+    }
+  }
+`;
+var SEARCH = `
+  query Search($input: SearchRequestInput!) {
+    search(input: $input) {
+      query
+      results
+      entityCounts
+      totalResults
+      metadata
+    }
+  }
+`;
+var SEARCH_BY_ENTITY_TYPE = `
+  query SearchByEntityType($entityType: String!, $query: String!, $filters: SearchFilterInput, $limit: Int, $offset: Int) {
+    searchByEntityType(entityType: $entityType, query: $query, filters: $filters, limit: $limit, offset: $offset) {
+      query
+      results
+      entityCounts
+      totalResults
+      metadata
+    }
+  }
+`;
+var GET_SYSTEM_CONFIG = `
+  query GetSystemConfig {
+    systemConfig {
+      version
+      revision
+      environment
+      deploymentType
+      hostname
+      hostIp
+    }
+  }
+`;
+var CREATE_WORKFLOW = `
+  mutation CreateWorkflow($input: CreateWorkflowDefinitionInput!) {
+    createWorkflowDefinition(input: $input) {
+      id
+      workflowKey
+      name
+      description
+      version
+      status
+      category
+      tags
+      icon
+      isActive
+      totalVersions
+      createdAt
+      updatedAt
+    }
+  }
+`;
+var UPDATE_WORKFLOW = `
+  mutation UpdateWorkflow($id: ID!, $input: UpdateWorkflowDefinitionInput!) {
+    updateWorkflowDefinition(id: $id, input: $input) {
+      id
+      workflowKey
+      name
+      description
+      version
+      status
+      category
+      tags
+      icon
+      isActive
+      totalVersions
+      createdAt
+      updatedAt
+    }
+  }
+`;
+var DELETE_WORKFLOW = `
+  mutation DeleteWorkflow($workflowKey: String!, $version: String) {
+    deleteWorkflowDefinition(workflowKey: $workflowKey, version: $version)
+  }
+`;
+var TRIGGER_WORKFLOW = `
+  mutation TriggerWorkflow($input: TriggerWorkflowInput!) {
+    triggerWorkflow(input: $input) {
+      runId
+      status
+      workflowKey
+      version
+      triggerNodeId
+    }
+  }
+`;
+var PUBLISH_WORKFLOW = `
+  mutation PublishWorkflow($id: ID!) {
+    publishWorkflow(id: $id) {
+      id
+      workflowKey
+      name
+      description
+      version
+      status
+      category
+      tags
+      icon
+      isActive
+      totalVersions
+      createdAt
+      updatedAt
+    }
+  }
+`;
+var ACTIVATE_WORKFLOW = `
+  mutation ActivateWorkflow($id: ID!) {
+    activateWorkflowDefinition(id: $id) {
+      id
+      workflowKey
+      name
+      description
+      version
+      status
+      category
+      tags
+      icon
+      isActive
+      totalVersions
+      createdAt
+      updatedAt
+    }
+  }
+`;
+var DEACTIVATE_WORKFLOW = `
+  mutation DeactivateWorkflow($id: ID!) {
+    deactivateWorkflowDefinition(id: $id) {
+      id
+      workflowKey
+      name
+      description
+      version
+      status
+      category
+      tags
+      icon
+      isActive
+      totalVersions
+      createdAt
+      updatedAt
+    }
+  }
+`;
+var DUPLICATE_WORKFLOW = `
+  mutation DuplicateWorkflow($workflowKey: String!, $version: String!, $input: DuplicateWorkflowInput!) {
+    duplicateWorkflow(workflowKey: $workflowKey, version: $version, input: $input) {
+      success
+      message
+      workflow {
+        id
+        workflowKey
+        name
+        description
+        version
+        status
+        category
+        tags
+        icon
+        isActive
+        totalVersions
+        createdAt
+        updatedAt
+      }
+    }
+  }
+`;
+var ARCHIVE_WORKFLOW = `
+  mutation ArchiveWorkflow($id: ID!) {
+    archiveWorkflow(id: $id) {
+      id
+      status
+    }
+  }
+`;
+var CANCEL_RUN = `
+  mutation CancelRun($id: ID!) {
+    cancelWorkflowRun(id: $id) {
+      id
+      status
+      completedAt
+      errorMessage
+    }
+  }
+`;
+var PAUSE_RUN = `
+  mutation PauseRun($id: ID!) {
+    pauseWorkflowRun(id: $id) {
+      id
+      status
+      completedAt
+      errorMessage
+    }
+  }
+`;
+var RESUME_RUN = `
+  mutation ResumeRun($id: ID!, $payload: JSON) {
+    resumeWorkflowRun(id: $id, payload: $payload) {
+      success
+      message
+      resumedFromNodeId
+      run {
+        id
+        status
+        completedAt
+        errorMessage
+      }
+    }
+  }
+`;
+var RETRY_RUN = `
+  mutation RetryNode($id: ID!, $nodeId: String!) {
+    retryNode(id: $id, nodeId: $nodeId) {
+      id
+      nodeId
+      nodeType
+      status
+      error
+      attemptCount
+    }
+  }
+`;
+var CREATE_CREDENTIAL = `
+  mutation CreateCredential($input: CreateConnectionInput!) {
+    createConnection(input: $input) {
+      id
+      name
+      description
+      status
+      providerId
+      provider {
+        id
+        key
+        name
+        authType
+      }
+      credentialSource
+      createdAt
+    }
+  }
+`;
+var AUTHENTICATE_CREDENTIAL_API_KEY = `
+  mutation AuthenticateCredentialApiKey($input: ApiKeyAuthInput!) {
+    authenticateWithApiKey(input: $input) {
+      id
+      name
+      status
+      grantedScopes
+      externalAccountName
+      errorMessage
+      updatedAt
+    }
+  }
+`;
+var AUTHENTICATE_CREDENTIAL_BASIC = `
+  mutation AuthenticateCredentialBasic($input: BasicAuthInput!) {
+    authenticateWithBasicAuth(input: $input) {
+      id
+      name
+      status
+      grantedScopes
+      externalAccountName
+      errorMessage
+      updatedAt
+    }
+  }
+`;
+var UPDATE_CREDENTIAL = `
+  mutation UpdateCredential($id: ID!, $input: UpdateConnectionInput!) {
+    updateConnection(id: $id, input: $input) {
+      id
+      name
+      description
+      status
+      config
+      updatedAt
+    }
+  }
+`;
+var DELETE_CREDENTIAL = `
+  mutation DeleteCredential($id: ID!, $deleteVaultSecret: Boolean) {
+    deleteConnection(id: $id, deleteVaultSecret: $deleteVaultSecret)
+  }
+`;
+var TEST_CREDENTIAL = `
+  mutation TestCredential($connectionId: ID!) {
+    testConnection(connectionId: $connectionId) {
+      success
+      message
+      latencyMs
+    }
+  }
+`;
+var CREATE_WEBHOOK = `
+  mutation CreateWebhook($input: CreateEventRegistrationInput!) {
+    createEventRegistration(input: $input) {
+      id
+      name
+      workflowKey
+      triggerNodeId
+      isActive
+      status
+      webhookUrl
+      webhookToken
+      updatedAt
+      createdAt
+    }
+  }
+`;
+var UPDATE_WEBHOOK = `
+  mutation UpdateWebhook($id: ID!, $input: UpdateEventRegistrationInput!) {
+    updateEventRegistration(id: $id, input: $input) {
+      id
+      name
+      workflowKey
+      triggerNodeId
+      isActive
+      status
+      webhookUrl
+      webhookToken
+      updatedAt
+    }
+  }
+`;
+var DELETE_WEBHOOK = `
+  mutation DeleteWebhook($id: ID!) {
+    deleteEventRegistration(id: $id)
+  }
+`;
+var TOGGLE_WEBHOOK = `
+  mutation ToggleWebhook($id: ID!, $isActive: Boolean!) {
+    toggleEventRegistration(id: $id, isActive: $isActive) {
+      id
+      name
+      workflowKey
+      triggerNodeId
+      isActive
+      status
+      webhookUrl
+      webhookToken
+      updatedAt
+    }
+  }
+`;
+var CREATE_SCHEDULED_JOB = `
+  mutation CreateScheduledJob($input: ScheduledJobInput!) {
+    createWorkflowScheduledJob(input: $input) {
+      success
+      message
+      job {
+        id
+        name
+        workflowKey
+        version
+        schedule
+        enabled
+        nextRun
+        lastRun
+        config
+        createdAt
+        updatedAt
+      }
+    }
+  }
+`;
+var UPDATE_SCHEDULED_JOB = `
+  mutation UpdateScheduledJob($jobId: ID!, $input: WorkflowUpdateScheduledJobInput!) {
+    updateWorkflowScheduledJob(jobId: $jobId, input: $input) {
+      success
+      message
+      job {
+        id
+        name
+        workflowKey
+        version
+        schedule
+        enabled
+        nextRun
+        lastRun
+        config
+        createdAt
+        updatedAt
+      }
+    }
+  }
+`;
+var DELETE_SCHEDULED_JOB = `
+  mutation DeleteScheduledJob($jobId: ID!) {
+    deleteWorkflowScheduledJob(jobId: $jobId) {
+      success
+      message
+    }
+  }
+`;
+
+// src/modules/fluidgrids/tools/helpers.ts
+function isClientErrorShape(error) {
+  return typeof error === "object" && error !== null && "response" in error && "request" in error;
+}
+function safeErrorMessage(error) {
+  if (isClientErrorShape(error)) {
+    const errors = error.response?.errors;
+    if (Array.isArray(errors) && errors.length > 0) {
+      const joined = errors.map((e) => e?.message).filter((m) => typeof m === "string" && m.length > 0).join("; ");
+      if (joined) return joined;
+    }
+    const status = error.response?.status;
+    return status === void 0 ? "GraphQL request failed" : `GraphQL error (status ${status})`;
+  }
+  return error instanceof Error ? error.message : String(error);
+}
+async function runTool(ctx, label, run) {
+  try {
+    return await run();
+  } catch (error) {
+    const message = safeErrorMessage(error);
+    ctx.logger.error(`fluidgrids ${label} failed`, { error: message });
+    return errorResult(`Failed (${label}): ${message}`);
+  }
+}
+function definedInput(obj) {
+  const out = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
+}
+function workflowPagination(limit, offset) {
+  if (limit === void 0 && offset === void 0) return void 0;
+  return definedInput({ limit, offset });
+}
+
+// src/modules/fluidgrids/tools/credentials.ts
+function pagination(limit, offset) {
+  if (limit === void 0 && offset === void 0) return void 0;
+  return definedInput({ limit, offset });
+}
+function registerCredentialTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "credentials_list")),
+    {
+      title: "List Credentials",
+      description: "List stored connections (credentials) available to workflows.",
+      annotations: { readOnlyHint: true },
+      inputSchema: {
+        providerId: z.string().optional().describe("Filter by provider ID"),
+        name: z.string().optional().describe("Filter by name"),
+        limit: z.number().optional().describe("Max results"),
+        offset: z.number().optional().describe("Offset for pagination")
+      }
+    },
+    async ({ providerId, name, limit, offset }) => runTool(ctx, "credentials_list", async () => {
+      const filter = definedInput({ providerId, name });
+      const data = await ctx.gql.workspace.request(
+        LIST_CREDENTIALS,
+        {
+          filter: Object.keys(filter).length > 0 ? filter : void 0,
+          pagination: pagination(limit, offset)
+        }
+      );
+      return jsonResult(data.getConnections);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "credentials_get")),
+    {
+      title: "Get Credential",
+      description: "Get one connection by ID. Secret material is never returned.",
+      annotations: { readOnlyHint: true },
+      inputSchema: { id: z.string().describe("Connection ID") }
+    },
+    async ({ id }) => runTool(ctx, "credentials_get", async () => {
+      const data = await ctx.gql.workspace.request(GET_CREDENTIAL, {
+        id
+      });
+      return jsonResult(data.getConnection);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "credentials_list_types")),
+    {
+      title: "List Credential Types",
+      description: "List the providers a connection can be created against.",
+      annotations: { readOnlyHint: true },
+      inputSchema: {
+        name: z.string().optional().describe("Filter by provider name"),
+        limit: z.number().optional().describe("Max results"),
+        offset: z.number().optional().describe("Offset for pagination")
+      }
+    },
+    async ({ name, limit, offset }) => runTool(ctx, "credentials_list_types", async () => {
+      const filter = definedInput({ name });
+      const data = await ctx.gql.workspace.request(
+        LIST_CREDENTIAL_TYPES,
+        {
+          filter: Object.keys(filter).length > 0 ? filter : void 0,
+          pagination: pagination(limit, offset)
+        }
+      );
+      return jsonResult(data.getProviders);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "credentials_create")),
+    {
+      title: "Create Credential",
+      description: "Create a connection against a provider. Secrets go to the vault; pass a reference, never a raw secret in config.",
+      inputSchema: {
+        name: z.string().describe("Connection name"),
+        providerId: z.string().describe("Provider ID"),
+        description: z.string().optional().describe("Description"),
+        config: z.unknown().optional().describe("Non-secret provider config as JSON"),
+        context: z.unknown().optional().describe("Context JSON"),
+        vaultId: z.string().optional().describe("Vault to store secret material in"),
+        credentialSecretId: z.string().optional().describe("Existing vault secret reference"),
+        managedSecretName: z.string().optional().describe("Managed secret name")
+      }
+    },
+    async (args) => runTool(ctx, "credentials_create", async () => {
+      const data = await ctx.gql.workspace.request(
+        CREATE_CREDENTIAL,
+        { input: definedInput({ ...args }) }
+      );
+      return jsonResult(data.createConnection);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "credentials_update")),
+    {
+      title: "Update Credential",
+      description: "Update a connection\u2019s name, description or non-secret config.",
+      inputSchema: {
+        id: z.string().describe("Connection ID"),
+        name: z.string().optional().describe("Name"),
+        description: z.string().optional().describe("Description"),
+        config: z.unknown().optional().describe("Non-secret provider config as JSON")
+      }
+    },
+    async ({ id, ...input }) => runTool(ctx, "credentials_update", async () => {
+      const data = await ctx.gql.workspace.request(
+        UPDATE_CREDENTIAL,
+        { id, input: definedInput(input) }
+      );
+      return jsonResult(data.updateConnection);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "credentials_delete")),
+    {
+      title: "Delete Credential",
+      description: "Delete a connection. Set deleteVaultSecret to also destroy the stored secret \u2014 that is irreversible.",
+      annotations: { destructiveHint: true },
+      inputSchema: {
+        id: z.string().describe("Connection ID"),
+        deleteVaultSecret: z.boolean().optional().describe("Also delete the vault secret")
+      }
+    },
+    async ({ id, deleteVaultSecret }) => runTool(ctx, "credentials_delete", async () => {
+      const data = await ctx.gql.workspace.request(
+        DELETE_CREDENTIAL,
+        { id, deleteVaultSecret }
+      );
+      return jsonResult(data.deleteConnection);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "credentials_test")),
+    {
+      title: "Test Credential",
+      description: "Verify a connection can authenticate against its provider.",
+      annotations: { readOnlyHint: true },
+      inputSchema: { connectionId: z.string().describe("Connection ID") }
+    },
+    async ({ connectionId }) => runTool(ctx, "credentials_test", async () => {
+      const data = await ctx.gql.workspace.request(TEST_CREDENTIAL, {
+        connectionId
+      });
+      return jsonResult(data.testConnection);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "credentials_auth_api_key")),
+    {
+      title: "Authenticate Credential (API key)",
+      description: "Attach an API key to a connection via the API-key auth flow.",
+      inputSchema: {
+        connectionId: z.string().describe("Connection ID"),
+        apiKey: z.string().describe("API key to store")
+      }
+    },
+    async ({ connectionId, apiKey }) => runTool(ctx, "credentials_auth_api_key", async () => {
+      const data = await ctx.gql.workspace.request(
+        AUTHENTICATE_CREDENTIAL_API_KEY,
+        { input: { connectionId, apiKey } }
+      );
+      return jsonResult(data.authenticateWithApiKey);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "credentials_auth_basic")),
+    {
+      title: "Authenticate Credential (basic)",
+      description: "Attach basic-auth credentials to a connection.",
+      inputSchema: {
+        connectionId: z.string().describe("Connection ID"),
+        username: z.string().describe("Username"),
+        password: z.string().describe("Password")
+      }
+    },
+    async ({ connectionId, username, password }) => runTool(ctx, "credentials_auth_basic", async () => {
+      const data = await ctx.gql.workspace.request(
+        AUTHENTICATE_CREDENTIAL_BASIC,
+        { input: { connectionId, username, password } }
+      );
+      return jsonResult(data.authenticateWithBasicAuth);
+    })
+  );
+}
+function registerInsightTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "dashboard_summary")),
+    {
+      title: "Dashboard Summary",
+      description: "Workflow, run and failure counters for the current workspace.",
+      annotations: { readOnlyHint: true },
+      inputSchema: { projectId: z.string().optional().describe("Scope to one project") }
+    },
+    async ({ projectId }) => runTool(ctx, "dashboard_summary", async () => {
+      const data = await ctx.gql.workspace.request(
+        GET_DASHBOARD_SUMMARY,
+        { projectId }
+      );
+      return jsonResult(data.dashboardSummary);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "usage_metrics")),
+    {
+      title: "Usage Metrics",
+      description: "Usage metrics over a date range \u2014 run minutes and execution counts.",
+      annotations: { readOnlyHint: true },
+      inputSchema: {
+        startDate: z.string().describe("ISO 8601 start of the range"),
+        endDate: z.string().describe("ISO 8601 end of the range"),
+        userId: z.string().optional().describe("Scope to one user"),
+        contextFilter: z.unknown().optional().describe("Context filter as JSON")
+      }
+    },
+    async (args) => runTool(ctx, "usage_metrics", async () => {
+      const data = await ctx.gql.workspace.request(GET_USAGE_METRICS, {
+        input: definedInput({ ...args })
+      });
+      return jsonResult(data.usageMetrics);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "search")),
+    {
+      title: "Search",
+      description: "Search across FluidGrids entities. Narrow with entityTypes when you know it.",
+      annotations: { readOnlyHint: true },
+      inputSchema: {
+        query: z.string().describe("Search query"),
+        entityTypes: z.array(z.string()).optional().describe("Restrict to these entity types"),
+        filters: z.unknown().optional().describe("Additional filters as JSON"),
+        highlight: z.boolean().optional().describe("Return highlighted snippets"),
+        limit: z.number().optional().describe("Max results"),
+        offset: z.number().optional().describe("Offset for pagination")
+      }
+    },
+    async (args) => runTool(ctx, "search", async () => {
+      const data = await ctx.gql.workspace.request(SEARCH, {
+        input: definedInput({ ...args })
+      });
+      return jsonResult(data.search);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "search_by_entity_type")),
+    {
+      title: "Search By Entity Type",
+      description: "Search within a single entity type.",
+      annotations: { readOnlyHint: true },
+      inputSchema: {
+        entityType: z.string().describe("Entity type to search"),
+        query: z.string().describe("Search query"),
+        filters: z.unknown().optional().describe("Additional filters as JSON"),
+        limit: z.number().optional().describe("Max results"),
+        offset: z.number().optional().describe("Offset for pagination")
+      }
+    },
+    async (args) => runTool(ctx, "search_by_entity_type", async () => {
+      const data = await ctx.gql.workspace.request(
+        SEARCH_BY_ENTITY_TYPE,
+        definedInput({ ...args })
+      );
+      return jsonResult(data.searchByEntityType);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "system_config")),
+    {
+      title: "System Config",
+      description: "Read the workflow engine\u2019s effective system configuration.",
+      annotations: { readOnlyHint: true },
+      inputSchema: {}
+    },
+    async () => runTool(ctx, "system_config", async () => {
+      const data = await ctx.gql.workspace.request(GET_SYSTEM_CONFIG);
+      return jsonResult(data.systemConfig);
+    })
+  );
+}
+var PublishTypeEnum = z.enum(["BUILTIN", "CUSTOM", "STORE"]);
+var NodeConfigStatusEnum = z.enum(["AVAILABLE", "DEPRECATED", "DISABLED"]);
+function registerNodeTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "nodes_list")),
+    {
+      title: "List Nodes",
+      description: "List the node types available to build workflows with, from the node endpoint config registry.",
+      annotations: { readOnlyHint: true },
+      inputSchema: {
+        nodeType: z.string().optional().describe("Filter by node type"),
+        publishType: PublishTypeEnum.optional().describe("BUILTIN, CUSTOM or STORE"),
+        status: NodeConfigStatusEnum.optional().describe("Filter by availability"),
+        limit: z.number().optional().describe("Max results"),
+        offset: z.number().optional().describe("Offset for pagination")
+      }
+    },
+    async ({ nodeType, publishType, status, limit, offset }) => runTool(ctx, "nodes_list", async () => {
+      const data = await ctx.gql.workspace.request(LIST_NODES, {
+        nodeType,
+        publishType,
+        status,
+        pagination: workflowPagination(limit, offset)
+      });
+      return jsonResult(data.nodeEndpointConfigs);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "nodes_get")),
+    {
+      title: "Get Node",
+      description: "Get one node type at a specific version, including its input fields and operations.",
+      annotations: { readOnlyHint: true },
+      inputSchema: {
+        nodeType: z.string().describe("Node type identifier"),
+        nodeVersion: z.string().describe("Node version")
+      }
+    },
+    async ({ nodeType, nodeVersion }) => runTool(ctx, "nodes_get", async () => {
+      const data = await ctx.gql.workspace.request(GET_NODE, {
+        nodeType,
+        nodeVersion
+      });
+      return jsonResult(data.nodeEndpointConfig);
+    })
+  );
+}
+var RunStatusEnum = z.enum([
+  "CANCELLED",
+  "COMPLETED",
+  "FAILED",
+  "PENDING",
+  "RUNNING",
+  "TERMINATED",
+  "WAITING"
+]);
+var RunLogLevelEnum = z.enum(["DEBUG", "ERROR", "INFO", "WARN"]);
+function registerRunTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "runs_list")),
+    {
+      title: "List Runs",
+      description: "List workflow runs, optionally filtered by workflowKey and status.",
+      annotations: { readOnlyHint: true },
+      inputSchema: {
+        workflowKey: z.string().optional().describe("Filter by workflow key"),
+        status: RunStatusEnum.optional().describe("Filter by run status"),
+        limit: z.number().optional().describe("Max results (default 10)"),
+        offset: z.number().optional().describe("Offset for pagination (default 0)")
+      }
+    },
+    async ({ workflowKey, status, limit, offset }) => runTool(ctx, "runs_list", async () => {
+      const data = await ctx.gql.workspace.request(LIST_RUNS, {
+        input: definedInput({ workflowKey, status, limit, offset })
+      });
+      return jsonResult(data.workflowRuns);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "runs_get")),
+    {
+      title: "Get Run",
+      description: "Get one workflow run, including per-node state. Poll this to follow a run to a terminal status.",
+      annotations: { readOnlyHint: true },
+      inputSchema: { id: z.string().describe("Run ID") }
+    },
+    async ({ id }) => runTool(ctx, "runs_get", async () => {
+      const data = await ctx.gql.workspace.request(GET_RUN, { id });
+      return jsonResult(data.workflowRun);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "runs_logs")),
+    {
+      title: "Get Run Logs",
+      description: "Read a run log, newest page first. Keyset paginated: pass the previous page cursor as `after`.",
+      annotations: { readOnlyHint: true },
+      inputSchema: {
+        runId: z.string().describe("Run ID"),
+        nodeId: z.string().optional().describe("Restrict to one node"),
+        minLevel: RunLogLevelEnum.optional().describe("Minimum log level"),
+        limit: z.number().optional().describe("Max log lines"),
+        after: z.string().optional().describe("Keyset cursor from a previous page"),
+        search: z.string().optional().describe("Substring filter"),
+        includeChildRuns: z.boolean().optional().describe("Include logs from child runs")
+      }
+    },
+    async (args) => runTool(ctx, "runs_logs", async () => {
+      const data = await ctx.gql.workspace.request(
+        GET_RUN_LOGS,
+        definedInput({ ...args })
+      );
+      return jsonResult(data.workflowRunLogs);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "runs_cancel")),
+    {
+      title: "Cancel Run",
+      description: "Cancel an in-flight run. Terminal runs cannot be cancelled.",
+      annotations: { destructiveHint: true },
+      inputSchema: { id: z.string().describe("Run ID") }
+    },
+    async ({ id }) => runTool(ctx, "runs_cancel", async () => {
+      const data = await ctx.gql.workspace.request(CANCEL_RUN, {
+        id
+      });
+      return jsonResult(data.cancelWorkflowRun);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "runs_pause")),
+    {
+      title: "Pause Run",
+      description: "Pause a running workflow run.",
+      inputSchema: { id: z.string().describe("Run ID") }
+    },
+    async ({ id }) => runTool(ctx, "runs_pause", async () => {
+      const data = await ctx.gql.workspace.request(PAUSE_RUN, {
+        id
+      });
+      return jsonResult(data.pauseWorkflowRun);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "runs_resume")),
+    {
+      title: "Resume Run",
+      description: "Resume a paused or waiting run. `payload` supplies the data a Wait node is blocked on.",
+      inputSchema: {
+        id: z.string().describe("Run ID"),
+        payload: z.unknown().optional().describe("Payload to resume with")
+      }
+    },
+    async ({ id, payload }) => runTool(ctx, "runs_resume", async () => {
+      const data = await ctx.gql.workspace.request(RESUME_RUN, {
+        id,
+        payload
+      });
+      return jsonResult(data.resumeWorkflowRun);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "runs_retry_node")),
+    {
+      title: "Retry Node",
+      description: "Re-execute one failed node within a run, continuing from there.",
+      inputSchema: {
+        id: z.string().describe("Run ID"),
+        nodeId: z.string().describe("Node ID to retry")
+      }
+    },
+    async ({ id, nodeId }) => runTool(ctx, "runs_retry_node", async () => {
+      const data = await ctx.gql.workspace.request(RETRY_RUN, {
+        id,
+        nodeId
+      });
+      return jsonResult(data.retryNode);
+    })
+  );
+}
+function registerScheduledJobTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "scheduled_jobs_list")),
+    {
+      title: "List Scheduled Jobs",
+      description: "List schedules that trigger workflows on a cron or interval.",
+      annotations: { readOnlyHint: true },
+      inputSchema: {
+        enabled: z.boolean().optional().describe("Filter by enabled state"),
+        workflowKey: z.string().optional().describe("Filter by workflow key"),
+        limit: z.number().optional().describe("Max results"),
+        offset: z.number().optional().describe("Offset for pagination")
+      }
+    },
+    async ({ enabled, workflowKey, limit, offset }) => runTool(ctx, "scheduled_jobs_list", async () => {
+      const data = await ctx.gql.workspace.request(
+        LIST_SCHEDULED_JOBS,
+        { enabled, workflowKey, pagination: workflowPagination(limit, offset) }
+      );
+      return jsonResult(data.workflowScheduledJobs);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "scheduled_jobs_get")),
+    {
+      title: "Get Scheduled Job",
+      description: "Get one scheduled job by ID.",
+      annotations: { readOnlyHint: true },
+      inputSchema: { jobId: z.string().describe("Scheduled job ID") }
+    },
+    async ({ jobId }) => runTool(ctx, "scheduled_jobs_get", async () => {
+      const data = await ctx.gql.workspace.request(
+        GET_SCHEDULED_JOB,
+        { jobId }
+      );
+      return jsonResult(data.workflowScheduledJob);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "scheduled_jobs_create")),
+    {
+      title: "Create Scheduled Job",
+      description: "Schedule a workflow. `schedule` is the cron or interval expression the scheduler service evaluates.",
+      inputSchema: {
+        name: z.string().describe("Job name"),
+        workflowKey: z.string().describe("Workflow key to run"),
+        version: z.string().describe("Workflow version"),
+        schedule: z.string().describe("Cron or interval expression"),
+        enabled: z.boolean().optional().describe("Start enabled (default true)"),
+        config: z.unknown().optional().describe("Job config as JSON")
+      }
+    },
+    async (args) => runTool(ctx, "scheduled_jobs_create", async () => {
+      const data = await ctx.gql.workspace.request(
+        CREATE_SCHEDULED_JOB,
+        { input: definedInput({ ...args }) }
+      );
+      return jsonResult(data.createWorkflowScheduledJob);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "scheduled_jobs_update")),
+    {
+      title: "Update Scheduled Job",
+      description: "Update a scheduled job\u2019s name, schedule, config or enabled state.",
+      inputSchema: {
+        jobId: z.string().describe("Scheduled job ID"),
+        name: z.string().optional().describe("Name"),
+        schedule: z.string().optional().describe("Cron or interval expression"),
+        enabled: z.boolean().optional().describe("Enabled state"),
+        config: z.unknown().optional().describe("Job config as JSON")
+      }
+    },
+    async ({ jobId, ...input }) => runTool(ctx, "scheduled_jobs_update", async () => {
+      const data = await ctx.gql.workspace.request(
+        UPDATE_SCHEDULED_JOB,
+        { jobId, input: definedInput(input) }
+      );
+      return jsonResult(data.updateWorkflowScheduledJob);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "scheduled_jobs_delete")),
+    {
+      title: "Delete Scheduled Job",
+      description: "Delete a scheduled job permanently.",
+      annotations: { destructiveHint: true },
+      inputSchema: { jobId: z.string().describe("Scheduled job ID") }
+    },
+    async ({ jobId }) => runTool(ctx, "scheduled_jobs_delete", async () => {
+      const data = await ctx.gql.workspace.request(
+        DELETE_SCHEDULED_JOB,
+        { jobId }
+      );
+      return jsonResult(data.deleteWorkflowScheduledJob);
+    })
+  );
+}
+var EventStatusEnum = z.enum(["ACTIVE", "ARCHIVED", "DISABLED", "PAUSED"]);
+function registerWebhookTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "webhooks_list")),
+    {
+      title: "List Webhooks",
+      description: "List event registrations (webhooks) that can trigger workflows.",
+      annotations: { readOnlyHint: true },
+      inputSchema: {
+        status: EventStatusEnum.optional().describe("Filter by status"),
+        workflowKey: z.string().optional().describe("Filter by workflow key")
+      }
+    },
+    async ({ status, workflowKey }) => runTool(ctx, "webhooks_list", async () => {
+      const data = await ctx.gql.workspace.request(
+        LIST_WEBHOOKS,
+        { status, workflowKey }
+      );
+      return jsonResult(data.eventRegistrations);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "webhooks_get")),
+    {
+      title: "Get Webhook",
+      description: "Get one event registration by ID.",
+      annotations: { readOnlyHint: true },
+      inputSchema: { id: z.string().describe("Event registration ID") }
+    },
+    async ({ id }) => runTool(ctx, "webhooks_get", async () => {
+      const data = await ctx.gql.workspace.request(GET_WEBHOOK, {
+        id
+      });
+      return jsonResult(data.eventRegistration);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "webhooks_create")),
+    {
+      title: "Create Webhook",
+      description: "Register an event source that triggers a workflow. triggerNodeId names the trigger node the event enters at.",
+      inputSchema: {
+        name: z.string().describe("Registration name"),
+        workflowKey: z.string().describe("Workflow key to trigger"),
+        triggerNodeId: z.string().describe("Trigger node ID"),
+        eventSource: z.string().optional().describe("Event source identifier"),
+        eventType: z.string().optional().describe("Event type"),
+        description: z.string().optional().describe("Description"),
+        config: z.unknown().optional().describe("Source-specific config as JSON"),
+        payloadMapping: z.unknown().optional().describe("Payload mapping as JSON"),
+        validationMethod: z.string().optional().describe("Signature validation method"),
+        signatureHeader: z.string().optional().describe("Header carrying the signature"),
+        apiKeyHeader: z.string().optional().describe("Header carrying the API key"),
+        secretToken: z.string().optional().describe("Shared secret for validation"),
+        projectId: z.string().optional().describe("Owning project ID"),
+        tags: z.array(z.string()).optional().describe("Tags")
+      }
+    },
+    async (args) => runTool(ctx, "webhooks_create", async () => {
+      const data = await ctx.gql.workspace.request(
+        CREATE_WEBHOOK,
+        { input: definedInput({ ...args }) }
+      );
+      return jsonResult(data.createEventRegistration);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "webhooks_update")),
+    {
+      title: "Update Webhook",
+      description: "Update an event registration.",
+      inputSchema: {
+        id: z.string().describe("Event registration ID"),
+        name: z.string().optional().describe("Name"),
+        description: z.string().optional().describe("Description"),
+        status: EventStatusEnum.optional().describe("Status"),
+        isActive: z.boolean().optional().describe("Active flag"),
+        config: z.unknown().optional().describe("Config as JSON"),
+        payloadMapping: z.unknown().optional().describe("Payload mapping as JSON"),
+        validationMethod: z.string().optional().describe("Signature validation method"),
+        secretToken: z.string().optional().describe("Shared secret"),
+        tags: z.array(z.string()).optional().describe("Tags")
+      }
+    },
+    async ({ id, ...input }) => runTool(ctx, "webhooks_update", async () => {
+      const data = await ctx.gql.workspace.request(
+        UPDATE_WEBHOOK,
+        { id, input: definedInput(input) }
+      );
+      return jsonResult(data.updateEventRegistration);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "webhooks_toggle")),
+    {
+      title: "Toggle Webhook",
+      description: "Enable or disable an event registration without deleting it.",
+      inputSchema: {
+        id: z.string().describe("Event registration ID"),
+        isActive: z.boolean().describe("True to enable, false to disable")
+      }
+    },
+    async ({ id, isActive }) => runTool(ctx, "webhooks_toggle", async () => {
+      const data = await ctx.gql.workspace.request(
+        TOGGLE_WEBHOOK,
+        { id, isActive }
+      );
+      return jsonResult(data.toggleEventRegistration);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "webhooks_delete")),
+    {
+      title: "Delete Webhook",
+      description: "Delete an event registration permanently.",
+      annotations: { destructiveHint: true },
+      inputSchema: { id: z.string().describe("Event registration ID") }
+    },
+    async ({ id }) => runTool(ctx, "webhooks_delete", async () => {
+      const data = await ctx.gql.workspace.request(
+        DELETE_WEBHOOK,
+        { id }
+      );
+      return jsonResult(data.deleteEventRegistration);
+    })
+  );
+}
+var WorkflowStatusEnum = z.enum(["ACTIVE", "ARCHIVED", "DEPRECATED", "DRAFT"]);
+function registerWorkflowTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "workflows_list")),
+    {
+      title: "List Workflows",
+      description: "List FluidGrids workflow definitions with optional filters and pagination. Use latestOnly to collapse a workflowKey to its newest version.",
+      annotations: { readOnlyHint: true },
+      inputSchema: {
+        status: WorkflowStatusEnum.optional().describe("Filter by workflow status"),
+        category: z.string().optional().describe("Filter by category"),
+        tags: z.array(z.string()).optional().describe("Filter by tags"),
+        latestOnly: z.boolean().optional().describe("Return only the latest version per workflowKey"),
+        limit: z.number().optional().describe("Max results (default 10)"),
+        offset: z.number().optional().describe("Offset for pagination (default 0)")
+      }
+    },
+    async ({ status, category, tags, latestOnly, limit, offset }) => runTool(ctx, "workflows_list", async () => {
+      const data = await ctx.gql.workspace.request(
+        LIST_WORKFLOWS,
+        { input: definedInput({ status, category, tags, latestOnly, limit, offset }) }
+      );
+      return jsonResult(data.workflowDefinitions);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "workflows_get")),
+    {
+      title: "Get Workflow",
+      description: "Get a single workflow definition by id, or by workflowKey (optionally pinned to a version). Without a version the executable version is resolved.",
+      annotations: { readOnlyHint: true },
+      inputSchema: {
+        id: z.string().optional().describe("Workflow definition ID"),
+        workflowKey: z.string().optional().describe("Workflow key (alternative to id)"),
+        version: z.string().optional().describe("Pin to a specific version")
+      }
+    },
+    async ({ id, workflowKey, version }) => runTool(ctx, "workflows_get", async () => {
+      const data = await ctx.gql.workspace.request(
+        GET_WORKFLOW,
+        {
+          id,
+          workflowKey,
+          version
+        }
+      );
+      return jsonResult(data.workflowDefinition);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "workflows_versions")),
+    {
+      title: "List Workflow Versions",
+      description: "List every stored version of one workflowKey.",
+      annotations: { readOnlyHint: true },
+      inputSchema: { workflowKey: z.string().describe("Workflow key") }
+    },
+    async ({ workflowKey }) => runTool(ctx, "workflows_versions", async () => {
+      const data = await ctx.gql.workspace.request(
+        GET_WORKFLOW_VERSIONS,
+        { workflowKey }
+      );
+      return jsonResult(data.workflowVersions);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "workflows_create")),
+    {
+      title: "Create Workflow",
+      description: "Create a workflow definition. definitionJson is the node/edge graph; workflowKey plus version identify it.",
+      inputSchema: {
+        workflowKey: z.string().describe("Stable key identifying the workflow"),
+        name: z.string().describe("Human-readable name"),
+        version: z.string().describe('Version string, e.g. "1.0.0"'),
+        definitionJson: z.unknown().describe("Workflow graph (nodes + edges) as JSON"),
+        description: z.string().optional().describe("Description"),
+        category: z.string().optional().describe("Category"),
+        icon: z.string().optional().describe("Icon identifier"),
+        alias: z.string().optional().describe("Alias"),
+        projectId: z.string().optional().describe("Owning project ID"),
+        context: z.unknown().optional().describe("Context JSON"),
+        tags: z.array(z.string()).optional().describe("Tags")
+      }
+    },
+    async (args) => runTool(ctx, "workflows_create", async () => {
+      const data = await ctx.gql.workspace.request(
+        CREATE_WORKFLOW,
+        { input: definedInput({ ...args }) }
+      );
+      return jsonResult(data.createWorkflowDefinition);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "workflows_update")),
+    {
+      title: "Update Workflow",
+      description: "Update a workflow definition by id. Saving a change to a published workflow forks a new version rather than mutating the active one.",
+      inputSchema: {
+        id: z.string().describe("Workflow definition ID"),
+        name: z.string().optional().describe("Name"),
+        description: z.string().optional().describe("Description"),
+        definitionJson: z.unknown().optional().describe("Workflow graph as JSON"),
+        category: z.string().optional().describe("Category"),
+        icon: z.string().optional().describe("Icon identifier"),
+        alias: z.string().optional().describe("Alias"),
+        context: z.unknown().optional().describe("Context JSON"),
+        tags: z.array(z.string()).optional().describe("Tags"),
+        version: z.string().optional().describe("Version")
+      }
+    },
+    async ({ id, ...input }) => runTool(ctx, "workflows_update", async () => {
+      const data = await ctx.gql.workspace.request(
+        UPDATE_WORKFLOW,
+        { id, input: definedInput(input) }
+      );
+      return jsonResult(data.updateWorkflowDefinition);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "workflows_delete")),
+    {
+      title: "Delete Workflow",
+      description: "Delete a workflow by key. Without a version every version of that key is deleted.",
+      annotations: { destructiveHint: true },
+      inputSchema: {
+        workflowKey: z.string().describe("Workflow key"),
+        version: z.string().optional().describe("Delete only this version")
+      }
+    },
+    async ({ workflowKey, version }) => runTool(ctx, "workflows_delete", async () => {
+      const data = await ctx.gql.workspace.request(
+        DELETE_WORKFLOW,
+        { workflowKey, version }
+      );
+      return jsonResult(data.deleteWorkflowDefinition);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "workflows_trigger")),
+    {
+      title: "Trigger Workflow",
+      description: "Start a workflow run. triggerNodeId names the trigger node to start from; stopAtNodeId runs only up to a node (step debugging).",
+      inputSchema: {
+        workflowKey: z.string().describe("Workflow key"),
+        version: z.string().describe("Workflow version"),
+        triggerNodeId: z.string().describe("ID of the trigger node to start from"),
+        triggerData: z.unknown().optional().describe("Payload passed to the trigger node"),
+        context: z.unknown().optional().describe("Run context JSON"),
+        stopAtNodeId: z.string().optional().describe("Stop after this node and mark the run COMPLETED")
+      }
+    },
+    async (args) => runTool(ctx, "workflows_trigger", async () => {
+      const data = await ctx.gql.workspace.request(
+        TRIGGER_WORKFLOW,
+        { input: definedInput({ ...args }) }
+      );
+      return jsonResult(data.triggerWorkflow);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "workflows_publish")),
+    {
+      title: "Publish Workflow",
+      description: "Publish a workflow definition, making that version the executable one.",
+      inputSchema: { id: z.string().describe("Workflow definition ID") }
+    },
+    async ({ id }) => runTool(ctx, "workflows_publish", async () => {
+      const data = await ctx.gql.workspace.request(
+        PUBLISH_WORKFLOW,
+        { id }
+      );
+      return jsonResult(data.publishWorkflow);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "workflows_activate")),
+    {
+      title: "Activate Workflow",
+      description: "Activate a workflow definition. Exactly one version per workflowKey may be ACTIVE.",
+      inputSchema: { id: z.string().describe("Workflow definition ID") }
+    },
+    async ({ id }) => runTool(ctx, "workflows_activate", async () => {
+      const data = await ctx.gql.workspace.request(
+        ACTIVATE_WORKFLOW,
+        { id }
+      );
+      return jsonResult(data.activateWorkflowDefinition);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "workflows_deactivate")),
+    {
+      title: "Deactivate Workflow",
+      description: "Deactivate a workflow definition so no version of the key is executable.",
+      inputSchema: { id: z.string().describe("Workflow definition ID") }
+    },
+    async ({ id }) => runTool(ctx, "workflows_deactivate", async () => {
+      const data = await ctx.gql.workspace.request(
+        DEACTIVATE_WORKFLOW,
+        { id }
+      );
+      return jsonResult(data.deactivateWorkflowDefinition);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "workflows_duplicate")),
+    {
+      title: "Duplicate Workflow",
+      description: "Copy an existing workflow version to a new workflowKey.",
+      inputSchema: {
+        workflowKey: z.string().describe("Source workflow key"),
+        version: z.string().describe("Source version"),
+        newWorkflowKey: z.string().describe("Key for the copy"),
+        newVersion: z.string().optional().describe("Version for the copy")
+      }
+    },
+    async ({ workflowKey, version, newWorkflowKey, newVersion }) => runTool(ctx, "workflows_duplicate", async () => {
+      const data = await ctx.gql.workspace.request(
+        DUPLICATE_WORKFLOW,
+        { workflowKey, version, input: definedInput({ newWorkflowKey, newVersion }) }
+      );
+      return jsonResult(data.duplicateWorkflow);
+    })
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "workflows_archive")),
+    {
+      title: "Archive Workflow",
+      description: "Archive a workflow definition. Reversible: archived workflows still list.",
+      annotations: { destructiveHint: true },
+      inputSchema: { id: z.string().describe("Workflow definition ID") }
+    },
+    async ({ id }) => runTool(ctx, "workflows_archive", async () => {
+      const data = await ctx.gql.workspace.request(
+        ARCHIVE_WORKFLOW,
+        { id }
+      );
+      return jsonResult(data.archiveWorkflow);
+    })
+  );
+}
+function registerFluidgridsPrompts(server, ctx, track) {
+  const p = ctx.productName;
+  const buildName = track(mcpPromptName(p, "build-workflow"));
+  const debugName = track(mcpPromptName(p, "debug-run"));
+  server.registerPrompt(
+    buildName,
+    {
+      title: "Build a Workflow",
+      description: "Guide for authoring a FluidGrids workflow end to end: pick nodes, create the definition, publish a version, then trigger it and confirm the run completes.",
+      argsSchema: {
+        goal: z.string().optional().describe("What the workflow should do"),
+        workflowKey: z.string().optional().describe("Workflow key to use")
+      }
+    },
+    ({ goal, workflowKey }) => {
+      ctx.logger.debug(`Prompt ${buildName} called`, { goal, workflowKey });
+      const goalNote = goal ? `The workflow should: ${goal}` : "Ask the user what the workflow should do before building anything.";
+      const keyNote = workflowKey ? `Use the workflowKey "${workflowKey}".` : "Choose a stable, descriptive workflowKey and confirm it with the user.";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Build a FluidGrids workflow.
+
+${goalNote}
+${keyNote}
+
+Follow this order and stop if a step fails:
+
+1. \`${p}_nodes_list\` \u2014 find the node types you need. Use \`${p}_nodes_get\` to read a
+   node's input fields before wiring it; do not guess field names.
+2. \`${p}_workflows_create\` \u2014 build \`definitionJson\` as a graph of nodes and edges.
+   Exactly one trigger node. Note its node id: triggering needs it.
+3. \`${p}_workflows_publish\` then \`${p}_workflows_activate\` \u2014 only an active version
+   is executable, and only one version per key may be ACTIVE.
+4. \`${p}_workflows_trigger\` \u2014 pass \`triggerNodeId\` and any \`triggerData\`.
+5. \`${p}_runs_get\` \u2014 poll until status is terminal (COMPLETED, FAILED, CANCELLED or
+   TERMINATED). Statuses are UPPERCASE.
+6. If it did not complete, run \`${p}_debug-run\` on the run id.
+
+If the workflow needs credentials, create them with \`${p}_credentials_create\` and
+verify with \`${p}_credentials_test\` BEFORE triggering \u2014 a missing connection fails
+the run at the node, not at save time.`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server.registerPrompt(
+    debugName,
+    {
+      title: "Debug a Run",
+      description: "Guide for diagnosing a FluidGrids run that failed or stalled: read node state, read the log, then retry the failing node or fix the definition.",
+      argsSchema: { runId: z.string().optional().describe("Run ID to diagnose") }
+    },
+    ({ runId }) => {
+      ctx.logger.debug(`Prompt ${debugName} called`, { runId });
+      const runNote = runId ? `Diagnose run "${runId}".` : `Ask for the run id, or find it with \`${p}_runs_list\` filtered to status FAILED.`;
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Diagnose a FluidGrids run.
+
+${runNote}
+
+1. \`${p}_runs_get\` \u2014 read the run and its per-node state. Identify the FIRST node that
+   did not succeed; later failures are usually consequences of it.
+2. \`${p}_runs_logs\` \u2014 read that node's log with \`nodeId\` set, \`minLevel\` ERROR first,
+   then widen to WARN/INFO if the error alone is not conclusive.
+3. Classify before acting:
+   - credential/auth error -> \`${p}_credentials_test\` the connection the node uses
+   - bad input -> compare against \`${p}_nodes_get\` input fields for that node type
+   - transient/upstream -> \`${p}_runs_retry_node\` is appropriate
+   - wrong graph -> fix \`definitionJson\` via \`${p}_workflows_update\` (this forks a new
+     version), then publish, activate and trigger again
+4. Only retry once you know which class it is. Retrying a bad definition just
+   reproduces the failure.
+
+A run stuck in WAITING is not failed \u2014 it is blocked on a Wait node. Resume it with
+\`${p}_runs_resume\` and the payload it expects.`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/modules/fluidgrids/resources.ts
+function registerFluidgridsResources(server, ctx, track) {
+  const schemaUri = track(mcpResourceUri(ctx.productName, "schema"));
+  const nodesUri = track(mcpResourceUri(ctx.productName, "nodes"));
+  server.registerResource(
+    "fluidgrids-schema",
+    schemaUri,
+    {
+      title: "FluidGrids Domain Schema",
+      description: "Overview of the FluidGrids workflow-automation domain \u2014 entities, enums, and the per-entity tool surface.",
+      mimeType: "text/plain"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${schemaUri} requested`);
+      const schema = `# FluidGrids Domain (Overview)
+
+Visual workflow automation. A workflow is a graph of nodes; running one produces a run.
+
+## Core entities
+- WorkflowDefinition \u2014 identified by (workflowKey, version). Many versions per key;
+  at most ONE is ACTIVE. Saving over a published version forks a new version.
+- WorkflowRun \u2014 one execution. Has per-node state and a log stream.
+- NodeEndpointConfig \u2014 an available node type at a version (BUILTIN | CUSTOM | STORE).
+- Connection \u2014 a stored credential against a Provider. Secrets live in the vault.
+- EventRegistration \u2014 an event source (webhook) that triggers a workflow.
+- ScheduledJob \u2014 a cron/interval schedule that triggers a workflow.
+
+## Enums
+- WorkflowStatus: ACTIVE | ARCHIVED | DEPRECATED | DRAFT
+- RunStatus: PENDING | RUNNING | WAITING | COMPLETED | FAILED | CANCELLED | TERMINATED
+  (UPPERCASE on the wire \u2014 comparing lowercase is a known source of hangs)
+- RunLogLevel: DEBUG | INFO | WARN | ERROR
+- PublishType: BUILTIN | CUSTOM | STORE
+- NodeConfigStatus: AVAILABLE | DEPRECATED | DISABLED
+- EventStatus: ACTIVE | PAUSED | DISABLED | ARCHIVED
+
+## Typical sequence
+1. ${ctx.productName}_nodes_list \u2014 see what nodes exist
+2. ${ctx.productName}_workflows_create \u2014 create a definition with a definitionJson graph
+3. ${ctx.productName}_workflows_publish / _activate \u2014 make a version executable
+4. ${ctx.productName}_workflows_trigger \u2014 start a run
+5. ${ctx.productName}_runs_get / _runs_logs \u2014 follow it to a terminal status
+
+## Tier
+Every tool here is workspace tier and needs a workspace context. Sign in and
+select a workspace with the auth tools first.
+`;
+      return { contents: [{ uri: schemaUri, mimeType: "text/plain", text: schema }] };
+    }
+  );
+  server.registerResource(
+    "fluidgrids-nodes",
+    nodesUri,
+    {
+      title: "FluidGrids Node Catalogue",
+      description: "The node types currently available to build workflows with, read live from the node endpoint config registry.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${nodesUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(LIST_NODES, {
+          status: "AVAILABLE"
+        });
+        return {
+          contents: [
+            {
+              uri: nodesUri,
+              mimeType: "application/json",
+              text: JSON.stringify(data.nodeEndpointConfigs, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        const message = safeErrorMessage(error);
+        ctx.logger.error("fluidgrids nodes resource failed", { error: message });
+        return {
+          contents: [
+            {
+              uri: nodesUri,
+              mimeType: "application/json",
+              text: JSON.stringify(
+                {
+                  error: message,
+                  hint: "Sign in and select a workspace first \u2014 the node registry is workspace-scoped."
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+
+// src/modules/fluidgrids/index.ts
+var fluidgridsModule = {
+  id: "fluidgrids",
+  version: "0.0.1",
+  displayName: "FluidGrids",
+  capabilities: { tools: {}, resources: {}, prompts: {} },
+  register(server, ctx) {
+    const tools = [];
+    const resources = [];
+    const prompts = [];
+    const trackTool = (n) => {
+      tools.push(n);
+      return n;
+    };
+    const trackResource = (uri) => {
+      resources.push(uri);
+      return uri;
+    };
+    const trackPrompt = (n) => {
+      prompts.push(n);
+      return n;
+    };
+    registerWorkflowTools(server, ctx, trackTool);
+    registerRunTools(server, ctx, trackTool);
+    registerNodeTools(server, ctx, trackTool);
+    registerCredentialTools(server, ctx, trackTool);
+    registerWebhookTools(server, ctx, trackTool);
+    registerScheduledJobTools(server, ctx, trackTool);
+    registerInsightTools(server, ctx, trackTool);
+    registerFluidgridsResources(server, ctx, trackResource);
+    registerFluidgridsPrompts(server, ctx, trackPrompt);
+    return { tools, resources, prompts };
+  }
+};
+var fluidgrids_default = fluidgridsModule;
+
+export { fluidgrids_default as default };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map