@kadoa/mcp 0.5.16 → 0.5.18

package/README.md

@@ -64,7 +64,14 @@ Point your client to `https://mcp.kadoa.com/mcp` with OAuth authentication.
 | `scrape` | Immediately fetch one URL as markdown or raw HTML (shown only for enabled workspaces) |
 | `create_workflow` | Create an agentic navigation workflow from a prompt |
 | `list_workflows` | List all workflows with status |
-| `get_workflow` | Get detailed workflow information |
+| `get_workflow` | Get canonical intent, Assistant/session, template ownership, run health, schedule, location, monitoring, and validation details |
+| `request_workflow_update` | Ask the workflow Assistant to change extraction intent, navigation, sourcing, pagination, or generated behavior without changing the workflow ID |
+| `get_workflow_assistant` | Get the workflow Assistant's current activity and any pending clarification question |
+| `answer_workflow_assistant_question` | Answer the workflow Assistant's current clarification question and resume it |
+| `interrupt_workflow_assistant` | Safely interrupt active Assistant work without pausing the workflow schedule |
+| `resume_workflow_assistant` | Resume an idle/interrupted Lighthouse or Julie session with its persisted persona |
+| `stop_workflow_assistant` | Stop active Assistant work without deleting or replacing the workflow |
+| `get_workflow_strategy` | Get the current customer-safe extraction/build strategy for an Assistant or custom-script workflow |
 | `get_workflow_history` | Get the workflow's configuration revision history (audit log) — who changed it, when, from which channel, and a `changedFields` summary per revision |
 | `list_workflow_runs` | List a workflow's execution run history (status, start/finish, record count, errors); filter by outcome and paginate |
 | `run_workflow` | Execute a workflow |
@@ -72,7 +79,7 @@ Point your client to `https://mcp.kadoa.com/mcp` with OAuth authentication.
 | `delete_workflow` | Delete a workflow |
 | `approve_workflow` | Approve and activate a workflow |
 | `pause_workflow` | Pause an active workflow |
-| `update_workflow` | Update workflow configuration and schema |
+| `update_workflow` | Update deterministic configuration, including location, schedule timezone, monitoring conditions, and unlimited rows |
 | `whoami` | Show current user details, auth method, and team memberships |
 | `team_list` | List all teams you belong to and see which is active |
 | `team_switch` | Switch the active team by name or ID |
@@ -144,6 +151,50 @@ Claude calls run_workflow and waits for completion, then fetches
 the latest data with fetch_data so you can verify the changes.
 ```
 
+### Update deterministic workflow settings
+
+```
+> You: Run wf_abc123 from the US at 8 AM New York time on weekdays,
+       alert when price changes above 100, and remove its row limit.
+
+Claude calls get_workflow first because monitoring is a replacement setting,
+then calls update_workflow with a manual US location, a weekday cron schedule
+in `America/New_York`, monitoring fields/conditions, and `limit: null` for all
+rows.
+```
+
+### Update an Assistant-built workflow without replacing it
+
+```
+> You: Update workflow wf_abc123 to follow pagination and extract the detail-page URL.
+
+Claude calls request_workflow_update. Kadoa keeps wf_abc123 and returns the
+Assistant session, thread, and job identifiers.
+
+> You: Does Kadoa need anything from me?
+
+Claude calls get_workflow_assistant. If a clarification is pending, Claude
+shows the question and calls answer_workflow_assistant_question with your
+answer. It does not poll or sleep-wait for the Assistant.
+
+> You: How does this workflow extract the data now?
+
+Claude calls get_workflow_strategy and shows the customer-safe sourcing,
+navigation, and extraction approach.
+
+> You: Interrupt the Assistant for now, then resume it later.
+
+Claude calls interrupt_workflow_assistant. When asked later, it calls
+resume_workflow_assistant, which preserves whether the session is Lighthouse
+or Julie. stop_workflow_assistant cancels active Assistant work without
+pausing or deleting the workflow itself.
+```
+
+Use `update_workflow` for deterministic metadata such as name, schedule, tags,
+and limits. Use template version/apply tools for template-controlled parts.
+Never delete and recreate a workflow to work around an Assistant update—the
+workflow ID is part of downstream integrations and history.
+
 ### Monitor and clean up
 
 ```

package/dist/index.js

