@doist/automations-mcp 1.3.0 → 1.4.1

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

@@ -2973,22 +2973,22 @@ var require_compile = __commonJS({
       }
     }
     exports.compileSchema = compileSchema;
-    function resolveRef(root15, baseId, ref) {
+    function resolveRef(root16, baseId, ref) {
       var _a;
       ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, ref);
-      const schOrFunc = root15.refs[ref];
+      const schOrFunc = root16.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve.call(this, root15, ref);
+      let _sch = resolve.call(this, root16, ref);
       if (_sch === void 0) {
-        const schema = (_a = root15.localRefs) === null || _a === void 0 ? void 0 : _a[ref];
+        const schema = (_a = root16.localRefs) === null || _a === void 0 ? void 0 : _a[ref];
         const { schemaId } = this.opts;
         if (schema)
-          _sch = new SchemaEnv({ schema, schemaId, root: root15, baseId });
+          _sch = new SchemaEnv({ schema, schemaId, root: root16, baseId });
       }
       if (_sch === void 0)
         return;
-      return root15.refs[ref] = inlineOrCompile.call(this, _sch);
+      return root16.refs[ref] = inlineOrCompile.call(this, _sch);
     }
     exports.resolveRef = resolveRef;
     function inlineOrCompile(sch) {
@@ -3006,23 +3006,23 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve(root15, ref) {
+    function resolve(root16, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
-      return sch || this.schemas[ref] || resolveSchema.call(this, root15, ref);
+      return sch || this.schemas[ref] || resolveSchema.call(this, root16, ref);
     }
-    function resolveSchema(root15, ref) {
+    function resolveSchema(root16, ref) {
       const p = this.opts.uriResolver.parse(ref);
       const refPath = (0, resolve_1._getFullPath)(this.opts.uriResolver, p);
-      let baseId = (0, resolve_1.getFullPath)(this.opts.uriResolver, root15.baseId, void 0);
-      if (Object.keys(root15.schema).length > 0 && refPath === baseId) {
-        return getJsonPointer.call(this, p, root15);
+      let baseId = (0, resolve_1.getFullPath)(this.opts.uriResolver, root16.baseId, void 0);
+      if (Object.keys(root16.schema).length > 0 && refPath === baseId) {
+        return getJsonPointer.call(this, p, root16);
       }
       const id = (0, resolve_1.normalizeId)(refPath);
       const schOrRef = this.refs[id] || this.schemas[id];
       if (typeof schOrRef == "string") {
-        const sch = resolveSchema.call(this, root15, schOrRef);
+        const sch = resolveSchema.call(this, root16, schOrRef);
         if (typeof (sch === null || sch === void 0 ? void 0 : sch.schema) !== "object")
           return;
         return getJsonPointer.call(this, p, sch);
@@ -3037,7 +3037,7 @@ var require_compile = __commonJS({
         const schId = schema[schemaId];
         if (schId)
           baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
-        return new SchemaEnv({ schema, schemaId, root: root15, baseId });
+        return new SchemaEnv({ schema, schemaId, root: root16, baseId });
       }
       return getJsonPointer.call(this, p, schOrRef);
     }
@@ -3049,7 +3049,7 @@ var require_compile = __commonJS({
       "dependencies",
       "definitions"
     ]);
-    function getJsonPointer(parsedRef, { baseId, schema, root: root15 }) {
+    function getJsonPointer(parsedRef, { baseId, schema, root: root16 }) {
       var _a;
       if (((_a = parsedRef.fragment) === null || _a === void 0 ? void 0 : _a[0]) !== "/")
         return;
@@ -3068,10 +3068,10 @@ var require_compile = __commonJS({
       let env;
       if (typeof schema != "boolean" && schema.$ref && !(0, util_1.schemaHasRulesButRef)(schema, this.RULES)) {
         const $ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schema.$ref);
-        env = resolveSchema.call(this, root15, $ref);
+        env = resolveSchema.call(this, root16, $ref);
       }
       const { schemaId } = this.opts;
-      env = env || new SchemaEnv({ schema, schemaId, root: root15, baseId });
+      env = env || new SchemaEnv({ schema, schemaId, root: root16, baseId });
       if (env.schema !== env.root.schema)
         return env;
       return void 0;
@@ -4226,8 +4226,8 @@ var require_core = __commonJS({
           keyRef = sch;
         if (sch === void 0) {
           const { schemaId } = this.opts;
-          const root15 = new compile_1.SchemaEnv({ schema: {}, schemaId });
-          sch = compile_1.resolveSchema.call(this, root15, keyRef);
+          const root16 = new compile_1.SchemaEnv({ schema: {}, schemaId });
+          sch = compile_1.resolveSchema.call(this, root16, keyRef);
           if (!sch)
             return;
           this.refs[keyRef] = sch;
@@ -4588,20 +4588,20 @@ var require_ref = __commonJS({
       code(cxt) {
         const { gen, schema: $ref, it } = cxt;
         const { baseId, schemaEnv: env, validateName, opts, self } = it;
-        const { root: root15 } = env;
-        if (($ref === "#" || $ref === "#/") && baseId === root15.baseId)
+        const { root: root16 } = env;
+        if (($ref === "#" || $ref === "#/") && baseId === root16.baseId)
           return callRootRef();
-        const schOrEnv = compile_1.resolveRef.call(self, root15, baseId, $ref);
+        const schOrEnv = compile_1.resolveRef.call(self, root16, baseId, $ref);
         if (schOrEnv === void 0)
           throw new ref_error_1.default(it.opts.uriResolver, baseId, $ref);
         if (schOrEnv instanceof compile_1.SchemaEnv)
           return callValidate(schOrEnv);
         return inlineRefSchema(schOrEnv);
         function callRootRef() {
-          if (env === root15)
+          if (env === root16)
             return callRef(cxt, validateName, env, env.$async);
-          const rootName = gen.scopeValue("root", { ref: root15 });
-          return callRef(cxt, (0, codegen_1._)`${rootName}.validate`, root15, root15.$async);
+          const rootName = gen.scopeValue("root", { ref: root16 });
+          return callRef(cxt, (0, codegen_1._)`${rootName}.validate`, root16, root16.$async);
         }
         function callValidate(sch) {
           const v = getValidate(cxt, sch);
@@ -7014,6 +7014,8 @@ var USAGE_BILLING_DENIAL_CODES = [
   "usage_billing_insufficient_credit",
   "usage_billing_no_billing_account"
 ];
+var USAGE_BILLING_TEMPORARILY_UNAVAILABLE_CODE = "usage_billing_temporarily_unavailable";
+var USAGE_BILLING_UNAVAILABLE_CODE = "usage_billing_unavailable";
 
 // ../../packages/core/dist/esm/constants/webhook-event-subscription.constants.js
 var WEBHOOK_EVENT_TYPES = [
@@ -7054,71 +7056,98 @@ var MODEL_CATALOG = {
   "gemini-2.5-flash-lite": {
     provider: "gemini",
     family: "2.5",
-    providerModelId: "gemini-2.5-flash-lite"
+    providerModelId: "gemini-2.5-flash-lite",
+    manifestSelectable: true
   },
   "gemini-2.5-flash": {
     provider: "gemini",
     family: "2.5",
-    providerModelId: "gemini-2.5-flash"
+    providerModelId: "gemini-2.5-flash",
+    manifestSelectable: true
   },
   "gemini-3.1-pro": {
     provider: "gemini",
     family: "3",
-    providerModelId: "gemini-3.1-pro-preview"
+    providerModelId: "gemini-3.1-pro-preview",
+    manifestSelectable: true
   },
   "gemini-3.8-flash": {
     provider: "gemini",
     family: "3",
-    providerModelId: "gemini-3.8-flash"
+    providerModelId: "gemini-3.8-flash",
+    manifestSelectable: true
   },
   "claude-opus-4-6": {
     provider: "anthropic",
     family: "4.6",
-    providerModelId: "claude-opus-4-6"
+    providerModelId: "claude-opus-4-6",
+    manifestSelectable: true
   },
   "claude-sonnet-5": {
     provider: "anthropic",
     family: "5",
-    providerModelId: "claude-sonnet-5"
+    providerModelId: "claude-sonnet-5",
+    manifestSelectable: true
+  },
+  "claude-sonnet-5-5": {
+    provider: "anthropic",
+    family: "5",
+    providerModelId: "claude-sonnet-5-5",
+    manifestSelectable: false
+  },
+  "claude-haiku-5-5": {
+    provider: "anthropic",
+    family: "5",
+    providerModelId: "claude-haiku-5-5",
+    manifestSelectable: false
   },
   "claude-sonnet-4-6": {
     provider: "anthropic",
     family: "4.6",
-    providerModelId: "claude-sonnet-4-6"
+    providerModelId: "claude-sonnet-4-6",
+    manifestSelectable: true
   },
   "claude-haiku-4-5": {
     provider: "anthropic",
     family: "4.5",
-    providerModelId: "claude-haiku-4-5"
+    providerModelId: "claude-haiku-4-5",
+    manifestSelectable: true
   },
   "deepseek-v4-flash": {
     provider: "openrouter",
     family: "deepseek",
-    providerModelId: "deepseek/deepseek-v4-flash-0731"
+    providerModelId: "deepseek/deepseek-v4-flash-0731",
+    manifestSelectable: true
   },
   "deepseek-v4-pro": {
     provider: "openrouter",
     family: "deepseek",
-    providerModelId: "deepseek/deepseek-v4-pro"
+    providerModelId: "deepseek/deepseek-v4-pro",
+    manifestSelectable: true
   },
   "mimo-v2.5": {
     provider: "openrouter",
     family: "mimo",
-    providerModelId: "xiaomi/mimo-v2.5"
+    providerModelId: "xiaomi/mimo-v2.5",
+    manifestSelectable: true
   },
   "mimo-v2.5-pro": {
     provider: "openrouter",
     family: "mimo",
-    providerModelId: "xiaomi/mimo-v2.5-pro"
+    providerModelId: "xiaomi/mimo-v2.5-pro",
+    manifestSelectable: true
   },
   "glm-5.2": {
     provider: "openrouter",
     family: "glm",
-    providerModelId: "z-ai/glm-5.2"
+    providerModelId: "z-ai/glm-5.2",
+    manifestSelectable: true
   }
 };
 var SUPPORTED_LLM_MODELS = Object.keys(MODEL_CATALOG);
 var SUPPORTED_SEARCH_MODELS = SUPPORTED_LLM_MODELS.filter(supportsWebSearch);
+var MANIFEST_LLM_MODELS = SUPPORTED_LLM_MODELS.filter((modelId) => MODEL_CATALOG[modelId].manifestSelectable);
+var MANIFEST_SEARCH_MODELS = MANIFEST_LLM_MODELS.filter((modelId) => supportsWebSearch(modelId));
 function supportsWebSearch(modelId) {
   const { provider } = MODEL_CATALOG[modelId];
   return provider === "gemini" || provider === "anthropic";
@@ -7158,7 +7187,161 @@ var admitUsersResponseSchema = z.object({
 });
 
 // ../../packages/core/dist/esm/schemas/admin-reliability.schema.js
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
+
+// ../../packages/core/dist/esm/schemas/usage-billing.schema.js
+import { z as z2 } from "zod";
+var UsageBillingProductSchema = z2.literal("automations");
+var USAGE_BILLING_BLOCK_REASONS = [
+  "insufficient_credit",
+  "temporarily_unavailable"
+];
+var USAGE_BILLING_AUTHORIZATION_DENIAL_REASONS = [
+  ...USAGE_BILLING_BLOCK_REASONS,
+  "no_billing_account"
+];
+var UsageBillingAuthorizationDenialReasonSchema = z2.enum(USAGE_BILLING_AUTHORIZATION_DENIAL_REASONS);
+var UsageBillingBlockReasonSchema = z2.enum(USAGE_BILLING_BLOCK_REASONS);
+var UsageBillingAccountSchema = z2.object({
+  id: z2.string().regex(/^[1-9]\d*$/),
+  type: z2.literal("user")
+});
+var RESERVATION_ID_MAX_LENGTH = 100;
+var EXTERNAL_EVENT_ID_MAX_LENGTH = 100;
+var CATEGORY_MAX_LENGTH = 64;
+var AuthorizeUsageRequestSchema = z2.object({
+  product: UsageBillingProductSchema,
+  account: UsageBillingAccountSchema,
+  reservation_id: z2.string().min(1).max(RESERVATION_ID_MAX_LENGTH),
+  category: z2.string().min(1).max(CATEGORY_MAX_LENGTH)
+});
+var UsageBillingUnitsSchema = z2.number().int().nonnegative();
+var UsageBillingBalanceSchema = z2.number().int();
+var RecordUsageRefsSchema = z2.record(z2.string().max(40), z2.string().max(500)).refine((refs) => Object.keys(refs).length <= 50);
+var AuthorizeUsageResponseSchema = z2.discriminatedUnion("decision", [
+  z2.object({
+    decision: z2.literal("allowed"),
+    reservation_id: z2.string().min(1),
+    available_units: UsageBillingBalanceSchema
+  }),
+  z2.object({
+    decision: z2.literal("denied"),
+    reason: UsageBillingAuthorizationDenialReasonSchema,
+    available_units: UsageBillingBalanceSchema
+  })
+]);
+var RecordUsageRequestSchema = z2.object({
+  product: UsageBillingProductSchema,
+  account: UsageBillingAccountSchema,
+  reservation_id: z2.string().min(1).max(RESERVATION_ID_MAX_LENGTH),
+  external_event_id: z2.string().min(1).max(EXTERNAL_EVENT_ID_MAX_LENGTH).refine((value) => !value.startsWith("reservation:")),
+  category: z2.string().min(1).max(CATEGORY_MAX_LENGTH),
+  status: z2.enum(["success", "failed", "cancelled", "timed_out", "partial"]),
+  incurred_cost: z2.number().int().nonnegative(),
+  refs: RecordUsageRefsSchema.optional(),
+  description: z2.string().min(1).max(255)
+});
+var RecordUsageResponseSchema = z2.object({
+  recorded: z2.boolean(),
+  charged_units: UsageBillingUnitsSchema,
+  available_units: UsageBillingBalanceSchema
+});
+var TOP_UP_USD_MIN_AMOUNT = 500;
+var TopUpCurrencySchema = z2.preprocess((value) => typeof value === "string" ? value.toLowerCase() : value, z2.literal("usd"));
+var StartTopUpRequestSchema = z2.object({
+  amount: z2.number().int().min(TOP_UP_USD_MIN_AMOUNT),
+  // The public OpenAPI example uses lowercase `usd`; the backend also
+  // normalizes caller casing before checking the currently supported currency.
+  currency: TopUpCurrencySchema,
+  return_url: z2.url()
+});
+var StartTopUpResponseSchema = z2.object({
+  session_id: z2.string().min(1),
+  checkout_url: z2.url()
+});
+var BillingPortalUrlRequestSchema = z2.object({
+  return_url: z2.url()
+});
+var BillingPortalUrlResponseSchema = z2.object({
+  billing_portal_url: z2.url()
+});
+var ReadStateResponseSchema = z2.object({
+  available_units: UsageBillingBalanceSchema,
+  available_amount: UsageBillingBalanceSchema,
+  currency: z2.string(),
+  usage_allowed: z2.boolean(),
+  low_balance: z2.boolean(),
+  depleted: z2.boolean(),
+  /**
+   * Additive hold-free snapshot. These fields remain optional until every
+   * Todoist producer emits them, and balances may be overdrawn after a
+   * settlement.
+   */
+  settled_units: UsageBillingBalanceSchema.optional(),
+  settled_amount: UsageBillingBalanceSchema.optional(),
+  is_settled_low_balance: z2.boolean().optional(),
+  usage_block_reason: UsageBillingBlockReasonSchema.nullable().optional()
+});
+var UsageBillingAmountSchema = UsageBillingUnitsSchema.nullable();
+var UsageBillingEntrySchema = z2.object({
+  id: z2.number().int().positive(),
+  type: z2.string().min(1),
+  created_at: z2.iso.datetime(),
+  category: z2.string().min(1).optional(),
+  status: z2.string().min(1).optional(),
+  charged_units: UsageBillingAmountSchema,
+  /** `charged_units` in integer microdollars. `null` exactly when it is. */
+  charged_amount: UsageBillingAmountSchema,
+  credited_units: UsageBillingAmountSchema,
+  /** `credited_units` in integer microdollars. `null` exactly when it is. */
+  credited_amount: UsageBillingAmountSchema,
+  refs: z2.record(z2.string(), z2.unknown()).optional(),
+  description: z2.string().optional()
+}).refine((entry) => entry.charged_units === null === (entry.charged_amount === null) && entry.credited_units === null === (entry.credited_amount === null), { message: "Each units field and its amount must be null together" });
+var USAGE_BILLING_ENTRY_TYPES = [
+  "usage_settled",
+  "top_up",
+  "adjustment",
+  "void",
+  "expiry",
+  "chargeback"
+];
+var UsageBillingEntryTypeSchema = z2.enum(USAGE_BILLING_ENTRY_TYPES);
+var ReadTransactionsResponseSchema = z2.object({
+  /**
+   * On the page rather than on each entry: an account pins one price for its
+   * whole life, so no two entries can differ.
+   */
+  currency: z2.string(),
+  entries: z2.array(UsageBillingEntrySchema),
+  has_more: z2.boolean(),
+  /** Absent on the last page. */
+  next_cursor: z2.string().min(1).optional()
+});
+var ReadUsageSummaryRequestSchema = z2.object({
+  /** Omit to total every category. */
+  category: z2.string().min(1).optional(),
+  /** Start of the window, inclusive. Omit to start at the account's first event. */
+  since: z2.iso.datetime().optional(),
+  /** End of the window, exclusive. Omit to run to now. */
+  until: z2.iso.datetime().optional()
+});
+var ReadUsageSummaryResponseSchema = z2.object({
+  currency: z2.string(),
+  usage_count: UsageBillingUnitsSchema,
+  charged_units: UsageBillingUnitsSchema,
+  /** `charged_units` in integer microdollars. `0` on an account with no usage. */
+  charged_amount: UsageBillingUnitsSchema
+});
+var GrantWelcomeCreditRequestSchema = z2.object({
+  product: UsageBillingProductSchema,
+  account: UsageBillingAccountSchema,
+  operator: z2.email().max(254)
+});
+var GrantWelcomeCreditResponseSchema = z2.object({
+  status: z2.enum(["granted", "already_granted"]),
+  grant_id: z2.string().min(1)
+});
 
 // ../../packages/core/dist/esm/types/failure-category.types.js
 var FAILURE_CATEGORIES = [
@@ -7184,22 +7367,22 @@ var FAILURE_CATEGORIES = [
   "billing_unavailable",
   "unknown"
 ];
-var SKIP_CATEGORIES = ["insufficient_credit"];
+var SKIP_CATEGORIES = USAGE_BILLING_AUTHORIZATION_DENIAL_REASONS;
 
 // ../../packages/core/dist/esm/schemas/automation-run.schema.js
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // ../../packages/core/dist/esm/schemas/shared.schema.js
-import { z as z2 } from "zod";
-var RolloutCompatibleNullableStringSchema = z2.string().nullish().transform((value) => value ?? null);
+import { z as z3 } from "zod";
+var RolloutCompatibleNullableStringSchema = z3.string().nullish().transform((value) => value ?? null);
 
 // ../../packages/core/dist/esm/schemas/query-param.schema.js
-import { z as z3 } from "zod";
-var isoDateTimeOrDateQueryParamSchema = z3.union([
-  z3.iso.datetime({ offset: true }),
-  z3.iso.date()
+import { z as z4 } from "zod";
+var isoDateTimeOrDateQueryParamSchema = z4.union([
+  z4.iso.datetime({ offset: true }),
+  z4.iso.date()
 ]);
-var booleanQueryParamSchema = z3.preprocess((value) => value === "true" ? true : value === "false" ? false : value, z3.boolean());
+var booleanQueryParamSchema = z4.preprocess((value) => value === "true" ? true : value === "false" ? false : value, z4.boolean());
 var booleanQueryFlagSchema = booleanQueryParamSchema.optional().transform((value) => value === true);
 
 // ../../packages/core/dist/esm/schemas/automation-run.schema.js
@@ -7220,8 +7403,8 @@ function isEmptyRunDateRange(range) {
     return false;
   return untilExclusive ? since.getTime() >= until.getTime() : since.getTime() > until.getTime();
 }
-var ListAutomationRunsQuerySchema = z4.object({
-  status: z4.enum(AUTOMATION_RUN_STATUSES).optional(),
+var ListAutomationRunsQuerySchema = z5.object({
+  status: z5.enum(AUTOMATION_RUN_STATUSES).optional(),
   since: isoDateTimeOrDateQueryParamSchema.optional(),
   until: isoDateTimeOrDateQueryParamSchema.optional()
 }).superRefine((query, ctx) => {
@@ -7233,45 +7416,45 @@ var ListAutomationRunsQuerySchema = z4.object({
     });
   }
 });
-var AutomationRunResultSchema = z4.object({
-  type: z4.literal("markdown"),
-  text: z4.string().trim().min(1).max(AUTOMATION_RUN_RESULT_TEXT_MAX_LENGTH)
+var AutomationRunResultSchema = z5.object({
+  type: z5.literal("markdown"),
+  text: z5.string().trim().min(1).max(AUTOMATION_RUN_RESULT_TEXT_MAX_LENGTH)
 });
 var RolloutCompatibleAutomationRunResultSchema = AutomationRunResultSchema.nullish().transform((result) => {
   return result ?? null;
 });
 var automationRunDtoBaseShape = {
-  id: z4.string(),
-  automationId: z4.string(),
-  createdAt: z4.string(),
-  updatedAt: z4.string(),
+  id: z5.string(),
+  automationId: z5.string(),
+  createdAt: z5.string(),
+  updatedAt: z5.string(),
   result: RolloutCompatibleAutomationRunResultSchema,
-  temporalUrl: z4.string().nullish(),
+  temporalUrl: z5.string().nullish(),
   // Whoever started the run from the app; null for schedules, webhooks and
   // API triggers, and for a worker that predates the field.
   triggeredBy: RolloutCompatibleNullableStringSchema
 };
-var AutomationRunDtoSchema = z4.discriminatedUnion("status", [
-  z4.object({ ...automationRunDtoBaseShape, status: z4.literal("pending") }),
-  z4.object({ ...automationRunDtoBaseShape, status: z4.literal("running") }),
-  z4.object({ ...automationRunDtoBaseShape, status: z4.literal("completed") }),
-  z4.object({ ...automationRunDtoBaseShape, status: z4.literal("cancelled") }),
-  z4.object({
+var AutomationRunDtoSchema = z5.discriminatedUnion("status", [
+  z5.object({ ...automationRunDtoBaseShape, status: z5.literal("pending") }),
+  z5.object({ ...automationRunDtoBaseShape, status: z5.literal("running") }),
+  z5.object({ ...automationRunDtoBaseShape, status: z5.literal("completed") }),
+  z5.object({ ...automationRunDtoBaseShape, status: z5.literal("cancelled") }),
+  z5.object({
     ...automationRunDtoBaseShape,
-    status: z4.literal("failed"),
-    failureReason: z4.string().nullish(),
-    failureCategory: z4.enum(FAILURE_CATEGORIES).nullish().catch(null)
+    status: z5.literal("failed"),
+    failureReason: z5.string().nullish(),
+    failureCategory: z5.enum(FAILURE_CATEGORIES).nullish().catch(null)
   }),
-  z4.object({
+  z5.object({
     ...automationRunDtoBaseShape,
-    status: z4.literal("skipped"),
-    skipReason: z4.string().nullish(),
-    skipCategory: z4.enum(SKIP_CATEGORIES).nullish()
+    status: z5.literal("skipped"),
+    skipReason: z5.string().nullish(),
+    skipCategory: z5.enum(SKIP_CATEGORIES).nullish()
   })
 ]);
-var automationRunListResponseSchema = z4.object({
-  data: z4.array(AutomationRunDtoSchema),
-  nextCursor: z4.string().nullable()
+var automationRunListResponseSchema = z5.object({
+  data: z5.array(AutomationRunDtoSchema),
+  nextCursor: z5.string().nullable()
 });
 var MAX_TOOL_CALL_ARGUMENT_KEYS = 32;
 var MAX_TOOL_CALL_ARGUMENT_KEY_LENGTH = 64;
@@ -7290,41 +7473,41 @@ var TOOL_CALL_ERROR_CATEGORIES = [
   "invalid-request",
   "unknown"
 ];
-var ToolCallTimestampSchema = z4.union([z4.string(), z4.date()]).transform((timestamp) => timestamp instanceof Date ? timestamp.toISOString() : timestamp);
-var SafeToolCallDtoSchema = z4.object({
-  id: z4.string(),
-  name: z4.string(),
-  argumentKeys: z4.array(z4.string()),
-  hasResult: z4.boolean(),
-  hasError: z4.boolean(),
-  outcome: z4.enum(TOOL_CALL_OUTCOMES).optional(),
-  errorCategory: z4.enum(TOOL_CALL_ERROR_CATEGORIES).optional(),
-  resultPreview: z4.string().max(MAX_TOOL_CALL_PREVIEW_LENGTH).optional(),
-  errorPreview: z4.string().max(MAX_TOOL_CALL_PREVIEW_LENGTH).optional(),
+var ToolCallTimestampSchema = z5.union([z5.string(), z5.date()]).transform((timestamp) => timestamp instanceof Date ? timestamp.toISOString() : timestamp);
+var SafeToolCallDtoSchema = z5.object({
+  id: z5.string(),
+  name: z5.string(),
+  argumentKeys: z5.array(z5.string()),
+  hasResult: z5.boolean(),
+  hasError: z5.boolean(),
+  outcome: z5.enum(TOOL_CALL_OUTCOMES).optional(),
+  errorCategory: z5.enum(TOOL_CALL_ERROR_CATEGORIES).optional(),
+  resultPreview: z5.string().max(MAX_TOOL_CALL_PREVIEW_LENGTH).optional(),
+  errorPreview: z5.string().max(MAX_TOOL_CALL_PREVIEW_LENGTH).optional(),
   timestamp: ToolCallTimestampSchema
 });
-var LegacyToolCallDtoInputSchema = z4.object({
-  id: z4.string(),
-  name: z4.string(),
-  arguments: z4.record(z4.string(), z4.unknown()).optional(),
-  result: z4.unknown().optional(),
-  error: z4.unknown().optional(),
-  errorStatus: z4.number().int().min(100).max(599).optional(),
-  errorCode: z4.string().optional(),
+var LegacyToolCallDtoInputSchema = z5.object({
+  id: z5.string(),
+  name: z5.string(),
+  arguments: z5.record(z5.string(), z5.unknown()).optional(),
+  result: z5.unknown().optional(),
+  error: z5.unknown().optional(),
+  errorStatus: z5.number().int().min(100).max(599).optional(),
+  errorCode: z5.string().optional(),
   timestamp: ToolCallTimestampSchema
 });
-var ToolCallDtoInputSchema = z4.union([SafeToolCallDtoSchema, LegacyToolCallDtoInputSchema]);
-var ToolCallDtoSchema = z4.preprocess((toolCall) => {
+var ToolCallDtoInputSchema = z5.union([SafeToolCallDtoSchema, LegacyToolCallDtoInputSchema]);
+var ToolCallDtoSchema = z5.preprocess((toolCall) => {
   const parsed = ToolCallDtoInputSchema.safeParse(toolCall);
   return parsed.success ? normalizeToolCallDto(parsed.data) : toolCall;
 }, SafeToolCallDtoSchema);
-var ToolCallDtosSchema = z4.preprocess((toolCalls) => {
+var ToolCallDtosSchema = z5.preprocess((toolCalls) => {
   if (!Array.isArray(toolCalls)) {
     return toolCalls;
   }
   const parsedToolCalls = toolCalls.map((toolCall) => ToolCallDtoInputSchema.safeParse(toolCall)).filter((result) => result.success).map((result) => result.data);
   return parsedToolCalls.length === toolCalls.length ? normalizeToolCallDtos(parsedToolCalls) : toolCalls;
-}, z4.array(SafeToolCallDtoSchema));
+}, z5.array(SafeToolCallDtoSchema));
 var AUTOMATION_RUN_DEBUG_REASONS = [
   "condition-not-met",
   "exit-condition-met",
@@ -7333,42 +7516,42 @@ var AUTOMATION_RUN_DEBUG_REASONS = [
   "run-result-not-configured",
   "run-result-empty"
 ];
-var AutomationRunDebugReasonSchema = z4.enum(AUTOMATION_RUN_DEBUG_REASONS);
-var AutomationRunStepDtoOutputSchema = z4.object({
-  stepId: z4.string(),
-  type: z4.string(),
-  description: z4.string(),
-  status: z4.enum(AUTOMATION_RUN_STATUSES),
-  startedAt: z4.string().optional(),
-  completedAt: z4.string().optional(),
-  result: z4.unknown().optional(),
-  error: z4.string().optional(),
-  generatedCode: z4.string().optional(),
+var AutomationRunDebugReasonSchema = z5.enum(AUTOMATION_RUN_DEBUG_REASONS);
+var AutomationRunStepDtoOutputSchema = z5.object({
+  stepId: z5.string(),
+  type: z5.string(),
+  description: z5.string(),
+  status: z5.enum(AUTOMATION_RUN_STATUSES),
+  startedAt: z5.string().optional(),
+  completedAt: z5.string().optional(),
+  result: z5.unknown().optional(),
+  error: z5.string().optional(),
+  generatedCode: z5.string().optional(),
   toolCalls: ToolCallDtosSchema.optional(),
   debugReason: AutomationRunDebugReasonSchema.optional()
 });
 var AutomationRunStepDtoSchema = AutomationRunStepDtoOutputSchema;
 var automationRunDetailDtoBaseShape = {
   ...automationRunDtoBaseShape,
-  steps: z4.array(AutomationRunStepDtoSchema)
+  steps: z5.array(AutomationRunStepDtoSchema)
 };
-var AutomationRunDetailDtoSchema = z4.discriminatedUnion("status", [
-  z4.object({ ...automationRunDetailDtoBaseShape, status: z4.literal("pending") }),
-  z4.object({ ...automationRunDetailDtoBaseShape, status: z4.literal("running") }),
-  z4.object({ ...automationRunDetailDtoBaseShape, status: z4.literal("completed") }),
-  z4.object({ ...automationRunDetailDtoBaseShape, status: z4.literal("cancelled") }),
-  z4.object({ ...automationRunDetailDtoBaseShape, status: z4.literal("data-expired") }),
-  z4.object({
+var AutomationRunDetailDtoSchema = z5.discriminatedUnion("status", [
+  z5.object({ ...automationRunDetailDtoBaseShape, status: z5.literal("pending") }),
+  z5.object({ ...automationRunDetailDtoBaseShape, status: z5.literal("running") }),
+  z5.object({ ...automationRunDetailDtoBaseShape, status: z5.literal("completed") }),
+  z5.object({ ...automationRunDetailDtoBaseShape, status: z5.literal("cancelled") }),
+  z5.object({ ...automationRunDetailDtoBaseShape, status: z5.literal("data-expired") }),
+  z5.object({
     ...automationRunDetailDtoBaseShape,
-    status: z4.literal("failed"),
-    failureReason: z4.string().nullish(),
-    failureCategory: z4.enum(FAILURE_CATEGORIES).nullish().catch(null)
+    status: z5.literal("failed"),
+    failureReason: z5.string().nullish(),
+    failureCategory: z5.enum(FAILURE_CATEGORIES).nullish().catch(null)
   }),
-  z4.object({
+  z5.object({
     ...automationRunDetailDtoBaseShape,
-    status: z4.literal("skipped"),
-    skipReason: z4.string().nullish(),
-    skipCategory: z4.enum(SKIP_CATEGORIES).nullish()
+    status: z5.literal("skipped"),
+    skipReason: z5.string().nullish(),
+    skipCategory: z5.enum(SKIP_CATEGORIES).nullish()
   })
 ]);
 function summarizeToolCallArgumentKeys(args) {
@@ -7708,7 +7891,7 @@ function isRecord(value) {
 // ../../packages/core/dist/esm/schemas/admin-reliability.schema.js
 var MAX_RELIABILITY_WINDOW_DAYS = 90;
 var MAX_RELIABILITY_WINDOW_MS = MAX_RELIABILITY_WINDOW_DAYS * 24 * 60 * 60 * 1e3;
-var adminReliabilityQuerySchema = z5.object({
+var adminReliabilityQuerySchema = z6.object({
   since: isoDateTimeOrDateQueryParamSchema.optional(),
   until: isoDateTimeOrDateQueryParamSchema.optional()
 }).refine((query) => {
@@ -7723,108 +7906,113 @@ var adminReliabilityQuerySchema = z5.object({
   path: ["since"],
   message: `Date range must be at most ${MAX_RELIABILITY_WINDOW_DAYS} days`
 });
-var adminReliabilityTotalsSchema = z5.object({
-  totalAutomations: z5.number(),
-  enabledAutomations: z5.number(),
-  totalLiveRuns: z5.number(),
-  terminalLiveRuns: z5.number(),
-  completedLiveRuns: z5.number(),
-  failedLiveRuns: z5.number(),
-  skippedLiveRuns: z5.number(),
-  insufficientCreditSkippedRuns: z5.number(),
-  failureRate: z5.number()
-});
-var adminReliabilityFailureCategorySchema = z5.object({
-  category: z5.enum(FAILURE_CATEGORIES).nullable(),
-  failures: z5.number(),
-  shareOfFailedRuns: z5.number(),
-  shareOfTerminalRuns: z5.number()
-});
-var adminReliabilityDailyRowSchema = z5.object({
-  date: z5.iso.date(),
-  terminalLiveRuns: z5.number(),
-  completedLiveRuns: z5.number(),
-  failedLiveRuns: z5.number(),
-  skippedLiveRuns: z5.number(),
-  insufficientCreditSkippedRuns: z5.number(),
-  failureRate: z5.number()
-});
-var adminReliabilityResponseSchema = z5.object({
-  since: z5.iso.datetime({ offset: true }),
-  until: z5.iso.datetime({ offset: true }),
+var adminReliabilityTotalsSchema = z6.object({
+  totalAutomations: z6.number(),
+  enabledAutomations: z6.number(),
+  totalLiveRuns: z6.number(),
+  terminalLiveRuns: z6.number(),
+  completedLiveRuns: z6.number(),
+  failedLiveRuns: z6.number(),
+  skippedLiveRuns: z6.number(),
+  insufficientCreditSkippedRuns: z6.number(),
+  failureRate: z6.number()
+});
+var adminReliabilityFailureCategorySchema = z6.object({
+  category: z6.enum(FAILURE_CATEGORIES).nullable(),
+  failures: z6.number(),
+  shareOfFailedRuns: z6.number(),
+  shareOfTerminalRuns: z6.number()
+});
+var adminReliabilityDailyRowSchema = z6.object({
+  date: z6.iso.date(),
+  terminalLiveRuns: z6.number(),
+  completedLiveRuns: z6.number(),
+  failedLiveRuns: z6.number(),
+  skippedLiveRuns: z6.number(),
+  insufficientCreditSkippedRuns: z6.number(),
+  failureRate: z6.number()
+});
+var adminReliabilityResponseSchema = z6.object({
+  since: z6.iso.datetime({ offset: true }),
+  until: z6.iso.datetime({ offset: true }),
   totals: adminReliabilityTotalsSchema,
-  failureCategories: z5.array(adminReliabilityFailureCategorySchema),
-  daily: z5.array(adminReliabilityDailyRowSchema)
+  failureCategories: z6.array(adminReliabilityFailureCategorySchema),
+  daily: z6.array(adminReliabilityDailyRowSchema)
 });
 
 // ../../packages/core/dist/esm/schemas/admin-sample-automation.schema.js
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // ../../packages/core/dist/esm/schemas/connector.schema.js
-import { z as z6 } from "zod";
-var TriggerSupportedEventSchema = z6.object({
-  id: z6.string(),
-  name: z6.string(),
-  description: z6.string()
-});
-var ConnectorCapabilitiesSchema = z6.object({
-  mcp: z6.object({
-    serverUrl: z6.string(),
-    scopes: z6.array(z6.string()),
-    connectionIds: z6.array(z6.string())
+import { z as z7 } from "zod";
+var TriggerSupportedEventSchema = z7.object({
+  id: z7.string(),
+  name: z7.string(),
+  description: z7.string()
+});
+var ConnectorCapabilitiesSchema = z7.object({
+  mcp: z7.object({
+    serverUrl: z7.string(),
+    scopes: z7.array(z7.string()),
+    connectionIds: z7.array(z7.string())
   }).optional(),
-  triggers: z6.object({
-    scopes: z6.array(z6.string()),
-    connectionIds: z6.array(z6.string()),
-    supportedEvents: z6.array(TriggerSupportedEventSchema)
+  triggers: z7.object({
+    scopes: z7.array(z7.string()),
+    connectionIds: z7.array(z7.string()),
+    supportedEvents: z7.array(TriggerSupportedEventSchema)
   }).optional()
 });
-var ConnectorSchema = z6.object({
-  id: z6.string(),
-  name: z6.string(),
-  description: z6.string(),
-  iconUrl: z6.url().nullable().optional(),
+var ConnectorSchema = z7.object({
+  id: z7.string(),
+  name: z7.string(),
+  description: z7.string(),
+  iconUrl: z7.url().nullable().optional(),
   capabilities: ConnectorCapabilitiesSchema,
   /** Whether this connector has any user account setup flow. */
-  requiresConnection: z6.boolean(),
+  requiresConnection: z7.boolean(),
   /**
    * Whether the connector is a product-owned built-in service. This is
    * independent from whether a third-party connector requires account setup.
    */
-  isSystem: z6.boolean().optional(),
+  isSystem: z7.boolean().optional(),
   /**
    * Managed connectors (e.g. WhatsApp) share a single linked identity across
    * connection types — one onboarding covers both action and trigger uses.
    * The FE collapses per-type rows into a single account when this is true.
    */
-  isManaged: z6.boolean().optional()
+  isManaged: z7.boolean().optional(),
+  /**
+   * The service only admits loopback OAuth clients, so account setup runs in
+   * the Automations CLI on the user's machine instead of the web app.
+   */
+  connectsViaCli: z7.boolean().optional()
 });
-var GetConnectorsQuerySchema = z6.object({
-  query: z6.string().optional()
+var GetConnectorsQuerySchema = z7.object({
+  query: z7.string().optional()
 });
-var GetConnectorActionsQuerySchema = z6.object({
-  connectionId: z6.uuid().optional()
+var GetConnectorActionsQuerySchema = z7.object({
+  connectionId: z7.uuid().optional()
 });
-var ConnectorActionsResponseSchema = z6.object({
-  actions: z6.array(z6.object({
-    name: z6.string(),
-    title: z6.string().optional(),
-    description: z6.string()
+var ConnectorActionsResponseSchema = z7.object({
+  actions: z7.array(z7.object({
+    name: z7.string(),
+    title: z7.string().optional(),
+    description: z7.string()
   }))
 });
-var connectorDetailsSchema = z6.object({
-  name: z6.string(),
-  displayName: z6.string(),
-  description: z6.string(),
-  iconUrl: z6.string().nullable().optional()
+var connectorDetailsSchema = z7.object({
+  name: z7.string(),
+  displayName: z7.string(),
+  description: z7.string(),
+  iconUrl: z7.string().nullable().optional()
 });
-var connectorListResponseSchema = z6.object({
-  data: z6.array(ConnectorSchema),
-  nextCursor: z6.string().nullable()
+var connectorListResponseSchema = z7.object({
+  data: z7.array(ConnectorSchema),
+  nextCursor: z7.string().nullable()
 });
 
 // ../../packages/core/dist/esm/schemas/manifest.schema.js
-import { z as z7 } from "zod/v4";
+import { z as z8 } from "zod/v4";
 
 // ../../packages/core/dist/esm/utils/duration.js
 var durationUnits = ["ms", "s", "m", "h", "d", "w"];
@@ -8001,19 +8189,19 @@ function resolvePropertySchemaInSchema(schema, propertyPath) {
 
 // ../../packages/core/dist/esm/schemas/manifest.schema.js
 var uuidv7Regex = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-7[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/i;
-var uuidv7Schema = z7.string().regex(uuidv7Regex);
+var uuidv7Schema = z8.string().regex(uuidv7Regex);
 var timezoneComponent = "[A-Za-z0-9+]+(?:[._+-][A-Za-z0-9+]+)*";
-var durationStringSchema = z7.string().regex(durationStringRegex, "Must be a valid duration string (e.g., '500ms', '10s', '1m')").meta({
+var durationStringSchema = z8.string().regex(durationStringRegex, "Must be a valid duration string (e.g., '500ms', '10s', '1m')").meta({
   description: "A duration string, composed of a positive integer and a unit: 'ms', 's', 'm', 'h', 'd', 'w'."
 });
-var retrySchema = z7.object({
-  maxAttempts: z7.number().int().min(EXECUTION_RETRY_MIN_RETRIES).max(EXECUTION_RETRY_MAX_RETRIES).default(EXECUTION_RETRY_DEFAULT_RETRIES).meta({ description: "The number of retries after the initial step attempt." }),
-  strategy: z7.enum(["fixed", "exponential_backoff"]).default("exponential_backoff").meta({ description: "The backoff strategy to use for retries." }),
+var retrySchema = z8.object({
+  maxAttempts: z8.number().int().min(EXECUTION_RETRY_MIN_RETRIES).max(EXECUTION_RETRY_MAX_RETRIES).default(EXECUTION_RETRY_DEFAULT_RETRIES).meta({ description: "The number of retries after the initial step attempt." }),
+  strategy: z8.enum(["fixed", "exponential_backoff"]).default("exponential_backoff").meta({ description: "The backoff strategy to use for retries." }),
   delay: durationStringSchema.default(EXECUTION_RETRY_DEFAULT_DELAY).meta({
     description: "The initial delay between retries (e.g., '500ms', '1m', '10m')."
   })
 }).meta({ description: "Defines the retry policy for a failed step." });
-var onErrorSchema = z7.object({
+var onErrorSchema = z8.object({
   retries: retrySchema.optional()
 }).meta({
   description: "Defines the error handling policy for the automation or a specific step."
@@ -8024,13 +8212,13 @@ var executionTimeoutSchema = durationStringSchema.refine((value) => {
 }, { message: "Execution timeout must be between 1 minute and 60 minutes" }).meta({
   description: "Maximum runtime for a single step, expressed as a duration string (e.g., '10m')."
 });
-var executionPolicySchema = z7.object({
+var executionPolicySchema = z8.object({
   timeout: executionTimeoutSchema.optional().default(EXECUTION_TIMEOUT_DEFAULT),
   onError: onErrorSchema.optional()
 }).meta({
   description: "Defines how long a step may run and how failures are retried. Available globally and per step."
 });
-var intervalScheduleSchema = z7.string().regex(intervalScheduleRegex, "Must be a valid interval string (e.g., '45m' or '6h/5h')").meta({ description: "An interval string (e.g., '45m' or '6h/5h')." });
+var intervalScheduleSchema = z8.string().regex(intervalScheduleRegex, "Must be a valid interval string (e.g., '45m' or '6h/5h')").meta({ description: "An interval string (e.g., '45m' or '6h/5h')." });
 var cronScheduleSchema = (() => {
   function createCronField(rangePattern) {
     return `(?:(?:(?:\\*|(?:${rangePattern})(?:-(?:${rangePattern}))?)(?:\\/\\d+)?)(?:,(?:(?:\\*|(?:${rangePattern})(?:-(?:${rangePattern}))?)(?:\\/\\d+)?))*)`;
@@ -8042,72 +8230,72 @@ var cronScheduleSchema = (() => {
   const dayOfWeek = createCronField("[0-6]");
   const cronExpressionRegex = new RegExp(`^${minutes}\\s+${hours}\\s+${dayOfMonth}\\s+${month}\\s+${dayOfWeek}$`);
   const timezoneRegex = new RegExp(`^${timezoneComponent}(?:/${timezoneComponent})*$`);
-  return z7.object({
-    timezone: z7.string().regex(timezoneRegex, "Must be a valid IANA Time Zone name").meta({
+  return z8.object({
+    timezone: z8.string().regex(timezoneRegex, "Must be a valid IANA Time Zone name").meta({
       description: "IANA Time Zone name (e.g., America/New_York). Required for cron schedules."
     }),
-    expression: z7.string().regex(cronExpressionRegex, "Must be a valid 5-part cron expression").meta({
+    expression: z8.string().regex(cronExpressionRegex, "Must be a valid 5-part cron expression").meta({
       description: "Standard 5-part cron expression (minute hour day month dayOfWeek)"
     })
   }).meta({
     description: "A cron schedule with required timezone"
   });
 })();
-var scheduleValueSchema = z7.union([intervalScheduleSchema, cronScheduleSchema]).meta({ description: "The schedule definition for the trigger." });
+var scheduleValueSchema = z8.union([intervalScheduleSchema, cronScheduleSchema]).meta({ description: "The schedule definition for the trigger." });
 var TRIGGER_TYPES = ["schedule", "webhook", "api"];
-var scheduleTriggerSchema = z7.object({
-  type: z7.literal("schedule"),
+var scheduleTriggerSchema = z8.object({
+  type: z8.literal("schedule"),
   value: scheduleValueSchema,
-  description: z7.string().optional().meta({ description: "A natural language description of what the trigger does." })
+  description: z8.string().optional().meta({ description: "A natural language description of what the trigger does." })
 });
-var webhookTriggerSchema = z7.object({
-  type: z7.literal("webhook"),
-  event: z7.string({
+var webhookTriggerSchema = z8.object({
+  type: z8.literal("webhook"),
+  event: z8.string({
     message: 'Webhook triggers require an "event" field with the event type (e.g., "todoist.item.added").'
   }).regex(/^[a-z0-9-]+\.[a-z0-9_]+\.[a-z0-9_]+(\.[a-z0-9_]+)*$/, "Event type must be in the format 'connector.entity.action' with exactly 3 required parts, optionally followed by additional segments (e.g., 'todoist.item.added', 'google-calendar.event.created')").meta({
     description: "The event type to listen for (e.g., 'todoist.item.added', 'gmail.message.new'). This references a specific trigger definition from a connector."
   }),
-  outputSchema: z7.object({
-    type: z7.string({
+  outputSchema: z8.object({
+    type: z8.string({
       message: 'outputSchema must be a valid JSON Schema with a "type" field. Use {"type": "string"} or {"type": "object", ...}.'
     })
   }, {
     message: 'Webhook triggers require an "outputSchema" field describing the trigger payload structure.'
-  }).catchall(z7.unknown()).meta({
+  }).catchall(z8.unknown()).meta({
     description: "A JSON Schema that describes the structure of the trigger payload."
   }),
-  inputSchema: z7.record(z7.string(), z7.unknown()).optional().meta({
+  inputSchema: z8.record(z8.string(), z8.unknown()).optional().meta({
     description: "An optional JSON Schema to filter the CloudEvent data field. Only events matching this schema will trigger the automation."
   }),
-  description: z7.string().optional().meta({ description: "A natural language description of what the trigger does." })
+  description: z8.string().optional().meta({ description: "A natural language description of what the trigger does." })
 });
-var apiTriggerIdSchema = z7.string().regex(uuidv7Regex, "API trigger ID must be a valid UUIDv7");
-var apiTriggerSchema = z7.object({
-  type: z7.literal("api"),
+var apiTriggerIdSchema = z8.string().regex(uuidv7Regex, "API trigger ID must be a valid UUIDv7");
+var apiTriggerSchema = z8.object({
+  type: z8.literal("api"),
   id: apiTriggerIdSchema.optional().meta({
     description: "A system-generated unique ID for the trigger endpoint (UUIDv7 format). Auto-generated if not provided."
   }),
-  outputSchema: z7.object({
-    type: z7.string({
+  outputSchema: z8.object({
+    type: z8.string({
       message: 'outputSchema must be a valid JSON Schema with a "type" field. Use {"type": "string"} or {"type": "object", ...}.'
     })
   }, {
     message: 'API triggers require an "outputSchema" field describing the trigger payload structure.'
-  }).catchall(z7.unknown()).meta({
+  }).catchall(z8.unknown()).meta({
     description: "A JSON Schema that describes the structure of the trigger payload."
   }),
-  inputSchema: z7.object({
-    type: z7.string({
+  inputSchema: z8.object({
+    type: z8.string({
       message: 'inputSchema must be a valid JSON Schema with a "type" field. Use {"type": "string"} or {"type": "object", ...}.'
     })
   }, {
     message: 'API triggers with input validation require an "inputSchema" field to validate incoming request payloads.'
-  }).catchall(z7.unknown()).optional().meta({
+  }).catchall(z8.unknown()).optional().meta({
     description: "Optional JSON Schema to validate incoming request payloads."
   }),
-  description: z7.string().optional().meta({ description: "A natural language description of what the trigger does." })
+  description: z8.string().optional().meta({ description: "A natural language description of what the trigger does." })
 });
-var triggerSchema = z7.discriminatedUnion("type", [scheduleTriggerSchema, webhookTriggerSchema, apiTriggerSchema], {
+var triggerSchema = z8.discriminatedUnion("type", [scheduleTriggerSchema, webhookTriggerSchema, apiTriggerSchema], {
   message: 'Invalid trigger configuration. Schedule triggers need "value", webhook triggers need "event" and "outputSchema", API triggers need "outputSchema" (and optionally "id" and "inputSchema" for advanced features). Use the correct fields for your trigger type.'
 }).meta({ description: "Defines the event that initiates an automation run." });
 function validateTriggersConstraints(triggers, ctx) {
@@ -8116,7 +8304,7 @@ function validateTriggersConstraints(triggers, ctx) {
   const types = new Set(triggers.map((t) => t.type));
   if (types.size > 1) {
     ctx.addIssue({
-      code: z7.ZodIssueCode.custom,
+      code: z8.ZodIssueCode.custom,
       message: "All triggers must be the same type. Cannot mix schedule, webhook, and api triggers."
     });
     return;
@@ -8124,7 +8312,7 @@ function validateTriggersConstraints(triggers, ctx) {
   const triggerType = triggers[0]?.type;
   if ((triggerType === "schedule" || triggerType === "api") && triggers.length > 1) {
     ctx.addIssue({
-      code: z7.ZodIssueCode.custom,
+      code: z8.ZodIssueCode.custom,
       message: `Only one ${triggerType} trigger is allowed per automation.`
     });
     return;
@@ -8134,7 +8322,7 @@ function validateTriggersConstraints(triggers, ctx) {
     const connectors = new Set(events.map((e) => e.split(".")[0]));
     if (connectors.size > 1) {
       ctx.addIssue({
-        code: z7.ZodIssueCode.custom,
+        code: z8.ZodIssueCode.custom,
         message: `All webhook triggers must be from the same connector. Found: ${[...connectors].join(", ")}.`
       });
       return;
@@ -8142,20 +8330,20 @@ function validateTriggersConstraints(triggers, ctx) {
     const duplicateEvents = events.filter((e, i) => events.indexOf(e) !== i);
     if (duplicateEvents.length > 0) {
       ctx.addIssue({
-        code: z7.ZodIssueCode.custom,
+        code: z8.ZodIssueCode.custom,
         message: `Duplicate trigger events are not allowed: ${[...new Set(duplicateEvents)].join(", ")}.`
       });
     }
   }
 }
-var triggersSchema = z7.array(triggerSchema).nonempty({ message: "At least one trigger is required." }).superRefine(validateTriggersConstraints).meta({
+var triggersSchema = z8.array(triggerSchema).nonempty({ message: "At least one trigger is required." }).superRefine(validateTriggersConstraints).meta({
   description: "An array of triggers for the automation. Multiple webhook triggers from the same connector are supported."
 });
-var stepIdSchema = z7.string().regex(/^[a-zA-Z][a-zA-Z0-9]*$/, "ID must be in camelCase format (no dashes or underscores allowed)").meta({ description: "A unique camelCase identifier for the step." });
-var resultFromPathSchema = z7.string().regex(/^[a-zA-Z_]\w*(\.[a-zA-Z_]\w*)*$/, 'Path must be a dot-separated property path like "text" or "task.description".').meta({
+var stepIdSchema = z8.string().regex(/^[a-zA-Z][a-zA-Z0-9]*$/, "ID must be in camelCase format (no dashes or underscores allowed)").meta({ description: "A unique camelCase identifier for the step." });
+var resultFromPathSchema = z8.string().regex(/^[a-zA-Z_]\w*(\.[a-zA-Z_]\w*)*$/, 'Path must be a dot-separated property path like "text" or "task.description".').meta({
   description: 'Dot-separated property path relative to a step output, such as "text" or "task.description".'
 });
-var resultFromSchema = z7.object({
+var resultFromSchema = z8.object({
   stepId: stepIdSchema.meta({
     description: "The step whose output should be used as the persisted run result."
   }),
@@ -8163,28 +8351,28 @@ var resultFromSchema = z7.object({
 }).strict().meta({
   description: "Declares which step output becomes the persisted user-facing automation run result."
 });
-var stepOutputSchema = z7.object({
-  type: z7.string({
+var stepOutputSchema = z8.object({
+  type: z8.string({
     message: 'outputSchema must be a valid JSON Schema with a "type" field. Use {"type": "string"} or {"type": "object", ...}.'
   })
-}).catchall(z7.unknown()).meta({ description: "A JSON Schema object defining the expected output of this step." });
-var searchStepOutputSchema = z7.object({
-  type: z7.literal("string").meta({
+}).catchall(z8.unknown()).meta({ description: "A JSON Schema object defining the expected output of this step." });
+var searchStepOutputSchema = z8.object({
+  type: z8.literal("string").meta({
     description: 'Must be "string" for search steps.'
   })
 }).strict().default({ type: "string" }).meta({
   description: 'JSON Schema for search step output. Must be exactly {"type": "string"}.'
 });
-var exitOnSchema = z7.record(z7.string(), z7.unknown()).meta({
+var exitOnSchema = z8.record(z8.string(), z8.unknown()).meta({
   description: "A JSON Schema object that terminates the automation's run if matched. Otherwise, or if omitted, the automation continues to the next step."
 });
-var ifConditionSchema = z7.string().regex(ifConditionRegex, `Must be a single comparison, e.g. "{{steps.askUser.choice}} == 'archive'": a {{steps.<id>.<path>}} or {{trigger.<path>}} reference, then == or !=, then a single-quoted literal. No boolean combinators.`).meta({
+var ifConditionSchema = z8.string().regex(ifConditionRegex, `Must be a single comparison, e.g. "{{steps.askUser.choice}} == 'archive'": a {{steps.<id>.<path>}} or {{trigger.<path>}} reference, then == or !=, then a single-quoted literal. No boolean combinators.`).meta({
   description: `An optional condition gating whether this step runs, e.g. "{{steps.askUser.choice}} == 'archive'". A single comparison against an earlier step or trigger value; when false the step is skipped.`
 });
-var baseStepSchema = z7.object({
+var baseStepSchema = z8.object({
   id: stepIdSchema,
-  title: z7.string().optional().meta({ description: "A short human-readable title of the step." }),
-  description: z7.string().meta({ description: "A human-readable description of what the step does." }),
+  title: z8.string().optional().meta({ description: "A short human-readable title of the step." }),
+  description: z8.string().meta({ description: "A human-readable description of what the step does." }),
   if: ifConditionSchema.optional(),
   exitOn: exitOnSchema.optional().meta({
     description: "A JSON Schema object that terminates the automation's run if the step output matches. If omitted or not matched, execution continues."
@@ -8194,76 +8382,76 @@ var baseStepSchema = z7.object({
   })
 });
 var MODEL_TIERS = ["lite", "flash", "pro"];
-var SUPPORTED_MODEL_REFERENCES = [...MODEL_TIERS, ...SUPPORTED_LLM_MODELS];
-var modelReferenceSchema = z7.enum(SUPPORTED_MODEL_REFERENCES).meta({
+var SUPPORTED_MODEL_REFERENCES = [...MODEL_TIERS, ...MANIFEST_LLM_MODELS];
+var modelReferenceSchema = z8.enum(SUPPORTED_MODEL_REFERENCES).meta({
   description: "A stable model tier (lite, flash, pro) or a supported literal model override."
 });
-var llmStepSchema = baseStepSchema.merge(z7.object({
-  type: z7.literal("llm"),
-  prompt: z7.string().meta({ description: "The prompt template to be sent to the LLM." }),
+var llmStepSchema = baseStepSchema.merge(z8.object({
+  type: z8.literal("llm"),
+  prompt: z8.string().meta({ description: "The prompt template to be sent to the LLM." }),
   outputSchema: stepOutputSchema,
   model: modelReferenceSchema,
-  tools: z7.record(z7.string(), z7.array(z7.string())).default({}).meta({
+  tools: z8.record(z8.string(), z8.array(z8.string())).default({}).meta({
     description: 'A mapping from MCP server connector IDs to arrays of their tool names (e.g., {"todoist": ["find-tasks-by-date"], "linear": ["create-issue"]}).'
   })
 })).strict();
-var codegenStepSchema = baseStepSchema.merge(z7.object({
-  type: z7.literal("codegen"),
-  prompt: z7.string().meta({
+var codegenStepSchema = baseStepSchema.merge(z8.object({
+  type: z8.literal("codegen"),
+  prompt: z8.string().meta({
     description: "The goal or instruction for what the generated code should accomplish."
   }),
   outputSchema: stepOutputSchema,
   model: modelReferenceSchema,
-  tools: z7.record(z7.string(), z7.array(z7.string())).default({}).meta({
+  tools: z8.record(z8.string(), z8.array(z8.string())).default({}).meta({
     description: 'A mapping from MCP server connector IDs to arrays of their tool names that will be available in the generated code (e.g., {"todoist": ["find-tasks", "update-tasks"]}).'
   }),
-  extractedUrls: z7.array(z7.url()).optional().meta({
+  extractedUrls: z8.array(z8.url()).optional().meta({
     description: "URLs that will be fetched during step execution (auto-extracted from prompt examples)"
   })
 }));
-var runtimeSchema = z7.object({
-  language: z7.literal("typescript").meta({
+var runtimeSchema = z8.object({
+  language: z8.literal("typescript").meta({
     description: "Programming language. Only 'typescript' is supported in v0."
   }),
-  version: z7.enum(SUPPORTED_RUNTIME_VERSIONS).meta({
+  version: z8.enum(SUPPORTED_RUNTIME_VERSIONS).meta({
     description: "Language specification version. Supported values: '5.9', '6.0'."
   })
 }).meta({
   description: "Defines the execution environment for the code step."
 });
-var codeStepSchema = baseStepSchema.merge(z7.object({
-  type: z7.literal("code"),
+var codeStepSchema = baseStepSchema.merge(z8.object({
+  type: z8.literal("code"),
   outputSchema: stepOutputSchema,
   runtime: runtimeSchema.optional().default({ language: "typescript", version: "5.9" }).meta({
     description: "An object defining the execution environment. If omitted, it defaults to TypeScript 5.9."
   }),
-  code: z7.string().meta({
+  code: z8.string().meta({
     description: "The code to execute. It has access to trigger and steps objects."
   }),
-  extractedUrls: z7.array(z7.url()).optional().meta({
+  extractedUrls: z8.array(z8.url()).optional().meta({
     description: "URLs that will be fetched during step execution (auto-extracted from code)"
   })
 }));
-var searchStepSchema = baseStepSchema.merge(z7.object({
-  type: z7.literal("search"),
-  prompt: z7.string().min(1).meta({
+var searchStepSchema = baseStepSchema.merge(z8.object({
+  type: z8.literal("search"),
+  prompt: z8.string().min(1).meta({
     description: "The search prompt to execute using web search."
   }),
   outputSchema: searchStepOutputSchema,
-  model: z7.enum([...MODEL_TIERS, ...SUPPORTED_SEARCH_MODELS]).optional().meta({
+  model: z8.enum([...MODEL_TIERS, ...MANIFEST_SEARCH_MODELS]).optional().meta({
     description: "A stable tier (lite, flash, pro) or a supported search-enabled literal model override."
   })
 }));
-var delayStepOutputSchema = z7.object({
-  type: z7.literal("object").meta({
+var delayStepOutputSchema = z8.object({
+  type: z8.literal("object").meta({
     description: 'Must be "object" for delay steps.'
   })
-}).catchall(z7.unknown()).meta({
+}).catchall(z8.unknown()).meta({
   description: 'JSON Schema for delay step output. Must include {"type": "object"}.'
 });
 var baseDelayStepSchema = baseStepSchema.omit({ execution: true });
-var delayStepSchema = baseDelayStepSchema.merge(z7.object({
-  type: z7.literal("delay"),
+var delayStepSchema = baseDelayStepSchema.merge(z8.object({
+  type: z8.literal("delay"),
   duration: durationStringSchema.meta({
     description: "Duration to delay the execution for as a duration string, e.g., '1d', '1w', '2h'."
   }),
@@ -8275,16 +8463,16 @@ var askExpiresAfterSchema = durationStringSchema.refine((value) => durationStrin
 }).meta({
   description: "How long to wait for a response before the prompt expires, as a duration string (e.g. '1w'). Defaults to 1w, capped at 30d. On expiry the run terminates."
 });
-var askOptionSchema = z7.object({
-  label: z7.string().min(1).meta({ description: "The button text shown to the user." }),
-  value: z7.string().min(1).meta({
+var askOptionSchema = z8.object({
+  label: z8.string().min(1).meta({ description: "The button text shown to the user." }),
+  value: z8.string().min(1).meta({
     description: "The machine value emitted as the choice. Unique within the step."
   }),
-  terminate: z7.boolean().optional().default(false).meta({
+  terminate: z8.boolean().optional().default(false).meta({
     description: 'When true, choosing this option stops the run and no later steps execute (the explicit "deny"/"stop" path).'
   })
 }).strict().meta({ description: "A single selectable option in an ask step." });
-var askOptionsSchema = z7.array(askOptionSchema).min(2, "An ask step requires at least two options.").superRefine((options, ctx) => {
+var askOptionsSchema = z8.array(askOptionSchema).min(2, "An ask step requires at least two options.").superRefine((options, ctx) => {
   const seen = /* @__PURE__ */ new Set();
   for (let index = 0; index < options.length; index++) {
     const value = options[index]?.value;
@@ -8292,7 +8480,7 @@ var askOptionsSchema = z7.array(askOptionSchema).min(2, "An ask step requires at
       continue;
     if (seen.has(value)) {
       ctx.addIssue({
-        code: z7.ZodIssueCode.custom,
+        code: z8.ZodIssueCode.custom,
         message: `Duplicate option value "${value}". Option values must be unique within an ask step.`,
         path: [index, "value"]
       });
@@ -8308,19 +8496,19 @@ var askStepOutputSchema = stepOutputSchema.refine((schema) => {
 }).meta({
   description: 'A JSON Schema describing the ask step output. Must be an object with a "choice" property whose value is one of the option values.'
 });
-var askStepSchema = baseAskStepSchema.merge(z7.object({
-  type: z7.literal("ask"),
-  message: z7.string().min(1).meta({
+var askStepSchema = baseAskStepSchema.merge(z8.object({
+  type: z8.literal("ask"),
+  message: z8.string().min(1).meta({
     description: 'The short headline shown to the user, e.g. "Archive or delete 3 inactive projects?".'
   }),
-  details: z7.string().optional().meta({
+  details: z8.string().optional().meta({
     description: "Optional longer markdown context, e.g. a preview of what each option would do."
   }),
   options: askOptionsSchema,
   expiresAfter: askExpiresAfterSchema.optional().default(ASK_EXPIRES_AFTER_DEFAULT),
   outputSchema: askStepOutputSchema
 })).strict();
-var stepSchema = z7.discriminatedUnion("type", [
+var stepSchema = z8.discriminatedUnion("type", [
   llmStepSchema,
   codegenStepSchema,
   codeStepSchema,
@@ -8332,22 +8520,22 @@ var MANIFEST_VERSIONS = [0, 1];
 var CURRENT_MANIFEST_VERSION = MANIFEST_VERSIONS[MANIFEST_VERSIONS.length - 1];
 var manifestVersionSchema = (() => {
   const [firstVersion, ...otherVersions] = MANIFEST_VERSIONS;
-  let schema = z7.literal(firstVersion);
+  let schema = z8.literal(firstVersion);
   for (const version of otherVersions) {
-    schema = schema.or(z7.literal(version));
+    schema = schema.or(z8.literal(version));
   }
   return schema;
 })().meta({
   description: `The version of the manifest schema. Latest is ${MANIFEST_VERSIONS[MANIFEST_VERSIONS.length - 1]}.`
 });
-var manifestSchemaBase = z7.object({
+var manifestSchemaBase = z8.object({
   manifestVersion: manifestVersionSchema,
-  name: z7.string().min(1).meta({
+  name: z8.string().min(1).meta({
     description: "A human-readable name for the automation that can include spaces."
   }),
-  description: z7.string().meta({ description: "A human-readable description of the automation's purpose." }),
+  description: z8.string().meta({ description: "A human-readable description of the automation's purpose." }),
   triggers: triggersSchema,
-  overlap: z7.enum([
+  overlap: z8.enum([
     "skip",
     "buffer_one",
     "buffer_all",
@@ -8359,14 +8547,14 @@ var manifestSchemaBase = z7.object({
   }),
   execution: executionPolicySchema.optional().meta({ description: "Global defaults for timeout and retry behavior." }),
   resultFrom: resultFromSchema.optional(),
-  steps: z7.array(stepSchema).nonempty().meta({ description: "An ordered array of step objects that define the workflow." })
+  steps: z8.array(stepSchema).nonempty().meta({ description: "An ordered array of step objects that define the workflow." })
 }).meta({ description: "The root schema for an Automation Manifest, defining its behavior." });
 var manifestSchema = manifestSchemaBase.superRefine(validateManifestResultFrom).superRefine(validateManifestTemplateVariables).superRefine(validateManifestAskOverlap).superRefine(validateManifestAskChoiceEnum);
 var partialManifestSchema = manifestSchemaBase.partial().extend({
   // Override steps to allow empty array for drafts (remove .nonempty() requirement)
-  steps: z7.array(stepSchema).default([]),
+  steps: z8.array(stepSchema).default([]),
   // Override triggers to allow empty array for drafts (remove .nonempty() but keep invariants)
-  triggers: z7.array(triggerSchema).superRefine(validateTriggersConstraints).optional()
+  triggers: z8.array(triggerSchema).superRefine(validateTriggersConstraints).optional()
 }).required({
   manifestVersion: true,
   steps: true
@@ -8422,8 +8610,8 @@ function validateTemplateVariable({ variable, context, stepId, currentStepGuard,
   if (parts.length === 0) {
     return null;
   }
-  const [root15, ...rest] = parts;
-  if (root15 === "trigger") {
+  const [root16, ...rest] = parts;
+  if (root16 === "trigger") {
     if (rest.length === 0) {
       return `Step "${stepId}" ${sourceType} references "{{trigger}}" without a property. Use {{trigger.<property>}} syntax (e.g., {{trigger.payload}}, {{trigger.metadata}}).`;
     }
@@ -8446,7 +8634,7 @@ function validateTemplateVariable({ variable, context, stepId, currentStepGuard,
     }
     return null;
   }
-  if (root15 === "steps") {
+  if (root16 === "steps") {
     const referencedStepId = rest[0];
     if (!referencedStepId) {
       return `Step "${stepId}" ${sourceType} references "steps" but is missing the step identifier in template variable "{{${variable}}}". Use {{steps.<stepId>}} syntax.`;
@@ -8487,7 +8675,7 @@ function validateManifestAskOverlap(data, ctx) {
   const overlap = data.overlap ?? "skip";
   if (!BOUNDED_OVERLAP_MODES.includes(overlap)) {
     ctx.addIssue({
-      code: z7.ZodIssueCode.custom,
+      code: z8.ZodIssueCode.custom,
       message: `Manifests with an ask step must use a bounded overlap mode (${BOUNDED_OVERLAP_MODES.join(", ")}). "${overlap}" can accumulate parked or buffered runs while a prompt waits for a response.`,
       path: ["overlap"]
     });
@@ -8504,7 +8692,7 @@ function validateManifestAskChoiceEnum(data, ctx) {
     const choiceEnum = choiceSchema?.enum;
     if (!Array.isArray(choiceEnum)) {
       ctx.addIssue({
-        code: z7.ZodIssueCode.custom,
+        code: z8.ZodIssueCode.custom,
         message: `Ask step "${step.id ?? stepIndex}" outputSchema must declare choice as an enum of the option values.`,
         path: choicePath
       });
@@ -8513,7 +8701,7 @@ function validateManifestAskChoiceEnum(data, ctx) {
     const nonStringEnum = choiceEnum.filter((value) => typeof value !== "string");
     if (nonStringEnum.length > 0) {
       ctx.addIssue({
-        code: z7.ZodIssueCode.custom,
+        code: z8.ZodIssueCode.custom,
         message: `Ask step "${step.id ?? stepIndex}" outputSchema choice enum must contain only string values; ask options always emit strings.`,
         path: choicePath
       });
@@ -8531,7 +8719,7 @@ function validateManifestAskChoiceEnum(data, ctx) {
       unexpected.length > 0 ? `unexpected ${unexpected.map((v) => `'${v}'`).join(", ")}` : ""
     ].filter(Boolean).join("; ");
     ctx.addIssue({
-      code: z7.ZodIssueCode.custom,
+      code: z8.ZodIssueCode.custom,
       message: `Ask step "${step.id ?? stepIndex}" outputSchema choice enum must list exactly the option values (${detail}).`,
       path: choicePath
     });
@@ -8545,7 +8733,7 @@ function validateManifestResultFrom(data, ctx) {
   const referencedStep = steps.find((step) => step.id === data.resultFrom?.stepId);
   if (!referencedStep) {
     ctx.addIssue({
-      code: z7.ZodIssueCode.custom,
+      code: z8.ZodIssueCode.custom,
       message: `resultFrom.stepId references unknown step "${data.resultFrom.stepId}".`,
       path: ["resultFrom", "stepId"]
     });
@@ -8553,7 +8741,7 @@ function validateManifestResultFrom(data, ctx) {
   }
   if (referencedStep.if) {
     ctx.addIssue({
-      code: z7.ZodIssueCode.custom,
+      code: z8.ZodIssueCode.custom,
       message: `resultFrom.stepId references step "${referencedStep.id}", which only runs conditionally (\`if\`). resultFrom must point at a step that always runs.`,
       path: ["resultFrom", "stepId"]
     });
@@ -8562,7 +8750,7 @@ function validateManifestResultFrom(data, ctx) {
   const outputSchema23 = referencedStep.outputSchema;
   if (!outputSchema23) {
     ctx.addIssue({
-      code: z7.ZodIssueCode.custom,
+      code: z8.ZodIssueCode.custom,
       message: `resultFrom.stepId references step "${referencedStep.id}" without an outputSchema.`,
       path: ["resultFrom", "stepId"]
     });
@@ -8571,7 +8759,7 @@ function validateManifestResultFrom(data, ctx) {
   if (!data.resultFrom.path) {
     if (!isPlainStringSchema(outputSchema23)) {
       ctx.addIssue({
-        code: z7.ZodIssueCode.custom,
+        code: z8.ZodIssueCode.custom,
         message: "resultFrom.path may be omitted only when the referenced step outputSchema is a string.",
         path: ["resultFrom", "path"]
       });
@@ -8582,7 +8770,7 @@ function validateManifestResultFrom(data, ctx) {
   const resolvedSchema = resolvePropertySchemaInSchema(outputSchema23, propertyPath);
   if (!resolvedSchema) {
     ctx.addIssue({
-      code: z7.ZodIssueCode.custom,
+      code: z8.ZodIssueCode.custom,
       message: `resultFrom.path "${data.resultFrom.path}" does not exist in step "${referencedStep.id}" outputSchema.`,
       path: ["resultFrom", "path"]
     });
@@ -8590,7 +8778,7 @@ function validateManifestResultFrom(data, ctx) {
   }
   if (!isStringTypedSchema(resolvedSchema)) {
     ctx.addIssue({
-      code: z7.ZodIssueCode.custom,
+      code: z8.ZodIssueCode.custom,
       message: "resultFrom.path must resolve to a string value.",
       path: ["resultFrom", "path"]
     });
@@ -8721,7 +8909,7 @@ function validateManifestTemplateVariables(data, ctx) {
         });
         if (error) {
           ctx.addIssue({
-            code: z7.ZodIssueCode.custom,
+            code: z8.ZodIssueCode.custom,
             message: error,
             path: ["steps", stepIndex, "if"]
           });
@@ -8734,7 +8922,7 @@ function validateManifestTemplateVariables(data, ctx) {
       });
       if (literalError) {
         ctx.addIssue({
-          code: z7.ZodIssueCode.custom,
+          code: z8.ZodIssueCode.custom,
           message: literalError,
           path: ["steps", stepIndex, "if"]
         });
@@ -8756,7 +8944,7 @@ function validateManifestTemplateVariables(data, ctx) {
           unavailableStepRefs.add(parts[1]);
         } else {
           ctx.addIssue({
-            code: z7.ZodIssueCode.custom,
+            code: z8.ZodIssueCode.custom,
             message: error,
             path: ["steps", stepIndex, "prompt"]
           });
@@ -8786,7 +8974,7 @@ function validateManifestTemplateVariables(data, ctx) {
           if (!error)
             continue;
           ctx.addIssue({
-            code: z7.ZodIssueCode.custom,
+            code: z8.ZodIssueCode.custom,
             message: error,
             path: ["steps", stepIndex, fieldName]
           });
@@ -8803,14 +8991,14 @@ function validateManifestTemplateVariables(data, ctx) {
       const sourceType = step.type === "code" ? "code" : "prompt";
       const fieldName = step.type === "code" ? "code" : "prompt";
       ctx.addIssue({
-        code: z7.ZodIssueCode.custom,
+        code: z8.ZodIssueCode.custom,
         message: `Step "${step.id}" ${sourceType} references step "${referencedStepId}" before it is available. Steps can only reference outputs from earlier steps.`,
         path: ["steps", stepIndex, fieldName]
       });
     }
     for (const err of propertyPathErrors) {
       ctx.addIssue({
-        code: z7.ZodIssueCode.custom,
+        code: z8.ZodIssueCode.custom,
         message: err.message,
         path: err.path
       });
@@ -8825,45 +9013,45 @@ function validateManifestTemplateVariables(data, ctx) {
 }
 
 // ../../packages/core/dist/esm/schemas/admin-sample-automation.schema.js
-var sampleAutomationIdSchema = z8.string().trim().min(1, "Sample automation ID is required").max(100, "Sample automation ID must be 100 characters or fewer").regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Sample automation ID must use lowercase letters, numbers, and hyphens only");
-var sampleAutomationInstructionsSchema = z8.string().nullable();
-var adminSampleAutomationSchema = z8.object({
+var sampleAutomationIdSchema = z9.string().trim().min(1, "Sample automation ID is required").max(100, "Sample automation ID must be 100 characters or fewer").regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Sample automation ID must use lowercase letters, numbers, and hyphens only");
+var sampleAutomationInstructionsSchema = z9.string().nullable();
+var adminSampleAutomationSchema = z9.object({
   id: sampleAutomationIdSchema,
   manifest: manifestSchema,
   instructions: sampleAutomationInstructionsSchema.default(null),
-  connectorNames: z8.array(z8.string()),
-  connectorDetails: z8.array(connectorDetailsSchema),
-  isPublished: z8.boolean(),
-  isOneClickInstallEnabled: z8.boolean().default(false),
-  staffPick: z8.boolean().default(false),
-  createdAt: z8.string().datetime(),
-  updatedAt: z8.string().datetime()
-});
-var adminSampleAutomationsSchema = z8.array(adminSampleAutomationSchema);
-var createAdminSampleAutomationSchema = z8.object({
+  connectorNames: z9.array(z9.string()),
+  connectorDetails: z9.array(connectorDetailsSchema),
+  isPublished: z9.boolean(),
+  isOneClickInstallEnabled: z9.boolean().default(false),
+  staffPick: z9.boolean().default(false),
+  createdAt: z9.string().datetime(),
+  updatedAt: z9.string().datetime()
+});
+var adminSampleAutomationsSchema = z9.array(adminSampleAutomationSchema);
+var createAdminSampleAutomationSchema = z9.object({
   id: sampleAutomationIdSchema,
   manifest: manifestSchema,
   instructions: sampleAutomationInstructionsSchema.default(null),
-  isPublished: z8.boolean().default(false),
-  isOneClickInstallEnabled: z8.boolean().default(false),
-  staffPick: z8.boolean().default(false)
+  isPublished: z9.boolean().default(false),
+  isOneClickInstallEnabled: z9.boolean().default(false),
+  staffPick: z9.boolean().default(false)
 });
-var updateAdminSampleAutomationSchema = z8.object({
+var updateAdminSampleAutomationSchema = z9.object({
   manifest: manifestSchema,
   instructions: sampleAutomationInstructionsSchema.optional(),
-  isPublished: z8.boolean(),
-  isOneClickInstallEnabled: z8.boolean().optional(),
-  staffPick: z8.boolean().optional()
+  isPublished: z9.boolean(),
+  isOneClickInstallEnabled: z9.boolean().optional(),
+  staffPick: z9.boolean().optional()
 });
-var toggleAdminSampleAutomationPublicationSchema = z8.object({
-  isPublished: z8.boolean()
+var toggleAdminSampleAutomationPublicationSchema = z9.object({
+  isPublished: z9.boolean()
 });
-var deleteAdminSampleAutomationSchema = z8.object({
-  title: z8.string().min(1, "Sample automation title confirmation is required")
+var deleteAdminSampleAutomationSchema = z9.object({
+  title: z9.string().min(1, "Sample automation title confirmation is required")
 });
 
 // ../../packages/core/dist/esm/schemas/automation.schema.js
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 
 // ../../packages/core/dist/esm/types/automation.types.js
 var AUTOMATION_CONNECTION_STATUSES = ["ready", "almost-ready", "not-ready"];
@@ -8874,177 +9062,202 @@ var AUTOMATION_DISABLED_REASONS = [
 ];
 
 // ../../packages/core/dist/esm/schemas/connection.schema.js
-import { z as z9 } from "zod";
-var CreateConnectionParamsSchema = z9.object({
-  connectorId: z9.string(),
-  capability: z9.enum(CONNECTION_TYPES),
-  name: z9.string().optional()
-});
-var CreateConnectionBodySchema = z9.object({
-  automationIds: z9.array(z9.uuid()).optional()
-});
-var OAuthConnectionSetupSchema = z9.object({
-  kind: z9.literal("oauth"),
-  authorizationUrl: z9.string().url()
-});
-var ManagedConnectionSetupSchema = z9.object({
-  kind: z9.literal("managed"),
-  code: z9.string().regex(MANAGED_CONNECTION_SETUP_CODE_EXACT_REGEX),
-  instructions: z9.string(),
-  deepLinkUrl: z9.string().url().nullable(),
-  expiresAt: z9.iso.datetime()
-});
-var ConnectionSetupSchema = z9.discriminatedUnion("kind", [
+import { z as z10 } from "zod";
+var CreateConnectionParamsSchema = z10.object({
+  connectorId: z10.string(),
+  capability: z10.enum(CONNECTION_TYPES),
+  name: z10.string().optional()
+});
+var CreateConnectionBodySchema = z10.object({
+  automationIds: z10.array(z10.uuid()).optional()
+});
+var ImportLocalOAuthConnectionBodySchema = z10.object({
+  /** The public client the CLI registered; the server bound the grant to it. */
+  clientId: z10.string().min(1),
+  accessToken: z10.string().min(1),
+  refreshToken: z10.string().min(1).optional(),
+  /** Seconds until `accessToken` expires, as the token endpoint reported it. */
+  expiresIn: z10.number().int().positive().optional(),
+  /**
+   * A broken connection of the caller's, for the same connector, whose
+   * automation bindings move to the new grant when the account cannot be
+   * matched to it.
+   */
+  repairConnectionId: z10.uuid().optional()
+});
+var LocalOAuthSetupSchema = z10.object({
+  /** RFC 7591 registration endpoint; null when the server offers none. */
+  registrationEndpoint: z10.string().url().nullable(),
+  authorizationEndpoint: z10.string().url(),
+  tokenEndpoint: z10.string().url(),
+  /** RFC 8707 resource indicator for the MCP server, when it advertises one. */
+  resource: z10.string().url().nullable(),
+  scopes: z10.array(z10.string())
+});
+var OAuthConnectionSetupSchema = z10.object({
+  kind: z10.literal("oauth"),
+  authorizationUrl: z10.string().url()
+});
+var ManagedConnectionSetupSchema = z10.object({
+  kind: z10.literal("managed"),
+  code: z10.string().regex(MANAGED_CONNECTION_SETUP_CODE_EXACT_REGEX),
+  instructions: z10.string(),
+  deepLinkUrl: z10.string().url().nullable(),
+  expiresAt: z10.iso.datetime()
+});
+var ConnectionSetupSchema = z10.discriminatedUnion("kind", [
   OAuthConnectionSetupSchema,
   ManagedConnectionSetupSchema
 ]);
-var CreateConnectionResponseSchema = z9.object({
-  connectionId: z9.uuid(),
+var CreateConnectionResponseSchema = z10.object({
+  connectionId: z10.uuid(),
   setup: ConnectionSetupSchema.nullable()
 });
-var ConnectionCapabilitySchema = z9.object({
-  capability: z9.enum(CONNECTION_TYPES),
-  scopes: z9.array(z9.string()),
-  authorizedAt: z9.iso.datetime()
-});
-var ConnectionSchema = z9.object({
-  id: z9.uuid(),
-  name: z9.string(),
-  connectorId: z9.string(),
-  connectorIconUrl: z9.url().nullable().optional(),
-  capabilities: z9.array(ConnectionCapabilitySchema),
-  accountDisplayLabel: z9.string().optional(),
-  status: z9.enum(CONNECTION_STATUSES).optional(),
-  createdAt: z9.string().optional(),
-  metadata: z9.record(z9.string(), z9.unknown()),
+var ConnectionCapabilitySchema = z10.object({
+  capability: z10.enum(CONNECTION_TYPES),
+  scopes: z10.array(z10.string()),
+  authorizedAt: z10.iso.datetime()
+});
+var ConnectionSchema = z10.object({
+  id: z10.uuid(),
+  name: z10.string(),
+  connectorId: z10.string(),
+  connectorIconUrl: z10.url().nullable().optional(),
+  capabilities: z10.array(ConnectionCapabilitySchema),
+  accountDisplayLabel: z10.string().optional(),
+  status: z10.enum(CONNECTION_STATUSES).optional(),
+  createdAt: z10.string().optional(),
+  metadata: z10.record(z10.string(), z10.unknown()),
   setup: ConnectionSetupSchema.nullable()
 });
-var ConnectionDetailsSchema = z9.object({
-  id: z9.uuid(),
-  name: z9.string(),
-  connectorId: z9.string(),
-  connectorIconUrl: z9.url().nullable().optional(),
-  capabilities: z9.array(ConnectionCapabilitySchema),
-  accountDisplayLabel: z9.string(),
-  status: z9.enum(CONNECTION_STATUSES),
-  createdAt: z9.string(),
-  metadata: z9.record(z9.string(), z9.unknown()),
+var ConnectionDetailsSchema = z10.object({
+  id: z10.uuid(),
+  name: z10.string(),
+  connectorId: z10.string(),
+  connectorIconUrl: z10.url().nullable().optional(),
+  capabilities: z10.array(ConnectionCapabilitySchema),
+  accountDisplayLabel: z10.string(),
+  status: z10.enum(CONNECTION_STATUSES),
+  createdAt: z10.string(),
+  metadata: z10.record(z10.string(), z10.unknown()),
   setup: ConnectionSetupSchema.nullable()
 });
-var GetConnectionsQuerySchema = z9.object({
+var GetConnectionsQuerySchema = z10.object({
   /**
    * Capability filter. `type` is accepted as a deprecated alias during the
    * rolling-deploy window where older FE/SDK builds may still send the old
    * query param. Remove once all clients are on the post-PR1 SDK.
    */
-  capability: z9.enum(CONNECTION_TYPES).optional(),
-  type: z9.enum(CONNECTION_TYPES).optional(),
-  connectorId: z9.string().optional(),
-  status: z9.enum(CONNECTION_STATUSES).optional()
+  capability: z10.enum(CONNECTION_TYPES).optional(),
+  type: z10.enum(CONNECTION_TYPES).optional(),
+  connectorId: z10.string().optional(),
+  status: z10.enum(CONNECTION_STATUSES).optional()
 });
-var GetConnectionsResponseSchema = z9.object({
-  connections: z9.array(ConnectionSchema)
+var GetConnectionsResponseSchema = z10.object({
+  connections: z10.array(ConnectionSchema)
 });
-var DependentAutomationSchema = z9.object({
-  id: z9.string(),
-  name: z9.string(),
-  description: z9.string(),
-  enabled: z9.boolean(),
-  connectorStatus: z9.enum(["ready", "attention", "missing"]),
-  requiredConnectionTypes: z9.array(z9.enum(CONNECTION_TYPES))
+var DependentAutomationSchema = z10.object({
+  id: z10.string(),
+  name: z10.string(),
+  description: z10.string(),
+  enabled: z10.boolean(),
+  connectorStatus: z10.enum(["ready", "attention", "missing"]),
+  requiredConnectionTypes: z10.array(z10.enum(CONNECTION_TYPES))
 });
-var GetConnectionDependentAutomationsResponseSchema = z9.object({
-  automations: z9.array(DependentAutomationSchema)
+var GetConnectionDependentAutomationsResponseSchema = z10.object({
+  automations: z10.array(DependentAutomationSchema)
 });
 var CONNECTION_IN_USE_CONFLICT_CODE = "connection_in_use_conflict";
-var BlockingAutomationSchema = z9.object({
-  id: z9.string(),
-  name: z9.string()
+var BlockingAutomationSchema = z10.object({
+  id: z10.string(),
+  name: z10.string()
 });
-var ConnectionInUseConflictSchema = z9.object({
-  code: z9.literal(CONNECTION_IN_USE_CONFLICT_CODE),
-  message: z9.string(),
-  automations: z9.array(BlockingAutomationSchema)
+var ConnectionInUseConflictSchema = z10.object({
+  code: z10.literal(CONNECTION_IN_USE_CONFLICT_CODE),
+  message: z10.string(),
+  automations: z10.array(BlockingAutomationSchema)
 });
 
 // ../../packages/core/dist/esm/schemas/automation.schema.js
-var runStatusSchema = z10.discriminatedUnion("status", [
-  z10.object({
-    status: z10.literal("pending"),
-    lastRun: z10.iso.datetime().optional()
+var runStatusSchema = z11.discriminatedUnion("status", [
+  z11.object({
+    status: z11.literal("pending"),
+    lastRun: z11.iso.datetime().optional()
   }),
-  z10.object({
-    status: z10.literal("running"),
-    lastRun: z10.iso.datetime()
+  z11.object({
+    status: z11.literal("running"),
+    lastRun: z11.iso.datetime()
   }),
-  z10.object({
-    status: z10.literal("completed"),
-    lastRun: z10.iso.datetime()
+  z11.object({
+    status: z11.literal("completed"),
+    lastRun: z11.iso.datetime()
   }),
-  z10.object({
-    status: z10.literal("failed"),
-    lastRun: z10.iso.datetime(),
-    failureReason: z10.string().optional()
+  z11.object({
+    status: z11.literal("failed"),
+    lastRun: z11.iso.datetime(),
+    failureReason: z11.string().optional()
   }),
-  z10.object({
-    status: z10.literal("cancelled"),
-    lastRun: z10.iso.datetime()
+  z11.object({
+    status: z11.literal("cancelled"),
+    lastRun: z11.iso.datetime()
   }),
-  z10.object({
-    status: z10.literal("skipped"),
-    lastRun: z10.iso.datetime(),
-    skipReason: z10.string().optional(),
-    skipCategory: z10.enum(SKIP_CATEGORIES).optional()
+  z11.object({
+    status: z11.literal("skipped"),
+    lastRun: z11.iso.datetime(),
+    skipReason: z11.string().optional(),
+    skipCategory: z11.enum(SKIP_CATEGORIES).optional()
   })
 ]);
-var automationSchema = z10.object({
-  id: z10.string(),
-  connections: z10.array(ConnectionDetailsSchema),
-  enabled: z10.boolean(),
+var automationSchema = z11.object({
+  id: z11.string(),
+  connections: z11.array(ConnectionDetailsSchema),
+  enabled: z11.boolean(),
   status: runStatusSchema,
-  connectionStatus: z10.enum(AUTOMATION_CONNECTION_STATUSES),
-  draftId: z10.string().nullable(),
-  manifest: z10.union([manifestSchema, z10.record(z10.string(), z10.unknown())]).nullable(),
-  updatedAt: z10.iso.datetime(),
+  connectionStatus: z11.enum(AUTOMATION_CONNECTION_STATUSES),
+  draftId: z11.string().nullable(),
+  manifest: z11.union([manifestSchema, z11.record(z11.string(), z11.unknown())]).nullable(),
+  updatedAt: z11.iso.datetime(),
+  // The person who created the automation; null only from an API instance that predates it.
+  createdBy: RolloutCompatibleNullableStringSchema,
   // The last person who changed the automation; null until someone has.
   updatedBy: RolloutCompatibleNullableStringSchema,
   // null means the automation belongs to the creator's personal space
-  workspaceId: z10.string().nullable(),
-  visibility: z10.enum(AUTOMATION_VISIBILITIES),
-  isOwner: z10.boolean(),
-  disabledReason: z10.enum(AUTOMATION_DISABLED_REASONS).nullable()
+  workspaceId: z11.string().nullable(),
+  visibility: z11.enum(AUTOMATION_VISIBILITIES),
+  isOwner: z11.boolean(),
+  disabledReason: z11.enum(AUTOMATION_DISABLED_REASONS).nullable()
 });
-var automationListResponseSchema = z10.object({
-  data: z10.array(automationSchema),
-  nextCursor: z10.string().nullable()
+var automationListResponseSchema = z11.object({
+  data: z11.array(automationSchema),
+  nextCursor: z11.string().nullable()
 });
-var updateAutomationSchema = z10.object({
-  enabled: z10.boolean().optional(),
+var updateAutomationSchema = z11.object({
+  enabled: z11.boolean().optional(),
   manifest: manifestSchema.optional()
 }).refine((data) => Object.keys(data).length > 0, {
   message: "At least one field must be provided"
 });
-var updateAutomationMetadataSchema = z10.object({
-  name: z10.string().min(1),
-  description: z10.string()
+var updateAutomationMetadataSchema = z11.object({
+  name: z11.string().min(1),
+  description: z11.string()
 });
-var updateAutomationScheduleSchema = z10.object({
+var updateAutomationScheduleSchema = z11.object({
   value: scheduleValueSchema
 });
-var updateAutomationVisibilitySchema = z10.object({
-  visibility: z10.enum(AUTOMATION_VISIBILITIES)
+var updateAutomationVisibilitySchema = z11.object({
+  visibility: z11.enum(AUTOMATION_VISIBILITIES)
 });
-var moveAutomationSchema = z10.object({
-  visibility: z10.enum(AUTOMATION_VISIBILITIES).default("workspace")
+var moveAutomationSchema = z11.object({
+  visibility: z11.enum(AUTOMATION_VISIBILITIES).default("workspace")
 });
 
 // ../../packages/core/dist/esm/schemas/automation-connection.schema.js
-import z11 from "zod";
-var AutomationConnectionMappingSchema = z11.object({
-  connectorId: z11.string().trim().min(1, "connectorId is required"),
-  connectionId: z11.string().trim().min(1, "connectionId is required")
+import z12 from "zod";
+var AutomationConnectionMappingSchema = z12.object({
+  connectorId: z12.string().trim().min(1, "connectorId is required"),
+  connectionId: z12.string().trim().min(1, "connectionId is required")
 }).strict();
-var UpsertAutomationConnectionSchema = z11.object({
+var UpsertAutomationConnectionSchema = z12.object({
   connectionId: uuidv7Schema.min(1, "connectionId is required"),
   /**
    * Manifest slot to bind this connection to. Required when the
@@ -9053,37 +9266,37 @@ var UpsertAutomationConnectionSchema = z11.object({
    * onboarding). Optional for single-capability connections, where
    * the service infers the role from `connection.capabilities[0]`.
    */
-  connectionType: z11.enum(CONNECTION_TYPES).optional()
+  connectionType: z12.enum(CONNECTION_TYPES).optional()
 }).strict();
-var SetAutomationConnectionsSchema = z11.object({
-  mappings: z11.array(AutomationConnectionMappingSchema).nonempty("mappings cannot be empty")
+var SetAutomationConnectionsSchema = z12.object({
+  mappings: z12.array(AutomationConnectionMappingSchema).nonempty("mappings cannot be empty")
 }).strict();
-var RequiredConnectorSchema = z11.object({
-  connectorName: z11.string(),
-  connectorId: z11.string(),
-  connectorDisplayName: z11.string(),
-  description: z11.string(),
-  connectorIconUrl: z11.string().nullable(),
-  requiredTypes: z11.array(z11.enum(CONNECTION_TYPES)),
+var RequiredConnectorSchema = z12.object({
+  connectorName: z12.string(),
+  connectorId: z12.string(),
+  connectorDisplayName: z12.string(),
+  description: z12.string(),
+  connectorIconUrl: z12.string().nullable(),
+  requiredTypes: z12.array(z12.enum(CONNECTION_TYPES)),
   /** Whether uses of this connector require a Connection binding. */
-  requiresConnection: z11.boolean(),
+  requiresConnection: z12.boolean(),
   /**
    * Product-owned built-in status. Connection validation uses
    * `requiresConnection` independently from this UI classification.
    */
-  isSystem: z11.boolean().optional()
-});
-var AutomationConnectionSchema = z11.object({
-  connectorId: z11.string(),
-  connectionId: z11.uuid(),
-  connectorName: z11.string(),
-  connectorIconUrl: z11.url().nullable().optional(),
-  status: z11.enum(CONNECTION_STATUSES),
-  type: z11.enum(CONNECTION_TYPES)
-});
-var ConnectorTypeStatusSchema = z11.object({
-  required: z11.boolean(),
-  status: z11.enum(CONNECTOR_TYPE_STATUSES),
+  isSystem: z12.boolean().optional()
+});
+var AutomationConnectionSchema = z12.object({
+  connectorId: z12.string(),
+  connectionId: z12.uuid(),
+  connectorName: z12.string(),
+  connectorIconUrl: z12.url().nullable().optional(),
+  status: z12.enum(CONNECTION_STATUSES),
+  type: z12.enum(CONNECTION_TYPES)
+});
+var ConnectorTypeStatusSchema = z12.object({
+  required: z12.boolean(),
+  status: z12.enum(CONNECTOR_TYPE_STATUSES),
   connection: ConnectionSchema.pick({
     id: true,
     accountDisplayLabel: true,
@@ -9092,32 +9305,32 @@ var ConnectorTypeStatusSchema = z11.object({
   }).optional(),
   setup: ConnectionSetupSchema.nullable()
 });
-var AutomationConnectorStatusSchema = z11.object({
-  id: z11.string(),
-  name: z11.string(),
-  description: z11.string(),
-  iconUrl: z11.string().nullable(),
+var AutomationConnectorStatusSchema = z12.object({
+  id: z12.string(),
+  name: z12.string(),
+  description: z12.string(),
+  iconUrl: z12.string().nullable(),
   mcp: ConnectorTypeStatusSchema,
   trigger: ConnectorTypeStatusSchema
 });
-var AutomationConnectionValidationSchema = z11.object({
-  required: z11.array(RequiredConnectorSchema),
-  mapped: z11.array(AutomationConnectionSchema),
-  missing: z11.array(z11.object({
-    connectorName: z11.string(),
-    connectionType: z11.enum(CONNECTION_TYPES),
-    reason: z11.enum(CONNECTION_ISSUE_REASONS)
+var AutomationConnectionValidationSchema = z12.object({
+  required: z12.array(RequiredConnectorSchema),
+  mapped: z12.array(AutomationConnectionSchema),
+  missing: z12.array(z12.object({
+    connectorName: z12.string(),
+    connectionType: z12.enum(CONNECTION_TYPES),
+    reason: z12.enum(CONNECTION_ISSUE_REASONS)
   })),
-  connectors: z11.array(AutomationConnectorStatusSchema),
-  isReady: z11.boolean()
+  connectors: z12.array(AutomationConnectorStatusSchema),
+  isReady: z12.boolean()
 });
-var GetRequiredConnectorsResponseSchema = z11.object({
-  required: z11.array(RequiredConnectorSchema)
+var GetRequiredConnectorsResponseSchema = z12.object({
+  required: z12.array(RequiredConnectorSchema)
 });
-var GetAutomationConnectionsResponseSchema = z11.object({
-  data: z11.array(AutomationConnectionSchema)
+var GetAutomationConnectionsResponseSchema = z12.object({
+  data: z12.array(AutomationConnectionSchema)
 });
-var UpsertAutomationConnectionResponseSchema = z11.object({
+var UpsertAutomationConnectionResponseSchema = z12.object({
   data: AutomationConnectionSchema
 });
 var ManifestConnectionCheckResultSchema = AutomationConnectionValidationSchema.pick({
@@ -9126,389 +9339,406 @@ var ManifestConnectionCheckResultSchema = AutomationConnectionValidationSchema.p
 });
 
 // ../../packages/core/dist/esm/schemas/automation-execution.schema.js
-import { z as z12 } from "zod";
-var AutomationRunDebugEventSchema = z12.union([
-  z12.object({
-    stepId: z12.string(),
+import { z as z13 } from "zod";
+var AutomationRunDebugEventSchema = z13.union([
+  z13.object({
+    stepId: z13.string(),
     reason: AutomationRunDebugReasonSchema.exclude(["run-result-not-configured"])
   }),
-  z12.object({
-    reason: z12.literal("run-result-not-configured")
+  z13.object({
+    reason: z13.literal("run-result-not-configured")
   }).strict()
 ]);
-var groundingMetadataSchema = z12.object({
-  webSearchQueries: z12.array(z12.string()).optional(),
-  searchEntryPoint: z12.object({
-    renderedContent: z12.string().optional()
+var groundingMetadataSchema = z13.object({
+  webSearchQueries: z13.array(z13.string()).optional(),
+  searchEntryPoint: z13.object({
+    renderedContent: z13.string().optional()
   }).optional(),
-  groundingChunks: z12.array(z12.object({
-    web: z12.object({
-      uri: z12.string(),
-      title: z12.string().optional(),
-      domain: z12.string().optional()
+  groundingChunks: z13.array(z13.object({
+    web: z13.object({
+      uri: z13.string(),
+      title: z13.string().optional(),
+      domain: z13.string().optional()
     }).optional()
   })).optional(),
-  groundingSupports: z12.array(z12.object({
-    segment: z12.object({
-      startIndex: z12.number(),
-      endIndex: z12.number(),
-      text: z12.string().optional()
+  groundingSupports: z13.array(z13.object({
+    segment: z13.object({
+      startIndex: z13.number(),
+      endIndex: z13.number(),
+      text: z13.string().optional()
     }),
-    groundingChunkIndices: z12.array(z12.number()),
-    confidenceScores: z12.array(z12.number()).optional()
+    groundingChunkIndices: z13.array(z13.number()),
+    confidenceScores: z13.array(z13.number()).optional()
   })).optional(),
-  retrievalMetadata: z12.record(z12.string(), z12.unknown()).optional()
+  retrievalMetadata: z13.record(z13.string(), z13.unknown()).optional()
 });
-var automationStepUsageSchema = z12.object({
-  inputTokens: z12.number().nonnegative(),
-  outputTokens: z12.number().nonnegative(),
-  totalTokens: z12.number().nonnegative(),
-  totalCostMicroDollars: z12.number().nonnegative()
+var automationStepUsageSchema = z13.object({
+  inputTokens: z13.number().nonnegative(),
+  outputTokens: z13.number().nonnegative(),
+  totalTokens: z13.number().nonnegative(),
+  totalCostMicroDollars: z13.number().nonnegative()
 });
-var automationOutputSchema = z12.object({
-  stepId: z12.string(),
-  result: z12.unknown(),
+var automationOutputSchema = z13.object({
+  stepId: z13.string(),
+  result: z13.unknown(),
   toolCalls: ToolCallDtosSchema.optional(),
-  generatedCode: z12.string().optional(),
+  generatedCode: z13.string().optional(),
   groundingMetadata: groundingMetadataSchema.optional(),
   usage: automationStepUsageSchema.optional()
 });
-var automationExecutionResultSchema = z12.discriminatedUnion("status", [
-  z12.object({
-    status: z12.literal("success"),
-    outputs: z12.array(automationOutputSchema),
-    debugEvents: z12.array(AutomationRunDebugEventSchema).optional()
+var automationExecutionResultSchema = z13.discriminatedUnion("status", [
+  z13.object({
+    status: z13.literal("success"),
+    outputs: z13.array(automationOutputSchema),
+    debugEvents: z13.array(AutomationRunDebugEventSchema).optional()
   }),
-  z12.object({
-    status: z12.literal("skipped"),
-    skipReason: z12.string()
+  z13.object({
+    status: z13.literal("skipped"),
+    skipReason: z13.string()
   })
 ]);
 
 // ../../packages/core/dist/esm/schemas/automation-draft.schema.js
-import { z as z13 } from "zod";
-var automationDraftSchema = z13.object({
-  id: z13.string(),
-  partialManifest: z13.record(z13.string(), z13.unknown()),
-  isComplete: z13.boolean(),
-  automationId: z13.string().nullable(),
+import { z as z14 } from "zod";
+var automationDraftSchema = z14.object({
+  id: z14.string(),
+  partialManifest: z14.record(z14.string(), z14.unknown()),
+  isComplete: z14.boolean(),
+  automationId: z14.string().nullable(),
   conversationId: RolloutCompatibleNullableStringSchema,
   // null means the draft was authored in the creator's personal space
-  workspaceId: z13.string().nullable(),
-  createdAt: z13.string(),
-  updatedAt: z13.string(),
-  connectorDetails: z13.array(connectorDetailsSchema).optional()
+  workspaceId: z14.string().nullable(),
+  createdAt: z14.string(),
+  updatedAt: z14.string(),
+  connectorDetails: z14.array(connectorDetailsSchema).optional()
 });
-var automationDraftValidationSchema = z13.object({
-  state: z13.enum(["incomplete", "ready"]),
-  issues: z13.array(z13.string()),
-  modified: z13.boolean()
+var automationDraftValidationSchema = z14.object({
+  state: z14.enum(["incomplete", "ready"]),
+  issues: z14.array(z14.string()),
+  modified: z14.boolean()
 });
 var automationDraftWithValidationSchema = automationDraftValidationSchema.extend({
   draft: automationDraftSchema
 });
-var automationDraftListResponseSchema = z13.object({
-  data: z13.array(automationDraftSchema),
-  nextCursor: z13.string().nullable()
+var automationDraftListResponseSchema = z14.object({
+  data: z14.array(automationDraftSchema),
+  nextCursor: z14.string().nullable()
 });
-var finalizeAutomationDraftResponseSchema = z13.object({
+var finalizeAutomationDraftResponseSchema = z14.object({
   automation: automationSchema
 });
-var testAutomationDraftResponseSchema = z13.object({
-  success: z13.literal(true)
+var testAutomationDraftResponseSchema = z14.object({
+  success: z14.literal(true)
+});
+var AUTOMATION_OPEN_DRAFT_CONFLICT_CODE = "automation_open_draft_conflict";
+var AutomationOpenDraftConflictSchema = z14.object({
+  code: z14.literal(AUTOMATION_OPEN_DRAFT_CONFLICT_CODE),
+  message: z14.string(),
+  draftId: z14.string()
+});
+var AUTOMATION_DRAFT_NOT_READY_CODE = "automation_draft_not_ready";
+var AutomationDraftNotReadySchema = z14.object({
+  code: z14.literal(AUTOMATION_DRAFT_NOT_READY_CODE),
+  message: z14.string()
 });
 
 // ../../packages/core/dist/esm/schemas/automation-draft-connection.schema.js
-import z14 from "zod";
-var CreateAutomationDraftConnectionSchema = z14.object({
-  connectorId: z14.string().trim().min(1, "connectorId is required"),
-  connectionType: z14.enum(CONNECTION_TYPES),
+import z15 from "zod";
+var CreateAutomationDraftConnectionSchema = z15.object({
+  connectorId: z15.string().trim().min(1, "connectorId is required"),
+  connectionType: z15.enum(CONNECTION_TYPES),
   connectionId: uuidv7Schema.min(1, "connectionId is required")
 }).strict();
-var AutomationDraftConnectionSchema = z14.object({
-  draftId: z14.string(),
-  connectorId: z14.string(),
-  connectionId: z14.uuid(),
-  connectionType: z14.enum(CONNECTION_TYPES),
-  connectorName: z14.string(),
-  connectorIconUrl: z14.url().nullable().optional(),
-  status: z14.enum(CONNECTION_STATUSES),
-  createdAt: z14.string(),
-  updatedAt: z14.string()
-});
-var AutomationDraftConnectorStatusSchema = z14.object({
-  id: z14.string(),
-  name: z14.string(),
-  description: z14.string(),
-  iconUrl: z14.string().nullable(),
+var AutomationDraftConnectionSchema = z15.object({
+  draftId: z15.string(),
+  connectorId: z15.string(),
+  connectionId: z15.uuid(),
+  connectionType: z15.enum(CONNECTION_TYPES),
+  connectorName: z15.string(),
+  connectorIconUrl: z15.url().nullable().optional(),
+  status: z15.enum(CONNECTION_STATUSES),
+  createdAt: z15.string(),
+  updatedAt: z15.string()
+});
+var AutomationDraftConnectorStatusSchema = z15.object({
+  id: z15.string(),
+  name: z15.string(),
+  description: z15.string(),
+  iconUrl: z15.string().nullable(),
   mcp: ConnectorTypeStatusSchema,
   trigger: ConnectorTypeStatusSchema
 });
-var AutomationDraftConnectionValidationSchema = z14.object({
-  draftId: z14.string(),
-  connected: z14.array(AutomationDraftConnectionSchema),
-  missing: z14.array(z14.object({
-    connectorName: z14.string(),
-    connectionType: z14.enum(CONNECTION_TYPES),
-    reason: z14.enum(CONNECTION_ISSUE_REASONS)
+var AutomationDraftConnectionValidationSchema = z15.object({
+  draftId: z15.string(),
+  connected: z15.array(AutomationDraftConnectionSchema),
+  missing: z15.array(z15.object({
+    connectorName: z15.string(),
+    connectionType: z15.enum(CONNECTION_TYPES),
+    reason: z15.enum(CONNECTION_ISSUE_REASONS)
   })),
-  connectors: z14.array(AutomationDraftConnectorStatusSchema),
-  isValid: z14.boolean()
+  connectors: z15.array(AutomationDraftConnectorStatusSchema),
+  isValid: z15.boolean()
 });
-var GetAutomationDraftConnectionsResponseSchema = z14.object({
-  connections: z14.array(AutomationDraftConnectionSchema)
+var GetAutomationDraftConnectionsResponseSchema = z15.object({
+  connections: z15.array(AutomationDraftConnectionSchema)
 });
-var GetAutomationDraftConnectionValidationResponseSchema = z14.object({
+var GetAutomationDraftConnectionValidationResponseSchema = z15.object({
   validation: AutomationDraftConnectionValidationSchema
 });
 
 // ../../packages/core/dist/esm/schemas/automation-draft-message.schema.js
-import { z as z15 } from "zod";
-var saveMessageSchema = z15.object({
-  role: z15.string(),
-  parts: z15.unknown(),
-  order: z15.number(),
-  messageId: z15.string()
+import { z as z16 } from "zod";
+var saveMessageSchema = z16.object({
+  role: z16.string(),
+  parts: z16.unknown(),
+  order: z16.number(),
+  messageId: z16.string()
 });
 
 // ../../packages/core/dist/esm/schemas/chat.schema.js
-import { z as z16 } from "zod";
-var chatConversationSchema = z16.object({
-  id: z16.string(),
-  title: z16.string().nullable(),
-  archivedAt: z16.string().nullable(),
-  isArchived: z16.boolean(),
-  todoistUserId: z16.string(),
+import { z as z17 } from "zod";
+var chatConversationSchema = z17.object({
+  id: z17.string(),
+  title: z17.string().nullable(),
+  archivedAt: z17.string().nullable(),
+  isArchived: z17.boolean(),
+  todoistUserId: z17.string(),
   // null means the conversation was authored in the user's personal space
-  workspaceId: z16.string().nullable(),
-  createdAt: z16.string(),
-  updatedAt: z16.string()
+  workspaceId: z17.string().nullable(),
+  createdAt: z17.string(),
+  updatedAt: z17.string()
 });
 var chatMessageSchema = saveMessageSchema;
-var getConversationsResponseSchema = z16.array(chatConversationSchema);
-var getMessagesResponseSchema = z16.array(chatMessageSchema);
-var chatCompactionStatusSchema = z16.enum(["starting", "complete", "failed"]);
-var chatCompactionBlockerSchema = z16.enum([
+var getConversationsResponseSchema = z17.array(chatConversationSchema);
+var getMessagesResponseSchema = z17.array(chatMessageSchema);
+var chatCompactionStatusSchema = z17.enum(["starting", "complete", "failed"]);
+var chatCompactionBlockerSchema = z17.enum([
   "none",
   "insufficient_messages",
   "trailing_unanswered_user",
   "incomplete_tool_interaction"
 ]);
-var chatCompactionResultStatusSchema = z16.enum(["compacted", "skipped", "stale", "failed"]);
-var chatCompactionStatusDataSchema = z16.object({
+var chatCompactionResultStatusSchema = z17.enum(["compacted", "skipped", "stale", "failed"]);
+var chatCompactionStatusDataSchema = z17.object({
   status: chatCompactionStatusSchema,
-  conversationId: z16.string(),
-  compactionId: z16.string(),
-  message: z16.string()
-});
-var chatCompactionTelemetryDataSchema = z16.object({
-  kind: z16.literal("telemetry"),
-  phase: z16.enum(["snapshot", "post-compaction"]),
-  conversationId: z16.string(),
-  compactionId: z16.string().nullable(),
-  triggerMessages: z16.number().int().positive(),
-  triggerTokens: z16.number().int().positive(),
-  hardMaxTokens: z16.number().int().positive(),
-  preserveRecentTurns: z16.number().int().positive(),
-  messageCountAfterCutoff: z16.number().int().nonnegative(),
-  estimatedTokens: z16.number().int().nonnegative(),
-  thresholdProgressPercent: z16.number().int().min(0).max(100),
-  shouldCompact: z16.boolean(),
-  boundaryEligible: z16.boolean(),
+  conversationId: z17.string(),
+  compactionId: z17.string(),
+  message: z17.string()
+});
+var chatCompactionTelemetryDataSchema = z17.object({
+  kind: z17.literal("telemetry"),
+  phase: z17.enum(["snapshot", "post-compaction"]),
+  conversationId: z17.string(),
+  compactionId: z17.string().nullable(),
+  triggerMessages: z17.number().int().positive(),
+  triggerTokens: z17.number().int().positive(),
+  hardMaxTokens: z17.number().int().positive(),
+  preserveRecentTurns: z17.number().int().positive(),
+  messageCountAfterCutoff: z17.number().int().nonnegative(),
+  estimatedTokens: z17.number().int().nonnegative(),
+  thresholdProgressPercent: z17.number().int().min(0).max(100),
+  shouldCompact: z17.boolean(),
+  boundaryEligible: z17.boolean(),
   blocker: chatCompactionBlockerSchema,
-  attempted: z16.boolean(),
+  attempted: z17.boolean(),
   resultStatus: chatCompactionResultStatusSchema.nullable(),
-  messagesSummarized: z16.number().int().nonnegative().nullable(),
-  cutoffOrder: z16.number().int().positive().nullable()
+  messagesSummarized: z17.number().int().nonnegative().nullable(),
+  cutoffOrder: z17.number().int().positive().nullable()
 });
-var chatCompactionDataSchema = z16.union([
+var chatCompactionDataSchema = z17.union([
   chatCompactionStatusDataSchema,
   chatCompactionTelemetryDataSchema
 ]);
-var chatCompactionDataPartSchema = z16.object({
-  type: z16.literal("data-compaction"),
+var chatCompactionDataPartSchema = z17.object({
+  type: z17.literal("data-compaction"),
   data: chatCompactionDataSchema
 });
-var chatConversationTitleUpdatedDataSchema = z16.object({
-  kind: z16.literal("conversation-title-updated"),
-  conversationId: z16.string(),
-  title: z16.string()
+var chatConversationTitleUpdatedDataSchema = z17.object({
+  kind: z17.literal("conversation-title-updated"),
+  conversationId: z17.string(),
+  title: z17.string()
 });
-var chatConversationDataPartSchema = z16.object({
-  type: z16.literal("data-conversation"),
+var chatConversationDataPartSchema = z17.object({
+  type: z17.literal("data-conversation"),
   data: chatConversationTitleUpdatedDataSchema
 });
-var chatUsagePhaseSchema = z16.enum(["streaming", "final"]);
-var chatUsageMessageMetadataSchema = z16.object({
-  kind: z16.literal("usage"),
+var chatUsagePhaseSchema = z17.enum(["streaming", "final"]);
+var chatUsageMessageMetadataSchema = z17.object({
+  kind: z17.literal("usage"),
   phase: chatUsagePhaseSchema,
-  modelId: z16.string(),
-  providerNames: z16.array(z16.string()).optional(),
-  inputTokens: z16.number().int().nonnegative(),
-  noCacheInputTokens: z16.number().int().nonnegative(),
-  cacheReadInputTokens: z16.number().int().nonnegative(),
-  cacheWriteInputTokens: z16.number().int().nonnegative(),
-  outputTokens: z16.number().int().nonnegative(),
-  totalTokens: z16.number().int().nonnegative(),
-  inputCostMicroDollars: z16.number().int().nonnegative(),
-  outputCostMicroDollars: z16.number().int().nonnegative(),
-  totalCostMicroDollars: z16.number().int().nonnegative(),
+  modelId: z17.string(),
+  providerNames: z17.array(z17.string()).optional(),
+  inputTokens: z17.number().int().nonnegative(),
+  noCacheInputTokens: z17.number().int().nonnegative(),
+  cacheReadInputTokens: z17.number().int().nonnegative(),
+  cacheWriteInputTokens: z17.number().int().nonnegative(),
+  outputTokens: z17.number().int().nonnegative(),
+  totalTokens: z17.number().int().nonnegative(),
+  inputCostMicroDollars: z17.number().int().nonnegative(),
+  outputCostMicroDollars: z17.number().int().nonnegative(),
+  totalCostMicroDollars: z17.number().int().nonnegative(),
   /**
    * Part of `totalCostMicroDollars` that builds the shared prompt prefix, and is not billed.
    * Defaulted so a client running ahead of the server still parses the metadata it sends.
    */
-  cacheWrite1hCostMicroDollars: z16.number().int().nonnegative().default(0),
-  searchCostMicroDollars: z16.number().int().nonnegative(),
-  nestedLlmCostMicroDollars: z16.number().int().nonnegative(),
-  estimatedUserInputTokens: z16.number().int().nonnegative(),
-  estimatedUserInputCostMicroDollars: z16.number().int().nonnegative(),
-  estimatedBaselineInputTokens: z16.number().int().nonnegative(),
-  estimatedBaselineInputCostMicroDollars: z16.number().int().nonnegative()
-});
-var chatUsageStreamEventSchema = z16.object({
-  type: z16.string(),
+  cacheWrite1hCostMicroDollars: z17.number().int().nonnegative().default(0),
+  searchCostMicroDollars: z17.number().int().nonnegative(),
+  nestedLlmCostMicroDollars: z17.number().int().nonnegative(),
+  estimatedUserInputTokens: z17.number().int().nonnegative(),
+  estimatedUserInputCostMicroDollars: z17.number().int().nonnegative(),
+  estimatedBaselineInputTokens: z17.number().int().nonnegative(),
+  estimatedBaselineInputCostMicroDollars: z17.number().int().nonnegative()
+});
+var chatUsageStreamEventSchema = z17.object({
+  type: z17.string(),
   messageMetadata: chatUsageMessageMetadataSchema
 });
-var chatUsagePreviewSchema = z16.object({
-  kind: z16.literal("preview"),
-  modelId: z16.string(),
-  estimatedBaselineInputTokens: z16.number().int().nonnegative(),
-  estimatedBaselineInputCostMicroDollars: z16.number().int().nonnegative(),
-  excludesToolSchemaOverhead: z16.boolean()
-});
-var chatStreamRequestErrorResponseSchema = z16.object({
-  message: z16.string(),
-  statusCode: z16.number().int(),
-  code: z16.enum(USAGE_BILLING_DENIAL_CODES).optional().catch(void 0)
+var chatUsagePreviewSchema = z17.object({
+  kind: z17.literal("preview"),
+  modelId: z17.string(),
+  estimatedBaselineInputTokens: z17.number().int().nonnegative(),
+  estimatedBaselineInputCostMicroDollars: z17.number().int().nonnegative(),
+  excludesToolSchemaOverhead: z17.boolean()
+});
+var chatStreamRequestErrorResponseSchema = z17.object({
+  message: z17.string(),
+  statusCode: z17.number().int(),
+  code: z17.enum([
+    ...USAGE_BILLING_DENIAL_CODES,
+    USAGE_BILLING_TEMPORARILY_UNAVAILABLE_CODE,
+    USAGE_BILLING_UNAVAILABLE_CODE
+  ]).optional().catch(void 0),
+  /** Present only when the server establishes whether work started. */
+  execution_started: z17.boolean().optional()
 });
 var CHAT_CONVERSATION_STATUSES = ["active", "archived", "all"];
-var chatConversationStatusSchema = z16.enum(CHAT_CONVERSATION_STATUSES);
-var getChatConversationsQuerySchema = z16.object({
+var chatConversationStatusSchema = z17.enum(CHAT_CONVERSATION_STATUSES);
+var getChatConversationsQuerySchema = z17.object({
   status: chatConversationStatusSchema.default("active"),
-  limit: z16.coerce.number().int().positive().max(200).default(10)
+  limit: z17.coerce.number().int().positive().max(200).default(10)
 });
-var createChatConversationSchema = z16.object({
-  title: z16.string().nullable().optional()
+var createChatConversationSchema = z17.object({
+  title: z17.string().nullable().optional()
 });
-var updateChatConversationSchema = z16.object({
-  title: z16.string().nullable().optional(),
-  isArchived: z16.boolean().optional()
+var updateChatConversationSchema = z17.object({
+  title: z17.string().nullable().optional(),
+  isArchived: z17.boolean().optional()
 }).refine((value) => value.title !== void 0 || value.isArchived !== void 0, {
   message: "At least one field must be provided"
 });
 
 // ../../packages/core/dist/esm/chat-tools/complete-automation-draft.js
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 
 // ../../packages/core/dist/esm/schemas/automation-preview-artifact.schema.js
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var automationPreviewSources = ["synthetic", "run"];
 var automationPreviewKinds = ["content", "action", "none", "error"];
 var automationPreviewGenerationKinds = ["content", "action", "none"];
-var automationPreviewSourceSchema = z17.enum(automationPreviewSources);
-var automationPreviewKindSchema = z17.enum(automationPreviewKinds);
-var automationPreviewGenerationKindSchema = z17.enum(automationPreviewGenerationKinds);
-var automationPreviewArtifactSchema = z17.object({
+var automationPreviewSourceSchema = z18.enum(automationPreviewSources);
+var automationPreviewKindSchema = z18.enum(automationPreviewKinds);
+var automationPreviewGenerationKindSchema = z18.enum(automationPreviewGenerationKinds);
+var automationPreviewArtifactSchema = z18.object({
   source: automationPreviewSourceSchema,
   kind: automationPreviewKindSchema,
-  manifestHash: z17.string().regex(/^[a-f0-9]{64}$/, "manifestHash must be a sha256 hex digest"),
-  title: z17.string().trim().min(1),
-  summary: z17.string().trim().min(1),
-  markdown: z17.string().trim().min(1).nullable()
+  manifestHash: z18.string().regex(/^[a-f0-9]{64}$/, "manifestHash must be a sha256 hex digest"),
+  title: z18.string().trim().min(1),
+  summary: z18.string().trim().min(1),
+  markdown: z18.string().trim().min(1).nullable()
 }).superRefine((artifact, ctx) => {
   if (artifact.kind === "content" && artifact.markdown == null) {
     ctx.addIssue({
-      code: z17.ZodIssueCode.custom,
+      code: z18.ZodIssueCode.custom,
       message: "content artifacts must include markdown",
       path: ["markdown"]
     });
   }
   if (artifact.kind !== "content" && artifact.markdown != null) {
     ctx.addIssue({
-      code: z17.ZodIssueCode.custom,
+      code: z18.ZodIssueCode.custom,
       message: "only content artifacts may include markdown",
       path: ["markdown"]
     });
   }
 });
-var automationPreviewGenerationSchema = z17.object({
+var automationPreviewGenerationSchema = z18.object({
   kind: automationPreviewGenerationKindSchema,
-  title: z17.string().trim().min(1),
-  summary: z17.string().trim().min(1),
-  markdown: z17.string().trim().min(1).nullish()
+  title: z18.string().trim().min(1),
+  summary: z18.string().trim().min(1),
+  markdown: z18.string().trim().min(1).nullish()
 });
 
 // ../../packages/core/dist/esm/chat-tools/complete-automation-draft.js
-var CompleteAutomationDraftActionSchema = z18.enum(["create", "update"]);
-var CompleteAutomationDraftInputSchema = z18.object({
-  draftId: z18.string().min(1).describe("The draft ID to generate an automation preview for."),
-  language: z18.string().trim().min(1).optional().describe("Optional human language name for the preview. When relevant, pass the language used in the current user conversation.")
-});
-var CompleteAutomationDraftOutputSchema = z18.union([
-  z18.object({
-    success: z18.literal(true),
-    message: z18.string().min(1),
-    instructions: z18.string().min(1),
-    draftId: z18.string().min(1),
+var CompleteAutomationDraftActionSchema = z19.enum(["create", "update"]);
+var CompleteAutomationDraftInputSchema = z19.object({
+  draftId: z19.string().min(1).describe("The draft ID to generate an automation preview for."),
+  language: z19.string().trim().min(1).optional().describe("Optional human language name for the preview. When relevant, pass the language used in the current user conversation.")
+});
+var CompleteAutomationDraftOutputSchema = z19.union([
+  z19.object({
+    success: z19.literal(true),
+    message: z19.string().min(1),
+    instructions: z19.string().min(1),
+    draftId: z19.string().min(1),
     action: CompleteAutomationDraftActionSchema,
     artifact: automationPreviewArtifactSchema
   }),
-  z18.object({
-    success: z18.literal(false),
-    message: z18.string().min(1),
-    instructions: z18.string().min(1),
-    draftId: z18.string().min(1)
+  z19.object({
+    success: z19.literal(false),
+    message: z19.string().min(1),
+    instructions: z19.string().min(1),
+    draftId: z19.string().min(1)
   })
 ]);
-var toolCompleteAutomationDraftSchema = z18.object({
-  type: z18.literal("tool-complete-automation-draft"),
-  toolCallId: z18.string().min(1),
-  state: z18.literal("input-available"),
+var toolCompleteAutomationDraftSchema = z19.object({
+  type: z19.literal("tool-complete-automation-draft"),
+  toolCallId: z19.string().min(1),
+  state: z19.literal("input-available"),
   input: CompleteAutomationDraftInputSchema
 });
-var toolCompleteAutomationDraftResultSchema = z18.object({
-  type: z18.literal("tool-complete-automation-draft"),
-  toolCallId: z18.string().min(1),
-  state: z18.literal("output-available"),
+var toolCompleteAutomationDraftResultSchema = z19.object({
+  type: z19.literal("tool-complete-automation-draft"),
+  toolCallId: z19.string().min(1),
+  state: z19.literal("output-available"),
   input: CompleteAutomationDraftInputSchema,
   output: CompleteAutomationDraftOutputSchema
 });
 
 // ../../packages/core/dist/esm/chat-tools/publish-draft.js
-import { z as z19 } from "zod";
-var PublishDraftInputSchema = z19.object({
-  draftId: z19.string().min(1).describe("The draft ID to preview and publish."),
-  language: z19.string().trim().min(1).optional().describe("Optional human language name for the preview. When relevant, pass the language used in the current user conversation.")
+import { z as z20 } from "zod";
+var PublishDraftInputSchema = z20.object({
+  draftId: z20.string().min(1).describe("The draft ID to preview and publish."),
+  language: z20.string().trim().min(1).optional().describe("Optional human language name for the preview. When relevant, pass the language used in the current user conversation.")
 });
-var PublishDraftOutputSchema = z19.union([
-  z19.object({
-    success: z19.literal(true),
-    message: z19.string().min(1),
-    instructions: z19.string().min(1),
-    draftId: z19.string().min(1),
+var PublishDraftOutputSchema = z20.union([
+  z20.object({
+    success: z20.literal(true),
+    message: z20.string().min(1),
+    instructions: z20.string().min(1),
+    draftId: z20.string().min(1),
     action: CompleteAutomationDraftActionSchema,
-    automationId: z19.string().min(1),
+    automationId: z20.string().min(1),
     previewArtifact: automationPreviewArtifactSchema.optional()
   }),
-  z19.object({
-    success: z19.literal(false),
-    message: z19.string().min(1),
-    instructions: z19.string().min(1),
-    draftId: z19.string().min(1),
+  z20.object({
+    success: z20.literal(false),
+    message: z20.string().min(1),
+    instructions: z20.string().min(1),
+    draftId: z20.string().min(1),
     action: CompleteAutomationDraftActionSchema.optional(),
     previewArtifact: automationPreviewArtifactSchema.optional()
   })
 ]);
-var toolPublishDraftSchema = z19.object({
-  type: z19.literal("tool-publish-draft"),
-  toolCallId: z19.string().min(1),
-  state: z19.literal("input-available"),
+var toolPublishDraftSchema = z20.object({
+  type: z20.literal("tool-publish-draft"),
+  toolCallId: z20.string().min(1),
+  state: z20.literal("input-available"),
   input: PublishDraftInputSchema
 });
-var toolPublishDraftResultSchema = z19.object({
-  type: z19.literal("tool-publish-draft"),
-  toolCallId: z19.string().min(1),
-  state: z19.literal("output-available"),
+var toolPublishDraftResultSchema = z20.object({
+  type: z20.literal("tool-publish-draft"),
+  toolCallId: z20.string().min(1),
+  state: z20.literal("output-available"),
   input: PublishDraftInputSchema,
   output: PublishDraftOutputSchema
 });
@@ -9523,102 +9753,102 @@ function isPublishDraftResult(part) {
 }
 
 // ../../packages/core/dist/esm/chat-tools/test-automation-draft.js
-import { z as z20 } from "zod";
-var TestAutomationDraftInputSchema = z20.object({
-  draftId: z20.string().min(1).describe("The draft ID to test.")
+import { z as z21 } from "zod";
+var TestAutomationDraftInputSchema = z21.object({
+  draftId: z21.string().min(1).describe("The draft ID to test.")
 });
-var automationTestRunStepStatusSchema = z20.object({
-  stepId: z20.string().min(1),
-  status: z20.enum(AUTOMATION_RUN_STATUSES)
+var automationTestRunStepStatusSchema = z21.object({
+  stepId: z21.string().min(1),
+  status: z21.enum(AUTOMATION_RUN_STATUSES)
 });
-var automationTestRunProgressSchema = z20.object({
-  draftId: z20.string().min(1),
-  status: z20.enum(AUTOMATION_RUN_STATUSES),
-  steps: z20.array(automationTestRunStepStatusSchema).default([])
+var automationTestRunProgressSchema = z21.object({
+  draftId: z21.string().min(1),
+  status: z21.enum(AUTOMATION_RUN_STATUSES),
+  steps: z21.array(automationTestRunStepStatusSchema).default([])
 });
-var automationTestRunPreviewTriggerSchema = z20.union([
-  z20.object({
-    type: z20.literal("schedule"),
+var automationTestRunPreviewTriggerSchema = z21.union([
+  z21.object({
+    type: z21.literal("schedule"),
     value: scheduleValueSchema,
-    description: z20.string().optional()
+    description: z21.string().optional()
   }),
-  z20.object({
-    type: z20.literal("api"),
-    description: z20.string().optional()
+  z21.object({
+    type: z21.literal("api"),
+    description: z21.string().optional()
   }),
-  z20.object({
-    type: z20.literal("webhook"),
-    event: z20.string().min(1),
-    description: z20.string().optional()
+  z21.object({
+    type: z21.literal("webhook"),
+    event: z21.string().min(1),
+    description: z21.string().optional()
   })
 ]);
-var automationTestRunPreviewAskSchema = z20.object({
-  message: z20.string().min(1),
-  expiresAfter: z20.string().min(1),
-  options: z20.array(z20.object({ label: z20.string().min(1), terminate: z20.boolean() }))
-});
-var automationTestRunPreviewStepSchema = z20.object({
-  stepId: z20.string().min(1),
-  title: z20.string().optional(),
-  description: z20.string(),
-  connectorIds: z20.array(z20.string().min(1)).default([]),
+var automationTestRunPreviewAskSchema = z21.object({
+  message: z21.string().min(1),
+  expiresAfter: z21.string().min(1),
+  options: z21.array(z21.object({ label: z21.string().min(1), terminate: z21.boolean() }))
+});
+var automationTestRunPreviewStepSchema = z21.object({
+  stepId: z21.string().min(1),
+  title: z21.string().optional(),
+  description: z21.string(),
+  connectorIds: z21.array(z21.string().min(1)).default([]),
   /** Present only for `ask` steps; its presence identifies them. */
   ask: automationTestRunPreviewAskSchema.optional()
 });
-var automationTestRunPreviewSchema = z20.object({
-  triggers: z20.array(automationTestRunPreviewTriggerSchema).default([]),
-  steps: z20.array(automationTestRunPreviewStepSchema).default([])
+var automationTestRunPreviewSchema = z21.object({
+  triggers: z21.array(automationTestRunPreviewTriggerSchema).default([]),
+  steps: z21.array(automationTestRunPreviewStepSchema).default([])
 });
-var TestAutomationDraftOutputSchema = z20.union([
-  z20.object({
-    success: z20.literal(true),
-    message: z20.string().min(1),
-    draftId: z20.string().min(1),
+var TestAutomationDraftOutputSchema = z21.union([
+  z21.object({
+    success: z21.literal(true),
+    message: z21.string().min(1),
+    draftId: z21.string().min(1),
     action: CompleteAutomationDraftActionSchema,
     preview: automationTestRunPreviewSchema,
     testRun: automationTestRunProgressSchema
   }),
-  z20.object({
-    success: z20.literal(false),
-    message: z20.string().min(1),
-    draftId: z20.string().min(1),
+  z21.object({
+    success: z21.literal(false),
+    message: z21.string().min(1),
+    draftId: z21.string().min(1),
     action: CompleteAutomationDraftActionSchema.optional()
   })
 ]);
-var toolTestAutomationDraftSchema = z20.object({
-  type: z20.literal("tool-test-draft"),
-  toolCallId: z20.string().min(1),
-  state: z20.literal("input-available"),
+var toolTestAutomationDraftSchema = z21.object({
+  type: z21.literal("tool-test-draft"),
+  toolCallId: z21.string().min(1),
+  state: z21.literal("input-available"),
   input: TestAutomationDraftInputSchema
 });
-var toolTestAutomationDraftResultSchema = z20.object({
-  type: z20.literal("tool-test-draft"),
-  toolCallId: z20.string().min(1),
-  state: z20.literal("output-available"),
+var toolTestAutomationDraftResultSchema = z21.object({
+  type: z21.literal("tool-test-draft"),
+  toolCallId: z21.string().min(1),
+  state: z21.literal("output-available"),
   input: TestAutomationDraftInputSchema,
   output: TestAutomationDraftOutputSchema
 });
 
 // ../../packages/core/dist/esm/chat-tools/prompt-enable-push.js
-import { z as z21 } from "zod";
-var PromptEnablePushInputSchema = z21.object({
-  draftId: z21.string().min(1).optional().describe("Optional draft ID currently being edited, if available")
+import { z as z22 } from "zod";
+var PromptEnablePushInputSchema = z22.object({
+  draftId: z22.string().min(1).optional().describe("Optional draft ID currently being edited, if available")
 });
-var PromptEnablePushOutputSchema = z21.object({
-  enabled: z21.boolean().describe("Whether the user finished enabling push notifications and has at least one active subscription."),
-  deviceCount: z21.number().int().min(0).describe("Number of active push devices the user has registered."),
-  message: z21.string().min(1).describe("Human-readable status describing the outcome of the prompt.")
+var PromptEnablePushOutputSchema = z22.object({
+  enabled: z22.boolean().describe("Whether the user finished enabling push notifications and has at least one active subscription."),
+  deviceCount: z22.number().int().min(0).describe("Number of active push devices the user has registered."),
+  message: z22.string().min(1).describe("Human-readable status describing the outcome of the prompt.")
 });
-var toolPromptEnablePushSchema = z21.object({
-  type: z21.literal("tool-prompt-enable-push-notifications"),
-  toolCallId: z21.string().min(1),
-  state: z21.literal("input-available"),
+var toolPromptEnablePushSchema = z22.object({
+  type: z22.literal("tool-prompt-enable-push-notifications"),
+  toolCallId: z22.string().min(1),
+  state: z22.literal("input-available"),
   input: PromptEnablePushInputSchema
 });
-var toolPromptEnablePushResultSchema = z21.object({
-  type: z21.literal("tool-prompt-enable-push-notifications"),
-  toolCallId: z21.string().min(1),
-  state: z21.literal("output-available"),
+var toolPromptEnablePushResultSchema = z22.object({
+  type: z22.literal("tool-prompt-enable-push-notifications"),
+  toolCallId: z22.string().min(1),
+  state: z22.literal("output-available"),
   input: PromptEnablePushInputSchema,
   output: PromptEnablePushOutputSchema
 });
@@ -9627,42 +9857,42 @@ function isPromptEnablePush(part) {
 }
 
 // ../../packages/core/dist/esm/chat-tools/select-connections.js
-import { z as z22 } from "zod";
-var SelectConnectionTypeSchema = z22.enum(["mcp", "trigger"]);
-var ConnectionItemSchema = z22.object({
-  connectorId: z22.string().min(1).describe("The connector ID to select a connection for"),
-  serviceName: z22.string().min(1).describe("The human-readable name of the service"),
+import { z as z23 } from "zod";
+var SelectConnectionTypeSchema = z23.enum(["mcp", "trigger"]);
+var ConnectionItemSchema = z23.object({
+  connectorId: z23.string().min(1).describe("The connector ID to select a connection for"),
+  serviceName: z23.string().min(1).describe("The human-readable name of the service"),
   connectionType: SelectConnectionTypeSchema.describe('Type of connection needed: "mcp" for actions, "trigger" for events')
 });
-var SelectConnectionsInputSchema = z22.object({
-  draftId: z22.string().min(1).describe("The draft ID these connections belong to"),
-  connections: z22.array(ConnectionItemSchema).min(1).describe("List of connections needed for this automation")
+var SelectConnectionsInputSchema = z23.object({
+  draftId: z23.string().min(1).describe("The draft ID these connections belong to"),
+  connections: z23.array(ConnectionItemSchema).min(1).describe("List of connections needed for this automation")
 });
-var ConnectionResultItemSchema = z22.union([
-  z22.object({
-    type: z22.literal("success"),
-    connectionId: z22.string().min(1),
-    connectorId: z22.string().min(1),
+var ConnectionResultItemSchema = z23.union([
+  z23.object({
+    type: z23.literal("success"),
+    connectionId: z23.string().min(1),
+    connectorId: z23.string().min(1),
     connectionType: SelectConnectionTypeSchema
   }),
-  z22.object({
-    type: z22.literal("error"),
-    message: z22.string().min(1),
-    connectorId: z22.string().min(1),
+  z23.object({
+    type: z23.literal("error"),
+    message: z23.string().min(1),
+    connectorId: z23.string().min(1),
     connectionType: SelectConnectionTypeSchema
   })
 ]);
-var SelectConnectionsOutputSchema = z22.array(ConnectionResultItemSchema);
-var toolSelectConnectionsSchema = z22.object({
-  type: z22.literal("tool-select-connections"),
-  toolCallId: z22.string().min(1),
-  state: z22.literal("input-available"),
+var SelectConnectionsOutputSchema = z23.array(ConnectionResultItemSchema);
+var toolSelectConnectionsSchema = z23.object({
+  type: z23.literal("tool-select-connections"),
+  toolCallId: z23.string().min(1),
+  state: z23.literal("input-available"),
   input: SelectConnectionsInputSchema
 });
-var toolSelectConnectionsResultSchema = z22.object({
-  type: z22.literal("tool-select-connections"),
-  toolCallId: z22.string().min(1),
-  state: z22.literal("output-available"),
+var toolSelectConnectionsResultSchema = z23.object({
+  type: z23.literal("tool-select-connections"),
+  toolCallId: z23.string().min(1),
+  state: z23.literal("output-available"),
   input: SelectConnectionsInputSchema,
   output: SelectConnectionsOutputSchema
 });
@@ -9671,33 +9901,33 @@ function isSelectConnections(part) {
 }
 
 // ../../packages/core/dist/esm/chat-tools/remove-draft-connection.js
-import { z as z23 } from "zod";
-var RemoveDraftConnectionInputSchema = z23.object({
-  draftId: z23.string().min(1).describe("The draft ID to remove the connection from"),
-  connectorId: z23.string().min(1).describe("The connector ID to remove from the draft"),
-  connectionType: z23.enum(CONNECTION_TYPES).optional().describe("Optional connection type to remove. Omit to remove all draft links for this connector."),
-  force: z23.boolean().optional().default(false).describe("When false, removal is blocked if the current draft manifest still requires the connector. When true, removal is allowed and the draft may become unpublishable until edited.")
-});
-var RemovedDraftConnectionItemSchema = z23.object({
-  connectorId: z23.string().min(1),
-  connectionType: z23.enum(CONNECTION_TYPES)
-});
-var RemoveDraftConnectionOutputSchema = z23.object({
-  success: z23.boolean(),
-  message: z23.string().min(1),
-  draftId: z23.string().min(1),
-  removed: z23.array(RemovedDraftConnectionItemSchema)
-});
-var toolRemoveDraftConnectionSchema = z23.object({
-  type: z23.literal("tool-remove-draft-connection"),
-  toolCallId: z23.string().min(1),
-  state: z23.literal("input-available"),
+import { z as z24 } from "zod";
+var RemoveDraftConnectionInputSchema = z24.object({
+  draftId: z24.string().min(1).describe("The draft ID to remove the connection from"),
+  connectorId: z24.string().min(1).describe("The connector ID to remove from the draft"),
+  connectionType: z24.enum(CONNECTION_TYPES).optional().describe("Optional connection type to remove. Omit to remove all draft links for this connector."),
+  force: z24.boolean().optional().default(false).describe("When false, removal is blocked if the current draft manifest still requires the connector. When true, removal is allowed and the draft may become unpublishable until edited.")
+});
+var RemovedDraftConnectionItemSchema = z24.object({
+  connectorId: z24.string().min(1),
+  connectionType: z24.enum(CONNECTION_TYPES)
+});
+var RemoveDraftConnectionOutputSchema = z24.object({
+  success: z24.boolean(),
+  message: z24.string().min(1),
+  draftId: z24.string().min(1),
+  removed: z24.array(RemovedDraftConnectionItemSchema)
+});
+var toolRemoveDraftConnectionSchema = z24.object({
+  type: z24.literal("tool-remove-draft-connection"),
+  toolCallId: z24.string().min(1),
+  state: z24.literal("input-available"),
   input: RemoveDraftConnectionInputSchema
 });
-var toolRemoveDraftConnectionResultSchema = z23.object({
-  type: z23.literal("tool-remove-draft-connection"),
-  toolCallId: z23.string().min(1),
-  state: z23.literal("output-available"),
+var toolRemoveDraftConnectionResultSchema = z24.object({
+  type: z24.literal("tool-remove-draft-connection"),
+  toolCallId: z24.string().min(1),
+  state: z24.literal("output-available"),
   input: RemoveDraftConnectionInputSchema,
   output: RemoveDraftConnectionOutputSchema
 });
@@ -9709,14 +9939,16 @@ var MAX_COHORT_RESULTS = 366;
 var MAX_COHORT_ROWS = 120;
 
 // ../../packages/core/dist/esm/schemas/cohorts.schema.js
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 var FRONTEND_COHORT_EVENTS = [
   "session:started",
   "onboarding:completed",
   "chat:sent",
   "automation:repaired",
   "template:used",
-  "top-up:completed"
+  "top-up:completed",
+  "guided-creation:started",
+  "guided-creation:completed"
 ];
 var BACKEND_COHORT_EVENTS = [
   // API-process (publish lifecycle)
@@ -9734,37 +9966,37 @@ var BACKEND_COHORT_EVENTS = [
   "workspace:automation:moved"
 ];
 var COHORT_EVENTS = [...FRONTEND_COHORT_EVENTS, ...BACKEND_COHORT_EVENTS];
-var cohortEventSchema = z24.enum(COHORT_EVENTS);
-var frontendCohortEventSchema = z24.enum(FRONTEND_COHORT_EVENTS);
-var backendCohortEventSchema = z24.enum(BACKEND_COHORT_EVENTS);
+var cohortEventSchema = z25.enum(COHORT_EVENTS);
+var frontendCohortEventSchema = z25.enum(FRONTEND_COHORT_EVENTS);
+var backendCohortEventSchema = z25.enum(BACKEND_COHORT_EVENTS);
 var PLATFORM_VALUES = ["web", "ios", "android", "desktop"];
-var platformValueSchema = z24.enum(PLATFORM_VALUES);
+var platformValueSchema = z25.enum(PLATFORM_VALUES);
 var USER_PROPERTY_EVENTS = [
   "platform:web",
   "platform:ios",
   "platform:android",
   "platform:desktop"
 ];
-var userPropertyEventSchema = z24.enum(USER_PROPERTY_EVENTS);
-var markableCohortEventSchema = z24.union([cohortEventSchema, userPropertyEventSchema]);
-var registerCohortEventSchema = z24.object({
+var userPropertyEventSchema = z25.enum(USER_PROPERTY_EVENTS);
+var markableCohortEventSchema = z25.union([cohortEventSchema, userPropertyEventSchema]);
+var registerCohortEventSchema = z25.object({
   event_name: frontendCohortEventSchema,
   // The client knows the platform it runs on (the backend always sees `api`),
   // so it reports it here; the backend co-marks the caller's `platform:<value>`
   // property for the active period. Optional — absent means "don't update".
   platform: platformValueSchema.optional()
 });
-var registerCohortEventResponseSchema = z24.object({
-  status: z24.literal("ok")
+var registerCohortEventResponseSchema = z25.object({
+  status: z25.literal("ok")
 });
 var MAX_REDIS_BITMAP_OFFSET = 2 ** 32 - 1;
-var registerInternalCohortEventSchema = z24.object({
+var registerInternalCohortEventSchema = z25.object({
   event_name: backendCohortEventSchema,
-  user_id: z24.string().regex(/^\d+$/, "user_id must be a non-negative integer string").refine((value) => Number(value) <= MAX_REDIS_BITMAP_OFFSET, "user_id exceeds the maximum Redis bitmap offset")
+  user_id: z25.string().regex(/^\d+$/, "user_id must be a non-negative integer string").refine((value) => Number(value) <= MAX_REDIS_BITMAP_OFFSET, "user_id exceeds the maximum Redis bitmap offset")
 });
-var cohortTimeGroupSchema = z24.enum(RESOLUTIONS);
-var cohortFilterOperatorSchema = z24.enum(FILTER_OPERATORS);
-var cohortStartDateSchema = z24.string().regex(/^\d{4}-\d{2}-\d{2}$/, "startDate must be YYYY-MM-DD").refine((value) => {
+var cohortTimeGroupSchema = z25.enum(RESOLUTIONS);
+var cohortFilterOperatorSchema = z25.enum(FILTER_OPERATORS);
+var cohortStartDateSchema = z25.string().regex(/^\d{4}-\d{2}-\d{2}$/, "startDate must be YYYY-MM-DD").refine((value) => {
   const date = /* @__PURE__ */ new Date(`${value}T00:00:00Z`);
   return !Number.isNaN(date.getTime()) && date.toISOString().startsWith(value);
 }, { message: "startDate must be a real calendar date" });
@@ -9773,7 +10005,7 @@ function coerceToArray(value) {
     return void 0;
   return Array.isArray(value) ? value : [value];
 }
-var cohortMatrixQuerySchema = z24.object({
+var cohortMatrixQuerySchema = z25.object({
   /** The event that defines who enters the cohort. */
   cohortEvent: cohortEventSchema,
   /** The event that counts as "coming back". */
@@ -9791,11 +10023,11 @@ var cohortMatrixQuerySchema = z24.object({
    * these platforms in the period being evaluated. Multi-select;
    * absent/empty means no platform filter.
    */
-  platform: z24.preprocess(coerceToArray, z24.array(platformValueSchema)).optional(),
+  platform: z25.preprocess(coerceToArray, z25.array(platformValueSchema)).optional(),
   timeGroup: cohortTimeGroupSchema,
   asPercent: booleanQueryParamSchema.optional(),
-  numResults: z24.coerce.number().int().positive().max(MAX_COHORT_RESULTS).optional(),
-  numOfRows: z24.coerce.number().int().nonnegative().max(MAX_COHORT_ROWS).optional(),
+  numResults: z25.coerce.number().int().positive().max(MAX_COHORT_RESULTS).optional(),
+  numOfRows: z25.coerce.number().int().nonnegative().max(MAX_COHORT_ROWS).optional(),
   startDate: cohortStartDateSchema.optional()
 }).superRefine((query, ctx) => {
   if (query.cohortFilterOperator && !query.cohortFilter) {
@@ -9820,13 +10052,13 @@ var cohortMatrixQuerySchema = z24.object({
     });
   }
 });
-var cohortMatrixRowSchema = z24.object({
-  date: z24.iso.datetime(),
-  cohortSize: z24.number(),
-  values: z24.array(z24.number().nullable())
+var cohortMatrixRowSchema = z25.object({
+  date: z25.iso.datetime(),
+  cohortSize: z25.number(),
+  values: z25.array(z25.number().nullable())
 });
-var cohortMatrixResponseSchema = z24.object({
-  rows: z24.array(cohortMatrixRowSchema)
+var cohortMatrixResponseSchema = z25.object({
+  rows: z25.array(cohortMatrixRowSchema)
 });
 
 // ../../packages/core/dist/esm/types/workspace.types.js
@@ -9870,22 +10102,22 @@ function assertKnownTimezone(timezone) {
 
 // ../../packages/core/dist/esm/schemas/manifest.validation.js
 var import_ajv_formats = __toESM(require_dist(), 1);
-import { z as z25 } from "zod/v4";
+import { z as z26 } from "zod/v4";
 
 // ../../packages/core/dist/esm/schemas/notification-dispatch.schema.js
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 
 // ../../packages/core/dist/esm/schemas/notification.schema.js
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 var NOTIFICATION_TYPES = ["notification", "prompt"];
 var INFO_NOTIFICATION_STATUSES = ["active"];
 var PROMPT_NOTIFICATION_STATUSES = ["pending", "responded", "expired"];
 var INFO_NOTIFICATION_RESPONSES = ["read", "dismissed"];
 var NOTIFICATION_RESPONSES = [...INFO_NOTIFICATION_RESPONSES];
-var NotificationResponseSchema = z26.object({
-  status: z26.enum(INFO_NOTIFICATION_RESPONSES).optional(),
-  action: z26.literal("answer").optional(),
-  value: z26.string().min(1).optional()
+var NotificationResponseSchema = z27.object({
+  status: z27.enum(INFO_NOTIFICATION_RESPONSES).optional(),
+  action: z27.literal("answer").optional(),
+  value: z27.string().min(1).optional()
 }).refine((data) => {
   const isStatusResponse = data.status !== void 0 && data.action === void 0;
   const isAnswer = data.action === "answer" && data.value !== void 0 && data.status === void 0;
@@ -9895,39 +10127,39 @@ var NOTIFICATION_STATUSES = [
   ...INFO_NOTIFICATION_STATUSES,
   ...PROMPT_NOTIFICATION_STATUSES
 ];
-var notificationBaseSchema = z26.object({
-  id: z26.string(),
-  userId: z26.string(),
-  automationId: z26.string().nullable(),
-  automationRunId: z26.string().nullable(),
-  stepId: z26.string().nullable(),
-  message: z26.string(),
-  details: z26.string().nullable(),
-  readAt: z26.string().nullable(),
-  dismissedAt: z26.string().nullable(),
-  createdAt: z26.string(),
-  updatedAt: z26.string()
+var notificationBaseSchema = z27.object({
+  id: z27.string(),
+  userId: z27.string(),
+  automationId: z27.string().nullable(),
+  automationRunId: z27.string().nullable(),
+  stepId: z27.string().nullable(),
+  message: z27.string(),
+  details: z27.string().nullable(),
+  readAt: z27.string().nullable(),
+  dismissedAt: z27.string().nullable(),
+  createdAt: z27.string(),
+  updatedAt: z27.string()
 });
 var InfoNotificationSchema = notificationBaseSchema.extend({
-  type: z26.literal("notification"),
-  status: z26.literal("active"),
-  expiresAt: z26.null(),
-  respondedAt: z26.null()
+  type: z27.literal("notification"),
+  status: z27.literal("active"),
+  expiresAt: z27.null(),
+  respondedAt: z27.null()
 });
-var PromptOptionSchema = z26.object({
-  label: z26.string(),
-  value: z26.string(),
-  terminate: z26.boolean()
+var PromptOptionSchema = z27.object({
+  label: z27.string(),
+  value: z27.string(),
+  terminate: z27.boolean()
 });
 var PromptNotificationSchema = notificationBaseSchema.extend({
-  type: z26.literal("prompt"),
-  status: z26.enum(PROMPT_NOTIFICATION_STATUSES),
-  options: z26.array(PromptOptionSchema),
-  response: z26.string().nullable(),
-  expiresAt: z26.string().nullable(),
-  respondedAt: z26.string().nullable()
-});
-var NotificationSchema = z26.discriminatedUnion("type", [
+  type: z27.literal("prompt"),
+  status: z27.enum(PROMPT_NOTIFICATION_STATUSES),
+  options: z27.array(PromptOptionSchema),
+  response: z27.string().nullable(),
+  expiresAt: z27.string().nullable(),
+  respondedAt: z27.string().nullable()
+});
+var NotificationSchema = z27.discriminatedUnion("type", [
   InfoNotificationSchema,
   PromptNotificationSchema
 ]);
@@ -9935,92 +10167,92 @@ var VALID_STATUSES_BY_NOTIFICATION_TYPE = {
   notification: INFO_NOTIFICATION_STATUSES,
   prompt: PROMPT_NOTIFICATION_STATUSES
 };
-var ListNotificationsQuerySchema = z26.object({
-  type: z26.enum(NOTIFICATION_TYPES).optional(),
-  status: z26.enum(NOTIFICATION_STATUSES).optional(),
+var ListNotificationsQuerySchema = z27.object({
+  type: z27.enum(NOTIFICATION_TYPES).optional(),
+  status: z27.enum(NOTIFICATION_STATUSES).optional(),
   // Non-empty: `?automationId=` would otherwise parse to `''` and silently
   // widen the query to every notification the caller can see.
-  automationId: z26.string().min(1).optional()
+  automationId: z27.string().min(1).optional()
 }).refine((data) => {
   if (data.type && data.status) {
     return VALID_STATUSES_BY_NOTIFICATION_TYPE[data.type].includes(data.status);
   }
   return true;
 }, { message: "Invalid status for the specified notification type" });
-var NotificationListResponseSchema = z26.object({
-  data: z26.array(NotificationSchema),
-  nextCursor: z26.string().nullable()
+var NotificationListResponseSchema = z27.object({
+  data: z27.array(NotificationSchema),
+  nextCursor: z27.string().nullable()
 });
-var PendingPromptAutomationsResponseSchema = z26.object({
-  automationIds: z26.array(z26.string())
+var PendingPromptAutomationsResponseSchema = z27.object({
+  automationIds: z27.array(z27.string())
 });
 
 // ../../packages/core/dist/esm/schemas/notification-dispatch.schema.js
-var automationRunFailedDispatchSchema = z27.object({
-  kind: z27.literal("automation_run_failed"),
-  userId: z27.string().min(1),
-  automationId: z27.string().min(1),
-  automationRunId: z27.string().min(1),
-  failureReason: z27.string().min(1)
-});
-var connectionBrokenDispatchSchema = z27.object({
-  kind: z27.literal("connection_broken"),
-  userId: z27.string().min(1),
-  connectionId: z27.string().min(1),
-  connectorId: z27.string().min(1),
-  connectorName: z27.string().min(1),
-  connectorDisplayName: z27.string().min(1),
-  reason: z27.string().min(1),
-  automationId: z27.string().min(1).optional()
-});
-var promptPendingDispatchSchema = z27.object({
-  kind: z27.literal("prompt_pending"),
-  userId: z27.string().min(1),
-  automationId: z27.string().min(1),
-  automationRunId: z27.string().min(1),
-  promptId: z27.string().min(1),
+var automationRunFailedDispatchSchema = z28.object({
+  kind: z28.literal("automation_run_failed"),
+  userId: z28.string().min(1),
+  automationId: z28.string().min(1),
+  automationRunId: z28.string().min(1),
+  failureReason: z28.string().min(1)
+});
+var connectionBrokenDispatchSchema = z28.object({
+  kind: z28.literal("connection_broken"),
+  userId: z28.string().min(1),
+  connectionId: z28.string().min(1),
+  connectorId: z28.string().min(1),
+  connectorName: z28.string().min(1),
+  connectorDisplayName: z28.string().min(1),
+  reason: z28.string().min(1),
+  automationId: z28.string().min(1).optional()
+});
+var promptPendingDispatchSchema = z28.object({
+  kind: z28.literal("prompt_pending"),
+  userId: z28.string().min(1),
+  automationId: z28.string().min(1),
+  automationRunId: z28.string().min(1),
+  promptId: z28.string().min(1),
   // The question being asked, surfaced in the email and push bodies. Optional
   // so the dispatch stays valid if a prompt ever carries no headline text.
-  question: z27.string().min(1).optional(),
+  question: z28.string().min(1).optional(),
   // The prompt's answer choices and wait deadline, carried so the dispatcher
   // can mint one capability token per option and render the answers as
   // notification action buttons. Both are optional: a dispatch without them
   // still delivers, as a plain notification the user taps to open the app.
   options: PromptOptionSchema.array().optional(),
-  expiresAt: z27.iso.datetime().optional()
+  expiresAt: z28.iso.datetime().optional()
 });
-var promptResolvedDispatchSchema = z27.object({
-  kind: z27.literal("prompt_resolved"),
-  userId: z27.string().min(1),
-  automationId: z27.string().min(1).optional(),
-  promptId: z27.string().min(1),
-  resolution: z27.enum(["responded", "expired"])
+var promptResolvedDispatchSchema = z28.object({
+  kind: z28.literal("prompt_resolved"),
+  userId: z28.string().min(1),
+  automationId: z28.string().min(1).optional(),
+  promptId: z28.string().min(1),
+  resolution: z28.enum(["responded", "expired"])
 });
 var usageBalanceFields = {
-  userId: z27.string().min(1),
-  currency: z27.string().min(1)
+  userId: z28.string().min(1),
+  currency: z28.string().min(1)
 };
-var balanceLowDispatchSchema = z27.object({
-  kind: z27.literal("balance_low"),
+var balanceLowDispatchSchema = z28.object({
+  kind: z28.literal("balance_low"),
   ...usageBalanceFields,
   // Positive, because this fires above the gate limit while automations are
   // still running, and its copy quotes the figure. A zero or negative value
   // reaching here would render "-$3.50 left" to a user.
-  balanceUnits: z27.number().int().positive(),
-  balanceAmount: z27.number().int().positive()
+  balanceUnits: z28.number().int().positive(),
+  balanceAmount: z28.number().int().positive()
 });
-var insufficientBalanceDispatchSchema = z27.object({
-  kind: z27.literal("insufficient_balance"),
+var insufficientBalanceDispatchSchema = z28.object({
+  kind: z28.literal("insufficient_balance"),
   ...usageBalanceFields,
   // Unbounded on purpose, unlike `balance_low`. A run is never clamped
   // mid-flight, so one that overruns its cap can drive the balance below
   // zero — the beta accepts that rather than dropping a charge already paid
   // to the provider. This copy quotes no figure, so a negative value never
   // reaches the user.
-  balanceUnits: z27.number().int(),
-  balanceAmount: z27.number().int()
+  balanceUnits: z28.number().int(),
+  balanceAmount: z28.number().int()
 });
-var notificationDispatchSchema = z27.discriminatedUnion("kind", [
+var notificationDispatchSchema = z28.discriminatedUnion("kind", [
   automationRunFailedDispatchSchema,
   connectionBrokenDispatchSchema,
   promptPendingDispatchSchema,
@@ -10030,243 +10262,108 @@ var notificationDispatchSchema = z27.discriminatedUnion("kind", [
 ]);
 
 // ../../packages/core/dist/esm/schemas/oauth-callback.schema.js
-import { z as z28 } from "zod";
-var oauthCallbackCompletionRequestSchema = z28.object({
-  code: z28.string().optional(),
-  state: z28.string().optional(),
-  error: z28.string().optional(),
-  error_description: z28.string().optional()
-});
-var oauthCallbackSuccessResultSchema = z28.object({
-  isSuccess: z28.literal(true),
-  connectionId: z28.string(),
-  connector: z28.string(),
-  connectorName: z28.string(),
-  connectorIconUrl: z28.string().optional()
-});
-var oauthCallbackFailureResultSchema = z28.object({
-  isSuccess: z28.literal(false),
-  error: z28.string(),
-  errorDescription: z28.string().optional(),
-  connector: z28.string().optional(),
-  connectorName: z28.string().optional(),
-  connectorIconUrl: z28.string().optional()
-});
-var oauthCallbackCompletionResultSchema = z28.discriminatedUnion("isSuccess", [
+import { z as z29 } from "zod";
+var oauthCallbackCompletionRequestSchema = z29.object({
+  code: z29.string().optional(),
+  state: z29.string().optional(),
+  error: z29.string().optional(),
+  error_description: z29.string().optional()
+});
+var oauthCallbackSuccessResultSchema = z29.object({
+  isSuccess: z29.literal(true),
+  connectionId: z29.string(),
+  connector: z29.string(),
+  connectorName: z29.string(),
+  connectorIconUrl: z29.string().optional()
+});
+var oauthCallbackFailureResultSchema = z29.object({
+  isSuccess: z29.literal(false),
+  error: z29.string(),
+  errorDescription: z29.string().optional(),
+  connector: z29.string().optional(),
+  connectorName: z29.string().optional(),
+  connectorIconUrl: z29.string().optional()
+});
+var oauthCallbackCompletionResultSchema = z29.discriminatedUnion("isSuccess", [
   oauthCallbackSuccessResultSchema,
   oauthCallbackFailureResultSchema
 ]);
 
 // ../../packages/core/dist/esm/schemas/pagination.schema.js
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 var DEFAULT_PAGINATION_LIMIT = 20;
 var MAX_PAGINATION_LIMIT = 100;
-var CursorPaginationSchema = z29.object({
-  cursor: z29.string().optional(),
-  limit: z29.preprocess((val) => Number(val), z29.number().int().min(1).max(MAX_PAGINATION_LIMIT)).default(DEFAULT_PAGINATION_LIMIT)
+var CursorPaginationSchema = z30.object({
+  cursor: z30.string().optional(),
+  limit: z30.preprocess((val) => Number(val), z30.number().int().min(1).max(MAX_PAGINATION_LIMIT)).default(DEFAULT_PAGINATION_LIMIT)
 });
 
 // ../../packages/core/dist/esm/schemas/push-subscription.schema.js
-import { z as z30 } from "zod";
-var PushSubscriptionKeysSchema = z30.object({
-  p256dh: z30.string().min(1).max(255),
-  auth: z30.string().min(1).max(255)
+import { z as z31 } from "zod";
+var PushSubscriptionKeysSchema = z31.object({
+  p256dh: z31.string().min(1).max(255),
+  auth: z31.string().min(1).max(255)
 });
-var RegisterPushSubscriptionSchema = z30.object({
-  endpoint: z30.url().max(768),
+var RegisterPushSubscriptionSchema = z31.object({
+  endpoint: z31.url().max(768),
   keys: PushSubscriptionKeysSchema,
-  deviceName: z30.string().max(255).optional()
+  deviceName: z31.string().max(255).optional()
 });
-var UpdatePushSubscriptionSchema = z30.object({
-  deviceName: z30.string().max(255).nullable().optional()
+var UpdatePushSubscriptionSchema = z31.object({
+  deviceName: z31.string().max(255).nullable().optional()
 });
-var RemovePushSubscriptionByEndpointQuerySchema = z30.object({
-  endpoint: z30.url().max(768)
+var RemovePushSubscriptionByEndpointQuerySchema = z31.object({
+  endpoint: z31.url().max(768)
 });
-var PushSubscriptionSchema = z30.object({
-  id: z30.string(),
-  endpoint: z30.string(),
-  deviceName: z30.string().nullable(),
-  userAgent: z30.string().nullable(),
-  createdAt: z30.string(),
-  updatedAt: z30.string(),
-  lastUsedAt: z30.string().nullable()
+var PushSubscriptionSchema = z31.object({
+  id: z31.string(),
+  endpoint: z31.string(),
+  deviceName: z31.string().nullable(),
+  userAgent: z31.string().nullable(),
+  createdAt: z31.string(),
+  updatedAt: z31.string(),
+  lastUsedAt: z31.string().nullable()
 });
-var PushSubscriptionListResponseSchema = z30.object({
-  subscriptions: z30.array(PushSubscriptionSchema)
+var PushSubscriptionListResponseSchema = z31.object({
+  subscriptions: z31.array(PushSubscriptionSchema)
 });
 
 // ../../packages/core/dist/esm/schemas/sample-automation.schema.js
-import { z as z31 } from "zod";
-var sampleAutomationSchema = z31.object({
-  id: z31.string(),
-  manifest: manifestSchema,
-  connectorDetails: z31.array(connectorDetailsSchema),
-  isOneClickInstallEnabled: z31.boolean().default(false),
-  staffPick: z31.boolean().default(false)
-});
-var sampleAutomationsSchema = z31.array(sampleAutomationSchema);
-
-// ../../packages/core/dist/esm/schemas/subscription.schema.js
 import { z as z32 } from "zod";
-var createSubscriptionSchema = z32.object({
-  connectorId: z32.string().min(1, "Connector ID is required"),
-  connectionId: z32.string().min(1, "Connection ID is required"),
-  triggerEventId: z32.string().min(1, "Trigger event ID is required"),
-  outputSchema: z32.record(z32.string(), z32.unknown()),
-  inputSchema: z32.record(z32.string(), z32.unknown()).optional()
-});
-var subscriptionResponseSchema = z32.object({
+var sampleAutomationSchema = z32.object({
   id: z32.string(),
-  agentId: z32.string(),
-  connectorId: z32.string(),
-  connectionId: z32.string(),
-  triggerEventId: z32.string(),
-  providerType: z32.enum(PROVIDER_TYPES),
-  status: z32.enum(WEBHOOK_SUBSCRIPTION_STATUSES),
-  outputSchema: z32.record(z32.string(), z32.unknown()).optional(),
-  inputSchema: z32.record(z32.string(), z32.unknown()).optional(),
-  webhook: z32.object({
-    endpoint: z32.string(),
-    providerConfig: z32.record(z32.string(), z32.unknown()).optional()
-  }).optional(),
-  createdAt: z32.string(),
-  updatedAt: z32.string()
+  manifest: manifestSchema,
+  connectorDetails: z32.array(connectorDetailsSchema),
+  isOneClickInstallEnabled: z32.boolean().default(false),
+  staffPick: z32.boolean().default(false)
 });
+var sampleAutomationsSchema = z32.array(sampleAutomationSchema);
 
-// ../../packages/core/dist/esm/schemas/usage-billing.schema.js
+// ../../packages/core/dist/esm/schemas/subscription.schema.js
 import { z as z33 } from "zod";
-var UsageBillingProductSchema = z33.literal("automations");
-var UsageBillingAccountSchema = z33.object({
-  id: z33.string().regex(/^[1-9]\d*$/),
-  type: z33.literal("user")
-});
-var RESERVATION_ID_MAX_LENGTH = 100;
-var EXTERNAL_EVENT_ID_MAX_LENGTH = 100;
-var CATEGORY_MAX_LENGTH = 64;
-var AuthorizeUsageRequestSchema = z33.object({
-  product: UsageBillingProductSchema,
-  account: UsageBillingAccountSchema,
-  reservation_id: z33.string().min(1).max(RESERVATION_ID_MAX_LENGTH),
-  category: z33.string().min(1).max(CATEGORY_MAX_LENGTH)
-});
-var UsageBillingUnitsSchema = z33.number().int().nonnegative();
-var UsageBillingBalanceSchema = z33.number().int();
-var RecordUsageRefsSchema = z33.record(z33.string().max(40), z33.string().max(500)).refine((refs) => Object.keys(refs).length <= 50);
-var AuthorizeUsageResponseSchema = z33.discriminatedUnion("decision", [
-  z33.object({
-    decision: z33.literal("allowed"),
-    reservation_id: z33.string().min(1),
-    available_units: UsageBillingBalanceSchema
-  }),
-  z33.object({
-    decision: z33.literal("denied"),
-    reason: z33.enum(["insufficient_credit", "no_billing_account"]),
-    available_units: UsageBillingBalanceSchema
-  })
-]);
-var RecordUsageRequestSchema = z33.object({
-  product: UsageBillingProductSchema,
-  account: UsageBillingAccountSchema,
-  reservation_id: z33.string().min(1).max(RESERVATION_ID_MAX_LENGTH),
-  external_event_id: z33.string().min(1).max(EXTERNAL_EVENT_ID_MAX_LENGTH).refine((value) => !value.startsWith("reservation:")),
-  category: z33.string().min(1).max(CATEGORY_MAX_LENGTH),
-  status: z33.enum(["success", "failed", "cancelled", "timed_out", "partial"]),
-  incurred_cost: z33.number().int().nonnegative(),
-  refs: RecordUsageRefsSchema.optional(),
-  description: z33.string().min(1).max(255)
-});
-var RecordUsageResponseSchema = z33.object({
-  recorded: z33.boolean(),
-  charged_units: UsageBillingUnitsSchema,
-  available_units: UsageBillingBalanceSchema
-});
-var TOP_UP_USD_MIN_AMOUNT = 500;
-var TopUpCurrencySchema = z33.preprocess((value) => typeof value === "string" ? value.toLowerCase() : value, z33.literal("usd"));
-var StartTopUpRequestSchema = z33.object({
-  amount: z33.number().int().min(TOP_UP_USD_MIN_AMOUNT),
-  // The public OpenAPI example uses lowercase `usd`; the backend also
-  // normalizes caller casing before checking the currently supported currency.
-  currency: TopUpCurrencySchema,
-  return_url: z33.url()
-});
-var StartTopUpResponseSchema = z33.object({
-  session_id: z33.string().min(1),
-  checkout_url: z33.url()
-});
-var BillingPortalUrlRequestSchema = z33.object({
-  return_url: z33.url()
-});
-var BillingPortalUrlResponseSchema = z33.object({
-  billing_portal_url: z33.url()
-});
-var ReadStateResponseSchema = z33.object({
-  available_units: UsageBillingBalanceSchema,
-  available_amount: UsageBillingBalanceSchema,
-  currency: z33.string(),
-  usage_allowed: z33.boolean(),
-  low_balance: z33.boolean(),
-  depleted: z33.boolean()
-});
-var UsageBillingAmountSchema = UsageBillingUnitsSchema.nullable();
-var UsageBillingEntrySchema = z33.object({
-  id: z33.number().int().positive(),
-  type: z33.string().min(1),
-  created_at: z33.iso.datetime(),
-  category: z33.string().min(1).optional(),
-  status: z33.string().min(1).optional(),
-  charged_units: UsageBillingAmountSchema,
-  /** `charged_units` in integer microdollars. `null` exactly when it is. */
-  charged_amount: UsageBillingAmountSchema,
-  credited_units: UsageBillingAmountSchema,
-  /** `credited_units` in integer microdollars. `null` exactly when it is. */
-  credited_amount: UsageBillingAmountSchema,
-  refs: z33.record(z33.string(), z33.unknown()).optional(),
-  description: z33.string().optional()
-}).refine((entry) => entry.charged_units === null === (entry.charged_amount === null) && entry.credited_units === null === (entry.credited_amount === null), { message: "Each units field and its amount must be null together" });
-var USAGE_BILLING_ENTRY_TYPES = [
-  "usage_settled",
-  "top_up",
-  "adjustment",
-  "void",
-  "expiry",
-  "chargeback"
-];
-var UsageBillingEntryTypeSchema = z33.enum(USAGE_BILLING_ENTRY_TYPES);
-var ReadTransactionsResponseSchema = z33.object({
-  /**
-   * On the page rather than on each entry: an account pins one price for its
-   * whole life, so no two entries can differ.
-   */
-  currency: z33.string(),
-  entries: z33.array(UsageBillingEntrySchema),
-  has_more: z33.boolean(),
-  /** Absent on the last page. */
-  next_cursor: z33.string().min(1).optional()
-});
-var ReadUsageSummaryRequestSchema = z33.object({
-  /** Omit to total every category. */
-  category: z33.string().min(1).optional(),
-  /** Start of the window, inclusive. Omit to start at the account's first event. */
-  since: z33.iso.datetime().optional(),
-  /** End of the window, exclusive. Omit to run to now. */
-  until: z33.iso.datetime().optional()
-});
-var ReadUsageSummaryResponseSchema = z33.object({
-  currency: z33.string(),
-  usage_count: UsageBillingUnitsSchema,
-  charged_units: UsageBillingUnitsSchema,
-  /** `charged_units` in integer microdollars. `0` on an account with no usage. */
-  charged_amount: UsageBillingUnitsSchema
-});
-var GrantWelcomeCreditRequestSchema = z33.object({
-  product: UsageBillingProductSchema,
-  account: UsageBillingAccountSchema,
-  operator: z33.email().max(254)
-});
-var GrantWelcomeCreditResponseSchema = z33.object({
-  status: z33.enum(["granted", "already_granted"]),
-  grant_id: z33.string().min(1)
+var createSubscriptionSchema = z33.object({
+  connectorId: z33.string().min(1, "Connector ID is required"),
+  connectionId: z33.string().min(1, "Connection ID is required"),
+  triggerEventId: z33.string().min(1, "Trigger event ID is required"),
+  outputSchema: z33.record(z33.string(), z33.unknown()),
+  inputSchema: z33.record(z33.string(), z33.unknown()).optional()
+});
+var subscriptionResponseSchema = z33.object({
+  id: z33.string(),
+  agentId: z33.string(),
+  connectorId: z33.string(),
+  connectionId: z33.string(),
+  triggerEventId: z33.string(),
+  providerType: z33.enum(PROVIDER_TYPES),
+  status: z33.enum(WEBHOOK_SUBSCRIPTION_STATUSES),
+  outputSchema: z33.record(z33.string(), z33.unknown()).optional(),
+  inputSchema: z33.record(z33.string(), z33.unknown()).optional(),
+  webhook: z33.object({
+    endpoint: z33.string(),
+    providerConfig: z33.record(z33.string(), z33.unknown()).optional()
+  }).optional(),
+  createdAt: z33.string(),
+  updatedAt: z33.string()
 });
 
 // ../../packages/core/dist/esm/schemas/user-settings.schema.js
@@ -11031,6 +11128,9 @@ var automationDraftsEndpoints = {
 };
 
 // ../../packages/sdk/dist/esm/clients/automation-drafts/automation-drafts-client.js
+function toCreateQuery(translate) {
+  return translate === void 0 ? void 0 : { translate };
+}
 var AutomationDraftsClient = class extends BaseClient {
   async list(args = {}, options) {
     const { cursor, limit } = CursorPaginationSchema.parse(args);
@@ -11053,11 +11153,13 @@ var AutomationDraftsClient = class extends BaseClient {
   }
   async create(manifest, options) {
     const body = partialManifestSchema.parse(manifest);
+    const { translate, ...requestOptions } = options ?? {};
     const data = await this.request({
       method: "POST",
       path: automationDraftsEndpoints.list,
+      query: toCreateQuery(translate),
       body,
-      options
+      options: requestOptions
     });
     return automationDraftWithValidationSchema.parse(data);
   }
@@ -11344,11 +11446,23 @@ var WorkspaceAutomationRunsClient = class extends BaseClient {
 
 // ../../packages/sdk/dist/esm/clients/workspace-automation-draft-connections/endpoints.js
 var workspaceAutomationDraftConnectionsEndpoints = {
-  list: (workspaceId, draftId) => `/workspaces/${encodeURIComponent(workspaceId)}/automation-drafts/${encodeURIComponent(draftId)}/connections`
+  list: (workspaceId, draftId) => root6(workspaceId, draftId),
+  status: (workspaceId, draftId) => `${root6(workspaceId, draftId)}/status`
 };
+function root6(workspaceId, draftId) {
+  return `/workspaces/${encodeURIComponent(workspaceId)}/automation-drafts/${encodeURIComponent(draftId)}/connections`;
+}
 
 // ../../packages/sdk/dist/esm/clients/workspace-automation-draft-connections/workspace-automation-draft-connections-client.js
 var WorkspaceAutomationDraftConnectionsClient = class extends BaseClient {
+  async list(workspaceId, draftId, options) {
+    const data = await this.request({
+      method: "GET",
+      path: workspaceAutomationDraftConnectionsEndpoints.list(IdSchema.parse(workspaceId), IdSchema.parse(draftId)),
+      options
+    });
+    return GetAutomationDraftConnectionsResponseSchema.parse(data);
+  }
   async upsert(workspaceId, draftId, body, options) {
     const parsedBody = CreateAutomationDraftConnectionSchema.parse(body);
     const data = await this.request({
@@ -11359,14 +11473,23 @@ var WorkspaceAutomationDraftConnectionsClient = class extends BaseClient {
     });
     return AutomationDraftConnectionSchema.parse(data);
   }
+  async getStatus(workspaceId, draftId, options) {
+    const data = await this.request({
+      method: "GET",
+      path: workspaceAutomationDraftConnectionsEndpoints.status(IdSchema.parse(workspaceId), IdSchema.parse(draftId)),
+      options
+    });
+    return GetAutomationDraftConnectionValidationResponseSchema.parse(data);
+  }
 };
 
 // ../../packages/sdk/dist/esm/clients/workspace-automation-drafts/endpoints.js
 var workspaceAutomationDraftsEndpoints = {
-  list: (workspaceId) => `${root6(workspaceId)}`,
-  detail: (workspaceId, id) => `${root6(workspaceId)}/${encodeURIComponent(id)}`
+  list: (workspaceId) => `${root7(workspaceId)}`,
+  detail: (workspaceId, id) => `${root7(workspaceId)}/${encodeURIComponent(id)}`,
+  finalize: (workspaceId, id) => `${root7(workspaceId)}/${encodeURIComponent(id)}/finalize`
 };
-function root6(workspaceId) {
+function root7(workspaceId) {
   return `/workspaces/${encodeURIComponent(workspaceId)}/automation-drafts`;
 }
 
@@ -11390,6 +11513,29 @@ var WorkspaceAutomationDraftsClient = class extends BaseClient {
     });
     return automationDraftWithValidationSchema.parse(data);
   }
+  async create(workspaceId, manifest, options) {
+    const body = partialManifestSchema.parse(manifest);
+    const { translate, ...requestOptions } = options ?? {};
+    const data = await this.request({
+      method: "POST",
+      path: workspaceAutomationDraftsEndpoints.list(IdSchema.parse(workspaceId)),
+      // Only sent when set, so a default create is unchanged on the wire.
+      query: translate === void 0 ? void 0 : { translate },
+      body,
+      options: requestOptions
+    });
+    return automationDraftWithValidationSchema.parse(data);
+  }
+  async update(workspaceId, draftId, manifest, options) {
+    const body = partialManifestSchema.parse(manifest);
+    const data = await this.request({
+      method: "PUT",
+      path: workspaceAutomationDraftsEndpoints.detail(IdSchema.parse(workspaceId), IdSchema.parse(draftId)),
+      body,
+      options
+    });
+    return automationDraftWithValidationSchema.parse(data);
+  }
   /** Deletes the draft. Only its owner can; the API answers 404 otherwise. */
   async delete(workspaceId, draftId, options) {
     await this.request({
@@ -11398,6 +11544,15 @@ var WorkspaceAutomationDraftsClient = class extends BaseClient {
       options
     });
   }
+  /** Publishes the draft as a workspace automation, or updates the one it edits. */
+  async finalize(workspaceId, draftId, options) {
+    const data = await this.request({
+      method: "POST",
+      path: workspaceAutomationDraftsEndpoints.finalize(IdSchema.parse(workspaceId), IdSchema.parse(draftId)),
+      options
+    });
+    return finalizeAutomationDraftResponseSchema.parse(data);
+  }
 };
 
 // ../../packages/sdk/dist/esm/clients/workspace-chat/endpoints.js
@@ -11421,15 +11576,16 @@ var WorkspaceChatClient = class extends BaseClient {
 
 // ../../packages/sdk/dist/esm/clients/workspace-automations/endpoints.js
 var workspaceAutomationsEndpoints = {
-  list: (workspaceId) => `${root7(workspaceId)}`,
-  detail: (workspaceId, id) => `${root7(workspaceId)}/${encodeURIComponent(id)}`,
-  metadata: (workspaceId, id) => `${root7(workspaceId)}/${encodeURIComponent(id)}/metadata`,
-  schedule: (workspaceId, id) => `${root7(workspaceId)}/${encodeURIComponent(id)}/schedule`,
-  visibility: (workspaceId, id) => `${root7(workspaceId)}/${encodeURIComponent(id)}/visibility`,
-  move: (workspaceId, id) => `${root7(workspaceId)}/${encodeURIComponent(id)}/move`,
-  trigger: (workspaceId, id) => `${root7(workspaceId)}/${encodeURIComponent(id)}/trigger`
+  list: (workspaceId) => `${root8(workspaceId)}`,
+  detail: (workspaceId, id) => `${root8(workspaceId)}/${encodeURIComponent(id)}`,
+  metadata: (workspaceId, id) => `${root8(workspaceId)}/${encodeURIComponent(id)}/metadata`,
+  schedule: (workspaceId, id) => `${root8(workspaceId)}/${encodeURIComponent(id)}/schedule`,
+  visibility: (workspaceId, id) => `${root8(workspaceId)}/${encodeURIComponent(id)}/visibility`,
+  move: (workspaceId, id) => `${root8(workspaceId)}/${encodeURIComponent(id)}/move`,
+  trigger: (workspaceId, id) => `${root8(workspaceId)}/${encodeURIComponent(id)}/trigger`,
+  draft: (workspaceId, id) => `${root8(workspaceId)}/${encodeURIComponent(id)}/draft`
 };
-function root7(workspaceId) {
+function root8(workspaceId) {
   return `/workspaces/${encodeURIComponent(workspaceId)}/automations`;
 }
 
@@ -11527,12 +11683,33 @@ var WorkspaceAutomationsClient = class extends BaseClient {
       options
     });
   }
+  /** The edit draft currently open for the automation, if any (404 otherwise). */
+  async getDraft(workspaceId, id, options) {
+    const data = await this.request({
+      method: "GET",
+      path: workspaceAutomationsEndpoints.draft(IdSchema.parse(workspaceId), IdSchema.parse(id)),
+      options
+    });
+    return automationDraftSchema.parse(data);
+  }
+  /**
+   * Opens an edit draft seeded from the published manifest. Answers 409 when
+   * one is already open; see `getOpenDraftConflictError`.
+   */
+  async createDraft(workspaceId, id, options) {
+    const data = await this.request({
+      method: "POST",
+      path: workspaceAutomationsEndpoints.draft(IdSchema.parse(workspaceId), IdSchema.parse(id)),
+      options
+    });
+    return createDraftResponseSchema.parse(data);
+  }
 };
 
 // ../../packages/sdk/dist/esm/clients/workspaces/endpoints.js
-var root8 = "/workspaces";
+var root9 = "/workspaces";
 var workspacesEndpoints = {
-  list: root8
+  list: root9
 };
 
 // ../../packages/sdk/dist/esm/clients/workspaces/workspaces-client.js
@@ -11554,12 +11731,12 @@ var WorkspacesClient = class extends BaseClient {
 };
 
 // ../../packages/sdk/dist/esm/clients/chat/endpoints.js
-var root9 = "/chat/conversations";
+var root10 = "/chat/conversations";
 var chatEndpoints = {
-  conversations: root9,
-  conversation: (id) => `${root9}/${encodeURIComponent(id)}`,
-  messages: (id) => `${root9}/${encodeURIComponent(id)}/messages`,
-  usagePreview: (id) => `${root9}/${encodeURIComponent(id)}/usage-preview`
+  conversations: root10,
+  conversation: (id) => `${root10}/${encodeURIComponent(id)}`,
+  messages: (id) => `${root10}/${encodeURIComponent(id)}/messages`,
+  usagePreview: (id) => `${root10}/${encodeURIComponent(id)}/usage-preview`
 };
 
 // ../../packages/sdk/dist/esm/clients/chat/chat-client.js
@@ -11636,14 +11813,15 @@ var ChatClient = class extends BaseClient {
 import { z as z51 } from "zod";
 
 // ../../packages/sdk/dist/esm/clients/connections/endpoints.js
-var root10 = "/connections";
+var root11 = "/connections";
 var connectionsEndpoints = {
-  list: root10,
-  detail: (id) => `${root10}/${encodeURIComponent(id)}`,
-  token: (id) => `${root10}/${encodeURIComponent(id)}/token`,
-  dependentAutomations: (connectorId) => `${root10}/${encodeURIComponent(connectorId)}/automations`,
-  create: (connectorId, capability) => `${root10}/${encodeURIComponent(connectorId)}/${encodeURIComponent(capability)}`,
-  checkManifest: `${root10}/check-manifest`
+  list: root11,
+  detail: (id) => `${root11}/${encodeURIComponent(id)}`,
+  token: (id) => `${root11}/${encodeURIComponent(id)}/token`,
+  dependentAutomations: (connectorId) => `${root11}/${encodeURIComponent(connectorId)}/automations`,
+  create: (connectorId, capability) => `${root11}/${encodeURIComponent(connectorId)}/${encodeURIComponent(capability)}`,
+  localOAuth: (connectorId, capability) => `${root11}/${encodeURIComponent(connectorId)}/${encodeURIComponent(capability)}/local-oauth`,
+  checkManifest: `${root11}/check-manifest`
 };
 
 // ../../packages/sdk/dist/esm/clients/connections/connections-client.js
@@ -11722,6 +11900,41 @@ var ConnectionsClient = class extends BaseClient {
     });
     return CreateConnectionResponseSchema.parse(data);
   }
+  /**
+   * The authorization server endpoints and scopes for running a
+   * `connectsViaCli` connector's OAuth flow with a loopback client.
+   */
+  async getLocalOAuthSetup(args, options) {
+    const { connectorId, capability } = CreateConnectionParamsSchema.parse({
+      connectorId: IdSchema.parse(args.connectorId),
+      capability: args.capability
+    });
+    const data = await this.request({
+      method: "GET",
+      path: connectionsEndpoints.localOAuth(connectorId, capability),
+      options
+    });
+    return LocalOAuthSetupSchema.parse(data);
+  }
+  /**
+   * Stores a grant the CLI obtained with a loopback OAuth client, for a
+   * connector whose authorization server admits no hosted clients
+   * (`connectsViaCli`). The connection comes back already authorized.
+   */
+  async importLocalOAuth(args, options) {
+    const { connectorId, capability } = CreateConnectionParamsSchema.parse({
+      connectorId: IdSchema.parse(args.connectorId),
+      capability: args.capability
+    });
+    const body = ImportLocalOAuthConnectionBodySchema.parse(args.grant);
+    const data = await this.request({
+      method: "POST",
+      path: connectionsEndpoints.localOAuth(connectorId, capability),
+      body,
+      options
+    });
+    return CreateConnectionResponseSchema.parse(data);
+  }
   async checkManifest(manifest, options) {
     const parsedManifest = partialManifestSchema.parse(manifest);
     const data = await this.request({
@@ -11801,12 +12014,12 @@ function createClientContext(authToken, options = {}, apiOrigin = "automations")
 import { z as z54 } from "zod";
 
 // ../../packages/sdk/dist/esm/clients/notifications/endpoints.js
-var root11 = "/notifications";
+var root12 = "/notifications";
 var notificationsEndpoints = {
-  list: root11,
-  pendingPromptAutomations: `${root11}/pending-prompt-automations`,
-  detail: (id) => `${root11}/${encodeURIComponent(id)}`,
-  respond: (id) => `${root11}/${encodeURIComponent(id)}/respond`
+  list: root12,
+  pendingPromptAutomations: `${root12}/pending-prompt-automations`,
+  detail: (id) => `${root12}/${encodeURIComponent(id)}`,
+  respond: (id) => `${root12}/${encodeURIComponent(id)}/respond`
 };
 var pushRoot = "/push-subscriptions";
 var pushSubscriptionsEndpoints = {
@@ -11931,11 +12144,11 @@ var NotificationsClient = class extends BaseClient {
 };
 
 // ../../packages/sdk/dist/esm/clients/user-settings/endpoints.js
-var root12 = "/settings";
+var root13 = "/settings";
 var userSettingsEndpoints = {
-  onboarding: `${root12}/onboarding`,
-  preferences: `${root12}/preferences`,
-  terms: `${root12}/terms`
+  onboarding: `${root13}/onboarding`,
+  preferences: `${root13}/preferences`,
+  terms: `${root13}/terms`
 };
 
 // ../../packages/sdk/dist/esm/clients/user-settings/user-settings-client.js
@@ -12100,11 +12313,11 @@ var UsageBillingClient = class extends BaseClient {
 };
 
 // ../../packages/sdk/dist/esm/clients/webhook-event-subscriptions/endpoints.js
-var root13 = "/webhook-event-subscriptions";
+var root14 = "/webhook-event-subscriptions";
 var webhookEventSubscriptionsEndpoints = {
-  list: root13,
-  detail: (id) => `${root13}/${encodeURIComponent(id)}`,
-  deliveries: (id) => `${root13}/${encodeURIComponent(id)}/deliveries`
+  list: root14,
+  detail: (id) => `${root14}/${encodeURIComponent(id)}`,
+  deliveries: (id) => `${root14}/${encodeURIComponent(id)}/deliveries`
 };
 
 // ../../packages/sdk/dist/esm/clients/webhook-event-subscriptions/webhook-event-subscriptions-client.js
@@ -12180,12 +12393,12 @@ var WebhookEventSubscriptionsClient = class extends BaseClient {
 import { z as z56 } from "zod";
 
 // ../../packages/sdk/dist/esm/clients/webhook-subscriptions/endpoints.js
-function root14(automationId) {
+function root15(automationId) {
   return `/automations/${encodeURIComponent(automationId)}/subscriptions`;
 }
 var webhookSubscriptionsEndpoints = {
-  list: (automationId) => root14(automationId),
-  detail: (automationId, subscriptionId) => `${root14(automationId)}/${encodeURIComponent(subscriptionId)}`
+  list: (automationId) => root15(automationId),
+  detail: (automationId, subscriptionId) => `${root15(automationId)}/${encodeURIComponent(subscriptionId)}`
 };
 
 // ../../packages/sdk/dist/esm/clients/webhook-subscriptions/webhook-subscriptions-client.js
@@ -12358,6 +12571,7 @@ function summarizeAutomationListItem(dto) {
     visibility: dto.visibility,
     isOwner: dto.isOwner,
     ...dto.workspaceId ? { workspaceId: dto.workspaceId } : {},
+    ...dto.createdBy ? { createdBy: dto.createdBy } : {},
     ...dto.updatedBy ? { updatedBy: dto.updatedBy } : {},
     ...dto.disabledReason ? { disabledReason: dto.disabledReason } : {},
     triggers: triggers.flatMap((trigger) => summarizeTrigger(trigger) ?? []),
@@ -12936,7 +13150,7 @@ import { McpServer } from "@modelcontextprotocol/server";
 // package.json
 var package_default = {
   name: "@doist/automations-mcp",
-  version: "1.3.0",
+  version: "1.4.1",
   description: "MCP server and importable AI tools for Todoist Automations",
   type: "module",
   main: "./dist/index.js",
@@ -12982,7 +13196,7 @@ var package_default = {
     prepack: "npm run build"
   },
   dependencies: {
-    ai: "7.0.77",
+    ai: "7.0.86",
     zod: "4.6.5"
   },
   peerDependencies: {
@@ -12991,9 +13205,9 @@ var package_default = {
   devDependencies: {
     "@doist/automations-core": "*",
     "@doist/automations-sdk": "*",
-    "@modelcontextprotocol/client": "2.0.0",
-    "@modelcontextprotocol/server": "2.0.0",
-    "@types/node": "24.13.6",
+    "@modelcontextprotocol/client": "2.3.1",
+    "@modelcontextprotocol/server": "2.3.1",
+    "@types/node": "24.19.1",
     "conventional-changelog-conventionalcommits": "9.3.1",
     esbuild: "0.28.2",
     "gpt-tokenizer": "4.0.0",
@@ -13001,7 +13215,7 @@ var package_default = {
     "semantic-release-monorepo": "8.0.2",
     tsx: "4.23.15",
     typescript: "6.0.3",
-    vitest: "4.1.11"
+    vitest: "5.0.3"
   },
   engines: {
     node: ">=24.15.0 <25",
@@ -13259,6 +13473,9 @@ var automationSummarySchema = z60.object({
   visibility: z60.enum(AUTOMATION_VISIBILITIES),
   isOwner: z60.boolean(),
   workspaceId: z60.string().optional().describe("Absent for personal automations."),
+  createdBy: z60.string().optional().describe(
+    "The Todoist user id of whoever created the automation. It never changes, including when the automation is moved."
+  ),
   updatedBy: z60.string().optional().describe(
     "The Todoist user id of whoever last changed the automation, which in a workspace can be an admin rather than the creator. Absent until someone has changed it."
   ),
@@ -14923,7 +15140,7 @@ You have access to a user's Todoist Automations through the tools listed.
 - 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, 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 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.
 - 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.
@@ -14958,4 +15175,4 @@ export {
   DEFAULT_BASE_URL,
   getMcpServer
 };
-//# sourceMappingURL=chunk-JNUCEABU.js.map
+//# sourceMappingURL=chunk-NJYR6WQU.js.map