@kadoa/mcp 0.3.10-rc.3 → 0.3.11-rc.1

package/dist/index.js

@@ -44094,6 +44094,7 @@ function createClientDomains(params) {
   const entityResolverService = new EntityResolverService(client);
   const workflowsCoreService = new WorkflowsCoreService(client.apis.workflows);
   const schemasService = new SchemasService(client);
+  const variablesService = new VariablesService(client);
   const channelSetupService = new NotificationSetupService(channelsService, settingsService);
   const coreService = new ValidationCoreService(client);
   const rulesService = new ValidationRulesService(client);
@@ -44115,6 +44116,7 @@ function createClientDomains(params) {
     schema: schemasService,
     user: userService,
     validation,
+    variable: variablesService,
     crawler
   };
 }
@@ -44194,8 +44196,8 @@ var import_debug, __require2, BASE_PATH, BaseAPI = class {
   return needsSerialization ? JSON.stringify(value !== undefined ? value : {}, replaceWithSerializableTypeIfNeeded) : value || "";
 }, toPathString = function(url3) {
   return url3.pathname + url3.search + url3.hash;
-}, createRequestFunction = function(axiosArgs, globalAxios7, BASE_PATH2, configuration) {
-  return (axios2 = globalAxios7, basePath = BASE_PATH2) => {
+}, createRequestFunction = function(axiosArgs, globalAxios8, BASE_PATH2, configuration) {
+  return (axios2 = globalAxios8, basePath = BASE_PATH2) => {
     const axiosRequestArgs = { ...axiosArgs.options, url: (axios2.defaults.baseURL ? "" : configuration?.basePath ?? basePath) + axiosArgs.url };
     return axios2.request(axiosRequestArgs);
   };
@@ -45781,7 +45783,151 @@ var import_debug, __require2, BASE_PATH, BaseAPI = class {
       return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, axios_default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
     }
   };
-}, SchemasApi, WorkflowsApiAxiosParamCreator = function(configuration) {
+}, SchemasApi, VariablesApiAxiosParamCreator = function(configuration) {
+  return {
+    v4VariablesGet: async (options = {}) => {
+      const localVarPath = `/v4/variables/`;
+      const localVarUrlObj = new URL$1(localVarPath, DUMMY_BASE_URL);
+      let baseOptions;
+      if (configuration) {
+        baseOptions = configuration.baseOptions;
+      }
+      const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
+      const localVarHeaderParameter = {};
+      const localVarQueryParameter = {};
+      await setApiKeyToObject(localVarHeaderParameter, "x-api-key", configuration);
+      localVarHeaderParameter["Accept"] = "application/json";
+      setSearchParams(localVarUrlObj, localVarQueryParameter);
+      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+      return {
+        url: toPathString(localVarUrlObj),
+        options: localVarRequestOptions
+      };
+    },
+    v4VariablesPost: async (createVariableBody, options = {}) => {
+      const localVarPath = `/v4/variables/`;
+      const localVarUrlObj = new URL$1(localVarPath, DUMMY_BASE_URL);
+      let baseOptions;
+      if (configuration) {
+        baseOptions = configuration.baseOptions;
+      }
+      const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
+      const localVarHeaderParameter = {};
+      const localVarQueryParameter = {};
+      await setApiKeyToObject(localVarHeaderParameter, "x-api-key", configuration);
+      localVarHeaderParameter["Content-Type"] = "application/json";
+      localVarHeaderParameter["Accept"] = "application/json";
+      setSearchParams(localVarUrlObj, localVarQueryParameter);
+      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+      localVarRequestOptions.data = serializeDataIfNeeded(createVariableBody, localVarRequestOptions, configuration);
+      return {
+        url: toPathString(localVarUrlObj),
+        options: localVarRequestOptions
+      };
+    },
+    v4VariablesVariableIdDelete: async (variableId, options = {}) => {
+      assertParamExists("v4VariablesVariableIdDelete", "variableId", variableId);
+      const localVarPath = `/v4/variables/{variableId}`.replace(`{${"variableId"}}`, encodeURIComponent(String(variableId)));
+      const localVarUrlObj = new URL$1(localVarPath, DUMMY_BASE_URL);
+      let baseOptions;
+      if (configuration) {
+        baseOptions = configuration.baseOptions;
+      }
+      const localVarRequestOptions = { method: "DELETE", ...baseOptions, ...options };
+      const localVarHeaderParameter = {};
+      const localVarQueryParameter = {};
+      await setApiKeyToObject(localVarHeaderParameter, "x-api-key", configuration);
+      localVarHeaderParameter["Accept"] = "application/json";
+      setSearchParams(localVarUrlObj, localVarQueryParameter);
+      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+      return {
+        url: toPathString(localVarUrlObj),
+        options: localVarRequestOptions
+      };
+    },
+    v4VariablesVariableIdGet: async (variableId, options = {}) => {
+      assertParamExists("v4VariablesVariableIdGet", "variableId", variableId);
+      const localVarPath = `/v4/variables/{variableId}`.replace(`{${"variableId"}}`, encodeURIComponent(String(variableId)));
+      const localVarUrlObj = new URL$1(localVarPath, DUMMY_BASE_URL);
+      let baseOptions;
+      if (configuration) {
+        baseOptions = configuration.baseOptions;
+      }
+      const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
+      const localVarHeaderParameter = {};
+      const localVarQueryParameter = {};
+      await setApiKeyToObject(localVarHeaderParameter, "x-api-key", configuration);
+      localVarHeaderParameter["Accept"] = "application/json";
+      setSearchParams(localVarUrlObj, localVarQueryParameter);
+      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+      return {
+        url: toPathString(localVarUrlObj),
+        options: localVarRequestOptions
+      };
+    },
+    v4VariablesVariableIdPatch: async (variableId, updateVariableBody, options = {}) => {
+      assertParamExists("v4VariablesVariableIdPatch", "variableId", variableId);
+      const localVarPath = `/v4/variables/{variableId}`.replace(`{${"variableId"}}`, encodeURIComponent(String(variableId)));
+      const localVarUrlObj = new URL$1(localVarPath, DUMMY_BASE_URL);
+      let baseOptions;
+      if (configuration) {
+        baseOptions = configuration.baseOptions;
+      }
+      const localVarRequestOptions = { method: "PATCH", ...baseOptions, ...options };
+      const localVarHeaderParameter = {};
+      const localVarQueryParameter = {};
+      await setApiKeyToObject(localVarHeaderParameter, "x-api-key", configuration);
+      localVarHeaderParameter["Content-Type"] = "application/json";
+      localVarHeaderParameter["Accept"] = "application/json";
+      setSearchParams(localVarUrlObj, localVarQueryParameter);
+      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+      localVarRequestOptions.data = serializeDataIfNeeded(updateVariableBody, localVarRequestOptions, configuration);
+      return {
+        url: toPathString(localVarUrlObj),
+        options: localVarRequestOptions
+      };
+    }
+  };
+}, VariablesApiFp = function(configuration) {
+  const localVarAxiosParamCreator = VariablesApiAxiosParamCreator(configuration);
+  return {
+    async v4VariablesGet(options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.v4VariablesGet(options);
+      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+      const localVarOperationServerBasePath = operationServerMap["VariablesApi.v4VariablesGet"]?.[localVarOperationServerIndex]?.url;
+      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, axios_default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
+    },
+    async v4VariablesPost(createVariableBody, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.v4VariablesPost(createVariableBody, options);
+      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+      const localVarOperationServerBasePath = operationServerMap["VariablesApi.v4VariablesPost"]?.[localVarOperationServerIndex]?.url;
+      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, axios_default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
+    },
+    async v4VariablesVariableIdDelete(variableId, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.v4VariablesVariableIdDelete(variableId, options);
+      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+      const localVarOperationServerBasePath = operationServerMap["VariablesApi.v4VariablesVariableIdDelete"]?.[localVarOperationServerIndex]?.url;
+      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, axios_default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
+    },
+    async v4VariablesVariableIdGet(variableId, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.v4VariablesVariableIdGet(variableId, options);
+      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+      const localVarOperationServerBasePath = operationServerMap["VariablesApi.v4VariablesVariableIdGet"]?.[localVarOperationServerIndex]?.url;
+      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, axios_default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
+    },
+    async v4VariablesVariableIdPatch(variableId, updateVariableBody, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.v4VariablesVariableIdPatch(variableId, updateVariableBody, options);
+      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+      const localVarOperationServerBasePath = operationServerMap["VariablesApi.v4VariablesVariableIdPatch"]?.[localVarOperationServerIndex]?.url;
+      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, axios_default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
+    }
+  };
+}, VariablesApi, WorkflowsApiAxiosParamCreator = function(configuration) {
   return {
     v4ChangesChangeIdGet: async (changeId, xApiKey, authorization, options = {}) => {
       assertParamExists("v4ChangesChangeIdGet", "changeId", changeId);
@@ -47712,7 +47858,7 @@ var import_debug, __require2, BASE_PATH, BaseAPI = class {
     }));
     return channels;
   }