@@ -45666,6 +45666,7 @@ function createAxiosInstance(params) {
 }
 function createClientDomains(params) {
   const { client } = params;
+  const assistantService = new AssistantService(client.apis.agent);
   const changesService = new ChangesService(client);
   const userService = new UserService(client);
   const dataFetcherService = new DataFetcherService(client.apis.workflows);
@@ -45690,6 +45691,7 @@ function createClientDomains(params) {
   const validation = createValidationDomain(coreService, rulesService);
   const crawler = createCrawlerDomain(client);
   return {
+    assistant: assistantService,
     changes: changesService,
     extractionBuilderService,
     extraction: extractionService,
@@ -45741,7 +45743,59 @@ function createNotificationDomain(params) {
     }
   };
 }
-var import_debug, __require2, ChangeDifferenceType, KadoaErrorCode, _KadoaSdkException, KadoaSdkException, ERROR_MESSAGES, KadoaHttpException, createLogger = (namespace) => import_debug.default(`kadoa:${namespace}`), logger, debug, ChangesService = class {
+var import_debug, __require2, FREEFORM_ASSISTANT_ANSWER_KEY = "_freeform", KadoaErrorCode, _KadoaSdkException, KadoaSdkException, ERROR_MESSAGES, KadoaHttpException, AssistantService = class {
+  constructor(agentApi) {
+    this.agentApi = agentApi;
+  }
+  async requestWorkflowUpdate(workflowId, input) {
+    const response = await this.agentApi.v5AgentWorkflowAssistantMessage({
+      workflowId,
+      workflowAssistantMessageRequest: {
+        prompt: input.instructions,
+        ...input.threadId != null && { threadId: input.threadId }
+      }
+    });
+    const data = response.data?.data;
+    if (!data?.workflowId || !data.sessionId || !data.threadId) {
+      throw new KadoaSdkException("Workflow Assistant update response is missing required identifiers", {
+        code: "INTERNAL_ERROR",
+        details: { workflowId, response: response.data }
+      });
+    }
+    return data;
+  }
+  async getPauseState(sessionId) {
+    const response = await this.agentApi.v5AgentPauseState({ sessionId });
+    return response.data.data;
+  }
+  async answerQuestion(input) {
+    const response = await this.agentApi.v5AgentAnswer({
+      assistantAnswerRequest: {
+        sessionId: input.sessionId,
+        questionId: input.questionId,
+        answers: input.answers,
+        ...input.threadId != null && { threadId: input.threadId }
+      }
+    });
+    return response.data.data;
+  }
+  async getStrategy(sessionId) {
+    const response = await this.agentApi.v5AgentStrategy({ sessionId });
+    return response.data.data.strategy;
+  }
+  async interrupt(sessionId) {
+    const response = await this.agentApi.v5AgentInterrupt({ sessionId });
+    return response.data.data;
+  }
+  async resume(sessionId) {
+    const response = await this.agentApi.v5AgentResume({ sessionId });
+    return response.data.data;
+  }
+  async stop(sessionId) {
+    const response = await this.agentApi.v5AgentStop({ sessionId });
+    return response.data.data;
+  }
+}, ChangeDifferenceType, createLogger = (namespace) => import_debug.default(`kadoa:${namespace}`), logger, debug, ChangesService = class {
   constructor(client) {
     this.client = client;
   }
@@ -45804,12 +45858,206 @@ var import_debug, __require2, ChangeDifferenceType, KadoaErrorCode, _KadoaSdkExc
   return needsSerialization ? JSON.stringify(value !== undefined ? value : {}, replaceWithSerializableTypeIfNeeded) : value || "";
 }, toPathString = function(url3) {
   return url3.pathname + url3.search + url3.hash;
-}, createRequestFunction = function(axiosArgs, globalAxios11, BASE_PATH2, configuration) {
-  return (axios2 = globalAxios11, basePath = BASE_PATH2) => {
+}, createRequestFunction = function(axiosArgs, globalAxios12, BASE_PATH2, configuration) {
+  return (axios2 = globalAxios12, basePath = BASE_PATH2) => {
     const axiosRequestArgs = { ...axiosArgs.options, url: (axios2.defaults.baseURL ? "" : configuration?.basePath ?? basePath) + axiosArgs.url };
     return axios2.request(axiosRequestArgs);
   };
-}, CrawlerApiAxiosParamCreator = function(configuration) {
+}, AgentApiAxiosParamCreator = function(configuration) {
+  return {
+    v5AgentAnswer: async (assistantAnswerRequest, options = {}) => {
+      assertParamExists("v5AgentAnswer", "assistantAnswerRequest", assistantAnswerRequest);
+      const localVarPath = `/v5/agent/answer`;
+      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 = {};
+      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(assistantAnswerRequest, localVarRequestOptions, configuration);
+      return {
+        url: toPathString(localVarUrlObj),
+        options: localVarRequestOptions
+      };
+    },
+    v5AgentInterrupt: async (sessionId, options = {}) => {
+      assertParamExists("v5AgentInterrupt", "sessionId", sessionId);
+      const localVarPath = `/v5/agent/{sessionId}/interrupt`.replace(`{${"sessionId"}}`, encodeURIComponent(String(sessionId)));
+      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 = {};
+      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
+      };
+    },
+    v5AgentPauseState: async (sessionId, options = {}) => {
+      assertParamExists("v5AgentPauseState", "sessionId", sessionId);
+      const localVarPath = `/v5/agent/{sessionId}/pause-state`.replace(`{${"sessionId"}}`, encodeURIComponent(String(sessionId)));
+      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 = {};
+      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
+      };
+    },
+    v5AgentResume: async (sessionId, options = {}) => {
+      assertParamExists("v5AgentResume", "sessionId", sessionId);
+      const localVarPath = `/v5/agent/{sessionId}/resume`.replace(`{${"sessionId"}}`, encodeURIComponent(String(sessionId)));
+      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 = {};
+      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
+      };
+    },
+    v5AgentStop: async (sessionId, options = {}) => {
+      assertParamExists("v5AgentStop", "sessionId", sessionId);
+      const localVarPath = `/v5/agent/{sessionId}/stop`.replace(`{${"sessionId"}}`, encodeURIComponent(String(sessionId)));
+      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 = {};
+      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
+      };
+    },
+    v5AgentStrategy: async (sessionId, options = {}) => {
+      assertParamExists("v5AgentStrategy", "sessionId", sessionId);
+      const localVarPath = `/v5/agent/data/{sessionId}/strategy`.replace(`{${"sessionId"}}`, encodeURIComponent(String(sessionId)));
+      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 = {};
+      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
+      };
+    },
+    v5AgentWorkflowAssistantMessage: async (workflowId, workflowAssistantMessageRequest, options = {}) => {
+      assertParamExists("v5AgentWorkflowAssistantMessage", "workflowId", workflowId);
+      assertParamExists("v5AgentWorkflowAssistantMessage", "workflowAssistantMessageRequest", workflowAssistantMessageRequest);
+      const localVarPath = `/v5/agent/workflows/{workflowId}/assistant/messages`.replace(`{${"workflowId"}}`, encodeURIComponent(String(workflowId)));
+      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 = {};
+      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(workflowAssistantMessageRequest, localVarRequestOptions, configuration);
+      return {
+        url: toPathString(localVarUrlObj),
+        options: localVarRequestOptions
+      };
+    }
+  };
+}, AgentApiFp = function(configuration) {
+  const localVarAxiosParamCreator = AgentApiAxiosParamCreator(configuration);
+  return {
+    async v5AgentAnswer(assistantAnswerRequest, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.v5AgentAnswer(assistantAnswerRequest, options);
+      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+      const localVarOperationServerBasePath = operationServerMap["AgentApi.v5AgentAnswer"]?.[localVarOperationServerIndex]?.url;
+      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, axios_default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
+    },
+    async v5AgentInterrupt(sessionId, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.v5AgentInterrupt(sessionId, options);
+      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+      const localVarOperationServerBasePath = operationServerMap["AgentApi.v5AgentInterrupt"]?.[localVarOperationServerIndex]?.url;
+      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, axios_default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
+    },
+    async v5AgentPauseState(sessionId, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.v5AgentPauseState(sessionId, options);
+      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+      const localVarOperationServerBasePath = operationServerMap["AgentApi.v5AgentPauseState"]?.[localVarOperationServerIndex]?.url;
+      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, axios_default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
+    },
+    async v5AgentResume(sessionId, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.v5AgentResume(sessionId, options);
+      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+      const localVarOperationServerBasePath = operationServerMap["AgentApi.v5AgentResume"]?.[localVarOperationServerIndex]?.url;
+      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, axios_default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
+    },
+    async v5AgentStop(sessionId, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.v5AgentStop(sessionId, options);
+      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+      const localVarOperationServerBasePath = operationServerMap["AgentApi.v5AgentStop"]?.[localVarOperationServerIndex]?.url;
+      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, axios_default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
+    },
+    async v5AgentStrategy(sessionId, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.v5AgentStrategy(sessionId, options);
+      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+      const localVarOperationServerBasePath = operationServerMap["AgentApi.v5AgentStrategy"]?.[localVarOperationServerIndex]?.url;
+      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, axios_default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
+    },
+    async v5AgentWorkflowAssistantMessage(workflowId, workflowAssistantMessageRequest, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.v5AgentWorkflowAssistantMessage(workflowId, workflowAssistantMessageRequest, options);
+      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+      const localVarOperationServerBasePath = operationServerMap["AgentApi.v5AgentWorkflowAssistantMessage"]?.[localVarOperationServerIndex]?.url;
+      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, axios_default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
+    }
+  };
+}, AgentApi, CrawlerApiAxiosParamCreator = function(configuration) {
   return {
     v4CrawlBucketDataFilenameb64Get: async (filenameb64, contentType, cacheControl, options = {}) => {
       assertParamExists("v4CrawlBucketDataFilenameb64Get", "filenameb64", filenameb64);
@@ -50028,7 +50276,7 @@ var import_debug, __require2, ChangeDifferenceType, KadoaErrorCode, _KadoaSdkExc
     }));
     return channels;
   }
