@doist/automations-mcp 1.2.0 → 1.3.0

package/dist/{chunk-UOGVZEWA.js → chunk-JNUCEABU.js}

@@ -8559,8 +8559,8 @@ function validateManifestResultFrom(data, ctx) {
     });
     return;
   }
-  const outputSchema21 = referencedStep.outputSchema;
-  if (!outputSchema21) {
+  const outputSchema23 = referencedStep.outputSchema;
+  if (!outputSchema23) {
     ctx.addIssue({
       code: z7.ZodIssueCode.custom,
       message: `resultFrom.stepId references step "${referencedStep.id}" without an outputSchema.`,
@@ -8569,7 +8569,7 @@ function validateManifestResultFrom(data, ctx) {
     return;
   }
   if (!data.resultFrom.path) {
-    if (!isPlainStringSchema(outputSchema21)) {
+    if (!isPlainStringSchema(outputSchema23)) {
       ctx.addIssue({
         code: z7.ZodIssueCode.custom,
         message: "resultFrom.path may be omitted only when the referenced step outputSchema is a string.",
@@ -8579,7 +8579,7 @@ function validateManifestResultFrom(data, ctx) {
     return;
   }
   const propertyPath = data.resultFrom.path.split(".");
-  const resolvedSchema = resolvePropertySchemaInSchema(outputSchema21, propertyPath);
+  const resolvedSchema = resolvePropertySchemaInSchema(outputSchema23, propertyPath);
   if (!resolvedSchema) {
     ctx.addIssue({
       code: z7.ZodIssueCode.custom,
@@ -8628,11 +8628,11 @@ function validateIfConditionLiteral({ condition, context, stepId }) {
     const referencedStepId = parts[1];
     if (!referencedStepId)
       return null;
-    const outputSchema21 = context.steps.get(referencedStepId);
-    if (!outputSchema21)
+    const outputSchema23 = context.steps.get(referencedStepId);
+    if (!outputSchema23)
       return null;
     const propertyPath = parts.slice(2);
-    const resolved = propertyPath.length === 0 ? outputSchema21 : resolvePropertySchemaInSchema(outputSchema21, propertyPath);
+    const resolved = propertyPath.length === 0 ? outputSchema23 : resolvePropertySchemaInSchema(outputSchema23, propertyPath);
     if (!resolved)
       return null;
     return ifConditionLiteralError({ reference, literal, stepId, schema: resolved });
@@ -11390,6 +11390,14 @@ var WorkspaceAutomationDraftsClient = class extends BaseClient {
     });
     return automationDraftWithValidationSchema.parse(data);
   }
+  /** Deletes the draft. Only its owner can; the API answers 404 otherwise. */
+  async delete(workspaceId, draftId, options) {
+    await this.request({
+      method: "DELETE",
+      path: workspaceAutomationDraftsEndpoints.detail(IdSchema.parse(workspaceId), IdSchema.parse(draftId)),
+      options
+    });
+  }
 };
 
 // ../../packages/sdk/dist/esm/clients/workspace-chat/endpoints.js
@@ -11508,6 +11516,17 @@ var WorkspaceAutomationsClient = class extends BaseClient {
       options
     });
   }
+  /**
+   * Deletes the automation. Workspace admins may delete another member's
+   * team-visible automation; a private one is only reachable by its creator.
+   */
+  async delete(workspaceId, id, options) {
+    await this.request({
+      method: "DELETE",
+      path: workspaceAutomationsEndpoints.detail(IdSchema.parse(workspaceId), IdSchema.parse(id)),
+      options
+    });
+  }
 };
 
 // ../../packages/sdk/dist/esm/clients/workspaces/endpoints.js
@@ -12917,7 +12936,7 @@ import { McpServer } from "@modelcontextprotocol/server";
 // package.json
 var package_default = {
   name: "@doist/automations-mcp",
-  version: "1.2.0",
+  version: "1.3.0",
   description: "MCP server and importable AI tools for Todoist Automations",
   type: "module",
   main: "./dist/index.js",
@@ -12980,7 +12999,7 @@ var package_default = {
     "gpt-tokenizer": "4.0.0",
     "semantic-release": "25.0.9",
     "semantic-release-monorepo": "8.0.2",
-    tsx: "4.23.13",
+    tsx: "4.23.15",
     typescript: "6.0.3",
     vitest: "4.1.11"
   },
@@ -13133,7 +13152,7 @@ function registerTool({
   transport
 }) {
   const execute = tool.execute;
-  const { input: inputSchema, output: outputSchema21 } = getToolSchemas(tool);
+  const { input: inputSchema, output: outputSchema23 } = getToolSchemas(tool);
   const callback = async (args, ctx) => {
     try {
       const { textContent, structuredContent } = await execute(args, {
@@ -13160,7 +13179,7 @@ function registerTool({
     {
       description: tool.description,
       inputSchema,
-      ...outputSchema21 ? { outputSchema: outputSchema21 } : {},
+      ...outputSchema23 ? { outputSchema: outputSchema23 } : {},
       annotations: getMcpAnnotations(tool)
     },
     callback
@@ -13663,6 +13682,8 @@ var ToolNames = {
   SET_AUTOMATION_VISIBILITY: "set-automation-visibility",
   MOVE_AUTOMATION: "move-automation",
   TRIGGER_AUTOMATION: "trigger-automation",
+  DELETE_AUTOMATION: "delete-automation",
+  DELETE_DRAFT: "delete-draft",
   // Connection
   CONNECT_SERVICE: "connect-service",
   CHECK_CONNECTION: "check-connection",
@@ -13928,26 +13949,101 @@ var continueConversation = {
   }
 };
 
-// src/tools/disconnect-service.ts
+// src/tools/delete-automation.ts
+import { z as z65 } from "zod";
+
+// src/utils/workspace-scope.ts
 import { z as z64 } from "zod";
+var workspaceIdParameter = z64.string().optional().describe(
+  "Act on this Todoist workspace. Omit for the personal space. The two are separate: a workspace automation is not found in the personal space, and vice versa."
+);
+var requiredWorkspaceIdParameter = z64.string().describe("The Todoist workspace, as returned by list-workspaces.");
+function describeVisibility(visibility) {
+  return visibility === "workspace" ? "visible to the workspace" : "private to its creator";
+}
+function describeScope(workspaceId) {
+  return workspaceId === void 0 ? "personal" : `workspace ${workspaceId}`;
+}
+
+// src/tools/delete-automation.ts
 var parameters4 = {
-  connectionId: z64.string().describe("The connection to remove, as listed by get-connector."),
-  force: z64.boolean().optional().describe(
+  automationId: z65.string().describe("The automation to delete, as listed by find-automations or get-automation."),
+  workspaceId: workspaceIdParameter
+};
+var outputSchema3 = {
+  automationId: z65.string(),
+  deleted: z65.boolean()
+};
+var deleteAutomation = {
+  name: ToolNames.DELETE_AUTOMATION,
+  description: "Permanently deletes an automation, along with its schedule, run history and any unpublished edits. This cannot be undone. Takes effect immediately with no confirmation of its own, so read it first with get-automation so it is the right one and confirm intent with the user before calling. In a workspace, a member can delete only automations they created; a workspace admin can also delete another member\u2019s team-visible automation, but not a private one.",
+  parameters: parameters4,
+  outputSchema: outputSchema3,
+  annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true },
+  async execute({ automationId, workspaceId }, { api, signal }) {
+    const options = { signal };
+    if (workspaceId === void 0) {
+      await api.automations.delete(automationId, options);
+    } else {
+      await api.workspaceAutomations.delete(workspaceId, automationId, options);
+    }
+    return {
+      textContent: `Automation ${automationId} deleted (${describeScope(workspaceId)}).`,
+      structuredContent: { automationId, deleted: true }
+    };
+  }
+};
+
+// src/tools/delete-draft.ts
+import { z as z66 } from "zod";
+var parameters5 = {
+  draftId: z66.string().describe("The draft to delete, as listed by find-drafts or get-draft."),
+  workspaceId: workspaceIdParameter
+};
+var outputSchema4 = {
+  draftId: z66.string(),
+  deleted: z66.boolean()
+};
+var deleteDraft = {
+  name: ToolNames.DELETE_DRAFT,
+  description: "Permanently deletes a draft the user owns, discarding whatever has been authored in it. This cannot be undone. Takes effect immediately with no confirmation of its own, so read it first with get-draft so it is the right one and confirm intent with the user before calling. Deleting the last draft of a conversation archives that conversation. A published automation the draft was editing is untouched.",
+  parameters: parameters5,
+  outputSchema: outputSchema4,
+  annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true },
+  async execute({ draftId, workspaceId }, { api, signal }) {
+    const options = { signal };
+    if (workspaceId === void 0) {
+      await api.automationDrafts.delete(draftId, options);
+    } else {
+      await api.workspaceAutomationDrafts.delete(workspaceId, draftId, options);
+    }
+    return {
+      textContent: `Draft ${draftId} deleted (${describeScope(workspaceId)}).`,
+      structuredContent: { draftId, deleted: true }
+    };
+  }
+};
+
+// src/tools/disconnect-service.ts
+import { z as z67 } from "zod";
+var parameters6 = {
+  connectionId: z67.string().describe("The connection to remove, as listed by get-connector."),
+  force: z67.boolean().optional().describe(
     "Disconnect even though enabled automations still use the connection. They stop working until a new connection is linked. Only after the user has agreed."
   )
 };
-var outputSchema3 = {
-  connectionId: z64.string(),
-  disconnected: z64.boolean(),
-  blockingAutomations: z64.array(blockingAutomationSchema).optional().describe(
+var outputSchema5 = {
+  connectionId: z67.string(),
+  disconnected: z67.boolean(),
+  blockingAutomations: z67.array(blockingAutomationSchema).optional().describe(
     "Present when disconnected is false: the enabled automations that still use the connection."
   )
 };
 var disconnectService = {
   name: ToolNames.DISCONNECT_SERVICE,
   description: "Removes a linked account. Refuses, and lists them, when enabled automations still use the connection: disable those with update-automation first, or pass force after the user has agreed to break them. Disabled automations do not block it but need a new connection before they can run again. Takes effect immediately with no confirmation of its own, so confirm intent with the user first; get-connector with includeAutomations shows what depends on the service.",
-  parameters: parameters4,
-  outputSchema: outputSchema3,
+  parameters: parameters6,
+  outputSchema: outputSchema5,
   annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true },
   async execute({ connectionId, force }, { api, signal }) {
     try {
@@ -13971,45 +14067,32 @@ var disconnectService = {
 };
 
 // src/tools/find-automations.ts
-import { z as z67 } from "zod";
+import { z as z69 } from "zod";
 
 // src/utils/pagination.ts
-import { z as z65 } from "zod";
+import { z as z68 } from "zod";
 var paginationParameters = {
-  cursor: z65.string().optional().describe("Cursor from a previous call to fetch the next page. Omit for the first page."),
-  limit: z65.number().int().min(1).max(MAX_PAGINATION_LIMIT).optional().describe(`Page size, at most ${MAX_PAGINATION_LIMIT}. Omit for the default.`)
+  cursor: z68.string().optional().describe("Cursor from a previous call to fetch the next page. Omit for the first page."),
+  limit: z68.number().int().min(1).max(MAX_PAGINATION_LIMIT).optional().describe(`Page size, at most ${MAX_PAGINATION_LIMIT}. Omit for the default.`)
 };
 var paginationOutput = {
-  nextCursor: z65.string().optional().describe("Pass as `cursor` to fetch the next page. Absent when this page is the last.")
+  nextCursor: z68.string().optional().describe("Pass as `cursor` to fetch the next page. Absent when this page is the last.")
 };
 
-// src/utils/workspace-scope.ts
-import { z as z66 } from "zod";
-var workspaceIdParameter = z66.string().optional().describe(
-  "Act on this Todoist workspace. Omit for the personal space. The two are separate: a workspace automation is not found in the personal space, and vice versa."
-);
-var requiredWorkspaceIdParameter = z66.string().describe("The Todoist workspace, as returned by list-workspaces.");
-function describeVisibility(visibility) {
-  return visibility === "workspace" ? "visible to the workspace" : "private to its creator";
-}
-function describeScope(workspaceId) {
-  return workspaceId === void 0 ? "personal" : `workspace ${workspaceId}`;
-}
-
 // src/tools/find-automations.ts
-var parameters5 = {
+var parameters7 = {
   workspaceId: workspaceIdParameter,
   ...paginationParameters
 };
-var outputSchema4 = {
-  automations: z67.array(automationSummarySchema),
+var outputSchema6 = {
+  automations: z69.array(automationSummarySchema),
   ...paginationOutput
 };
 var findAutomations = {
   name: ToolNames.FIND_AUTOMATIONS,
   description: "Lists automations with their state and triggers, one page at a time. Use it to find the id of an automation before inspecting or changing it; ids are opaque and there is no lookup by name. Returns summaries without the manifest body.",
-  parameters: parameters5,
-  outputSchema: outputSchema4,
+  parameters: parameters7,
+  outputSchema: outputSchema6,
   annotations: {
     readOnlyHint: true,
     destructiveHint: false,
@@ -14031,26 +14114,26 @@ var findAutomations = {
 };
 
 // src/tools/find-connectors.ts
-import { z as z68 } from "zod";
-var parameters6 = {
-  query: z68.string().optional().describe("Text to match against connector names and descriptions. Ids are not searched."),
+import { z as z70 } from "zod";
+var parameters8 = {
+  query: z70.string().optional().describe("Text to match against connector names and descriptions. Ids are not searched."),
   capability: connectorCapabilitySchema.optional().describe(
     "Only connectors offering this capability. Does not narrow the connections listed under each."
   ),
-  connectionStatus: z68.enum(CONNECTION_STATUSES).optional().describe(
+  connectionStatus: z70.enum(CONNECTION_STATUSES).optional().describe(
     "Only connectors the user has a connection in this state for. With `capability`, the same connection must cover that capability."
   ),
-  withoutConnections: z68.boolean().optional().describe(
+  withoutConnections: z70.boolean().optional().describe(
     "Only connectors the user has no connection for. Cannot combine with connectionStatus."
   ),
-  includeConnections: z68.boolean().optional().describe(
+  includeConnections: z70.boolean().optional().describe(
     "Whether to list the user's connections under each connector. Defaults to true; false skips the lookup and disables the connection filters."
   )
 };
-var outputSchema5 = {
-  connectors: z68.array(
+var outputSchema7 = {
+  connectors: z70.array(
     connectorSummarySchema.extend({
-      connections: z68.array(connectorConnectionSummarySchema).optional().describe(
+      connections: z70.array(connectorConnectionSummarySchema).optional().describe(
         "The user's connections for this connector. Absent when includeConnections is false."
       )
     })
@@ -14059,8 +14142,8 @@ var outputSchema5 = {
 var findConnectors = {
   name: ToolNames.FIND_CONNECTORS,
   description: "Lists the services automations can use, with the user's connections to each. A connector is a service such as GitHub; a connection is one authorised account for it. Use it to see what is available, what the user has already linked, and which connector id to pass to get-connector.",
-  parameters: parameters6,
-  outputSchema: outputSchema5,
+  parameters: parameters8,
+  outputSchema: outputSchema7,
   annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
   async execute({ query, capability, connectionStatus, withoutConnections, includeConnections = true }, { api, signal }) {
     if (!includeConnections && (connectionStatus || withoutConnections)) {
@@ -14093,19 +14176,19 @@ var findConnectors = {
 };
 
 // src/tools/find-conversations.ts
-import { z as z69 } from "zod";
-var parameters7 = {
+import { z as z71 } from "zod";
+var parameters9 = {
   status: chatConversationStatusSchema.optional().describe(
     'Defaults to "active". Publishing an automation archives its conversation, so pass "archived" or "all" to find the conversation behind a published automation.'
   ),
-  limit: z69.number().int().min(1).max(200).optional().describe("At most this many, newest first. Defaults to 10.")
+  limit: z71.number().int().min(1).max(200).optional().describe("At most this many, newest first. Defaults to 10.")
 };
-var outputSchema6 = { conversations: z69.array(conversationSummarySchema) };
+var outputSchema8 = { conversations: z71.array(conversationSummarySchema) };
 var findConversations = {
   name: ToolNames.FIND_CONVERSATIONS,
   description: "Lists the user's conversations with the Automations agent, newest first. A conversation is one authoring session: it writes to a draft and ends when the automation is published. Use it to find a session to resume or to read; get-conversation has the messages and whether the agent is waiting on something.",
-  parameters: parameters7,
-  outputSchema: outputSchema6,
+  parameters: parameters9,
+  outputSchema: outputSchema8,
   annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
   async execute({ status, limit }, { api, signal }) {
     const dtos = await api.chat.listConversations({ status, limit }, { signal });
@@ -14119,20 +14202,20 @@ var findConversations = {
 };
 
 // src/tools/find-drafts.ts
-import { z as z70 } from "zod";
-var parameters8 = {
+import { z as z72 } from "zod";
+var parameters10 = {
   workspaceId: workspaceIdParameter,
   ...paginationParameters
 };
-var outputSchema7 = {
-  drafts: z70.array(draftSummarySchema),
+var outputSchema9 = {
+  drafts: z72.array(draftSummarySchema),
   ...paginationOutput
 };
 var findDrafts = {
   name: ToolNames.FIND_DRAFTS,
   description: "Lists automation drafts, one page at a time. A draft is an automation being authored or edited that has not been published yet; chat conversations write to drafts. Returns summaries without the manifest; get-draft has the manifest and whether it is ready to publish.",
-  parameters: parameters8,
-  outputSchema: outputSchema7,
+  parameters: parameters10,
+  outputSchema: outputSchema9,
   annotations: {
     readOnlyHint: true,
     destructiveHint: false,
@@ -14154,11 +14237,11 @@ var findDrafts = {
 };
 
 // src/tools/find-runs.ts
-import { z as z71 } from "zod";
-var parameters9 = {
-  automationId: z71.string().describe("The id of the automation, as returned by find-automations."),
+import { z as z73 } from "zod";
+var parameters11 = {
+  automationId: z73.string().describe("The id of the automation, as returned by find-automations."),
   workspaceId: workspaceIdParameter,
-  status: z71.enum(AUTOMATION_RUN_STATUSES).optional().describe(
+  status: z73.enum(AUTOMATION_RUN_STATUSES).optional().describe(
     "Only runs with this outcome. A run refused for an empty balance is `skipped`, not `failed`."
   ),
   since: isoDateTimeOrDateQueryParamSchema.optional().describe(
@@ -14169,12 +14252,12 @@ var parameters9 = {
   ),
   ...paginationParameters
 };
-var outputSchema8 = { runs: z71.array(runSummarySchema), ...paginationOutput };
+var outputSchema10 = { runs: z73.array(runSummarySchema), ...paginationOutput };
 var findRuns = {
   name: ToolNames.FIND_RUNS,
   description: "Lists the runs of one automation, newest first, one page at a time, with the outcome and failure reason of each. Use it to see whether an automation has been running and how it ended; get-run gives the steps of one run. Filters apply to when the run started.",
-  parameters: parameters9,
-  outputSchema: outputSchema8,
+  parameters: parameters11,
+  outputSchema: outputSchema10,
   annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
   async execute({ automationId, workspaceId, status, since, until, cursor, limit }, { api, signal }) {
     const options = { signal };
@@ -14193,15 +14276,15 @@ var findRuns = {
 };
 
 // src/tools/get-automation.ts
-import { z as z72 } from "zod";
-var parameters10 = {
-  automationId: z72.string().describe("The id of the automation, as returned by find-automations."),
+import { z as z74 } from "zod";
+var parameters12 = {
+  automationId: z74.string().describe("The id of the automation, as returned by find-automations."),
   workspaceId: workspaceIdParameter
 };
-var outputSchema9 = {
+var outputSchema11 = {
   automation: automationSummarySchema.extend({
-    draftId: z72.string().optional().describe("The draft holding unpublished edits to this automation, when there is one."),
-    manifest: z72.record(z72.string(), z72.unknown()).optional().describe(
+    draftId: z74.string().optional().describe("The draft holding unpublished edits to this automation, when there is one."),
+    manifest: z74.record(z74.string(), z74.unknown()).optional().describe(
       "The stored manifest: triggers, steps and settings. Absent when there is none."
     )
   })
@@ -14209,8 +14292,8 @@ var outputSchema9 = {
 var getAutomation = {
   name: ToolNames.GET_AUTOMATION,
   description: "Returns one automation in full, including its manifest. Use it to inspect what an automation does; find-automations gives the summary and the id.",
-  parameters: parameters10,
-  outputSchema: outputSchema9,
+  parameters: parameters12,
+  outputSchema: outputSchema11,
   annotations: {
     readOnlyHint: true,
     destructiveHint: false,
@@ -14233,23 +14316,23 @@ var getAutomation = {
 };
 
 // src/tools/get-connector.ts
-import { z as z73 } from "zod";
-var parameters11 = {
-  connectorId: z73.string().describe('The connector slug, such as "github", as listed by find-connectors.'),
-  includeAutomations: z73.boolean().optional().describe(
+import { z as z75 } from "zod";
+var parameters13 = {
+  connectorId: z75.string().describe('The connector slug, such as "github", as listed by find-connectors.'),
+  includeAutomations: z75.boolean().optional().describe(
     "Also list the published automations that use this connector, with whether each has a working connection."
   )
 };
-var outputSchema10 = {
+var outputSchema12 = {
   connector: connectorDetailSchema,
-  connections: z73.array(connectionSummarySchema).describe("The user's connections for this connector. Empty when none is linked."),
-  automations: z73.array(dependentAutomationSchema).optional().describe("Present when includeAutomations is true.")
+  connections: z75.array(connectionSummarySchema).describe("The user's connections for this connector. Empty when none is linked."),
+  automations: z75.array(dependentAutomationSchema).optional().describe("Present when includeAutomations is true.")
 };
 var getConnector = {
   name: ToolNames.GET_CONNECTOR,
   description: "Returns one connector with the events it can trigger on and the user's connections to it. Use it before connecting a service to see what it offers and whether an account is already linked, and with includeAutomations to see what depends on it before disconnecting.",
-  parameters: parameters11,
-  outputSchema: outputSchema10,
+  parameters: parameters13,
+  outputSchema: outputSchema12,
   annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
   async execute({ connectorId, includeAutomations = false }, { api, signal }) {
     const options = { signal };
@@ -14278,13 +14361,13 @@ var getConnector = {
 };
 
 // src/tools/get-conversation.ts
-import { z as z74 } from "zod";
-var parameters12 = {
-  conversationId: z74.string().describe("The id of the conversation, as returned by find-conversations.")
+import { z as z76 } from "zod";
+var parameters14 = {
+  conversationId: z76.string().describe("The id of the conversation, as returned by find-conversations.")
 };
-var outputSchema11 = {
+var outputSchema13 = {
   conversation: conversationSummarySchema,
-  messages: z74.array(conversationMessageSchema).describe("In order, oldest first."),
+  messages: z76.array(conversationMessageSchema).describe("In order, oldest first."),
   pendingAction: pendingActionSchema.optional().describe(
     "What the agent is waiting on before the conversation can continue. Absent when it is waiting on a plain reply, or on nothing."
   )
@@ -14292,8 +14375,8 @@ var outputSchema11 = {
 var getConversation = {
   name: ToolNames.GET_CONVERSATION,
   description: "Returns one conversation with its messages as visible text and any action the agent is waiting on. Use it to read what was said and to decide what to do next: the last assistant message is where the session resumes, and a pending action must be resolved before it can.",
-  parameters: parameters12,
-  outputSchema: outputSchema11,
+  parameters: parameters14,
+  outputSchema: outputSchema13,
   annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
   async execute({ conversationId }, { api, signal }) {
     const options = { signal };
@@ -14332,22 +14415,22 @@ function describePendingAction(action) {
 }
 
 // src/tools/get-draft.ts
-import { z as z75 } from "zod";
-var parameters13 = {
-  draftId: z75.string().describe("The id of the draft, as returned by find-drafts."),
+import { z as z77 } from "zod";
+var parameters15 = {
+  draftId: z77.string().describe("The id of the draft, as returned by find-drafts."),
   workspaceId: workspaceIdParameter
 };
-var outputSchema12 = {
+var outputSchema14 = {
   draft: draftSummarySchema.extend({
-    partialManifest: z75.record(z75.string(), z75.unknown()).optional().describe(
+    partialManifest: z77.record(z77.string(), z77.unknown()).optional().describe(
       "The manifest as authored so far; may be missing parts. Absent when nothing has been authored yet."
     ),
-    connectors: z75.array(z75.object({ connectorId: z75.string(), name: z75.string() })).optional().describe("The services the manifest uses.")
+    connectors: z77.array(z77.object({ connectorId: z77.string(), name: z77.string() })).optional().describe("The services the manifest uses.")
   }),
-  validation: z75.object({
-    state: z75.enum(["incomplete", "ready"]).describe('"ready" means the draft can be published as it stands.'),
-    issues: z75.array(z75.string()).describe("What stops it being published. Empty when ready."),
-    modified: z75.boolean().describe(
+  validation: z77.object({
+    state: z77.enum(["incomplete", "ready"]).describe('"ready" means the draft can be published as it stands.'),
+    issues: z77.array(z77.string()).describe("What stops it being published. Empty when ready."),
+    modified: z77.boolean().describe(
       "Whether publishing would change anything: false when the draft matches the automation it edits."
     )
   })
@@ -14355,8 +14438,8 @@ var outputSchema12 = {
 var getDraft = {
   name: ToolNames.GET_DRAFT,
   description: "Returns one draft with its partial manifest and validation state: whether it is ready to publish and, if not, what is missing.",
-  parameters: parameters13,
-  outputSchema: outputSchema12,
+  parameters: parameters15,
+  outputSchema: outputSchema14,
   annotations: {
     readOnlyHint: true,
     destructiveHint: false,
@@ -14387,21 +14470,21 @@ var getDraft = {
 };
 
 // src/tools/get-run.ts
-import { z as z76 } from "zod";
-var parameters14 = {
-  automationId: z76.string().describe("The id of the automation, as returned by find-automations."),
-  runId: z76.string().describe("The id of the run, as returned by find-runs."),
+import { z as z78 } from "zod";
+var parameters16 = {
+  automationId: z78.string().describe("The id of the automation, as returned by find-automations."),
+  runId: z78.string().describe("The id of the run, as returned by find-runs."),
   workspaceId: workspaceIdParameter,
-  full: z76.boolean().optional().describe(
+  full: z78.boolean().optional().describe(
     "Also return each step's raw result and generated code. The payload can be large; omit it unless the compact diagnostic is not enough."
   )
 };
-var outputSchema13 = { run: runDetailSchema };
+var outputSchema15 = { run: runDetailSchema };
 var getRun = {
   name: ToolNames.GET_RUN,
   description: "Returns one run with its result, steps and the tool calls each step made, as a compact diagnostic: what failed, where, and the start of each error. Use it to work out why a run failed or what it produced.",
-  parameters: parameters14,
-  outputSchema: outputSchema13,
+  parameters: parameters16,
+  outputSchema: outputSchema15,
   annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
   async execute({ automationId, runId, workspaceId, full = false }, { api, signal }) {
     const options = { signal };
@@ -14431,16 +14514,16 @@ function describeRun(run) {
 }
 
 // src/tools/list-workspaces.ts
-import { z as z77 } from "zod";
-var parameters15 = {};
-var outputSchema14 = {
-  workspaces: z77.array(
-    z77.object({
-      id: z77.string(),
-      name: z77.string(),
-      plan: z77.enum(WORKSPACE_PLANS),
-      role: z77.enum(WORKSPACE_ROLES).describe("The user\u2019s role in the workspace."),
-      access: z77.enum(WORKSPACE_ACCESS_LEVELS).describe(
+import { z as z79 } from "zod";
+var parameters17 = {};
+var outputSchema16 = {
+  workspaces: z79.array(
+    z79.object({
+      id: z79.string(),
+      name: z79.string(),
+      plan: z79.enum(WORKSPACE_PLANS),
+      role: z79.enum(WORKSPACE_ROLES).describe("The user\u2019s role in the workspace."),
+      access: z79.enum(WORKSPACE_ACCESS_LEVELS).describe(
         '"locked" means the plan does not cover Automations: the workspace is listed, but its automations cannot run and nothing can be created in it.'
       )
     })
@@ -14449,8 +14532,8 @@ var outputSchema14 = {
 var listWorkspaces = {
   name: ToolNames.LIST_WORKSPACES,
   description: "Lists the Todoist workspaces the user can use with Automations, with their ids. Workspaces the user cannot access are not listed. Call it to find the workspaceId for other tools; omit workspaceId on those tools for the personal space.",
-  parameters: parameters15,
-  outputSchema: outputSchema14,
+  parameters: parameters17,
+  outputSchema: outputSchema16,
   annotations: {
     readOnlyHint: true,
     destructiveHint: false,
@@ -14467,22 +14550,22 @@ var listWorkspaces = {
 };
 
 // src/tools/move-automation.ts
-import { z as z78 } from "zod";
-var parameters16 = {
-  automationId: z78.string().describe(
+import { z as z80 } from "zod";
+var parameters18 = {
+  automationId: z80.string().describe(
     "The id of the automation to move, as returned by find-automations. It may be a personal automation or one in another workspace."
   ),
-  workspaceId: z78.string().describe("The workspace to move it into, as returned by list-workspaces."),
-  visibility: z78.enum(AUTOMATION_VISIBILITIES).optional().describe(
+  workspaceId: z80.string().describe("The workspace to move it into, as returned by list-workspaces."),
+  visibility: z80.enum(AUTOMATION_VISIBILITIES).optional().describe(
     'How the automation is shared once moved. Defaults to "workspace", visible to every member; "private" keeps it to its creator.'
   )
 };
-var outputSchema15 = { automation: automationSummarySchema };
+var outputSchema17 = { automation: automationSummarySchema };
 var moveAutomation = {
   name: ToolNames.MOVE_AUTOMATION,
   description: "Moves an automation the user created into a workspace, from their personal space or from another workspace they can still use. It keeps running on the creator\u2019s own connections, and any unpublished edits move with it. The destination is always a workspace: nothing moves back to the personal space. Fails when the user did not create the automation, or when the workspace it is in now no longer includes them or Automations. Takes effect immediately with no confirmation of its own, so confirm intent with the user first.",
-  parameters: parameters16,
-  outputSchema: outputSchema15,
+  parameters: parameters18,
+  outputSchema: outputSchema17,
   annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true },
   async execute({ automationId, workspaceId, visibility }, { api, signal }) {
     const dto = await api.workspaceAutomations.move(
@@ -14500,35 +14583,35 @@ var moveAutomation = {
 };
 
 // src/tools/repair-connection.ts
-import { z as z79 } from "zod";
-var parameters17 = {
-  connectionId: z79.string().describe(
+import { z as z81 } from "zod";
+var parameters19 = {
+  connectionId: z81.string().describe(
     "The connection to repair, as listed by get-connector or reported by check-connection."
   )
 };
-var outputSchema16 = {
-  connectionId: z79.string().describe("The connection to pass to check-connection next."),
-  connectorId: z79.string(),
-  serviceName: z79.string(),
-  resumed: z79.boolean().describe(
+var outputSchema18 = {
+  connectionId: z81.string().describe("The connection to pass to check-connection next."),
+  connectorId: z81.string(),
+  serviceName: z81.string(),
+  resumed: z81.boolean().describe(
     "True when the existing pending setup was returned; false when a replacement was started."
   ),
-  replacedConnectionId: z79.string().optional().describe(
+  replacedConnectionId: z81.string().optional().describe(
     "The broken connection the replacement stands in for. Present when resumed is false."
   ),
-  status: z79.enum(["pending", "authorized"]).describe(
+  status: z81.enum(["pending", "authorized"]).describe(
     '"pending" until the user completes the setup; "authorized" when nothing was needed.'
   ),
   setup: connectionSetupSchema.optional().describe("What the user must complete. Absent when authorized."),
-  automations: z79.array(affectedAutomationSchema).optional().describe(
+  automations: z81.array(affectedAutomationSchema).optional().describe(
     "Personal automations that move to the replacement once it is authorised. Present when resumed is false."
   )
 };
 var repairConnection = {
   name: ToolNames.REPAIR_CONNECTION,
   description: "Fixes a connection that is not authorised. A pending one gets its setup returned again; an expired, errored or stale one is replaced by a new connection that the personal automations using it move to once the user authorises it. Returns what the user must complete, never waits, and tells you which connectionId to pass to check-connection.",
-  parameters: parameters17,
-  outputSchema: outputSchema16,
+  parameters: parameters19,
+  outputSchema: outputSchema18,
   annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false },
   async execute({ connectionId }, { api, signal }) {
     const options = { signal };
@@ -14583,26 +14666,26 @@ var repairConnection = {
 };
 
 // src/tools/set-automation-schedule.ts
-import { z as z80 } from "zod";
-var parameters18 = {
-  automationId: z80.string().describe("The id of the automation, as returned by find-automations."),
+import { z as z82 } from "zod";
+var parameters20 = {
+  automationId: z82.string().describe("The id of the automation, as returned by find-automations."),
   workspaceId: workspaceIdParameter,
-  cron: z80.string().optional().describe(
+  cron: z82.string().optional().describe(
     'A five-part cron expression such as "0 9 * * 1-5". Requires timezone. Use this or interval, not both.'
   ),
-  timezone: z80.string().optional().describe(
+  timezone: z82.string().optional().describe(
     'The IANA zone the cron expression is read in, such as "Europe/London". Only with cron.'
   ),
-  interval: z80.string().optional().describe(
+  interval: z82.string().optional().describe(
     'How often to run, as a number and unit: "45m", "6h", "1d", "1w". Use this or cron, not both.'
   )
 };
-var outputSchema17 = { automation: automationSummarySchema };
+var outputSchema19 = { automation: automationSummarySchema };
 var setAutomationSchedule = {
   name: ToolNames.SET_AUTOMATION_SCHEDULE,
   description: 'Changes when a schedule-triggered automation runs, as either a cron expression with a timezone or a fixed interval. Natural language such as "every weekday morning" is not accepted; translate it first. Takes effect immediately with no confirmation of its own, so confirm intent with the user first. Fails for automations that run on events or API calls.',
-  parameters: parameters18,
-  outputSchema: outputSchema17,
+  parameters: parameters20,
+  outputSchema: outputSchema19,
   annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true },
   async execute({ automationId, workspaceId, cron, timezone, interval }, { api, signal }) {
     const value = resolveScheduleInput(
@@ -14626,20 +14709,20 @@ var setAutomationSchedule = {
 };
 
 // src/tools/set-automation-visibility.ts
-import { z as z81 } from "zod";
-var parameters19 = {
-  automationId: z81.string().describe("The id of the automation, as returned by find-automations."),
+import { z as z83 } from "zod";
+var parameters21 = {
+  automationId: z83.string().describe("The id of the automation, as returned by find-automations."),
   workspaceId: requiredWorkspaceIdParameter,
-  visibility: z81.enum(AUTOMATION_VISIBILITIES).describe(
+  visibility: z83.enum(AUTOMATION_VISIBILITIES).describe(
     '"workspace": every member can see and run it. "private": only its creator can see it, workspace admins included.'
   )
 };
-var outputSchema18 = { automation: automationSummarySchema };
+var outputSchema20 = { automation: automationSummarySchema };
 var setAutomationVisibility = {
   name: ToolNames.SET_AUTOMATION_VISIBILITY,
   description: "Shares a workspace automation with the whole workspace, or takes it back to private. Only the creator can change it, or a workspace admin while it is team-visible; once private it is out of every admin\u2019s reach until the creator shares it again. Takes effect immediately with no confirmation of its own, so confirm intent with the user first. Workspace automations only: a personal automation has no team to be visible to.",
-  parameters: parameters19,
-  outputSchema: outputSchema18,
+  parameters: parameters21,
+  outputSchema: outputSchema20,
   annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true },
   async execute({ automationId, workspaceId, visibility }, { api, signal }) {
     const dto = await api.workspaceAutomations.updateVisibility(
@@ -14657,19 +14740,19 @@ var setAutomationVisibility = {
 };
 
 // src/tools/start-conversation.ts
-import { z as z82 } from "zod";
-var parameters20 = {
+import { z as z84 } from "zod";
+var parameters22 = {
   workspaceId: workspaceIdParameter.describe(
     "Author the automation in this Todoist workspace: the conversation, its draft and the published automation all belong there, and continue-conversation follows it automatically. Omit for the personal space."
   ),
-  message: z82.string().min(1).describe(
+  message: z84.string().min(1).describe(
     "What the user wants automated, in their words. Say whether the automation should be published or left as a draft; the agent otherwise asks."
   )
 };
 var startConversation = {
   name: ToolNames.START_CONVERSATION,
   description: "Creates a conversation with the Automations agent and runs its first turn: the agent designs an automation from the message, asks questions, or asks for service connections. Blocks until the turn ends, which can take minutes; progress is reported meanwhile. Returns the conversationId to continue with and the outcome: awaiting_input (reply with continue-conversation), action_required (resolve pendingAction first) or published. Runs on the user\u2019s own connections in either space.",
-  parameters: parameters20,
+  parameters: parameters22,
   outputSchema: turnResultSchema,
   annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false },
   async execute({ workspaceId, message }, { api, transport, signal, reportProgress }) {
@@ -14692,21 +14775,21 @@ var startConversation = {
 };
 
 // src/tools/trigger-automation.ts
-import { z as z83 } from "zod";
-var parameters21 = {
-  automationId: z83.string().describe("The id of the automation, as returned by find-automations."),
+import { z as z85 } from "zod";
+var parameters23 = {
+  automationId: z85.string().describe("The id of the automation, as returned by find-automations."),
   workspaceId: workspaceIdParameter
 };
-var outputSchema19 = {
-  automationId: z83.string(),
-  name: z83.string(),
-  accepted: z83.literal(true).describe("The backend accepted the run. It has not finished.")
+var outputSchema21 = {
+  automationId: z85.string(),
+  name: z85.string(),
+  accepted: z85.literal(true).describe("The backend accepted the run. It has not finished.")
 };
 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.",
-  parameters: parameters21,
-  outputSchema: outputSchema19,
+  parameters: parameters23,
+  outputSchema: outputSchema21,
   annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false },
   async execute({ automationId, workspaceId }, { api, signal }) {
     const options = { signal };
@@ -14731,22 +14814,22 @@ var triggerAutomation = {
 };
 
 // src/tools/update-automation.ts
-import { z as z84 } from "zod";
-var parameters22 = {
-  automationId: z84.string().describe("The id of the automation, as returned by find-automations."),
+import { z as z86 } from "zod";
+var parameters24 = {
+  automationId: z86.string().describe("The id of the automation, as returned by find-automations."),
   workspaceId: workspaceIdParameter,
-  name: z84.string().min(1).optional().describe("A new name. Omit to keep the current one."),
-  description: z84.string().optional().describe("A new description. Omit to keep the current one."),
-  enabled: z84.boolean().optional().describe(
+  name: z86.string().min(1).optional().describe("A new name. Omit to keep the current one."),
+  description: z86.string().optional().describe("A new description. Omit to keep the current one."),
+  enabled: z86.boolean().optional().describe(
     "Turn the automation on or off. Enabling fails while disabledReason is set: the system stopped it and the cause must be fixed first."
   )
 };
-var outputSchema20 = { automation: automationSummarySchema };
+var outputSchema22 = { automation: automationSummarySchema };
 var updateAutomation = {
   name: ToolNames.UPDATE_AUTOMATION,
   description: "Renames, describes, enables or disables an automation. Any one field can change alone; the others keep their current values. Takes effect immediately with no confirmation of its own, so confirm intent with the user first. Does not change what the automation does; that needs a conversation.",
-  parameters: parameters22,
-  outputSchema: outputSchema20,
+  parameters: parameters24,
+  outputSchema: outputSchema22,
   annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true },
   async execute({ automationId, workspaceId, name, description, enabled }, context) {
     const client = createClient(automationId, workspaceId, context);
@@ -14815,6 +14898,8 @@ var toolRegistry = {
   setAutomationVisibility,
   moveAutomation,
   triggerAutomation,
+  deleteAutomation,
+  deleteDraft,
   // Connection
   connectService,
   checkConnection,
@@ -14836,10 +14921,10 @@ 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 and disconnect-service act immediately: no preview, and no confirmation of their own. Read the target first (get-automation, or get-connector for a connection) so it is the right one, and confirm intent with the user before changing or running anything they did not explicitly ask for.
+- update-automation, set-automation-schedule, set-automation-visibility, move-automation, trigger-automation, delete-automation, 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.
 - A workspace automation is either visible to the whole workspace or private to its creator; isOwner says whether the user created it. 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 and set-automation-visibility 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.
+- 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.
 - Authoring happens in the space the conversation was started in: pass workspaceId to start-conversation to author a workspace automation, and continue-conversation follows it automatically.
 - connect-service and repair-connection never wait. They return what the user must complete (an authorisation link, or instructions and a code): relay it verbatim, let the user finish, then call check-connection with the connectionId. Retrying reuses the pending setup rather than creating another connection.
@@ -14873,4 +14958,4 @@ export {
   DEFAULT_BASE_URL,
   getMcpServer
 };
-//# sourceMappingURL=chunk-UOGVZEWA.js.map
+//# sourceMappingURL=chunk-JNUCEABU.js.map