@doist/automations-mcp 1.11.0 → 1.13.0

package/dist/{chunk-66AC5E4I.js → chunk-UZ45CAIT.js}

@@ -9418,6 +9418,11 @@ var automationListResponseSchema = z11.object({
   data: z11.array(automationSchema),
   nextCursor: z11.string().nullable()
 });
+var triggerAutomationResponseSchema = z11.object({
+  automationId: z11.string(),
+  runId: z11.string(),
+  status: z11.literal("pending")
+});
 var updateAutomationSchema = z11.object({
   enabled: z11.boolean().optional(),
   manifest: manifestSchema.optional()
@@ -10204,7 +10209,8 @@ var FRONTEND_COHORT_EVENTS = [
   "template:used",
   "top-up:completed",
   "guided-creation:started",
-  "guided-creation:completed"
+  "guided-creation:completed",
+  "workspace:switched"
 ];
 var BACKEND_COHORT_EVENTS = [
   // API-process (publish lifecycle)
@@ -11202,13 +11208,19 @@ var AutomationsRequestError = class extends Error {
    * scope: a challenge can say the grant falls short without saying of what.
    */
   requiredScope;
-  constructor(message, httpStatusCode, responseData, authChallenge) {
+  /**
+   * The `X-Request-Id` the response carried, which the backend logs the request
+   * under. Undefined in a browser unless the header is exposed by CORS.
+   */
+  requestId;
+  constructor(message, httpStatusCode, responseData, authChallenge, requestId) {
     super(message);
     this.name = "AutomationsRequestError";
     this.httpStatusCode = httpStatusCode;
     this.responseData = responseData;
     this.authChallenge = authChallenge;
     this.requiredScope = parseChallengeScope(authChallenge);
+    this.requestId = requestId;
   }
   isAuthError() {
     return this.httpStatusCode === 401 || this.httpStatusCode === 403;
@@ -11279,7 +11291,7 @@ async function request(args) {
   const data = await readResponseBody(response);
   if (!response.ok) {
     const message = typeof data === "object" && data !== null && "message" in data ? String(data.message) : response.statusText || `Request failed with status ${response.status}`;
-    throw new AutomationsRequestError(message, response.status, data, response.headers.get("WWW-Authenticate") ?? void 0);
+    throw new AutomationsRequestError(message, response.status, data, response.headers.get("WWW-Authenticate") ?? void 0, response.headers.get("X-Request-Id") ?? void 0);
   }
   return data;
 }
@@ -11699,13 +11711,15 @@ var AutomationsClient = class extends BaseClient {
     });
     return createDraftResponseSchema.parse(data);
   }
+  /** Starts a run now. Undefined from an API that predates returning the run. */
   async trigger(id, options) {
     const parsedId = IdSchema.parse(id);
-    await this.request({
+    const data = await this.request({
       method: "POST",
       path: automationsEndpoints.trigger(parsedId),
       options
     });
+    return triggerAutomationResponseSchema.optional().parse(data);
   }
   async test(id, options) {
     const parsedId = IdSchema.parse(id);
@@ -12040,13 +12054,17 @@ var WorkspaceAutomationsClient = class extends BaseClient {
     });
     return automationSchema.parse(data);
   }
-  /** Runs the automation now. The run executes as its creator, not as the caller. */
+  /**
+   * Runs the automation now. The run executes as its creator, not as the caller.
+   * Undefined from an API that predates returning the run.
+   */
   async trigger(workspaceId, id, options) {
-    await this.request({
+    const data = await this.request({
       method: "POST",
       path: workspaceAutomationsEndpoints.trigger(IdSchema.parse(workspaceId), IdSchema.parse(id)),
       options
     });
+    return triggerAutomationResponseSchema.optional().parse(data);
   }
   /**
    * Deletes the automation. Workspace admins may delete another member's
@@ -13451,31 +13469,11 @@ function readManifestName(manifest) {
   return typeof name === "string" && name.trim() ? name : "(unnamed)";
 }
 
-// ../../packages/sdk/dist/esm/drafts/draft-test.js
-var DRAFT_TEST_OUTCOMES = [
-  "passed",
-  "failed",
-  "skipped",
-  "cancelled",
-  "timed_out"
-];
+// ../../packages/sdk/dist/esm/runs/poll-until-closed.js
 var DEFAULT_POLL_INTERVALS_MS = { first: 2e3, max: 1e4 };
 var STATUS_REQUEST_GRACE_MS = 1e4;
-var OPEN_RUN_STATUSES = /* @__PURE__ */ new Set([
-  "pending",
-  "running"
-]);
-async function startDraftTest(draftApi, { draftId, request: request2 }) {
-  const started = await draftApi.test(draftId, request2);
-  return {
-    draftId,
-    testRunId: started.testRunId,
-    trigger: started.trigger,
-    connectorCalls: started.connectorCalls,
-    status: started.status
-  };
-}
-async function waitForDraftTest(draftApi, { draftId, testRunId }, { timeoutMs, pollIntervalsMs, requestGraceMs, onPoll, signal }) {
+var OPEN_RUN_STATUSES = /* @__PURE__ */ new Set(["pending", "running"]);
+async function pollUntilClosed(read, { timeoutMs, pollIntervalsMs, requestGraceMs, onPoll, signal }) {
   const intervals = pollIntervalsMs ?? DEFAULT_POLL_INTERVALS_MS;
   const deadline = Date.now() + timeoutMs;
   let intervalMs = intervals.first;
@@ -13484,24 +13482,64 @@ async function waitForDraftTest(draftApi, { draftId, testRunId }, { timeoutMs, p
   let last = null;
   while (true) {
     try {
-      last = await draftApi.getTestRun(draftId, testRunId, void 0, requestSignal);
+      last = await read(requestSignal);
     } catch (error) {
       if (signal.aborted || !requestTimeout.aborted)
         throw error;
-      return toFinished(last, "timed_out");
+      return { timedOut: true, run: last };
     }
     if (!OPEN_RUN_STATUSES.has(last.status)) {
-      return toFinished(last, toOutcome(last.status));
+      return { timedOut: false, run: last };
     }
     onPoll?.(last);
     const remainingMs = deadline - Date.now();
     if (remainingMs <= 0) {
-      return toFinished(last, "timed_out");
+      return { timedOut: true, run: last };
     }
     await delay(Math.min(intervalMs, remainingMs), signal);
     intervalMs = Math.min(intervalMs * 2, intervals.max);
   }
 }
+function delay(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal.reason);
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// ../../packages/sdk/dist/esm/drafts/draft-test.js
+var DRAFT_TEST_OUTCOMES = [
+  "passed",
+  "failed",
+  "skipped",
+  "cancelled",
+  "timed_out"
+];
+async function startDraftTest(draftApi, { draftId, request: request2 }) {
+  const started = await draftApi.test(draftId, request2);
+  return {
+    draftId,
+    testRunId: started.testRunId,
+    trigger: started.trigger,
+    connectorCalls: started.connectorCalls,
+    status: started.status
+  };
+}
+async function waitForDraftTest(draftApi, { draftId, testRunId }, options) {
+  const polled = await pollUntilClosed((requestSignal) => draftApi.getTestRun(draftId, testRunId, void 0, requestSignal), options);
+  return polled.timedOut ? toFinished(polled.run, "timed_out") : toFinished(polled.run, toOutcome(polled.run.status));
+}
 function toDraftTestTriggerSelector(value) {
   if (typeof value === "number")
     return { index: value };
@@ -13528,22 +13566,65 @@ function toOutcome(status) {
       return "failed";
   }
 }
-function delay(ms, signal) {
-  return new Promise((resolve, reject) => {
-    if (signal.aborted) {
-      reject(signal.reason);
-      return;
-    }
-    const onAbort = () => {
-      clearTimeout(timer);
-      reject(signal.reason);
+
+// ../../packages/sdk/dist/esm/runs/run-api.js
+function bindRunApi(api, workspaceId, { signal } = {}) {
+  if (workspaceId === null) {
+    return {
+      workspaceId: null,
+      getAutomation: (automationId) => api.automations.get(automationId, { signal }),
+      trigger: (automationId) => api.automations.trigger(automationId, { signal }),
+      getRun: (automationId, runId, args = {}, requestSignal) => api.automationRuns.get(automationId, runId, args, {
+        signal: requestSignal ?? signal
+      })
     };
-    const timer = setTimeout(() => {
-      signal.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-    signal.addEventListener("abort", onAbort, { once: true });
-  });
+  }
+  return {
+    workspaceId,
+    getAutomation: (automationId) => api.workspaceAutomations.get(workspaceId, automationId, { signal }),
+    trigger: (automationId) => api.workspaceAutomations.trigger(workspaceId, automationId, { signal }),
+    getRun: (automationId, runId, args = {}, requestSignal) => api.workspaceAutomationRuns.get(workspaceId, automationId, runId, args, {
+      signal: requestSignal ?? signal
+    })
+  };
+}
+
+// ../../packages/sdk/dist/esm/runs/run-wait.js
+var RUN_OUTCOMES = ["completed", "failed", "skipped", "cancelled", "timed_out"];
+async function waitForRun(runApi, { automationId, runId }, options) {
+  const polled = await pollUntilClosed((requestSignal) => runApi.getRun(automationId, runId, void 0, requestSignal), options);
+  return polled.timedOut ? toFinished2(polled.run, "timed_out") : toFinished2(polled.run, toOutcome2(polled.run.status));
+}
+function toFinished2(run, outcome) {
+  const failedStep = run ? findFailedStep(run) : null;
+  return {
+    outcome,
+    status: run?.status ?? "pending",
+    failedStep,
+    error: failedStep?.error ?? (run ? getRunOutcomeReason(run) : null) ?? (run?.status === "data-expired" ? "Temporal no longer holds this run's history, so its outcome is unknown" : null),
+    result: run?.result ?? null
+  };
+}
+function findFailedStep(run) {
+  const step = run.steps.find((candidate) => candidate.status === "failed");
+  return step ? { stepId: step.stepId, description: step.description, error: step.error ?? null } : null;
+}
+function toOutcome2(status) {
+  switch (status) {
+    case "completed":
+    case "skipped":
+    case "cancelled":
+      return status;
+    default:
+      return "failed";
+  }
+}
+
+// ../../packages/sdk/dist/esm/drafts/conversation-draft.js
+async function findConversationDraftId(api, { conversationId, workspaceId, signal }) {
+  const args = { limit: MAX_PAGINATION_LIMIT };
+  const page = workspaceId === null ? await api.automationDrafts.list(args, { signal }) : await api.workspaceAutomationDrafts.list(workspaceId, args, { signal });
+  return page.data.find((draft) => draft.conversationId === conversationId)?.id ?? null;
 }
 
 // ../../packages/sdk/dist/esm/chat-turn/connection-requirements.js
@@ -13935,6 +14016,67 @@ function assertSelectionsUnambiguous(requirements, selections) {
 
 // ../../packages/sdk/dist/esm/chat-turn/transport.js
 import { DefaultChatTransport, readUIMessageStream } from "ai";
+
+// ../../packages/sdk/dist/esm/chat-turn/errors.js
+var ChatTurnError = class extends Error {
+  conversationId;
+  requestId;
+  stage;
+  /** The API's error body, when it refused the request with one. */
+  response;
+  constructor({ conversationId, requestId, stage, cause }) {
+    const response = stage === "request" ? parseChatStreamRequestError(cause) : void 0;
+    super(response?.message ?? (cause instanceof Error ? cause.message : String(cause)), {
+      cause
+    });
+    this.name = "ChatTurnError";
+    this.conversationId = conversationId;
+    this.requestId = requestId;
+    this.stage = stage;
+    this.response = response;
+  }
+  get httpStatus() {
+    return this.response?.statusCode;
+  }
+};
+function parseChatStreamRequestError(error) {
+  if (!(error instanceof Error) || !error.message.trim().startsWith("{"))
+    return void 0;
+  let body;
+  try {
+    body = JSON.parse(error.message);
+  } catch {
+    return void 0;
+  }
+  const parsed = chatStreamRequestErrorResponseSchema.safeParse(body);
+  return parsed.success ? parsed.data : void 0;
+}
+function getChatTurnBillingRefusal(error) {
+  return getChatBillingRefusal(error instanceof ChatTurnError ? error.cause : error);
+}
+function readFailedRequest(error) {
+  if (error instanceof ChatTurnError) {
+    return {
+      requestId: error.requestId,
+      ...error.httpStatus !== void 0 ? { httpStatus: error.httpStatus } : {}
+    };
+  }
+  if (error instanceof AutomationsRequestError) {
+    return {
+      ...error.requestId ? { requestId: error.requestId } : {},
+      httpStatus: error.httpStatusCode
+    };
+  }
+  return {};
+}
+function classifyChatTurnFailure(error) {
+  const { httpStatus } = readFailedRequest(error);
+  if (httpStatus !== void 0)
+    return httpStatus < 500 ? "refused" : "broken";
+  return error instanceof ChatTurnError || error instanceof AutomationsNetworkError ? "broken" : "other";
+}
+
+// ../../packages/sdk/dist/esm/chat-turn/transport.js
 var ChatTurnTransport = class {
   transport;
   constructor({ token, baseUrl, headers, fetch: fetch2 }) {
@@ -13961,39 +14103,62 @@ var ChatTurnTransport = class {
   }
   /** Streams one server turn, reporting incremental text and deduplicated tool state changes. */
   async streamTurn({ conversationId, workspaceId = null, message, signal, onText, onToolActivity }) {
-    const stream = await this.transport.sendMessages({
-      trigger: "submit-message",
-      chatId: conversationId,
-      messageId: void 0,
-      messages: [message],
-      abortSignal: signal,
-      body: { conversationId, workspaceId }
-    });
+    const requestId = globalThis.crypto.randomUUID();
+    const fail = (stage, cause) => signal?.aborted ? cause : new ChatTurnError({ conversationId, requestId, stage, cause });
+    let stream;
+    try {
+      stream = await this.transport.sendMessages({
+        trigger: "submit-message",
+        chatId: conversationId,
+        messageId: void 0,
+        messages: [message],
+        abortSignal: signal,
+        headers: { "X-Request-Id": requestId },
+        body: { conversationId, workspaceId }
+      });
+    } catch (error) {
+      throw fail("request", error);
+    }
     let finalMessage;
     let emittedText = "";
     const emittedToolStates = /* @__PURE__ */ new Set();
-    for await (const currentMessage of readUIMessageStream({
-      stream,
-      terminateOnError: true
-    })) {
-      finalMessage = currentMessage;
-      const visibleText = getVisibleText(currentMessage);
-      if (visibleText.startsWith(emittedText)) {
-        const delta = visibleText.slice(emittedText.length);
-        if (delta)
-          onText?.(delta);
-        emittedText = visibleText;
-      }
-      for (const part of currentMessage.parts) {
-        const activity = toToolActivity(part);
-        if (!activity)
-          continue;
-        const key = `${activity.toolCallId}:${activity.state}`;
-        if (emittedToolStates.has(key))
-          continue;
-        emittedToolStates.add(key);
-        onToolActivity?.(activity);
+    let callbackError;
+    const report = (callback) => {
+      try {
+        callback();
+      } catch (error) {
+        callbackError = { error };
+        throw error;
+      }
+    };
+    try {
+      for await (const currentMessage of readUIMessageStream({
+        stream,
+        terminateOnError: true
+      })) {
+        finalMessage = currentMessage;
+        const visibleText = getVisibleText(currentMessage);
+        if (visibleText.startsWith(emittedText)) {
+          const delta = visibleText.slice(emittedText.length);
+          if (delta)
+            report(() => onText?.(delta));
+          emittedText = visibleText;
+        }
+        for (const part of currentMessage.parts) {
+          const activity = toToolActivity(part);
+          if (!activity)
+            continue;
+          const key = `${activity.toolCallId}:${activity.state}`;
+          if (emittedToolStates.has(key))
+            continue;
+          emittedToolStates.add(key);
+          report(() => onToolActivity?.(activity));
+        }
       }
+    } catch (error) {
+      if (callbackError)
+        throw callbackError.error;
+      throw fail("stream", error);
     }
     if (!finalMessage) {
       throw new Error("The Automations chat returned an empty response.");
@@ -14018,7 +14183,7 @@ import { McpServer } from "@modelcontextprotocol/server";
 // package.json
 var package_default = {
   name: "@doist/automations-mcp",
-  version: "1.11.0",
+  version: "1.13.0",
   description: "MCP server and importable AI tools for Todoist Automations",
   type: "module",
   main: "./dist/index.js",
@@ -14078,7 +14243,7 @@ var package_default = {
     "@types/node": "24.19.2",
     "conventional-changelog-conventionalcommits": "9.3.1",
     esbuild: "0.28.2",
-    "gpt-tokenizer": "4.0.3",
+    "gpt-tokenizer": "4.1.0",
     "semantic-release": "25.0.9",
     tsx: "4.23.15",
     typescript: "6.0.3",
@@ -15143,6 +15308,7 @@ function startProgressTicker(reportProgress, message, intervalMs = PROGRESS_INTE
 
 // src/utils/chat-turn.ts
 var TEXT_PREVIEW_LENGTH = 120;
+var DRAFT_LOOKUP_TIMEOUT_MS = 5e3;
 async function runTurn({
   reportProgress,
   progressIntervalMs = PROGRESS_INTERVAL_MS,
@@ -15169,8 +15335,9 @@ async function runTurn({
       onToolActivity: ({ tool, state }) => reportProgress(`${tool}: ${state}`)
     });
   } catch (error) {
+    stopProgress();
     throw new Error(
-      `Conversation ${turn.conversationId}: ${describeTurnError(error, turn.signal)}`
+      `Conversation ${turn.conversationId}: ${await describeTurnError(error, turn)}`
     );
   } finally {
     stopProgress();
@@ -15185,8 +15352,8 @@ function describeConversationError(conversationId) {
     throw new Error(`Conversation ${conversationId}: ${formatToolError(error)}`);
   };
 }
-function describeTurnError(error, signal) {
-  if (signal?.aborted) {
+async function describeTurnError(error, turn) {
+  if (turn.signal?.aborted) {
     return "the turn was cancelled before it finished. Whatever the assistant had said is saved; get-conversation shows it and continue-conversation resumes.";
   }
   if (error instanceof ChatTurnInputError) {
@@ -15203,11 +15370,28 @@ function describeTurnError(error, signal) {
         return error.message;
     }
   }
-  const refusal = getChatBillingRefusal(error)?.message;
+  const refusal = getChatTurnBillingRefusal(error)?.message;
   if (refusal !== void 0) {
     return `the turn was refused. ${refusal.endsWith(".") ? refusal : `${refusal}.`} Retrying won't help until the user acts.`;
   }
-  return `the turn failed. ${formatToolError(error)} The conversation is intact; continue-conversation resumes it.`;
+  const { requestId } = readFailedRequest(error);
+  const reason = formatToolError(error).replace(/\.?$/, ".");
+  const failed = `the turn failed${requestId ? ` (request ${requestId})` : ""}. ${reason} The conversation is intact; continue-conversation resumes it.`;
+  const draftId = classifyChatTurnFailure(error) === "broken" ? await findDraft(turn) : null;
+  return draftId ? `${failed} Its draft ${draftId} is saved; get-draft shows it.` : failed;
+}
+function findDraft({
+  api,
+  conversationId,
+  workspaceId,
+  signal
+}) {
+  const deadline = AbortSignal.timeout(DRAFT_LOOKUP_TIMEOUT_MS);
+  return findConversationDraftId(api, {
+    conversationId,
+    workspaceId: workspaceId ?? null,
+    signal: signal ? AbortSignal.any([signal, deadline]) : deadline
+  }).catch(() => null);
 }
 function describeTurnResult(result) {
   const next = describeNextStep(result);
@@ -16277,6 +16461,37 @@ var startConversation = {
 
 // src/tools/test-draft.ts
 import { z as z91 } from "zod";
+
+// src/utils/run-wait.ts
+async function waitWithProgress(wait, {
+  run,
+  subject,
+  startedStatus,
+  recovery,
+  timeoutMs,
+  signal,
+  reportProgress
+}) {
+  let state = startedStatus;
+  reportProgress(`${run} started; waiting up to ${timeoutMs / 6e4} min`);
+  const stopProgress = startProgressTicker(
+    reportProgress,
+    (elapsedSeconds) => `${run}: ${state} (${elapsedSeconds}s)`
+  );
+  try {
+    return await wait((polled) => {
+      const step = polled.steps.find((candidate) => candidate.status === "running");
+      state = step ? `running ${step.stepId}` : polled.status;
+    });
+  } catch (error) {
+    const why = signal.aborted ? "the wait was cancelled." : `checking on it failed: ${formatToolError(error).replace(/\.?$/, ".")}`;
+    throw new Error(`${subject} started, but ${why} ${recovery}`);
+  } finally {
+    stopProgress();
+  }
+}
+
+// src/tools/test-draft.ts
 var DEFAULT_WAIT_MINUTES = 10;
 var parameters27 = {
   draftId: z91.string().describe("The draft to test, as listed by find-drafts or get-draft."),
@@ -16333,11 +16548,23 @@ var testDraft = {
         structuredContent: { ...base, outcome: "started", status: started.status }
       };
     }
-    const finished = await waitWithProgress(draftApi, started, {
-      timeoutMs: waitMinutes * 6e4,
-      signal,
-      reportProgress
-    });
+    const timeoutMs = waitMinutes * 6e4;
+    const finished = await waitWithProgress(
+      (onPoll) => waitForDraftTest(draftApi, started, {
+        timeoutMs,
+        signal,
+        onPoll
+      }),
+      {
+        run: `Test run ${started.testRunId}`,
+        subject: `Test run ${started.testRunId} of draft ${draftId}`,
+        startedStatus: started.status,
+        recovery: "It keeps running; get-test-run shows how it ends, so do not start another test to check on it.",
+        timeoutMs,
+        signal,
+        reportProgress
+      }
+    );
     const output = {
       ...base,
       outcome: finished.outcome,
@@ -16358,36 +16585,6 @@ var testDraft = {
     };
   }
 };
-async function waitWithProgress(draftApi, started, {
-  timeoutMs,
-  signal,
-  reportProgress
-}) {
-  const run = `Test run ${started.testRunId}`;
-  let state = started.status;
-  reportProgress(`${run} started; waiting up to ${timeoutMs / 6e4} min`);
-  const stopProgress = startProgressTicker(
-    reportProgress,
-    (elapsedSeconds) => `${run}: ${state} (${elapsedSeconds}s)`
-  );
-  try {
-    return await waitForDraftTest(draftApi, started, {
-      timeoutMs,
-      signal,
-      onPoll: (polled) => {
-        const step = polled.steps.find((candidate) => candidate.status === "running");
-        state = step ? `running ${step.stepId}` : polled.status;
-      }
-    });
-  } catch (error) {
-    const why = signal.aborted ? "the wait was cancelled." : `checking on it failed: ${formatToolError(error).replace(/\.?$/, ".")}`;
-    throw new Error(
-      `${run} of draft ${started.draftId} started, but ${why} It keeps running; get-test-run shows how it ends, so do not start another test to check on it.`
-    );
-  } finally {
-    stopProgress();
-  }
-}
 function describeFinished(output, waitMinutes) {
   const run = `Test run ${output.testRunId} of draft ${output.draftId}`;
   const otherTriggers = output.trigger.count > 1 ? ` It tested trigger ${output.trigger.index} of ${output.trigger.count}; pass trigger to test another.` : "";
@@ -16410,24 +16607,35 @@ function describeFinished(output, waitMinutes) {
 
 // src/tools/trigger-automation.ts
 import { z as z92 } from "zod";
+var DEFAULT_WAIT_MINUTES2 = 10;
 var parameters28 = {
   automationId: z92.string().describe("The id of the automation, as returned by find-automations."),
+  waitMinutes: z92.number().int().min(0).max(30).optional().describe(
+    `How long to wait for the run to end; 0 returns once it starts. Default ${DEFAULT_WAIT_MINUTES2}.`
+  ),
   workspaceId: workspaceIdParameter
 };
 var outputSchema26 = {
   automationId: z92.string(),
   name: z92.string(),
-  accepted: z92.literal(true).describe("The backend accepted the run. It has not finished.")
+  runId: z92.string().optional().describe("get-run reads the run with it."),
+  outcome: z92.enum(["started", ...RUN_OUTCOMES]).describe(
+    "started: not waited for. timed_out: still going when the wait ended; it keeps running."
+  ),
+  status: runDetailSchema.shape.status.optional(),
+  failedStep: draftTestRunSchema.shape.failedStep,
+  error: z92.string().optional().describe("The failed step's error, else why the run failed or was skipped."),
+  result: runDetailSchema.shape.result
 };
 var triggerAutomation = {
   name: ToolNames.TRIGGER_AUTOMATION,
-  description: "Starts a run of a schedule-triggered automation now, without waiting for its next scheduled time, and returns as soon as the backend accepts it. The run happens in the background; find-runs shows the outcome. Runs even when the automation is disabled. Cannot start automations that run on events or API calls. Confirm intent with the user first.",
+  description: "Starts a run of a schedule-triggered automation now, without waiting for its next scheduled time, and waits for it to end, reporting progress meanwhile. Runs even when the automation is disabled. Cannot start automations that run on events or API calls. Confirm intent with the user first.",
   parameters: parameters28,
   outputSchema: outputSchema26,
   annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false },
-  async execute({ automationId, workspaceId }, { api, signal }) {
-    const options = { signal };
-    const dto = workspaceId === void 0 ? await api.automations.get(automationId, options) : await api.workspaceAutomations.get(workspaceId, automationId, options);
+  async execute({ automationId, waitMinutes = DEFAULT_WAIT_MINUTES2, workspaceId }, { api, signal, reportProgress }) {
+    const runApi = bindRunApi(api, workspaceId ?? null, { signal });
+    const dto = await runApi.getAutomation(automationId);
     const name = readManifestMetadata(dto)?.name ?? "(unnamed)";
     const triggerType = readPrimaryTriggerType(dto);
     if (triggerType !== "schedule") {
@@ -16435,17 +16643,71 @@ var triggerAutomation = {
         `"${name}" runs on ${triggerType ?? "no"} triggers and cannot be started by hand: a webhook automation runs when its event arrives, and an api automation needs an input payload this tool cannot supply.`
       );
     }
-    if (workspaceId === void 0) {
-      await api.automations.trigger(automationId, options);
-    } else {
-      await api.workspaceAutomations.trigger(workspaceId, automationId, options);
+    const started = await runApi.trigger(automationId);
+    if (!started) {
+      return {
+        textContent: `Run of "${name}" accepted. It runs in the background; find-runs shows the outcome.`,
+        structuredContent: { automationId, name, outcome: "started" }
+      };
+    }
+    const base = { automationId, name, runId: started.runId };
+    if (waitMinutes === 0) {
+      return {
+        textContent: `Run ${started.runId} of "${name}" started and runs in the background; get-run shows how it ends.`,
+        structuredContent: { ...base, outcome: "started", status: started.status }
+      };
     }
+    const timeoutMs = waitMinutes * 6e4;
+    const finished = await waitWithProgress(
+      (onPoll) => waitForRun(runApi, started, { timeoutMs, signal, onPoll }),
+      {
+        run: `Run ${started.runId}`,
+        subject: `Run ${started.runId} of "${name}"`,
+        startedStatus: started.status,
+        recovery: "It keeps running; get-run shows how it ends, so do not trigger it again to check on it.",
+        timeoutMs,
+        signal,
+        reportProgress
+      }
+    );
+    const output = {
+      ...base,
+      outcome: finished.outcome,
+      status: finished.status,
+      ...finished.failedStep ? {
+        failedStep: {
+          stepId: finished.failedStep.stepId,
+          description: finished.failedStep.description,
+          ...finished.failedStep.error ? { error: finished.failedStep.error } : {}
+        }
+      } : {},
+      ...finished.error ? { error: finished.error } : {},
+      ...finished.result ? { result: finished.result } : {}
+    };
     return {
-      textContent: `Run of "${name}" accepted. It runs in the background; find-runs shows the outcome.`,
-      structuredContent: { automationId, name, accepted: true }
+      textContent: describeFinished2(output, waitMinutes),
+      structuredContent: output
     };
   }
 };
+function describeFinished2(output, waitMinutes) {
+  const run = `Run ${output.runId} of "${output.name}"`;
+  switch (output.outcome) {
+    case "completed":
+      return `${run} completed.`;
+    case "failed": {
+      const step = output.failedStep ? ` at step ${output.failedStep.stepId}` : "";
+      const error = output.error ? `: ${output.error}` : "";
+      return `${run} failed${step}${error}. get-run shows every step.`;
+    }
+    case "skipped":
+      return `${run} was skipped${output.error ? `: ${output.error}` : ""}.`;
+    case "cancelled":
+      return `${run} was cancelled.`;
+    case "timed_out":
+      return `${run} was still ${output.status} after ${waitMinutes} min. It keeps running, possibly through a delay step; get-run shows how it ends.`;
+  }
+}
 
 // src/tools/update-automation.ts
 import { z as z93 } from "zod";
@@ -16595,7 +16857,7 @@ You have access to a user's Todoist Automations through the tools listed.
 - Every reference is an opaque id taken from a find- or get- tool. There is no lookup by name and no URL parsing: list first, then act on the id. Connector ids are the one exception: they are stable slugs such as github or slack.
 - An automation belongs either to the user's personal space or to one Todoist workspace, and the two are separate. Pass workspaceId to reach workspace automations; omit it for personal ones.
 - update-automation, set-automation-schedule, set-automation-visibility, move-automation, trigger-automation, delete-automation, update-draft, connect-draft, publish-draft, delete-draft and disconnect-service act immediately: no preview, and no confirmation of their own. Read the target first (get-automation, get-draft for a draft, or get-connector for a connection) so it is the right one, and confirm intent with the user before changing, running or deleting anything they did not explicitly ask for.
-- trigger-automation returns before the run finishes; find-runs shows the outcome.
+- trigger-automation waits for the run to end (waitMinutes, default 10); a run still going then keeps running, and get-run reads it.
 - A workspace automation is either visible to the whole workspace or private to its creator; isOwner says whether the user created it, and createdBy gives the creator's Todoist user id. Another member's automation is read-only for the user, but trigger-automation still works on it and the run executes on its creator's connections; find-runs shows who started each run as triggeredBy.
 - A workspace admin can update-automation, set-automation-visibility and delete-automation on another member's team-visible automation, but cannot reschedule it, change what it does (that needs its creator's draft or conversation) or reach a private one. updatedBy on an automation tells the creator's own change from an admin's.
 - move-automation puts an automation the user created into a workspace, from the personal space or another workspace, and never back out. Connections stay personal in every space: a moved or shared automation keeps running on its creator's own connections.
@@ -16633,4 +16895,4 @@ export {
   DEFAULT_BASE_URL,
   getMcpServer
 };
-//# sourceMappingURL=chunk-66AC5E4I.js.map
+//# sourceMappingURL=chunk-UZ45CAIT.js.map