-}, PUBLIC_API_URI, WSS_API_URI, REALTIME_API_URI, SDK_VERSION = "0.36.0", SDK_NAME = "kadoa-node-sdk", SDK_LANGUAGE = "node", debug6, 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.37.1", SDK_NAME = "kadoa-node-sdk", SDK_LANGUAGE = "node", debug6, 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();
@@ -51061,6 +51309,9 @@ var import_debug, __require2, ChangeDifferenceType, KadoaErrorCode, _KadoaSdkExc
     }
     return this.cache.get(ApiClass);
   }
+  get agent() {
+    return this.get(AgentApi);
+  }
   get schemas() {
     return this.get(SchemasApi);
   }
@@ -51113,6 +51364,7 @@ var import_debug, __require2, ChangeDifferenceType, KadoaErrorCode, _KadoaSdkExc
     });
     this.apis = new ApiRegistry(this._apiKey, this._baseUrl, this._axiosInstance, headers);
     const domains = createClientDomains({ client: this });
+    this.assistant = domains.assistant;
     this.changes = domains.changes;
     this.user = domains.user;
     this.extraction = domains.extraction;
@@ -51206,11 +51458,6 @@ var init_dist2 = __esm(() => {
       return __require.apply(this, arguments);
     throw Error('Dynamic require of "' + x + '" is not supported');
   });