-}, PUBLIC_API_URI, WSS_API_URI, REALTIME_API_URI, SDK_VERSION = "0.24.2", SDK_NAME = "kadoa-node-sdk", SDK_LANGUAGE = "node", debug5, isDrainControlMessage = (message) => message.type === "control.draining", isRealtimeEvent = (message) => message.type !== "heartbeat" && message.type !== "control.draining", _Realtime = class _Realtime2 {
+}, PUBLIC_API_URI, WSS_API_URI, REALTIME_API_URI, SDK_VERSION = "0.25.0", SDK_NAME = "kadoa-node-sdk", SDK_LANGUAGE = "node", debug5, isDrainControlMessage = (message) => message.type === "control.draining", isRealtimeEvent = (message) => message.type !== "heartbeat" && message.type !== "control.draining", _Realtime = class _Realtime2 {
   constructor(config2) {
     this.drainingSockets = /* @__PURE__ */ new Set;
     this.lastHeartbeat = Date.now();
@@ -48285,7 +48431,66 @@ var import_debug, __require2, BASE_PATH, BaseAPI = class {
     }
     return response.data.data;
   }
-}, JobStateEnum, TERMINAL_JOB_STATES, TERMINAL_RUN_STATES, debug6, WorkflowsCoreService = class {
+}, debug6, VariablesService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  get variablesApi() {
+    return this.client.apis.variables;
+  }
+  async list() {
+    const response = await this.variablesApi.v4VariablesGet();
+    return response.data.variables ?? [];
+  }
+  async get(variableId) {
+    debug6("Fetching variable with ID: %s", variableId);
+    const response = await this.variablesApi.v4VariablesVariableIdGet({
+      variableId
+    });
+    const variable = response.data.variable;
+    if (!variable) {
+      throw new KadoaSdkException(`${ERROR_MESSAGES.VARIABLE_NOT_FOUND}: ${variableId}`, {
+        code: KadoaErrorCode.NOT_FOUND,
+        details: { variableId }
+      });
+    }
+    return variable;
+  }
+  async create(body) {
+    debug6("Creating variable with key: %s", body.key);
+    const response = await this.variablesApi.v4VariablesPost({
+      createVariableBody: body
+    });
+    const variable = response.data.variable;
+    if (!variable) {
+      throw new KadoaSdkException(ERROR_MESSAGES.VARIABLE_CREATE_FAILED, {
+        code: KadoaErrorCode.INTERNAL_ERROR
+      });
+    }
+    return variable;
+  }
+  async update(variableId, body) {
+    debug6("Updating variable with ID: %s", variableId);
+    const response = await this.variablesApi.v4VariablesVariableIdPatch({
+      variableId,
+      updateVariableBody: body
+    });
+    const variable = response.data.variable;
+    if (!variable) {
+      throw new KadoaSdkException(`${ERROR_MESSAGES.VARIABLE_UPDATE_FAILED}: ${variableId}`, {
+        code: KadoaErrorCode.INTERNAL_ERROR,
+        details: { variableId }
+      });
+    }
+    return variable;
+  }
+  async delete(variableId) {
+    debug6("Deleting variable with ID: %s", variableId);
+    await this.variablesApi.v4VariablesVariableIdDelete({
+      variableId
+    });
+  }
+}, JobStateEnum, TERMINAL_JOB_STATES, TERMINAL_RUN_STATES, debug7, WorkflowsCoreService = class {
   constructor(workflowsApi) {
     this.workflowsApi = workflowsApi;
   }
@@ -48401,7 +48606,7 @@ var import_debug, __require2, BASE_PATH, BaseAPI = class {
   async wait(id, options) {
     const result = await pollUntil(async () => {
       const current = await this.get(id);
-      debug6("workflow %s state: %s", id, current.runState);
+      debug7("workflow %s state: %s", id, current.runState);
       return current;
     }, (current) => {
       if (options?.targetState && current.state === options.targetState) {
@@ -48447,7 +48652,7 @@ var import_debug, __require2, BASE_PATH, BaseAPI = class {
   async waitForJobCompletion(workflowId, jobId, options) {
     const result = await pollUntil(async () => {
       const current = await this.getJobStatus(workflowId, jobId);
-      debug6("workflow run %s state: %s", jobId, current.state);
+      debug7("workflow run %s state: %s", jobId, current.state);
       return current;
     }, (current) => {
       if (options?.targetStatus && current.state === options.targetStatus) {
@@ -48492,6 +48697,9 @@ var import_debug, __require2, BASE_PATH, BaseAPI = class {
   get notifications() {
     return this.get(NotificationsApi);
   }
+  get variables() {
+    return this.get(VariablesApi);
+  }
 }, KadoaClient = class {
   constructor(config2) {
     if (!config2.apiKey && !config2.bearerToken) {
@@ -48520,6 +48728,7 @@ var import_debug, __require2, BASE_PATH, BaseAPI = class {
     this.schema = domains.schema;
     this.notification = domains.notification;
     this.validation = domains.validation;
+    this.variable = domains.variable;
     this.crawler = domains.crawler;
     this._extractionBuilderService = domains.extractionBuilderService;
     checkForUpdates().catch(() => {});
@@ -48785,6 +48994,23 @@ var init_dist2 = __esm(() => {
       return SchemasApiFp(this.configuration).v4SchemasSchemaIdPut(requestParameters.schemaId, requestParameters.updateSchemaBody, options).then((request) => request(this.axios, this.basePath));
     }
   };
+  VariablesApi = class extends BaseAPI {
+    v4VariablesGet(options) {
+      return VariablesApiFp(this.configuration).v4VariablesGet(options).then((request) => request(this.axios, this.basePath));
+    }
+    v4VariablesPost(requestParameters = {}, options) {
+      return VariablesApiFp(this.configuration).v4VariablesPost(requestParameters.createVariableBody, options).then((request) => request(this.axios, this.basePath));
+    }
+    v4VariablesVariableIdDelete(requestParameters, options) {
+      return VariablesApiFp(this.configuration).v4VariablesVariableIdDelete(requestParameters.variableId, options).then((request) => request(this.axios, this.basePath));
+    }
+    v4VariablesVariableIdGet(requestParameters, options) {
+      return VariablesApiFp(this.configuration).v4VariablesVariableIdGet(requestParameters.variableId, options).then((request) => request(this.axios, this.basePath));
+    }
+    v4VariablesVariableIdPatch(requestParameters, options) {
+      return VariablesApiFp(this.configuration).v4VariablesVariableIdPatch(requestParameters.variableId, requestParameters.updateVariableBody, options).then((request) => request(this.axios, this.basePath));
+    }
+  };
   WorkflowsApi = class extends BaseAPI {
     v4ChangesChangeIdGet(requestParameters, options) {
       return WorkflowsApiFp(this.configuration).v4ChangesChangeIdGet(requestParameters.changeId, requestParameters.xApiKey, requestParameters.authorization, options).then((request) => request(this.axios, this.basePath));
@@ -48972,7 +49198,10 @@ var init_dist2 = __esm(() => {
     SCHEMAS_FETCH_ERROR: "Failed to fetch schemas",
     SCHEMA_CREATE_FAILED: "Failed to create schema",
     SCHEMA_UPDATE_FAILED: "Failed to update schema",
-    SCHEMA_DELETE_FAILED: "Failed to delete schema"
+    SCHEMA_DELETE_FAILED: "Failed to delete schema",
+    VARIABLE_NOT_FOUND: "Variable not found",
+    VARIABLE_CREATE_FAILED: "Failed to create variable",
+    VARIABLE_UPDATE_FAILED: "Failed to update variable"
   };
   KadoaSdkException = _KadoaSdkException;
   ERROR_MESSAGES = KadoaSdkException.ERROR_MESSAGES;
@@ -49079,7 +49308,8 @@ var init_dist2 = __esm(() => {
     crawl: createLogger("crawl"),
     notifications: createLogger("notifications"),
     schemas: createLogger("schemas"),
-    validation: createLogger("validation")
+    validation: createLogger("validation"),
+    variables: createLogger("variables")
   };
   _SchemaBuilder.FIELD_NAME_PATTERN = /^[A-Za-z0-9]+$/;
   _SchemaBuilder.TYPES_REQUIRING_EXAMPLE = [
@@ -49132,6 +49362,7 @@ var init_dist2 = __esm(() => {
     ABORTED: "ABORTED",
     TIMEOUT: "TIMEOUT"
   };
+  debug6 = logger.variables;
   JobStateEnum = {
     Finished: "FINISHED",
     Failed: "FAILED",
@@ -49152,7 +49383,7 @@ var init_dist2 = __esm(() => {
     "STOPPED",
     "CANCELLED"
   ]);
-  debug6 = logger.workflow;
+  debug7 = logger.workflow;
 });
 
 // src/client.ts
@@ -50208,6 +50439,112 @@ function registerTools(server, ctx) {
       message: `Switched to team "${match.name}". All subsequent API calls will use this team.`
     });
   }));
+  server.registerTool("create_variable", {
+    description: "Create a new variable. Variables are key-value pairs that can be referenced in workflow prompts using @variableKey syntax. Keys must be unique within the team scope.",
+    inputSchema: strictSchema({
+      key: exports_external.string().describe("Variable key (must be unique within scope). Referenced in prompts as @key."),
+      value: exports_external.string().describe("Variable value"),
+      dataType: exports_external.enum(["STRING", "NUMBER", "BOOLEAN", "JSON"]).optional().describe("Data type of the value (defaults to STRING)")
+    }),
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false
+    }
+  }, withErrorHandling("create_variable", async (args) => {
+    const variable = await ctx.client.variable.create({
+      key: args.key,
+      value: args.value,
+      ...args.dataType != null && { dataType: args.dataType }
+    });
+    return jsonResult({
+      success: true,
+      variable,
+      message: `Variable "${variable.key}" created. Use @${variable.key} in workflow prompts to reference it.`
+    });
+  }));
+  server.registerTool("list_variables", {
+    description: "List all variables in the current team scope. Variables are key-value pairs that can be referenced in workflow prompts using @variableKey syntax.",
+    inputSchema: strictSchema({}),
+    annotations: {
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true
+    }
+  }, withErrorHandling("list_variables", async () => {
+    const variables = await ctx.client.variable.list();
+    return jsonResult({
+      variables,
+      count: variables.length
+    });
+  }));
+  server.registerTool("get_variable", {
+    description: "Get a specific variable by its ID.",
+    inputSchema: strictSchema({
+      variableId: exports_external.string().describe("The variable ID")
+    }),
+    annotations: {
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true
+    }
+  }, withErrorHandling("get_variable", async (args) => {
+    const variable = await ctx.client.variable.get(args.variableId);
+    return jsonResult({ variable });
+  }));
+  server.registerTool("update_variable", {
+    description: "Update an existing variable. At least one field must be provided. If the variable key is referenced in workflow prompts (@variableKey), those workflows will automatically use the new value on next run.",
+    inputSchema: strictSchema({
+      variableId: exports_external.string().describe("The variable ID to update"),
+      key: exports_external.string().optional().describe("New variable key"),
+      value: exports_external.string().optional().describe("New variable value"),
+      dataType: exports_external.enum(["STRING", "NUMBER", "BOOLEAN", "JSON"]).optional().describe("New data type")
+    }),
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true
+    }
+  }, withErrorHandling("update_variable", async (args) => {
+    const { variableId, ...updates } = args;
+    const variable = await ctx.client.variable.update(variableId, updates);
+    return jsonResult({
+      success: true,
+      variable,
+      message: "Variable updated."
+    });
+  }));
+  server.registerTool("delete_variable", {
+    description: "Delete a variable permanently. This is irreversible. " + "You MUST first call this tool without confirmed=true to preview what will be deleted, " + "then show the user the variable key and ask for confirmation, " + "then call again with confirmed=true only after the user explicitly agrees.",
+    inputSchema: strictSchema({
+      variableId: exports_external.string().describe("The variable ID to delete"),
+      confirmed: exports_external.preprocess(coerceBoolean(), exports_external.boolean()).optional().describe("Set to true only after the user has explicitly confirmed deletion. Omit or set to false for the initial preview call.")
+    }),
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: true
+    }
+  }, withErrorHandling("delete_variable", async (args) => {
+    let variableKey = args.variableId;
+    try {
+      const variable = await ctx.client.variable.get(args.variableId);
+      variableKey = variable.key || args.variableId;
+    } catch {}
+    if (!args.confirmed) {
+      return jsonResult({
+        pending: true,
+        variableId: args.variableId,
+        variableKey,
+        message: `⚠️ You are about to permanently delete variable "${variableKey}". This cannot be undone. Ask the user to confirm, then call delete_variable again with confirmed=true.`
+      });
+    }
+    await ctx.client.variable.delete(args.variableId);
+    return jsonResult({
+      success: true,
+      message: `Variable "${variableKey}" (${args.variableId}) deleted.`
+    });
+  }));
 }
 var SchemaFieldShape, DASHBOARD_BASE_URL = "https://www.kadoa.com";
 var init_tools = __esm(() => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kadoa/mcp",
-  "version": "0.3.10-rc.3",
+  "version": "0.3.11-rc.1",
   "description": "Kadoa MCP Server — manage workflows from Claude Desktop, Cursor, and other MCP clients",
   "type": "module",
   "main": "dist/index.js",
@@ -24,7 +24,7 @@
     "prepublishOnly": "bun run check-types && bun run test:unit && bun run build"
   },
   "dependencies": {
-    "@kadoa/node-sdk": "^0.23.0",
+    "@kadoa/node-sdk": "^0.25.0",
     "@modelcontextprotocol/sdk": "^1.26.0",
     "express": "^5.2.1",
     "ioredis": "^5.6.1",