-  ChangeDifferenceType = {
-    Added: "added",
-    Removed: "removed",
-    Changed: "changed"
-  };
   KadoaErrorCode = {
     VALIDATION_ERROR: "VALIDATION_ERROR",
     BAD_REQUEST: "BAD_REQUEST",
@@ -51407,6 +51654,11 @@ var init_dist2 = __esm(() => {
       return "UNKNOWN";
     }
   };
+  ChangeDifferenceType = {
+    Added: "added",
+    Removed: "removed",
+    Changed: "changed"
+  };
   logger = {
     changes: createLogger("changes"),
     client: createLogger("client"),
@@ -51431,6 +51683,29 @@ var init_dist2 = __esm(() => {
     }
   };
   operationServerMap = {};
+  AgentApi = class extends BaseAPI {
+    v5AgentAnswer(requestParameters, options) {
+      return AgentApiFp(this.configuration).v5AgentAnswer(requestParameters.assistantAnswerRequest, options).then((request) => request(this.axios, this.basePath));
+    }
+    v5AgentInterrupt(requestParameters, options) {
+      return AgentApiFp(this.configuration).v5AgentInterrupt(requestParameters.sessionId, options).then((request) => request(this.axios, this.basePath));
+    }
+    v5AgentPauseState(requestParameters, options) {
+      return AgentApiFp(this.configuration).v5AgentPauseState(requestParameters.sessionId, options).then((request) => request(this.axios, this.basePath));
+    }
+    v5AgentResume(requestParameters, options) {
+      return AgentApiFp(this.configuration).v5AgentResume(requestParameters.sessionId, options).then((request) => request(this.axios, this.basePath));
+    }
+    v5AgentStop(requestParameters, options) {
+      return AgentApiFp(this.configuration).v5AgentStop(requestParameters.sessionId, options).then((request) => request(this.axios, this.basePath));
+    }
+    v5AgentStrategy(requestParameters, options) {
+      return AgentApiFp(this.configuration).v5AgentStrategy(requestParameters.sessionId, options).then((request) => request(this.axios, this.basePath));
+    }
+    v5AgentWorkflowAssistantMessage(requestParameters, options) {
+      return AgentApiFp(this.configuration).v5AgentWorkflowAssistantMessage(requestParameters.workflowId, requestParameters.workflowAssistantMessageRequest, options).then((request) => request(this.axios, this.basePath));
+    }
+  };
   CrawlerApi = class extends BaseAPI {
     v4CrawlBucketDataFilenameb64Get(requestParameters, options) {
       return CrawlerApiFp(this.configuration).v4CrawlBucketDataFilenameb64Get(requestParameters.filenameb64, requestParameters.contentType, requestParameters.cacheControl, options).then((request) => request(this.axios, this.basePath));
@@ -52175,6 +52450,67 @@ function mapRunStatus(state) {
       return state ?? "unknown";
   }
 }
+function isAssistantSessionResumable(status) {
+  return status != null && RESUMABLE_ASSISTANT_STATUSES.has(status);
+}
+function deriveAssistantActivity(input) {
+  const { pauseState } = input;
+  if (pauseState?.pendingQuestion && pauseState.pause?.status === "active")
+    return "waiting_for_input";
+  if (pauseState?.pause?.status === "resuming")
+    return "working";
+  if (pauseState?.pause?.reason === "interrupt" && pauseState.pause.status === "active")
+    return "interrupted";
+  if (!input.hasSession)
+    return input.assistantEligible ? "not_started" : "unsupported";
+  switch (input.sessionStatus) {
+    case "pending":
+    case "created":
+    case "active":
+      return "working";
+    case "idle":
+    case "inactive":
+      return "idle";
+    case "interrupted":
+      return "interrupted";
+    case "failed":
+    case "errored":
+      return "failed";
+    case "aborted":
+    case "timed_out":
+      return "closed";
+    default:
+      return "unknown";
+  }
+}
+function assistantControlTransitionError(input) {
+  const { action, sessionStatus, pauseState } = input;
+  const pause = pauseState.pause;
+  if (CLOSED_ASSISTANT_STATUSES.has(sessionStatus ?? "")) {
+    const verb = action === "resume" ? "resumed" : action === "interrupt" ? "interrupted" : "stopped";
+    return `The Assistant session is closed (${sessionStatus}) and cannot be ${verb}. Request a new workflow update to start a resumable session.`;
+  }
+  if (action === "resume") {
+    if (pause?.status === "resuming")
+      return "The Assistant session is already resuming.";
+    if (pause?.status === "active" && pause.reason === "question") {
+      return "The Assistant is waiting for a clarification answer. Use answer_workflow_assistant_question instead of resume.";
+    }
+    if (pause?.status === "active" && pause.reason === "interrupt")
+      return null;
+    if (IDLE_ASSISTANT_STATUSES.has(sessionStatus ?? ""))
+      return null;
+    return `The Assistant cannot be resumed while its session status is '${sessionStatus ?? "unknown"}'.`;
+  }
+  if (pause?.status === "active") {
+    if (action === "stop")
+      return null;
+    return pause.reason === "question" ? "The Assistant is already paused for a clarification question. Answer it or stop the session." : "The Assistant session is already interrupted.";
+  }
+  if (pause?.status === "resuming" || ACTIVE_ASSISTANT_STATUSES.has(sessionStatus ?? ""))
+    return null;
+  return `The Assistant cannot be ${action}ed while its session status is '${sessionStatus ?? "unknown"}'.`;
+}
 function workflowDashboardUrl(workflowId) {
   return `${DASHBOARD_BASE_URL}/workflow/${workflowId}`;
 }
@@ -52435,7 +52771,10 @@ function registerTools(server, ctx, capabilities) {
     return (builder) => {
       const entity = builder.entity(args.entity || "Data");
       for (const field of args.schema) {
-        entity.field(field.name, field.description || field.name, field.dataType || "STRING", { example: field.example });
+        entity.field(field.name, field.description || field.name, field.dataType || "STRING", {
+          example: field.example,
+          isKey: field.isKey
+        });
       }
       return entity;
     };
@@ -52701,7 +53040,7 @@ function registerTools(server, ctx, capabilities) {
     });
   }));
   server.registerTool("get_workflow", {
-    description: "Get detailed information about a specific workflow",
+    description: "Get canonical workflow details, including Assistant/session linkage, extraction intent, template-controlled parts, stale-data state, job/run state, schedule timezone, location, monitoring, validation, and realtime health. For Assistant-built workflows, extractionSpec—not the legacy prompt—is authoritative.",
     inputSchema: {
       workflowId: exports_external.string().describe("The workflow ID")
     },
@@ -52709,28 +53048,317 @@ function registerTools(server, ctx, capabilities) {
   }, withErrorHandling("get_workflow", async (args) => {
     const workflow = await ctx.client.workflow.get(args.workflowId);
     const additionalData = workflow.additionalData;
+    const extractionSpec = workflow.extractionSpec ?? null;
+    const legacyPrompt = typeof additionalData?.userPrompt === "string" ? additionalData.userPrompt : null;
+    const controlledParts = [
+      workflow.templateHasPrompt && "prompt",
+      workflow.templateHasSchema && "schema",
+      workflow.templateHasSchemaValidationRules && "schemaValidationRules",
+      workflow.templateHasNotifications && "notifications",
+      workflow.templateHasFrequency && "frequency"
+    ].filter((part) => typeof part === "string");
+    const hasTemplate = workflow.templateId != null || workflow.templateVersion != null;
+    const isRealtime = workflow.isRealTime === true || isRealTimeInterval(workflow.updateInterval);
     return jsonResult({
       id: workflow.id,
       name: workflow.name,
       dashboardUrl: workflowDashboardUrl(workflow.id),
       description: workflow.description,
       status: deriveStatusLabel(workflow),
+      state: workflow.state ?? null,
+      displayState: workflow.displayState ?? null,
+      runState: workflow.runState ?? null,
       urls: workflow.urls,
-      prompt: additionalData?.userPrompt,
+      prompt: extractionSpec ? null : legacyPrompt,
+      intentSource: extractionSpec ? "extraction_spec" : legacyPrompt ? "legacy_prompt" : null,
+      extractionSpec,
       entity: workflow.entity,
       schema: workflow.schema,
       navigationMode: workflow.navigationMode,
+      dataStale: workflow.dataStale ?? false,
+      assistantEligible: workflow.assistantEligible === true,
+      assistantSessionId: workflow.assistantSessionId ?? null,
+      assistantThreadId: workflow.assistantThreadId ?? null,
+      assistantSessionStatus: workflow.sessionStatus ?? null,
+      assistant: {
+        eligible: workflow.assistantEligible === true,
+        sessionId: workflow.assistantSessionId ?? null,
+        threadId: workflow.assistantThreadId ?? null,
+        sessionStatus: workflow.sessionStatus ?? null
+      },
+      template: hasTemplate ? {
+        id: workflow.templateId ?? null,
+        name: workflow.templateName ?? null,
+        version: workflow.templateVersion ?? null,
+        controlledParts,
+        hasSchemaValidationRules: workflow.hasSchemaValidationRules ?? false
+      } : null,
       updateInterval: workflow.updateInterval,
       schedules: workflow.schedules,
+      scheduleTimezone: workflow.scheduleTimezone ?? null,
       nextInvocation: workflow.nextInvocation,
-      limit: workflow.limit,
+      location: workflow.location ?? null,
+      limit: workflow.limit ?? null,
       tags: workflow.tags,
       totalRecords: workflow.totalRecords,
+      job: workflow.jobId ? {
+        id: workflow.jobId,
+        state: workflow.runState ?? null,
+        isFirstRun: workflow.isFirstRun ?? null,
+        startedAt: workflow.startedAt ?? null,
+        finishedAt: workflow.finishedAt ?? null,
+        estimatedFinishedAtUtc: workflow.estimatedFinishedAtUtc ?? null,
+        dataQualityIssues: workflow.dataQualityIssues ?? null,
+        errors: workflow.errors ?? []
+      } : null,
       startedAt: workflow.startedAt,
       finishedAt: workflow.finishedAt,
+      estimatedFinishedAtUtc: workflow.estimatedFinishedAtUtc ?? null,
       errors: workflow.errors,
       createdAt: workflow.createdAt,
-      notificationConfig: workflow.notificationConfig
+      notificationConfig: workflow.notificationConfig,
+      channelCounts: workflow.channelCounts ?? {},
+      dataValidation: workflow.dataValidation ?? null,
+      validationStatistics: workflow.validationStatistics ?? null,
+      realtime: isRealtime ? {
+        lastDataChangedAt: workflow.lastDataChangedAt ?? null,
+        observerHealth: workflow.observerHealth ?? null
+      } : null
+    });
+  }));
+  server.registerTool("request_workflow_update", {
+    description: "Request an Assistant-driven change to an existing workflow while preserving its workflowId. " + "Use for extraction intent, navigation, pagination, data sourcing, generated-script changes, and repair after a site redesign. " + "Use update_workflow instead for deterministic metadata such as name, schedule, location, tags, and limits. " + "For template-controlled prompt or schema changes, create and apply a template version instead. " + "The update is asynchronous: do not poll or sleep-wait; use get_workflow_assistant later. Never delete and recreate the workflow as a workaround.",
+    inputSchema: strictSchema({
+      workflowId: exports_external.string().min(1).describe("The existing workflow ID; it will not change"),
+      instructions: exports_external.string().min(1).describe("Natural-language instructions for the workflow Assistant"),
+      threadId: exports_external.string().optional().describe("Optional Assistant thread ID to continue")
+    }),
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
+  }, withErrorHandling("request_workflow_update", async (args) => {
+    const result = await ctx.client.assistant.requestWorkflowUpdate(args.workflowId, {
+      instructions: args.instructions,
+      threadId: args.threadId
+    });
+    if (result.workflowId !== args.workflowId) {
+      return errorResult(`The Assistant returned a different workflow ID (${result.workflowId}) than requested (${args.workflowId}). ` + "The update was not reported as successful because workflow identity must be preserved.");
+    }
+    return jsonResult({
+      success: true,
+      status: "accepted",
+      workflowId: result.workflowId,
+      sessionId: result.sessionId,
+      threadId: result.threadId,
+      jobId: result.jobId,
+      inputEventId: result.inputEventId,
+      dashboardUrl: workflowDashboardUrl(result.workflowId),
+      message: "Workflow update accepted. Use get_workflow_assistant later to check whether the Assistant is working or needs input; do not poll or sleep-wait."
+    });
+  }));
+  server.registerTool("get_workflow_assistant", {
+    description: "Get the current Assistant lifecycle for a workflow, including whether it is working, waiting for input, idle, interrupted, or closed and any pending customer question. Works for both Shelly/Lighthouse and Julie workflows.",
+    inputSchema: strictSchema({
+      workflowId: exports_external.string().min(1).describe("The workflow ID")
+    }),
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
+  }, withErrorHandling("get_workflow_assistant", async (args) => {
+    const workflow = await ctx.client.workflow.get(args.workflowId);
+    const sessionId = workflow.assistantSessionId ?? null;
+    const assistantEligible = workflow.assistantEligible === true;
+    const pauseState = sessionId ? await ctx.client.assistant.getPauseState(sessionId) : null;
+    const activity = deriveAssistantActivity({
+      assistantEligible,
+      hasSession: sessionId != null,
+      sessionStatus: workflow.sessionStatus,
+      pauseState
+    });
+    const canAcceptUpdate = ![
+      "unsupported",
+      "waiting_for_input",
+      "failed",
+      "closed",
+      "unknown"
+    ].includes(activity);
+    return jsonResult({
+      workflowId: workflow.id ?? args.workflowId,
+      assistantEligible,
+      sessionId,
+      threadId: workflow.assistantThreadId ?? null,
+      sessionStatus: workflow.sessionStatus ?? null,
+      activity,
+      canAcceptUpdate,
+      isTerminal: activity === "failed" || activity === "closed",
+      paused: pauseState?.paused ?? false,
+      pause: pauseState?.pause ?? null,
+      pendingQuestion: pauseState?.pendingQuestion ?? null
+    });
+  }));
+  server.registerTool("answer_workflow_assistant_question", {
+    description: "Answer the workflow Assistant's currently pending clarification question and resume it. " + "Use `answer` for a freeform response, or `answers` for the structured key/value response described by get_workflow_assistant. Provide exactly one. The question ID must still be current.",
+    inputSchema: strictSchema({
+      workflowId: exports_external.string().min(1).describe("The workflow ID"),
+      questionId: exports_external.string().min(1).describe("The pending question ID returned by get_workflow_assistant"),
+      answer: exports_external.string().min(1).optional().describe("Freeform answer"),
+      answers: exports_external.preprocess(coerceJson(), exports_external.record(exports_external.string(), exports_external.string())).optional().describe("Structured answer map; keys identify questions and values contain the selected/freeform answers")
+    }),
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
+  }, withErrorHandling("answer_workflow_assistant_question", async (args) => {
+    const hasFreeform = args.answer != null;
+    const hasStructured = args.answers != null;
+    if (hasFreeform === hasStructured) {
+      return errorResult("Provide exactly one of 'answer' (freeform) or 'answers' (structured).");
+    }
+    const workflow = await ctx.client.workflow.get(args.workflowId);
+    const sessionId = workflow.assistantSessionId;
+    if (!sessionId) {
+      return errorResult("This workflow does not have an Assistant session with a pending question.");
+    }
+    const pauseState = await ctx.client.assistant.getPauseState(sessionId);
+    const pendingQuestion = pauseState.pendingQuestion;
+    if (!pendingQuestion) {
+      return errorResult("The workflow Assistant does not currently have a pending question.");
+    }
+    if (pendingQuestion.questionId !== args.questionId) {
+      return errorResult(`Question '${args.questionId}' is stale. The current pending question ID is '${pendingQuestion.questionId}'. ` + "Call get_workflow_assistant to review it before answering.");
+    }
+    const answers = hasFreeform ? { [FREEFORM_ASSISTANT_ANSWER_KEY]: args.answer } : args.answers;
+    const threadId = pendingQuestion.threadId ?? workflow.assistantThreadId ?? undefined;
+    await ctx.client.assistant.answerQuestion({
+      sessionId,
+      questionId: args.questionId,
+      threadId,
+      answers
+    });
+    return jsonResult({
+      success: true,
+      workflowId: workflow.id ?? args.workflowId,
+      sessionId,
+      threadId: threadId ?? null,
+      questionId: args.questionId,
+      message: "Answer submitted. The workflow Assistant has been asked to resume."
+    });
+  }));
+  server.registerTool("interrupt_workflow_assistant", {
+    description: "Safely interrupt the active Assistant working on a workflow. This pauses Assistant reasoning/update work; it does not pause the workflow's extraction schedule. Use pause_workflow for scheduling instead.",
+    inputSchema: strictSchema({
+      workflowId: exports_external.string().min(1).describe("Workflow whose Assistant session should be interrupted")
+    }),
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
+  }, withErrorHandling("interrupt_workflow_assistant", async (args) => {
+    const workflow = await ctx.client.workflow.get(args.workflowId);
+    const sessionId = workflow.assistantSessionId;
+    if (!sessionId)
+      return errorResult("This workflow does not have an Assistant session to interrupt.");
+    const pauseState = await ctx.client.assistant.getPauseState(sessionId);
+    const transitionError = assistantControlTransitionError({
+      action: "interrupt",
+      sessionStatus: workflow.sessionStatus,
+      pauseState
+    });
+    if (transitionError)
+      return errorResult(transitionError);
+    const result = await ctx.client.assistant.interrupt(sessionId);
+    return jsonResult({
+      success: result.success,
+      status: "accepted",
+      action: "interrupt",
+      workflowId: workflow.id ?? args.workflowId,
+      sessionId,
+      delivery: result.delivery ?? null,
+      message: "Assistant interrupt accepted. Check get_workflow_assistant later; do not poll or sleep-wait."
+    });
+  }));
+  server.registerTool("resume_workflow_assistant", {
+    description: "Resume an idle or interrupted workflow Assistant using the persona and conversation persisted on its session. Works for both Lighthouse and Julie. This does not resume a paused workflow schedule; use approve_workflow for that.",
+    inputSchema: strictSchema({
+      workflowId: exports_external.string().min(1).describe("Workflow whose Assistant session should resume")
+    }),
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
+  }, withErrorHandling("resume_workflow_assistant", async (args) => {
+    const workflow = await ctx.client.workflow.get(args.workflowId);
+    const sessionId = workflow.assistantSessionId;
+    if (!sessionId)
+      return errorResult("This workflow does not have an Assistant session to resume.");
+    const pauseState = await ctx.client.assistant.getPauseState(sessionId);
+    const transitionError = assistantControlTransitionError({
+      action: "resume",
+      sessionStatus: workflow.sessionStatus,
+      pauseState
+    });
+    if (transitionError)
+      return errorResult(transitionError);
+    const result = await ctx.client.assistant.resume(sessionId);
+    if (result.sessionId !== sessionId) {
+      return errorResult(`The resume response returned session '${result.sessionId}' instead of '${sessionId}'. The action was not reported as successful because Assistant session identity must be preserved.`);
+    }
+    return jsonResult({
+      success: true,
+      status: "accepted",
+      action: "resume",
+      workflowId: workflow.id ?? args.workflowId,
+      sessionId,
+      jobId: result.jobId,
+      message: "Assistant resume accepted. Check get_workflow_assistant later; do not poll or sleep-wait."
+    });
+  }));
+  server.registerTool("stop_workflow_assistant", {
+    description: "Stop the active Assistant update for a workflow. This cancels Assistant work but does not delete, pause, or replace the workflow and does not change workflowId. Use pause_workflow separately to stop scheduled extraction runs.",
+    inputSchema: strictSchema({
+      workflowId: exports_external.string().min(1).describe("Workflow whose active Assistant session should stop")
+    }),
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false }
+  }, withErrorHandling("stop_workflow_assistant", async (args) => {
+    const workflow = await ctx.client.workflow.get(args.workflowId);
+    const sessionId = workflow.assistantSessionId;
+    if (!sessionId)
+      return errorResult("This workflow does not have an Assistant session to stop.");
+    const pauseState = await ctx.client.assistant.getPauseState(sessionId);
+    const transitionError = assistantControlTransitionError({
+      action: "stop",
+      sessionStatus: workflow.sessionStatus,
+      pauseState
+    });
+    if (transitionError)
+      return errorResult(transitionError);
+    const result = await ctx.client.assistant.stop(sessionId);
+    return jsonResult({
+      success: result.success,
+      status: "accepted",
+      action: "stop",
+      workflowId: workflow.id ?? args.workflowId,
+      sessionId,
+      message: "Assistant stop accepted. The workflow itself was left unchanged."
+    });
+  }));
+  server.registerTool("get_workflow_strategy", {
+    description: "Get the current customer-safe extraction/build strategy for a workflow: source approach, endpoints, interaction style, selectors, and realtime interval when applicable. Returns building rather than an error when an Assistant session has no build strategy yet.",
+    inputSchema: strictSchema({
+      workflowId: exports_external.string().min(1).describe("The workflow ID")
+    }),
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
+  }, withErrorHandling("get_workflow_strategy", async (args) => {
+    const workflow = await ctx.client.workflow.get(args.workflowId);
+    const sessionId = workflow.assistantSessionId;
+    if (sessionId) {
+      const strategy2 = await ctx.client.assistant.getStrategy(sessionId);
+      const status = strategy2 ? "ready" : isAssistantSessionResumable(workflow.sessionStatus) ? "building" : "unavailable";
+      return jsonResult({
+        workflowId: workflow.id ?? args.workflowId,
+        sessionId,
+        source: "assistant_build",
+        status,
+        strategy: strategy2,
+        ...status === "building" && {
+          message: "The Assistant session exists, but its build strategy is not ready yet. Check again later; do not poll."
+        }
+      });
+    }
+    const strategy = workflow.extractionStrategySummary ?? null;
+    return jsonResult({
+      workflowId: workflow.id ?? args.workflowId,
+      sessionId: null,
+      source: strategy ? "workflow_metadata" : null,
+      status: strategy ? "ready" : "unavailable",
+      strategy
     });
   }));
   server.registerTool("get_workflow_history", {
@@ -52999,9 +53627,9 @@ function registerTools(server, ctx, capabilities) {
   server.registerTool("update_workflow", {
     description: `Update a workflow's configuration. All fields are optional — only provided fields will be updated. Use this to change the name, URLs, extraction schema, entity, prompt, schedule, or other metadata.
 
-` + `IMPORTANT: You cannot change a workflow's interval to or from REAL_TIME. Real-time workflows are architecturally different (Observer service vs Scraper) and must be created as real-time from the start using create_workflow with interval='REAL_TIME'. To switch a workflow between real-time and regular, delete it and create a new one with the correct interval.
+` + `IMPORTANT: You cannot change a workflow's interval to or from REAL_TIME. Real-time workflows are architecturally different from scheduled workflows and must be created with create_realtime_monitor from the start. Existing workflows cannot be converted between these modes in place; do not delete and recreate a workflow as an update workaround.
 
-` + "PROMPT EDITS: `userPrompt` works on most workflows and re-derives the extraction intent. Some agent-built (Shelly) scheduled workflows reject it with `SHELLY_INTENT_REQUIRES_EXTRACTION_SPEC` because their intent is owned elsewhere. " + "If that happens, tell the user to change the extraction intent in Lighthouse chat in the Kadoa dashboard. NEVER delete and recreate the workflow to work around it — that mints a new workflowId, breaking anything downstream keyed to the old one (warehouse tables, connectors) and discarding the workflow's history.",
+` + "ASSISTANT-OWNED INTENT: Use request_workflow_update—not `userPrompt`—for agent-built workflow changes to extraction intent, navigation, pagination, data sourcing, repair, or generated scripts. `userPrompt` may be rejected with `SHELLY_INTENT_REQUIRES_EXTRACTION_SPEC` because those workflows' canonical intent is owned by the Assistant. " + "Call get_workflow first. If its template.controlledParts contains the setting, create and apply a template version instead of overriding the workflow directly. NEVER delete and recreate a workflow to work around an update limitation—that changes workflowId, breaks downstream tables/connectors, and discards history.",
     inputSchema: strictSchema({
       workflowId: exports_external.string().describe("The workflow ID to update"),
       name: exports_external.string().optional().describe("New name for the workflow"),
@@ -53031,7 +53659,10 @@ function registerTools(server, ctx, capabilities) {
         "CUSTOM"
       ]).optional().describe("How often the workflow should run. CUSTOM requires schedules. Note: REAL_TIME is NOT allowed here — real-time workflows must be created via create_workflow."),
       schedules: exports_external.preprocess(coerceArray(true), exports_external.array(exports_external.string())).optional().describe("Cron expressions for CUSTOM update interval"),
-      limit: exports_external.preprocess(coerceNumber(), exports_external.number()).optional().describe("Maximum number of records to extract per run")
+      timezone: exports_external.string().min(1).optional().describe("IANA timezone for cron schedules, for example America/New_York. A timezone-only update preserves existing cron expressions."),
+      location: exports_external.preprocess(coerceJson(), LocationSchema).optional().describe("Scraping location: {type:'auto'} or {type:'manual', isoCode:'US'}"),
+      monitoring: exports_external.preprocess(coerceJson(), MonitoringSchema).optional().describe("Complete monitoring replacement: fields to monitor and optional AND/OR conditions. Call get_workflow first because this replaces the existing monitoring configuration."),
+      limit: exports_external.preprocess(coerceNumber(), exports_external.number().positive().nullable()).optional().describe("Maximum records per run. Pass null to clear the limit and extract all rows.")
     }),
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
   }, withErrorHandling("update_workflow", async (args) => {
@@ -53041,15 +53672,22 @@ function registerTools(server, ctx, capabilities) {
       const isCurrentlyRealTime = isRealTimeInterval(workflow.updateInterval);
       const isRequestingRealTime = isRealTimeInterval(updates.updateInterval);
       if (isRequestingRealTime && !isCurrentlyRealTime) {
-        return errorResult("Cannot change a regular workflow's interval to REAL_TIME. " + "Real-time workflows use a different service (Observer) and must be created as real-time from the start. " + "Delete this workflow and create a new one with interval='REAL_TIME' using create_workflow.");
+        return errorResult("Cannot change a regular workflow's interval to REAL_TIME. " + "Real-time workflows use a different service and cannot replace this workflow in place. " + "The existing workflow was left unchanged.");
       }
       if (!isRequestingRealTime && isCurrentlyRealTime) {
-        return errorResult("Cannot change a real-time workflow's interval to a scheduled interval. " + "Real-time workflows are architecturally different and cannot be converted to regular workflows. " + "Delete this workflow and create a new one with the desired interval using create_workflow.");
+        return errorResult("Cannot change a real-time workflow's interval to a scheduled interval. " + "Real-time workflows are architecturally different and cannot be converted in place. " + "The existing workflow was left unchanged.");
       }
     }
     if (updates.updateInterval === "CUSTOM" && (!updates.schedules || updates.schedules.length === 0)) {
       return errorResult("updateInterval='CUSTOM' requires at least one cron expression in the 'schedules' field (e.g. '0 8 * * 2' for Tuesdays at 8am UTC).");
     }
+    if (updates.monitoring?.conditions) {
+      const monitoredFields = new Set(updates.monitoring.fields.map((field) => field.fieldName));
+      const unknownField = updates.monitoring.conditions.conditions.find((condition) => condition.type === "SINGLE" && condition.field && !monitoredFields.has(condition.field))?.field;
+      if (unknownField) {
+        return errorResult(`Monitoring condition field '${unknownField}' is not present in monitoring.fields. Include it in the replacement monitoring configuration.`);
+      }
+    }
     const result = await ctx.client.workflow.update(workflowId, updates);
     return jsonResult({
       success: true,
@@ -53699,7 +54337,7 @@ function registerTools(server, ctx, capabilities) {
     });
   }));
 }
-var SchemaFieldShape, DASHBOARD_BASE_URL = "https://www.kadoa.com", WORKFLOW_AUDIT_WATCHED_KEYS;
+var SchemaFieldShape, LocationSchema, MonitoringValueOperators, MonitoringValuelessOperators, MonitoringConditionOperatorSchema, MonitoringConditionSchema, MonitoringSchema, RESUMABLE_ASSISTANT_STATUSES, ACTIVE_ASSISTANT_STATUSES, IDLE_ASSISTANT_STATUSES, CLOSED_ASSISTANT_STATUSES, DASHBOARD_BASE_URL = "https://www.kadoa.com", WORKFLOW_AUDIT_WATCHED_KEYS;
 var init_tools = __esm(() => {
   init_dist2();
   init_zod();
@@ -53711,6 +54349,76 @@ var init_tools = __esm(() => {
     dataType: exports_external.enum(["STRING", "NUMBER", "BOOLEAN", "DATE", "DATETIME", "MONEY", "IMAGE", "LINK", "OBJECT", "ARRAY"]).optional().describe("Data type for the field"),
     isKey: exports_external.preprocess(coerceBoolean(), exports_external.boolean()).optional().describe("Marks this field as a key field — the stable identity used to match records across runs. Change detection diffs records by their key fields, so a monitored or real-time workflow without one cannot tell an updated record from a new one. Set it on whatever uniquely identifies a row (a detail URL, an ID, a ticker).")
   };
+  LocationSchema = exports_external.object({
+    type: exports_external.enum(["auto", "manual"]),
+    isoCode: exports_external.string().trim().min(2).optional()
+  }).strict().superRefine((location, ctx) => {
+    if (location.type === "manual" && !location.isoCode) {
+      ctx.addIssue({ code: exports_external.ZodIssueCode.custom, path: ["isoCode"], message: "isoCode is required for manual location" });
+    }
+    if (location.type === "auto" && location.isoCode) {
+      ctx.addIssue({ code: exports_external.ZodIssueCode.custom, path: ["isoCode"], message: "omit isoCode for auto location" });
+    }
+  });
+  MonitoringValueOperators = [
+    "MATCHES_REGEX",
+    "EQUALS",
+    "NOT_EQUALS",
+    "CONTAINS",
+    "NOT_CONTAINS",
+    "STARTS_WITH",
+    "ENDS_WITH",
+    "GREATER_THAN",
+    "LESS_THAN",
+    "GREATER_THAN_OR_EQUAL",
+    "LESS_THAN_OR_EQUAL",
+    "IN",
+    "NOT_IN",
+    "BEFORE",
+    "AFTER",
+    "WITHIN_LAST_DAYS"
+  ];
+  MonitoringValuelessOperators = ["IS_NULL", "IS_NOT_NULL", "IS_EMPTY", "IS_NOT_EMPTY"];
+  MonitoringConditionOperatorSchema = exports_external.enum([
+    ...MonitoringValueOperators,
+    ...MonitoringValuelessOperators
+  ]);
+  MonitoringConditionSchema = exports_external.object({
+    type: exports_external.enum(["SINGLE", "ANY"]),
+    field: exports_external.string().trim().min(1).optional(),
+    operator: MonitoringConditionOperatorSchema,
+    value: exports_external.union([exports_external.string(), exports_external.number(), exports_external.boolean()]).optional()
+  }).strict().superRefine((condition, ctx) => {
+    if (condition.type === "SINGLE" && !condition.field) {
+      ctx.addIssue({ code: exports_external.ZodIssueCode.custom, path: ["field"], message: "field is required for SINGLE conditions" });
+    }
+    const needsValue = MonitoringValueOperators.includes(condition.operator);
+    if (needsValue && condition.value === undefined) {
+      ctx.addIssue({ code: exports_external.ZodIssueCode.custom, path: ["value"], message: `${condition.operator} requires a value` });
+    }
+    if (!needsValue && condition.value !== undefined) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["value"],
+        message: `${condition.operator} does not accept a value`
+      });
+    }
+  });
+  MonitoringSchema = exports_external.object({
+    fields: exports_external.preprocess(coerceArray(), exports_external.array(exports_external.object({
+      fieldName: exports_external.string().trim().min(1),
+      operator: exports_external.enum(["changed", "added", "removed"]),
+      isKeyField: exports_external.preprocess(coerceBoolean(), exports_external.boolean()).optional()
+    }).strict()).min(1)),
+    conditions: exports_external.object({
+      logicalOperator: exports_external.enum(["AND", "OR"]),
+      conditions: exports_external.preprocess(coerceArray(), exports_external.array(MonitoringConditionSchema).min(1))
+    }).strict().optional()
+  }).strict();
+  RESUMABLE_ASSISTANT_STATUSES = new Set(["pending", "created", "active", "idle", "inactive", "interrupted"]);
+  ACTIVE_ASSISTANT_STATUSES = new Set(["pending", "created", "active"]);
+  IDLE_ASSISTANT_STATUSES = new Set(["idle", "inactive", "interrupted"]);
+  CLOSED_ASSISTANT_STATUSES = new Set(["failed", "errored", "aborted", "timed_out"]);
   WORKFLOW_AUDIT_WATCHED_KEYS = [
     "name",
     "tags",
@@ -53729,7 +54437,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@kadoa/mcp",
-    version: "0.5.16",
+    version: "0.5.18",
     description: "Kadoa MCP Server — manage workflows from Claude Desktop, Cursor, and other MCP clients",
     type: "module",
     main: "dist/index.js",
@@ -53753,7 +54461,7 @@ var init_package = __esm(() => {
       prepublishOnly: "bun run check-types && bun run test:unit && bun run build"
     },
     dependencies: {
-      "@kadoa/node-sdk": "^0.36.0",
+      "@kadoa/node-sdk": "^0.37.1",
       "@modelcontextprotocol/sdk": "^1.26.0",
       express: "^5.2.1",
       "express-rate-limit": "^8.2.1",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kadoa/mcp",
-  "version": "0.5.16",
+  "version": "0.5.18",
   "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.36.0",
+    "@kadoa/node-sdk": "^0.37.1",
     "@modelcontextprotocol/sdk": "^1.26.0",
     "express": "^5.2.1",
     "express-rate-limit": "^8.2.1",