skedyul 1.5.2 → 1.5.12

package/dist/esm/index.mjs

@@ -1,7 +1,7 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 
 // src/index.ts
-import { z as z15 } from "zod/v4";
+import { z as z16 } from "zod/v4";
 
 // src/types/invocation.ts
 function createToolCallContext(params) {
@@ -56,12 +56,118 @@ function isCronContext(ctx) {
   return ctx.trigger === "cron";
 }
 
-// src/types/tool.ts
+// src/types/estimation.ts
 import { z } from "zod/v4";
-var ToolResponseMetaSchema = z.object({
-  success: z.boolean(),
-  message: z.string(),
-  toolName: z.string()
+var MoneyMinorRangeSchema = z.object({
+  currency: z.string().min(3).max(3),
+  minorUnitsLow: z.number().int().nonnegative(),
+  minorUnitsHigh: z.number().int().nonnegative(),
+  minorUnitsExpected: z.number().int().nonnegative().optional()
+});
+var EstimationSkippedBreakdownSchema = z.object({
+  missingAddress: z.number().int().nonnegative(),
+  optOut: z.number().int().nonnegative(),
+  emptyMessage: z.number().int().nonnegative(),
+  unavailable: z.number().int().nonnegative()
+});
+var EstimationSchema = z.object({
+  deliverableCount: z.number().int().nonnegative(),
+  skippedCount: z.number().int().nonnegative().optional(),
+  skippedBreakdown: EstimationSkippedBreakdownSchema.optional(),
+  cost: MoneyMinorRangeSchema.optional()
+});
+function createMoneyMinorRange(params) {
+  return {
+    currency: params.currency,
+    minorUnitsLow: params.minorUnitsLow,
+    minorUnitsHigh: params.minorUnitsHigh,
+    ...params.minorUnitsExpected !== void 0 ? { minorUnitsExpected: params.minorUnitsExpected } : {}
+  };
+}
+function createEstimation(params) {
+  return {
+    deliverableCount: params.deliverableCount,
+    ...params.skippedCount !== void 0 ? { skippedCount: params.skippedCount } : {},
+    ...params.skippedBreakdown ? { skippedBreakdown: params.skippedBreakdown } : {},
+    ...params.cost ? { cost: params.cost } : {}
+  };
+}
+function computeSkewedExpectedMinorUnits(range) {
+  if (range.minorUnitsExpected !== void 0) {
+    return range.minorUnitsExpected;
+  }
+  if (range.minorUnitsLow === range.minorUnitsHigh) {
+    return range.minorUnitsLow;
+  }
+  return Math.round(0.8 * range.minorUnitsLow + 0.2 * range.minorUnitsHigh);
+}
+function formatMoneyMinorRange(range, locale) {
+  const formatter = new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency: range.currency
+  });
+  const low = formatter.format(range.minorUnitsLow / 100);
+  const high = formatter.format(range.minorUnitsHigh / 100);
+  if (range.minorUnitsLow === range.minorUnitsHigh) {
+    return low;
+  }
+  return `${low} \u2013 ${high}`;
+}
+function formatMoneyMinorEstimate(range, options) {
+  const formatter = new Intl.NumberFormat(options?.locale, {
+    style: "currency",
+    currency: range.currency
+  });
+  const maxSpreadRatio = options?.maxSpreadRatio ?? 4;
+  const spreadRatio = range.minorUnitsLow > 0 ? range.minorUnitsHigh / range.minorUnitsLow : 1;
+  if (spreadRatio > maxSpreadRatio) {
+    return formatMoneyMinorRange(range, options?.locale);
+  }
+  const expectedMinorUnits = options?.expectedMinorUnits ?? computeSkewedExpectedMinorUnits(range);
+  const expected = formatter.format(expectedMinorUnits / 100);
+  if (range.minorUnitsLow === range.minorUnitsHigh) {
+    return expected;
+  }
+  return `~${expected}`;
+}
+function parseEstimationFromBilling(billing) {
+  if (!billing || typeof billing !== "object") {
+    return void 0;
+  }
+  const record2 = billing;
+  const nested = record2.estimation;
+  if (nested && typeof nested === "object") {
+    const parsed = EstimationSchema.safeParse(nested);
+    if (parsed.success) {
+      return parsed.data;
+    }
+  }
+  const currency = typeof record2.currency === "string" && record2.currency.trim() !== "" ? record2.currency : void 0;
+  const minorUnitsLow = typeof record2.minorUnitsLow === "number" ? record2.minorUnitsLow : typeof record2.costCentsLow === "number" ? record2.costCentsLow : void 0;
+  const minorUnitsHigh = typeof record2.minorUnitsHigh === "number" ? record2.minorUnitsHigh : typeof record2.costCentsHigh === "number" ? record2.costCentsHigh : void 0;
+  const minorUnitsExpected = typeof record2.minorUnitsExpected === "number" ? record2.minorUnitsExpected : typeof record2.costCentsExpected === "number" ? record2.costCentsExpected : void 0;
+  const deliverableCount = typeof record2.deliverableCount === "number" ? record2.deliverableCount : void 0;
+  if (deliverableCount === void 0 || minorUnitsLow === void 0 || minorUnitsHigh === void 0 || !currency) {
+    return void 0;
+  }
+  return createEstimation({
+    deliverableCount,
+    skippedCount: typeof record2.skippedCount === "number" ? record2.skippedCount : void 0,
+    cost: createMoneyMinorRange({
+      currency,
+      minorUnitsLow,
+      minorUnitsHigh,
+      ...minorUnitsExpected !== void 0 ? { minorUnitsExpected } : {}
+    })
+  });
+}
+
+// src/types/tool.ts
+import { z as z2 } from "zod/v4";
+var ToolResponseMetaSchema = z2.object({
+  success: z2.boolean(),
+  message: z2.string(),
+  toolName: z2.string()
 });
 
 // src/types/tool-response.ts
@@ -202,11 +308,11 @@ function isRuntimeWebhookContext(ctx) {
 }
 
 // src/schemas.ts
-import { z as z7 } from "zod/v4";
+import { z as z8 } from "zod/v4";
 
 // src/schemas/crm-schema.ts
-import { z as z2 } from "zod/v4";
-var CRMFieldTypeSchema = z2.enum([
+import { z as z3 } from "zod/v4";
+var CRMFieldTypeSchema = z3.enum([
   "string",
   "long_string",
   "number",
@@ -218,125 +324,125 @@ var CRMFieldTypeSchema = z2.enum([
   "image",
   "object"
 ]);
-var CRMFieldRequirementSchema = z2.enum([
+var CRMFieldRequirementSchema = z3.enum([
   "optional",
   "on_create",
   "required"
 ]);
-var CRMFieldOptionSchema = z2.object({
-  label: z2.string(),
-  value: z2.string(),
-  color: z2.string().optional()
-});
-var CRMFieldDefinitionObjectSchema = z2.object({
-  options: z2.array(CRMFieldOptionSchema).optional(),
-  limitChoices: z2.number().optional(),
-  minLength: z2.number().optional(),
-  maxLength: z2.number().optional(),
-  min: z2.number().optional(),
-  max: z2.number().optional(),
-  pattern: z2.string().optional()
-});
-var CRMFieldDefinitionSchema = z2.union([
-  z2.string(),
+var CRMFieldOptionSchema = z3.object({
+  label: z3.string(),
+  value: z3.string(),
+  color: z3.string().optional()
+});
+var CRMFieldDefinitionObjectSchema = z3.object({
+  options: z3.array(CRMFieldOptionSchema).optional(),
+  limitChoices: z3.number().optional(),
+  minLength: z3.number().optional(),
+  maxLength: z3.number().optional(),
+  min: z3.number().optional(),
+  max: z3.number().optional(),
+  pattern: z3.string().optional()
+});
+var CRMFieldDefinitionSchema = z3.union([
+  z3.string(),
   CRMFieldDefinitionObjectSchema
 ]);
-var CRMFieldAppearanceSchemaZ = z2.object({
-  leftIcon: z2.string().optional(),
-  rightIcon: z2.string().optional(),
-  placeholder: z2.string().optional(),
-  helpText: z2.string().optional()
-});
-var CRMFieldSchemaZ = z2.object({
-  handle: z2.string().regex(/^[a-z][a-z0-9_]*$/, "Handle must be lowercase alphanumeric with underscores, starting with a letter"),
-  label: z2.string().min(1, "Label is required"),
+var CRMFieldAppearanceSchemaZ = z3.object({
+  leftIcon: z3.string().optional(),
+  rightIcon: z3.string().optional(),
+  placeholder: z3.string().optional(),
+  helpText: z3.string().optional()
+});
+var CRMFieldSchemaZ = z3.object({
+  handle: z3.string().regex(/^[a-z][a-z0-9_]*$/, "Handle must be lowercase alphanumeric with underscores, starting with a letter"),
+  label: z3.string().min(1, "Label is required"),
   type: CRMFieldTypeSchema,
   /** Field description - explains what the field is for (metadata, not UI) */
-  description: z2.string().optional(),
+  description: z3.string().optional(),
   /** Field appearance - UI presentation settings */
   appearance: CRMFieldAppearanceSchemaZ.optional(),
   requirement: CRMFieldRequirementSchema.optional(),
-  unique: z2.boolean().optional(),
-  list: z2.boolean().optional(),
-  default: z2.unknown().optional(),
+  unique: z3.boolean().optional(),
+  list: z3.boolean().optional(),
+  default: z3.unknown().optional(),
   definition: CRMFieldDefinitionSchema.optional()
 });
-var CRMModelSchemaZ = z2.object({
-  handle: z2.string().regex(/^[a-z][a-z0-9_]*$/, "Handle must be lowercase alphanumeric with underscores, starting with a letter"),
-  name: z2.string().min(1, "Name is required"),
-  namePlural: z2.string().optional(),
-  labelTemplate: z2.string().optional(),
-  description: z2.string().optional(),
-  icon: z2.string().optional(),
-  fields: z2.array(CRMFieldSchemaZ)
-});
-var CRMCardinalitySchema = z2.enum(["one_to_one", "one_to_many"]);
-var CRMOnDeleteSchema = z2.enum(["none", "cascade", "restrict"]);
-var CRMRelationshipLinkSchema = z2.object({
-  model: z2.string(),
-  field: z2.string(),
-  label: z2.string()
-});
-var CRMRelationshipSchemaZ = z2.object({
+var CRMModelSchemaZ = z3.object({
+  handle: z3.string().regex(/^[a-z][a-z0-9_]*$/, "Handle must be lowercase alphanumeric with underscores, starting with a letter"),
+  name: z3.string().min(1, "Name is required"),
+  namePlural: z3.string().optional(),
+  labelTemplate: z3.string().optional(),
+  description: z3.string().optional(),
+  icon: z3.string().optional(),
+  fields: z3.array(CRMFieldSchemaZ)
+});
+var CRMCardinalitySchema = z3.enum(["one_to_one", "one_to_many"]);
+var CRMOnDeleteSchema = z3.enum(["none", "cascade", "restrict"]);
+var CRMRelationshipLinkSchema = z3.object({
+  model: z3.string(),
+  field: z3.string(),
+  label: z3.string()
+});
+var CRMRelationshipSchemaZ = z3.object({
   source: CRMRelationshipLinkSchema,
   target: CRMRelationshipLinkSchema,
   cardinality: CRMCardinalitySchema,
   onDelete: CRMOnDeleteSchema.optional()
 });
-var CRMBlockTypeSchema = z2.enum([
+var CRMBlockTypeSchema = z3.enum([
   "spreadsheet",
   "form",
   "card",
   "metric",
   "kanban"
 ]);
-var CRMBlockSchemaZ = z2.object({
+var CRMBlockSchemaZ = z3.object({
   type: CRMBlockTypeSchema,
-  title: z2.string().optional(),
-  config: z2.unknown().optional(),
-  default: z2.boolean().optional()
+  title: z3.string().optional(),
+  config: z3.unknown().optional(),
+  default: z3.boolean().optional()
 });
-var CRMPageTypeSchema = z2.enum(["list", "instance"]);
-var CRMPageSchemaZ = z2.object({
-  path: z2.string(),
+var CRMPageTypeSchema = z3.enum(["list", "instance"]);
+var CRMPageSchemaZ = z3.object({
+  path: z3.string(),
   type: CRMPageTypeSchema,
-  title: z2.string(),
-  icon: z2.string().optional(),
-  modelHandle: z2.string(),
-  parentPath: z2.string().optional(),
-  baseQuery: z2.unknown().optional(),
-  blocks: z2.array(CRMBlockSchemaZ).optional()
-});
-var CRMNavigationNodeBaseSchemaZ = z2.object({
-  label: z2.string(),
-  icon: z2.string().optional(),
-  path: z2.string().optional(),
-  kind: z2.enum(["section", "group"]).optional(),
-  sortIndex: z2.number().optional()
-});
-var CRMNavigationItemSchemaZ = z2.lazy(
+  title: z3.string(),
+  icon: z3.string().optional(),
+  modelHandle: z3.string(),
+  parentPath: z3.string().optional(),
+  baseQuery: z3.unknown().optional(),
+  blocks: z3.array(CRMBlockSchemaZ).optional()
+});
+var CRMNavigationNodeBaseSchemaZ = z3.object({
+  label: z3.string(),
+  icon: z3.string().optional(),
+  path: z3.string().optional(),
+  kind: z3.enum(["section", "group"]).optional(),
+  sortIndex: z3.number().optional()
+});
+var CRMNavigationItemSchemaZ = z3.lazy(
   () => CRMNavigationNodeBaseSchemaZ.extend({
-    children: z2.array(CRMNavigationItemSchemaZ).optional()
+    children: z3.array(CRMNavigationItemSchemaZ).optional()
   })
 );
-var CRMNavigationSchemaZ = z2.object({
-  sidebar: z2.array(CRMNavigationItemSchemaZ).optional()
+var CRMNavigationSchemaZ = z3.object({
+  sidebar: z3.array(CRMNavigationItemSchemaZ).optional()
 });
-var CRMSchemaZ = z2.object({
+var CRMSchemaZ = z3.object({
   /** Schema format version for future compatibility */
-  $schema: z2.literal("https://skedyul.com/schemas/crm/v1").optional(),
+  $schema: z3.literal("https://skedyul.com/schemas/crm/v1").optional(),
   /** Schema name for identification */
-  name: z2.string().min(1, "Name is required"),
+  name: z3.string().min(1, "Name is required"),
   /** Optional description */
-  description: z2.string().optional(),
+  description: z3.string().optional(),
   /** Schema version (semver) */
-  version: z2.string().optional(),
+  version: z3.string().optional(),
   /** Model definitions */
-  models: z2.array(CRMModelSchemaZ),
+  models: z3.array(CRMModelSchemaZ),
   /** Relationship definitions */
-  relationships: z2.array(CRMRelationshipSchemaZ).optional(),
+  relationships: z3.array(CRMRelationshipSchemaZ).optional(),
   /** Page definitions */
-  pages: z2.array(CRMPageSchemaZ).optional(),
+  pages: z3.array(CRMPageSchemaZ).optional(),
   /** Navigation definitions */
   navigation: CRMNavigationSchemaZ.optional()
 });
@@ -363,11 +469,11 @@ function safeParseCRMSchema(data) {
 }
 
 // src/schemas/agent-schema-v3.ts
-import { z as z6 } from "zod/v4";
+import { z as z7 } from "zod/v4";
 
 // src/events/types.ts
-import { z as z3 } from "zod/v4";
-var ThreadEventTypeSchema = z3.enum([
+import { z as z4 } from "zod/v4";
+var ThreadEventTypeSchema = z4.enum([
   // Message events
   "thread.message.received",
   "thread.message.sent",
@@ -389,73 +495,73 @@ var ThreadEventTypeSchema = z3.enum([
   // Signal events
   "thread.signal.created"
 ]);
-var CustomEventTypeSchema = z3.string().regex(/^custom\.[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)*$/, {
+var CustomEventTypeSchema = z4.string().regex(/^custom\.[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)*$/, {
   message: "Custom event type must match pattern: custom.{namespace}.{event}"
 });
-var EventTypeSchema = z3.union([ThreadEventTypeSchema, CustomEventTypeSchema]);
-var ParticipantKindSchema = z3.enum(["CONTACT", "MEMBER", "AGENT", "WORKFLOW"]);
-var BaseEventPayloadSchema = z3.object({
-  threadId: z3.string(),
-  workplaceId: z3.string(),
-  timestamp: z3.string().datetime().optional()
+var EventTypeSchema = z4.union([ThreadEventTypeSchema, CustomEventTypeSchema]);
+var ParticipantKindSchema = z4.enum(["CONTACT", "MEMBER", "AGENT", "WORKFLOW"]);
+var BaseEventPayloadSchema = z4.object({
+  threadId: z4.string(),
+  workplaceId: z4.string(),
+  timestamp: z4.string().datetime().optional()
 });
 var MessageEventPayloadSchema = BaseEventPayloadSchema.extend({
-  message: z3.object({
-    id: z3.string(),
-    content: z3.string(),
-    senderId: z3.string().optional()
+  message: z4.object({
+    id: z4.string(),
+    content: z4.string(),
+    senderId: z4.string().optional()
   }),
-  participant: z3.object({
-    id: z3.string(),
+  participant: z4.object({
+    id: z4.string(),
     kind: ParticipantKindSchema,
-    displayName: z3.string().optional()
+    displayName: z4.string().optional()
   }).optional(),
-  isFirstMessage: z3.boolean().optional(),
-  messageCount: z3.number().optional()
+  isFirstMessage: z4.boolean().optional(),
+  messageCount: z4.number().optional()
 });
 var ParticipantEventPayloadSchema = BaseEventPayloadSchema.extend({
-  participant: z3.object({
-    id: z3.string(),
+  participant: z4.object({
+    id: z4.string(),
     kind: ParticipantKindSchema,
-    displayName: z3.string().optional(),
-    contactId: z3.string().optional(),
-    memberId: z3.string().optional(),
-    agentId: z3.string().optional(),
-    workflowId: z3.string().optional()
+    displayName: z4.string().optional(),
+    contactId: z4.string().optional(),
+    memberId: z4.string().optional(),
+    agentId: z4.string().optional(),
+    workflowId: z4.string().optional()
   })
 });
 var ContextChangedPayloadSchema = BaseEventPayloadSchema.extend({
-  context: z3.object({
-    handle: z3.string(),
-    model: z3.string(),
-    instanceId: z3.string()
+  context: z4.object({
+    handle: z4.string(),
+    model: z4.string(),
+    instanceId: z4.string()
   }),
-  change: z3.object({
-    field: z3.string().optional(),
-    oldValue: z3.unknown().optional(),
-    newValue: z3.unknown().optional()
+  change: z4.object({
+    field: z4.string().optional(),
+    oldValue: z4.unknown().optional(),
+    newValue: z4.unknown().optional()
   }).optional()
 });
 var StatusChangedPayloadSchema = BaseEventPayloadSchema.extend({
-  oldStatus: z3.string(),
-  newStatus: z3.string()
+  oldStatus: z4.string(),
+  newStatus: z4.string()
 });
 var ScheduledEventPayloadSchema = BaseEventPayloadSchema.extend({
-  scheduledEventId: z3.string(),
-  reason: z3.string().optional(),
-  context: z3.record(z3.string(), z3.unknown()).optional()
+  scheduledEventId: z4.string(),
+  reason: z4.string().optional(),
+  context: z4.record(z4.string(), z4.unknown()).optional()
 });
 var AgentWorkflowEventPayloadSchema = BaseEventPayloadSchema.extend({
-  agentId: z3.string().optional(),
-  workflowId: z3.string().optional(),
-  workflowRunId: z3.string().optional(),
-  outputs: z3.record(z3.string(), z3.unknown()).optional(),
-  error: z3.string().optional()
+  agentId: z4.string().optional(),
+  workflowId: z4.string().optional(),
+  workflowRunId: z4.string().optional(),
+  outputs: z4.record(z4.string(), z4.unknown()).optional(),
+  error: z4.string().optional()
 });
 var CustomEventPayloadSchema = BaseEventPayloadSchema.extend({
-  data: z3.record(z3.string(), z3.unknown()).optional()
+  data: z4.record(z4.string(), z4.unknown()).optional()
 });
-var ThreadEventPayloadSchema = z3.union([
+var ThreadEventPayloadSchema = z4.union([
   MessageEventPayloadSchema,
   ParticipantEventPayloadSchema,
   ContextChangedPayloadSchema,
@@ -464,164 +570,164 @@ var ThreadEventPayloadSchema = z3.union([
   AgentWorkflowEventPayloadSchema,
   CustomEventPayloadSchema
 ]);
-var ThreadEventSchema = z3.object({
-  id: z3.string(),
-  threadId: z3.string(),
+var ThreadEventSchema = z4.object({
+  id: z4.string(),
+  threadId: z4.string(),
   type: EventTypeSchema,
   payload: ThreadEventPayloadSchema,
-  emittedBy: z3.string().optional(),
-  createdAt: z3.string().datetime()
+  emittedBy: z4.string().optional(),
+  createdAt: z4.string().datetime()
 });
-var CreateThreadEventInputSchema = z3.object({
-  threadId: z3.string(),
+var CreateThreadEventInputSchema = z4.object({
+  threadId: z4.string(),
   type: EventTypeSchema,
-  payload: z3.record(z3.string(), z3.unknown()),
-  emittedBy: z3.string().optional()
+  payload: z4.record(z4.string(), z4.unknown()),
+  emittedBy: z4.string().optional()
 });
-var EventSubscriptionSchema = z3.object({
-  subscribes: z3.array(EventTypeSchema),
-  condition: z3.string().optional(),
-  cancels: z3.array(EventTypeSchema).optional(),
-  cancelCondition: z3.string().optional()
+var EventSubscriptionSchema = z4.object({
+  subscribes: z4.array(EventTypeSchema),
+  condition: z4.string().optional(),
+  cancels: z4.array(EventTypeSchema).optional(),
+  cancelCondition: z4.string().optional()
 });
-var EventWaitSchema = z3.object({
+var EventWaitSchema = z4.object({
   event: EventTypeSchema,
-  timeout: z3.string().optional(),
-  onTimeout: z3.string().optional()
+  timeout: z4.string().optional(),
+  onTimeout: z4.string().optional()
 });
-var EventsConfigSchema = z3.object({
-  subscribes: z3.array(EventTypeSchema).optional(),
-  condition: z3.string().optional(),
-  emits: z3.array(EventTypeSchema).optional(),
-  waits: z3.array(EventWaitSchema).optional(),
-  cancels: z3.array(EventTypeSchema).optional(),
-  cancelCondition: z3.string().optional()
+var EventsConfigSchema = z4.object({
+  subscribes: z4.array(EventTypeSchema).optional(),
+  condition: z4.string().optional(),
+  emits: z4.array(EventTypeSchema).optional(),
+  waits: z4.array(EventWaitSchema).optional(),
+  cancels: z4.array(EventTypeSchema).optional(),
+  cancelCondition: z4.string().optional()
 });
 
 // src/skills/types.ts
-import { z as z4 } from "zod/v4";
+import { z as z5 } from "zod/v4";
 var SKILL_SCHEMA_VERSION = "https://skedyul.com/schemas/skill/v1";
 var SKILL_SCHEMA_VERSION_V2 = "https://skedyul.com/schemas/skill/v2";
-var SkillSourceSchema = z4.enum(["BUILTIN", "S3", "APP", "EXTERNAL"]);
-var SkillToolRequirementSchema = z4.object({
-  requires: z4.array(z4.string()).optional(),
-  provides: z4.array(z4.string()).optional()
-});
-var SkillToolSandboxSchema = z4.object({
-  mock: z4.unknown().optional()
-});
-var ToolConstraintsSchema = z4.object({
-  maxCallsPerRun: z4.number().optional(),
-  idempotent: z4.boolean().optional(),
-  restricted: z4.boolean().optional(),
-  tags: z4.array(z4.string()).optional()
-});
-var SkillToolDefinitionSchema = z4.object({
-  tool: z4.string(),
-  description: z4.string().optional(),
-  overrides: z4.record(z4.string(), z4.unknown()).optional(),
+var SkillSourceSchema = z5.enum(["BUILTIN", "S3", "APP", "EXTERNAL"]);
+var SkillToolRequirementSchema = z5.object({
+  requires: z5.array(z5.string()).optional(),
+  provides: z5.array(z5.string()).optional()
+});
+var SkillToolSandboxSchema = z5.object({
+  mock: z5.unknown().optional()
+});
+var ToolConstraintsSchema = z5.object({
+  maxCallsPerRun: z5.number().optional(),
+  idempotent: z5.boolean().optional(),
+  restricted: z5.boolean().optional(),
+  tags: z5.array(z5.string()).optional()
+});
+var SkillToolDefinitionSchema = z5.object({
+  tool: z5.string(),
+  description: z5.string().optional(),
+  overrides: z5.record(z5.string(), z5.unknown()).optional(),
   sandbox: SkillToolSandboxSchema.optional(),
-  requiresApproval: z4.boolean().optional(),
+  requiresApproval: z5.boolean().optional(),
   constraints: ToolConstraintsSchema.optional()
 });
-var SkillToolsSchema = z4.union([
+var SkillToolsSchema = z5.union([
   SkillToolRequirementSchema,
-  z4.array(SkillToolDefinitionSchema)
+  z5.array(SkillToolDefinitionSchema)
 ]);
-var SkillExampleSchema = z4.object({
-  context: z4.string().optional(),
-  input: z4.string(),
-  reasoning: z4.string().optional(),
-  output: z4.string(),
-  tool_call: z4.string().optional()
+var SkillExampleSchema = z5.object({
+  context: z5.string().optional(),
+  input: z5.string(),
+  reasoning: z5.string().optional(),
+  output: z5.string(),
+  tool_call: z5.string().optional()
 });
-var CRMModelFieldRequirementsSchema = z4.object({
-  required: z4.array(z4.string()).optional(),
-  recommended: z4.array(z4.string()).optional()
+var CRMModelFieldRequirementsSchema = z5.object({
+  required: z5.array(z5.string()).optional(),
+  recommended: z5.array(z5.string()).optional()
 });
-var CRMContextSchema = z4.object({
-  models: z4.record(z4.string(), CRMModelFieldRequirementsSchema)
+var CRMContextSchema = z5.object({
+  models: z5.record(z5.string(), CRMModelFieldRequirementsSchema)
 });
-var SkillYAMLSchema = z4.object({
+var SkillYAMLSchema = z5.object({
   // Schema version
-  $schema: z4.string().optional(),
+  $schema: z5.string().optional(),
   // Identity
-  handle: z4.string(),
-  name: z4.string(),
-  version: z4.string().optional(),
-  description: z4.string().optional(),
+  handle: z5.string(),
+  name: z5.string(),
+  version: z5.string().optional(),
+  description: z5.string().optional(),
   // Instructions injected into agent system prompt
-  instructions: z4.string(),
+  instructions: z5.string(),
   // Tool configuration - supports both v1 and v2 formats
   tools: SkillToolsSchema.optional(),
   // CRM context - specifies which models/fields to include in schema
   crmContext: CRMContextSchema.optional(),
   // Few-shot examples
-  examples: z4.array(SkillExampleSchema).optional()
-});
-var SkillYAMLV2Schema = z4.object({
-  $schema: z4.literal(SKILL_SCHEMA_VERSION_V2).optional(),
-  handle: z4.string(),
-  name: z4.string(),
-  version: z4.string().optional(),
-  description: z4.string().optional(),
-  instructions: z4.string(),
-  tools: z4.array(SkillToolDefinitionSchema).optional(),
+  examples: z5.array(SkillExampleSchema).optional()
+});
+var SkillYAMLV2Schema = z5.object({
+  $schema: z5.literal(SKILL_SCHEMA_VERSION_V2).optional(),
+  handle: z5.string(),
+  name: z5.string(),
+  version: z5.string().optional(),
+  description: z5.string().optional(),
+  instructions: z5.string(),
+  tools: z5.array(SkillToolDefinitionSchema).optional(),
   crmContext: CRMContextSchema.optional(),
-  examples: z4.array(SkillExampleSchema).optional()
+  examples: z5.array(SkillExampleSchema).optional()
 });
-var SkillVersionWeightSchema = z4.object({
-  version: z4.number(),
-  weight: z4.number()
+var SkillVersionWeightSchema = z5.object({
+  version: z5.number(),
+  weight: z5.number()
 });
-var SkillRefSchema = z4.union([
-  z4.string(),
+var SkillRefSchema = z5.union([
+  z5.string(),
   // Just handle - uses latest published version
-  z4.object({
-    skill: z4.string(),
-    description: z4.string().optional(),
+  z5.object({
+    skill: z5.string(),
+    description: z5.string().optional(),
     // For AI SDK Agent Skills discovery
     /** Auto-inject this skill's instructions and tools on every agent turn */
-    alwaysLoad: z4.boolean().optional(),
+    alwaysLoad: z5.boolean().optional(),
     // Version selection (pick one):
-    version: z4.number().optional(),
+    version: z5.number().optional(),
     // Pin to specific version number
-    versions: z4.array(SkillVersionWeightSchema).optional(),
+    versions: z5.array(SkillVersionWeightSchema).optional(),
     // A/B testing weights
     // Legacy support:
-    instructions: z4.string().optional(),
+    instructions: z5.string().optional(),
     // Inline instructions (deprecated)
-    enabled: z4.boolean().optional()
+    enabled: z5.boolean().optional()
   })
 ]);
-var SkillMetadataSchema = z4.object({
-  id: z4.string(),
-  handle: z4.string(),
-  name: z4.string(),
-  version: z4.string().optional(),
-  description: z4.string().optional(),
+var SkillMetadataSchema = z5.object({
+  id: z5.string(),
+  handle: z5.string(),
+  name: z5.string(),
+  version: z5.string().optional(),
+  description: z5.string().optional(),
   source: SkillSourceSchema,
-  s3Key: z4.string().optional(),
-  appVersionId: z4.string().optional(),
-  workplaceId: z4.string().optional(),
-  createdAt: z4.string().datetime().optional(),
-  updatedAt: z4.string().datetime().optional()
-});
-var ResolvedSkillSchema = z4.object({
-  handle: z4.string(),
-  name: z4.string(),
-  instructions: z4.string().optional(),
-  description: z4.string().optional(),
-  tools: z4.array(z4.string()).optional(),
-  examples: z4.array(SkillExampleSchema).optional()
-});
-var LoadedSkillSchema = z4.object({
-  handle: z4.string(),
-  name: z4.string(),
-  instructions: z4.string().optional(),
-  description: z4.string().optional(),
-  tools: z4.array(SkillToolDefinitionSchema).optional(),
-  examples: z4.array(SkillExampleSchema).optional()
+  s3Key: z5.string().optional(),
+  appVersionId: z5.string().optional(),
+  workplaceId: z5.string().optional(),
+  createdAt: z5.string().datetime().optional(),
+  updatedAt: z5.string().datetime().optional()
+});
+var ResolvedSkillSchema = z5.object({
+  handle: z5.string(),
+  name: z5.string(),
+  instructions: z5.string().optional(),
+  description: z5.string().optional(),
+  tools: z5.array(z5.string()).optional(),
+  examples: z5.array(SkillExampleSchema).optional()
+});
+var LoadedSkillSchema = z5.object({
+  handle: z5.string(),
+  name: z5.string(),
+  instructions: z5.string().optional(),
+  description: z5.string().optional(),
+  tools: z5.array(SkillToolDefinitionSchema).optional(),
+  examples: z5.array(SkillExampleSchema).optional()
 });
 function isV2SkillTools(tools) {
   if (!tools) return false;
@@ -677,182 +783,182 @@ ${sections.join("\n\n---\n\n")}`;
 }
 
 // src/context/types.ts
-import { z as z5 } from "zod/v4";
-var CRMContextSchema2 = z5.object({
-  model: z5.string(),
-  instanceId: z5.string(),
-  data: z5.record(z5.string(), z5.unknown())
+import { z as z6 } from "zod/v4";
+var CRMContextSchema2 = z6.object({
+  model: z6.string(),
+  instanceId: z6.string(),
+  data: z6.record(z6.string(), z6.unknown())
 });
-var SenderContextSchema = z5.object({
+var SenderContextSchema = z6.object({
   kind: ParticipantKindSchema,
-  displayName: z5.string().optional(),
-  email: z5.string().optional(),
-  role: z5.string().optional(),
-  permissions: z5.array(z5.string()).optional(),
+  displayName: z6.string().optional(),
+  email: z6.string().optional(),
+  role: z6.string().optional(),
+  permissions: z6.array(z6.string()).optional(),
   crm: CRMContextSchema2.optional()
 });
-var ThreadContextItemSchema = z5.object({
-  handle: z5.string(),
-  model: z5.string(),
-  instanceId: z5.string(),
-  data: z5.record(z5.string(), z5.unknown()).optional()
-});
-var ThreadInfoSchema = z5.object({
-  id: z5.string(),
-  title: z5.string().optional(),
-  status: z5.string().optional(),
-  kind: z5.string().optional()
-});
-var SubscriptionSchema = z5.object({
-  identifierValue: z5.string(),
-  channelHandle: z5.string().optional()
-});
-var AssociationSchema = z5.object({
-  id: z5.string().optional(),
-  data: z5.record(z5.string(), z5.unknown())
-});
-var ContactSchema = z5.object({
-  id: z5.string().optional(),
-  name: z5.string().optional(),
+var ThreadContextItemSchema = z6.object({
+  handle: z6.string(),
+  model: z6.string(),
+  instanceId: z6.string(),
+  data: z6.record(z6.string(), z6.unknown()).optional()
+});
+var ThreadInfoSchema = z6.object({
+  id: z6.string(),
+  title: z6.string().optional(),
+  status: z6.string().optional(),
+  kind: z6.string().optional()
+});
+var SubscriptionSchema = z6.object({
+  identifierValue: z6.string(),
+  channelHandle: z6.string().optional()
+});
+var AssociationSchema = z6.object({
+  id: z6.string().optional(),
+  data: z6.record(z6.string(), z6.unknown())
+});
+var ContactSchema = z6.object({
+  id: z6.string().optional(),
+  name: z6.string().optional(),
   subscription: SubscriptionSchema.optional(),
-  associations: z5.record(z5.string(), AssociationSchema).optional()
+  associations: z6.record(z6.string(), AssociationSchema).optional()
 });
-var AgentSenderContextSchema = z5.object({
-  kind: z5.enum(["contact", "member"]),
-  displayName: z5.string().optional(),
-  role: z5.string().optional(),
-  permissions: z5.array(z5.string()).optional(),
+var AgentSenderContextSchema = z6.object({
+  kind: z6.enum(["contact", "member"]),
+  displayName: z6.string().optional(),
+  role: z6.string().optional(),
+  permissions: z6.array(z6.string()).optional(),
   contact: ContactSchema.optional()
 });
-var AgentThreadContextSchema = z5.object({
-  handle: z5.string(),
-  model: z5.string(),
-  data: z5.record(z5.string(), z5.unknown())
+var AgentThreadContextSchema = z6.object({
+  handle: z6.string(),
+  model: z6.string(),
+  data: z6.record(z6.string(), z6.unknown())
 });
-var AgentContextSchema = z5.object({
+var AgentContextSchema = z6.object({
   sender: AgentSenderContextSchema,
-  contexts: z5.array(AgentThreadContextSchema).optional()
+  contexts: z6.array(AgentThreadContextSchema).optional()
 });
-var ContextIssueSeveritySchema = z5.enum(["ERROR", "WARNING"]);
-var ContextIssueTypeSchema = z5.enum([
+var ContextIssueSeveritySchema = z6.enum(["ERROR", "WARNING"]);
+var ContextIssueTypeSchema = z6.enum([
   "MISSING_ROUTING_PARTICIPANT",
   "MISSING_ASSOCIATION",
   "MISSING_REQUIRED_FIELD",
   "MISSING_RECOMMENDED_FIELD"
 ]);
-var ContextIssueSchema = z5.object({
+var ContextIssueSchema = z6.object({
   type: ContextIssueTypeSchema,
   severity: ContextIssueSeveritySchema,
-  model: z5.string().optional(),
-  field: z5.string().optional(),
-  message: z5.string(),
-  suggestion: z5.string().optional()
+  model: z6.string().optional(),
+  field: z6.string().optional(),
+  message: z6.string(),
+  suggestion: z6.string().optional()
 });
-var ContextValidationResultSchema = z5.object({
-  valid: z5.boolean(),
-  degraded: z5.boolean(),
-  issues: z5.array(ContextIssueSchema)
+var ContextValidationResultSchema = z6.object({
+  valid: z6.boolean(),
+  degraded: z6.boolean(),
+  issues: z6.array(ContextIssueSchema)
 });
 var MockSenderContextSchema = AgentSenderContextSchema;
 var MockThreadContextSchema = AgentThreadContextSchema;
 var MockContextSchema = AgentContextSchema;
-var SandboxConfigSchema = z5.object({
-  enabled: z5.boolean().optional(),
+var SandboxConfigSchema = z6.object({
+  enabled: z6.boolean().optional(),
   /** @deprecated Use 'context' instead of 'mockContext' */
   mockContext: AgentContextSchema.optional(),
   context: AgentContextSchema.optional()
 });
 
 // src/schemas/agent-schema-v3.ts
-var PersonaVoiceFormatV3Schema = z6.object({
-  maxChars: z6.number().optional(),
-  noEmojis: z6.boolean().optional(),
-  noHyphens: z6.boolean().optional(),
-  noBulletPoints: z6.boolean().optional(),
-  maxQuestionsPerMessage: z6.number().optional(),
-  noSignOffs: z6.boolean().optional()
-});
-var PersonaVoiceV3Schema = z6.object({
-  style: z6.string(),
+var PersonaVoiceFormatV3Schema = z7.object({
+  maxChars: z7.number().optional(),
+  noEmojis: z7.boolean().optional(),
+  noHyphens: z7.boolean().optional(),
+  noBulletPoints: z7.boolean().optional(),
+  maxQuestionsPerMessage: z7.number().optional(),
+  noSignOffs: z7.boolean().optional()
+});
+var PersonaVoiceV3Schema = z7.object({
+  style: z7.string(),
   format: PersonaVoiceFormatV3Schema.optional()
 });
-var PersonaV3Schema = z6.object({
-  name: z6.string(),
+var PersonaV3Schema = z7.object({
+  name: z7.string(),
   voice: PersonaVoiceV3Schema
 });
-var ToolApprovalConfigSchema = z6.object({
-  required: z6.boolean().optional(),
-  requiredIf: z6.array(z6.string()).optional()
+var ToolApprovalConfigSchema = z7.object({
+  required: z7.boolean().optional(),
+  requiredIf: z7.array(z7.string()).optional()
 });
-var ToolSandboxConfigSchema = z6.object({
-  mock: z6.unknown().optional()
+var ToolSandboxConfigSchema = z7.object({
+  mock: z7.unknown().optional()
 });
-var ToolRefV3Schema = z6.union([
-  z6.string(),
-  z6.object({
-    tool: z6.string(),
-    description: z6.string().optional(),
+var ToolRefV3Schema = z7.union([
+  z7.string(),
+  z7.object({
+    tool: z7.string(),
+    description: z7.string().optional(),
     approval: ToolApprovalConfigSchema.optional(),
     sandbox: ToolSandboxConfigSchema.optional(),
-    overrides: z6.record(z6.string(), z6.unknown()).optional()
+    overrides: z7.record(z7.string(), z7.unknown()).optional()
   })
 ]);
-var AgentToolRefSchema = z6.union([
-  z6.string(),
-  z6.object({
-    tool: z6.string(),
-    description: z6.string().optional()
+var AgentToolRefSchema = z7.union([
+  z7.string(),
+  z7.object({
+    tool: z7.string(),
+    description: z7.string().optional()
   })
 ]);
-var WorkingMemoryConfigSchema = z6.object({
-  strategy: z6.enum(["full", "rolling_summary", "sliding_window"]).optional(),
-  maxTokens: z6.number().optional(),
-  summarizeAt: z6.number().optional()
+var WorkingMemoryConfigSchema = z7.object({
+  strategy: z7.enum(["full", "rolling_summary", "sliding_window"]).optional(),
+  maxTokens: z7.number().optional(),
+  summarizeAt: z7.number().optional()
 });
-var ExternalMemoryConfigSchema = z6.object({
-  enabled: z6.boolean().optional(),
-  ttl: z6.string().optional()
+var ExternalMemoryConfigSchema = z7.object({
+  enabled: z7.boolean().optional(),
+  ttl: z7.string().optional()
 });
-var SemanticMemoryConfigSchema = z6.object({
-  enabled: z6.boolean().optional(),
-  topK: z6.number().optional(),
-  scope: z6.enum(["thread", "instance", "workspace"]).optional()
+var SemanticMemoryConfigSchema = z7.object({
+  enabled: z7.boolean().optional(),
+  topK: z7.number().optional(),
+  scope: z7.enum(["thread", "instance", "workspace"]).optional()
 });
-var MemoryConfigV3Schema = z6.object({
+var MemoryConfigV3Schema = z7.object({
   working: WorkingMemoryConfigSchema.optional(),
-  persistent: z6.object({
-    namespace: z6.string().optional()
+  persistent: z7.object({
+    namespace: z7.string().optional()
   }).optional(),
   external: ExternalMemoryConfigSchema.optional(),
   semantic: SemanticMemoryConfigSchema.optional()
 });
-var RequiresApprovalPolicySchema = z6.object({
-  requiresApproval: z6.boolean().optional()
+var RequiresApprovalPolicySchema = z7.object({
+  requiresApproval: z7.boolean().optional()
 });
-var PoliciesConfigV3Schema = z6.object({
-  messages: z6.object({
+var PoliciesConfigV3Schema = z7.object({
+  messages: z7.object({
     send: RequiresApprovalPolicySchema.optional(),
     schedule: RequiresApprovalPolicySchema.optional()
   }).optional(),
-  tools: z6.object({
-    externalRequiresApproval: z6.boolean().optional(),
-    systemRequiresApproval: z6.boolean().optional()
+  tools: z7.object({
+    externalRequiresApproval: z7.boolean().optional(),
+    systemRequiresApproval: z7.boolean().optional()
   }).optional()
 });
-var RuntimeConfigV3Schema = z6.object({
+var RuntimeConfigV3Schema = z7.object({
   /** LLM model identifier for reasoning (e.g., "google/gemini-3.1-flash-lite") */
-  model: z6.string().optional(),
+  model: z7.string().optional(),
   /** LLM model for persona transformation (e.g., "openai/gpt-5-nano") */
-  personaModel: z6.string().optional()
+  personaModel: z7.string().optional()
 });
-var TimeWindowTimeStampSchema = z6.union([
-  z6.number().describe("Hour of day (0-23)"),
-  z6.object({
-    hour: z6.number(),
-    minute: z6.number().optional().default(0)
+var TimeWindowTimeStampSchema = z7.union([
+  z7.number().describe("Hour of day (0-23)"),
+  z7.object({
+    hour: z7.number(),
+    minute: z7.number().optional().default(0)
   })
 ]);
-var TimeWindowDayOfWeekSchema = z6.enum([
+var TimeWindowDayOfWeekSchema = z7.enum([
   "monday",
   "tuesday",
   "wednesday",
@@ -861,47 +967,47 @@ var TimeWindowDayOfWeekSchema = z6.enum([
   "saturday",
   "sunday"
 ]);
-var TimeWindowSlotAgentSchema = z6.object({
+var TimeWindowSlotAgentSchema = z7.object({
   startTime: TimeWindowTimeStampSchema,
   endTime: TimeWindowTimeStampSchema,
-  days: z6.array(TimeWindowDayOfWeekSchema)
+  days: z7.array(TimeWindowDayOfWeekSchema)
 });
-var ResponseModeSchema = z6.enum([
+var ResponseModeSchema = z7.enum([
   "immediate",
   "ack_and_schedule",
   "schedule_only"
 ]);
-var TimeWindowBehaviorSchema = z6.object({
+var TimeWindowBehaviorSchema = z7.object({
   /** How to handle responses in this window */
   responseMode: ResponseModeSchema,
   /** Prompt injection for this time context */
-  prompt: z6.string().optional().describe("Prompt injection for this time context"),
+  prompt: z7.string().optional().describe("Prompt injection for this time context"),
   /** Window to schedule responses for (when responseMode is ack_and_schedule or schedule_only) */
-  scheduleFor: z6.string().optional().describe("Window name to schedule responses for")
+  scheduleFor: z7.string().optional().describe("Window name to schedule responses for")
 });
-var TimeWindowPolicySchema = z6.object({
+var TimeWindowPolicySchema = z7.object({
   /** IANA timezone for the window (e.g., "Australia/Sydney") */
-  timezone: z6.string().describe('IANA timezone, e.g., "Australia/Sydney"'),
+  timezone: z7.string().describe('IANA timezone, e.g., "Australia/Sydney"'),
   /** Time slots when this window is active */
-  windows: z6.array(TimeWindowSlotAgentSchema),
+  windows: z7.array(TimeWindowSlotAgentSchema),
   /** Behavior for this window (optional - defaults to immediate response) */
   behavior: TimeWindowBehaviorSchema.optional()
 });
-var TimeWindowPoliciesSchema = z6.record(z6.string(), TimeWindowPolicySchema);
+var TimeWindowPoliciesSchema = z7.record(z7.string(), TimeWindowPolicySchema);
 var TimeWindowDefaultSchema = TimeWindowBehaviorSchema.describe(
   "Fallback behavior when no time window matches"
 );
-var ResponsesBehaviorConfigSchema = z6.object({
+var ResponsesBehaviorConfigSchema = z7.object({
   /**
    * Maximum immediate messages per agent run (acks, progress updates).
    * @default 1
    */
-  maxImmediate: z6.number().optional(),
+  maxImmediate: z7.number().optional(),
   /**
    * Maximum scheduled messages per agent run (follow-ups via sendAt).
    * @default 2
    */
-  maxScheduled: z6.number().optional(),
+  maxScheduled: z7.number().optional(),
   /**
    * Maximum intermediate messages per agent run.
    * Intermediate = progress updates, acknowledgments before task completion.
@@ -909,74 +1015,74 @@ var ResponsesBehaviorConfigSchema = z6.object({
    * @deprecated Use maxImmediate instead
    * @default 2
    */
-  maxIntermediate: z6.number().optional(),
+  maxIntermediate: z7.number().optional(),
   /**
    * Whether a final message is required before the run completes.
    * If true and no final message is sent, the run fails.
    * @default true
    */
-  requireFinal: z6.boolean().optional(),
+  requireFinal: z7.boolean().optional(),
   /**
    * Whether the agent can schedule messages for future delivery.
    * Scheduled messages typically require approval.
    * @default false
    */
-  allowSchedule: z6.boolean().optional(),
+  allowSchedule: z7.boolean().optional(),
   /**
    * Message splitting configuration.
    * Controls whether and how the agent splits responses into multiple messages.
    */
-  messageSplitting: z6.object({
+  messageSplitting: z7.object({
     /**
      * Whether to allow natural message splitting.
      * When true, the agent may split responses into multiple messages
      * when it improves conversational flow.
      */
-    enabled: z6.boolean(),
+    enabled: z7.boolean(),
     /**
      * Custom prompt to override the default message splitting guidance.
      * If not provided, uses sensible defaults for when to split vs. keep together.
      */
-    prompt: z6.string().optional()
+    prompt: z7.string().optional()
   }).optional()
 });
-var SchedulingDelaySchema = z6.object({
+var SchedulingDelaySchema = z7.object({
   /** Time unit amount */
-  amount: z6.number(),
+  amount: z7.number(),
   /** Time unit (e.g., "week", "weeks", "day", "days", "month", "months") */
-  unit: z6.string(),
+  unit: z7.string(),
   /** Optional time window to constrain the delay */
-  timeWindow: z6.string().optional()
+  timeWindow: z7.string().optional()
 });
-var SchedulingPatternSchema = z6.object({
+var SchedulingPatternSchema = z7.object({
   /** Trigger name for this pattern */
-  trigger: z6.string(),
+  trigger: z7.string(),
   /** Human-readable description of when this pattern applies */
-  description: z6.string().optional(),
+  description: z7.string().optional(),
   /** Example user phrases that match this pattern */
-  examples: z6.array(z6.string()).optional(),
+  examples: z7.array(z7.string()).optional(),
   /** Default delay for this pattern */
   defaultDelay: SchedulingDelaySchema.optional()
 });
-var SchedulingBehaviorConfigSchema = z6.object({
+var SchedulingBehaviorConfigSchema = z7.object({
   /**
    * Patterns that trigger scheduling suggestions.
    * The agent uses these to know when to add sendAt to messages.
    */
-  patterns: z6.array(SchedulingPatternSchema).optional(),
+  patterns: z7.array(SchedulingPatternSchema).optional(),
   /**
    * Default settings for scheduled messages.
    */
-  defaults: z6.object({
+  defaults: z7.object({
     /** Cancel scheduled message if user replies before send time (default: true) */
-    cancelOnActivity: z6.boolean().optional(),
+    cancelOnActivity: z7.boolean().optional(),
     /** Whether scheduled messages require approval (default: true) */
-    requiresApproval: z6.boolean().optional(),
+    requiresApproval: z7.boolean().optional(),
     /** Default time window policy to constrain all scheduled messages */
-    timeWindow: z6.string().optional().describe("Time window policy name for scheduled messages")
+    timeWindow: z7.string().optional().describe("Time window policy name for scheduled messages")
   }).optional()
 });
-var BehaviorConfigV3Schema = z6.object({
+var BehaviorConfigV3Schema = z7.object({
   /**
    * Response behavior - controls message sending via tool calls.
    * When configured, agents must explicitly call system:message:send
@@ -989,32 +1095,32 @@ var BehaviorConfigV3Schema = z6.object({
    */
   scheduling: SchedulingBehaviorConfigSchema.optional()
 });
-var PromptsConfigV3Schema = z6.object({
+var PromptsConfigV3Schema = z7.object({
   /** Main system prompt with workflow instructions */
-  system: z6.string().optional(),
+  system: z7.string().optional(),
   /** Injected during second pass when skills were loaded but tools not used */
-  recovery: z6.string().optional(),
+  recovery: z7.string().optional(),
   /** Injected during follow-up passes when context needs updating */
-  followUp: z6.string().optional(),
+  followUp: z7.string().optional(),
   /** Thread list title generation (system + user template with {{var}} placeholders) */
-  titleEnrichment: z6.object({
-    system: z6.string().optional(),
-    user: z6.string().optional()
+  titleEnrichment: z7.object({
+    system: z7.string().optional(),
+    user: z7.string().optional()
   }).optional()
 });
-var AgentYAMLV3Schema = z6.object({
-  $schema: z6.string().optional(),
-  handle: z6.string(),
-  name: z6.string(),
-  version: z6.string().optional(),
-  description: z6.string().optional(),
+var AgentYAMLV3Schema = z7.object({
+  $schema: z7.string().optional(),
+  handle: z7.string(),
+  name: z7.string(),
+  version: z7.string().optional(),
+  description: z7.string().optional(),
   // Persona - Who the agent is
   persona: PersonaV3Schema.optional(),
   // Skills - What the agent knows how to do (skills own their tools)
-  skills: z6.array(SkillRefSchema).optional(),
+  skills: z7.array(SkillRefSchema).optional(),
   // Tools - Always-available tools before any skill loads
   // Examples: system:settings:business_information:get
-  tools: z6.array(AgentToolRefSchema).optional(),
+  tools: z7.array(AgentToolRefSchema).optional(),
   /**
    * Events - When the agent activates
    * @deprecated Not yet implemented - this is a planned feature for event-driven agents.
@@ -1047,21 +1153,21 @@ var AgentYAMLV3Schema = z6.object({
 });
 
 // src/schemas.ts
-var EnvVisibilitySchema = z7.enum(["visible", "encrypted"]);
-var EnvVariableDefinitionSchema = z7.object({
-  label: z7.string(),
-  required: z7.boolean().optional(),
+var EnvVisibilitySchema = z8.enum(["visible", "encrypted"]);
+var EnvVariableDefinitionSchema = z8.object({
+  label: z8.string(),
+  required: z8.boolean().optional(),
   visibility: EnvVisibilitySchema.optional(),
-  default: z7.string().optional(),
-  description: z7.string().optional(),
-  placeholder: z7.string().optional()
-});
-var EnvSchemaSchema = z7.record(z7.string(), EnvVariableDefinitionSchema);
-var ComputeLayerTypeSchema = z7.enum(["serverless", "dedicated"]);
-var FieldOwnerSchema = z7.enum(["APP", "SHARED"]);
-var PrimitiveSchema = z7.union([z7.string(), z7.number(), z7.boolean()]);
-var PrimitiveOrArraySchema = z7.union([PrimitiveSchema, z7.array(PrimitiveSchema)]);
-var FilterOperatorSchema = z7.enum([
+  default: z8.string().optional(),
+  description: z8.string().optional(),
+  placeholder: z8.string().optional()
+});
+var EnvSchemaSchema = z8.record(z8.string(), EnvVariableDefinitionSchema);
+var ComputeLayerTypeSchema = z8.enum(["serverless", "dedicated"]);
+var FieldOwnerSchema = z8.enum(["APP", "SHARED"]);
+var PrimitiveSchema = z8.union([z8.string(), z8.number(), z8.boolean()]);
+var PrimitiveOrArraySchema = z8.union([PrimitiveSchema, z8.array(PrimitiveSchema)]);
+var FilterOperatorSchema = z8.enum([
   "eq",
   "neq",
   "gt",
@@ -1079,7 +1185,7 @@ var FilterOperatorSchema = z7.enum([
   "isEmpty",
   "isNotEmpty"
 ]);
-var FilterConditionSchema = z7.object({
+var FilterConditionSchema = z8.object({
   eq: PrimitiveOrArraySchema,
   neq: PrimitiveOrArraySchema,
   gt: PrimitiveOrArraySchema,
@@ -1097,27 +1203,27 @@ var FilterConditionSchema = z7.object({
   isEmpty: PrimitiveOrArraySchema,
   isNotEmpty: PrimitiveOrArraySchema
 }).partial();
-var StructuredFilterSchema = z7.record(
-  z7.string(),
+var StructuredFilterSchema = z8.record(
+  z8.string(),
   FilterConditionSchema
 );
-var ModelDependencySchema = z7.object({
-  model: z7.string(),
-  fields: z7.array(z7.string()).optional(),
+var ModelDependencySchema = z8.object({
+  model: z8.string(),
+  fields: z8.array(z8.string()).optional(),
   where: StructuredFilterSchema.optional()
 });
-var ChannelDependencySchema = z7.object({
-  channel: z7.string()
+var ChannelDependencySchema = z8.object({
+  channel: z8.string()
 });
-var WorkflowDependencySchema = z7.object({
-  workflow: z7.string()
+var WorkflowDependencySchema = z8.object({
+  workflow: z8.string()
 });
-var ResourceDependencySchema = z7.union([
+var ResourceDependencySchema = z8.union([
   ModelDependencySchema,
   ChannelDependencySchema,
   WorkflowDependencySchema
 ]);
-var FieldDataTypeSchema = z7.enum([
+var FieldDataTypeSchema = z8.enum([
   "LONG_STRING",
   "STRING",
   "NUMBER",
@@ -1130,74 +1236,74 @@ var FieldDataTypeSchema = z7.enum([
   "RELATION",
   "OBJECT"
 ]);
-var FieldOptionSchema = z7.object({
-  label: z7.string(),
-  value: z7.string(),
-  color: z7.string().optional()
-});
-var InlineFieldDefinitionSchema = z7.object({
-  limitChoices: z7.number().optional(),
-  options: z7.array(FieldOptionSchema).optional(),
-  minLength: z7.number().optional(),
-  maxLength: z7.number().optional(),
-  min: z7.number().optional(),
-  max: z7.number().optional(),
-  relatedModel: z7.string().optional(),
-  pattern: z7.string().optional()
-});
-var AppFieldVisibilitySchema = z7.object({
-  data: z7.boolean().optional(),
-  list: z7.boolean().optional(),
-  filters: z7.boolean().optional()
-});
-var FieldRequirementTypeSchema = z7.enum(["optional", "on_create", "required"]);
-var ModelFieldDefinitionSchema = z7.object({
-  handle: z7.string(),
-  label: z7.string(),
+var FieldOptionSchema = z8.object({
+  label: z8.string(),
+  value: z8.string(),
+  color: z8.string().optional()
+});
+var InlineFieldDefinitionSchema = z8.object({
+  limitChoices: z8.number().optional(),
+  options: z8.array(FieldOptionSchema).optional(),
+  minLength: z8.number().optional(),
+  maxLength: z8.number().optional(),
+  min: z8.number().optional(),
+  max: z8.number().optional(),
+  relatedModel: z8.string().optional(),
+  pattern: z8.string().optional()
+});
+var AppFieldVisibilitySchema = z8.object({
+  data: z8.boolean().optional(),
+  list: z8.boolean().optional(),
+  filters: z8.boolean().optional()
+});
+var FieldRequirementTypeSchema = z8.enum(["optional", "on_create", "required"]);
+var ModelFieldDefinitionSchema = z8.object({
+  handle: z8.string(),
+  label: z8.string(),
   type: FieldDataTypeSchema.optional(),
-  definition: z7.union([InlineFieldDefinitionSchema, z7.string()]).optional(),
+  definition: z8.union([InlineFieldDefinitionSchema, z8.string()]).optional(),
   /** Field requirement type: 'optional', 'on_create', or 'required' */
   requirement: FieldRequirementTypeSchema.optional(),
   /** @deprecated Use `requirement` instead */
-  required: z7.boolean().optional(),
-  unique: z7.boolean().optional(),
-  system: z7.boolean().optional(),
-  isList: z7.boolean().optional(),
-  defaultValue: z7.object({ value: z7.unknown() }).optional(),
-  description: z7.string().optional(),
+  required: z8.boolean().optional(),
+  unique: z8.boolean().optional(),
+  system: z8.boolean().optional(),
+  isList: z8.boolean().optional(),
+  defaultValue: z8.object({ value: z8.unknown() }).optional(),
+  description: z8.string().optional(),
   visibility: AppFieldVisibilitySchema.optional(),
   owner: FieldOwnerSchema.optional()
 });
-var ModelDefinitionSchema = z7.object({
-  handle: z7.string(),
-  name: z7.string(),
-  namePlural: z7.string().optional(),
-  labelTemplate: z7.string().optional(),
-  description: z7.string().optional(),
-  fields: z7.array(ModelFieldDefinitionSchema),
-  requires: z7.array(ResourceDependencySchema).optional(),
-  addDefaultPages: z7.boolean().optional(),
-  addNavigation: z7.boolean().optional(),
+var ModelDefinitionSchema = z8.object({
+  handle: z8.string(),
+  name: z8.string(),
+  namePlural: z8.string().optional(),
+  labelTemplate: z8.string().optional(),
+  description: z8.string().optional(),
+  fields: z8.array(ModelFieldDefinitionSchema),
+  requires: z8.array(ResourceDependencySchema).optional(),
+  addDefaultPages: z8.boolean().optional(),
+  addNavigation: z8.boolean().optional(),
   /** Root path for developer resource UI (e.g., '/access_requests'). Links internal model to a provision.pages entry. */
-  page: z7.string().optional()
+  page: z8.string().optional()
 });
-var RelationshipCardinalitySchema = z7.enum([
+var RelationshipCardinalitySchema = z8.enum([
   "ONE_TO_ONE",
   "ONE_TO_MANY"
 ]);
-var OnDeleteBehaviorSchema = z7.enum(["NONE", "CASCADE", "RESTRICT"]);
-var RelationshipLinkSchema = z7.object({
-  model: z7.string(),
-  field: z7.string(),
-  label: z7.string()
+var OnDeleteBehaviorSchema = z8.enum(["NONE", "CASCADE", "RESTRICT"]);
+var RelationshipLinkSchema = z8.object({
+  model: z8.string(),
+  field: z8.string(),
+  label: z8.string()
 });
-var RelationshipDefinitionSchema = z7.object({
+var RelationshipDefinitionSchema = z8.object({
   source: RelationshipLinkSchema,
   target: RelationshipLinkSchema,
   cardinality: RelationshipCardinalitySchema,
   onDelete: OnDeleteBehaviorSchema.default("NONE")
 });
-var ChannelCapabilityTypeSchema = z7.enum([
+var ChannelCapabilityTypeSchema = z8.enum([
   "messaging",
   // Text-based: SMS, WhatsApp, Messenger, DMs
   "voice",
@@ -1205,323 +1311,329 @@ var ChannelCapabilityTypeSchema = z7.enum([
   "video"
   // Video calls (future)
 ]);
-var ChannelCapabilitySchema = z7.object({
-  label: z7.string(),
+var ChannelBatchCapabilitySchema = z8.object({
+  send: z8.string(),
+  get_status: z8.string()
+});
+var ChannelCapabilitySchema = z8.object({
+  label: z8.string(),
   // Display name: "SMS", "WhatsApp Messages"
-  icon: z7.string().optional(),
+  icon: z8.string().optional(),
   // Lucide icon name
-  receive: z7.string().optional(),
+  receive: z8.string().optional(),
   // Inbound webhook handler
-  send: z7.string().optional()
+  send: z8.string().optional(),
   // Outbound tool handle
+  send_batch: z8.union([z8.string(), ChannelBatchCapabilitySchema]).optional()
+  // Batch outbound tool handle, or { send, get_status }
 });
-var ChannelFieldDefinitionSchema = z7.object({
-  handle: z7.string(),
-  label: z7.string(),
+var ChannelFieldDefinitionSchema = z8.object({
+  handle: z8.string(),
+  label: z8.string(),
   /** Field definition reference or inline definition */
-  definition: z7.union([InlineFieldDefinitionSchema, z7.string()]).optional(),
+  definition: z8.union([InlineFieldDefinitionSchema, z8.string()]).optional(),
   /** Marks this field as the identifier field for the channel */
-  identifier: z7.boolean().optional(),
+  identifier: z8.boolean().optional(),
   /** Whether this field is required */
-  required: z7.boolean().optional(),
+  required: z8.boolean().optional(),
   /** Default value when creating a new field */
-  defaultValue: z7.object({ value: z7.unknown() }).passthrough().optional(),
+  defaultValue: z8.object({ value: z8.unknown() }).passthrough().optional(),
   /** Visibility settings for the field */
-  visibility: z7.object({
-    data: z7.boolean().optional(),
-    list: z7.boolean().optional(),
-    filters: z7.boolean().optional()
+  visibility: z8.object({
+    data: z8.boolean().optional(),
+    list: z8.boolean().optional(),
+    filters: z8.boolean().optional()
   }).passthrough().optional(),
   /** Permission settings for the field */
-  permissions: z7.object({
-    read: z7.boolean().optional(),
-    write: z7.boolean().optional()
+  permissions: z8.object({
+    read: z8.boolean().optional(),
+    write: z8.boolean().optional()
   }).passthrough().optional()
 }).passthrough();
-var ChannelDefinitionSchema = z7.object({
-  handle: z7.string(),
-  label: z7.string(),
-  icon: z7.string().optional(),
+var ChannelDefinitionSchema = z8.object({
+  handle: z8.string(),
+  label: z8.string(),
+  icon: z8.string().optional(),
   /** Array of field definitions for this channel. One field must have identifier: true. */
-  fields: z7.array(ChannelFieldDefinitionSchema),
+  fields: z8.array(ChannelFieldDefinitionSchema),
   // Capabilities keyed by standard type (messaging, voice, video) - all optional
-  capabilities: z7.object({
+  capabilities: z8.object({
     messaging: ChannelCapabilitySchema.optional(),
     voice: ChannelCapabilitySchema.optional(),
     video: ChannelCapabilitySchema.optional()
   })
 });
-var WorkflowActionInputSchema = z7.object({
-  key: z7.string(),
-  label: z7.string(),
-  fieldRef: z7.object({
-    fieldHandle: z7.string(),
-    entityHandle: z7.string()
+var WorkflowActionInputSchema = z8.object({
+  key: z8.string(),
+  label: z8.string(),
+  fieldRef: z8.object({
+    fieldHandle: z8.string(),
+    entityHandle: z8.string()
   }).optional(),
-  template: z7.string().optional()
-});
-var WorkflowActionSchema = z7.object({
-  label: z7.string(),
-  handle: z7.string(),
-  batch: z7.boolean().optional(),
-  entityHandle: z7.string().optional(),
-  inputs: z7.array(WorkflowActionInputSchema).optional()
-});
-var WorkflowDefinitionSchema = z7.object({
-  path: z7.string(),
-  label: z7.string().optional(),
-  handle: z7.string().optional(),
-  requires: z7.array(ResourceDependencySchema).optional(),
-  actions: z7.array(WorkflowActionSchema)
-});
-var PageTypeSchema = z7.enum(["INSTANCE", "LIST"]);
-var PageBlockTypeSchema = z7.enum(["form", "spreadsheet", "kanban", "calendar", "link", "list", "card"]);
-var PageFieldTypeSchema = z7.enum(["STRING", "FILE", "NUMBER", "DATE", "BOOLEAN", "SELECT", "FORM", "RELATIONSHIP"]);
-var PageFieldSourceSchema = z7.object({
-  model: z7.string(),
-  field: z7.string()
-});
-var PageFormHeaderSchema = z7.object({
-  title: z7.string(),
-  description: z7.string().optional()
-});
-var PageActionDefinitionSchema = z7.object({
-  handle: z7.string(),
-  label: z7.string(),
-  handler: z7.string().optional(),
-  href: z7.string().optional(),
-  icon: z7.string().optional(),
-  variant: z7.enum(["primary", "secondary", "destructive", "outline"]).optional(),
-  isDisabled: z7.union([z7.boolean(), z7.string()]).optional(),
-  isHidden: z7.union([z7.boolean(), z7.string()]).optional()
+  template: z8.string().optional()
+});
+var WorkflowActionSchema = z8.object({
+  label: z8.string(),
+  handle: z8.string(),
+  batch: z8.boolean().optional(),
+  entityHandle: z8.string().optional(),
+  inputs: z8.array(WorkflowActionInputSchema).optional()
+});
+var WorkflowDefinitionSchema = z8.object({
+  path: z8.string(),
+  label: z8.string().optional(),
+  handle: z8.string().optional(),
+  requires: z8.array(ResourceDependencySchema).optional(),
+  actions: z8.array(WorkflowActionSchema)
+});
+var PageTypeSchema = z8.enum(["INSTANCE", "LIST"]);
+var PageBlockTypeSchema = z8.enum(["form", "spreadsheet", "kanban", "calendar", "link", "list", "card"]);
+var PageFieldTypeSchema = z8.enum(["STRING", "FILE", "NUMBER", "DATE", "BOOLEAN", "SELECT", "FORM", "RELATIONSHIP"]);
+var PageFieldSourceSchema = z8.object({
+  model: z8.string(),
+  field: z8.string()
+});
+var PageFormHeaderSchema = z8.object({
+  title: z8.string(),
+  description: z8.string().optional()
+});
+var PageActionDefinitionSchema = z8.object({
+  handle: z8.string(),
+  label: z8.string(),
+  handler: z8.string().optional(),
+  href: z8.string().optional(),
+  icon: z8.string().optional(),
+  variant: z8.enum(["primary", "secondary", "destructive", "outline"]).optional(),
+  isDisabled: z8.union([z8.boolean(), z8.string()]).optional(),
+  isHidden: z8.union([z8.boolean(), z8.string()]).optional()
 }).refine((data) => Boolean(data.handler || data.href), {
   message: "Page action requires handler or href"
 });
-var FormV2StylePropsSchema = z7.object({
-  id: z7.string(),
-  row: z7.number(),
-  col: z7.number(),
-  className: z7.string().optional(),
-  hidden: z7.boolean().optional()
-});
-var FieldSettingButtonPropsSchema = z7.object({
-  label: z7.string(),
-  variant: z7.enum(["default", "destructive", "outline", "secondary", "ghost", "link"]).optional(),
-  size: z7.enum(["default", "sm", "lg", "icon"]).optional(),
-  isLoading: z7.boolean().optional(),
+var FormV2StylePropsSchema = z8.object({
+  id: z8.string(),
+  row: z8.number(),
+  col: z8.number(),
+  className: z8.string().optional(),
+  hidden: z8.boolean().optional()
+});
+var FieldSettingButtonPropsSchema = z8.object({
+  label: z8.string(),
+  variant: z8.enum(["default", "destructive", "outline", "secondary", "ghost", "link"]).optional(),
+  size: z8.enum(["default", "sm", "lg", "icon"]).optional(),
+  isLoading: z8.boolean().optional(),
   /** Can be boolean or Liquid template string that resolves to boolean */
-  isDisabled: z7.union([z7.boolean(), z7.string()]).optional(),
-  leftIcon: z7.string().optional()
+  isDisabled: z8.union([z8.boolean(), z8.string()]).optional(),
+  leftIcon: z8.string().optional()
 });
-var RelationshipExtensionSchema = z7.object({
-  model: z7.string()
+var RelationshipExtensionSchema = z8.object({
+  model: z8.string()
 });
-var FormLayoutColumnDefinitionSchema = z7.object({
-  field: z7.string(),
-  colSpan: z7.number(),
-  dataType: z7.string().optional(),
-  subQuery: z7.unknown().optional()
+var FormLayoutColumnDefinitionSchema = z8.object({
+  field: z8.string(),
+  colSpan: z8.number(),
+  dataType: z8.string().optional(),
+  subQuery: z8.unknown().optional()
 });
-var FormLayoutRowDefinitionSchema = z7.object({
-  columns: z7.array(FormLayoutColumnDefinitionSchema)
+var FormLayoutRowDefinitionSchema = z8.object({
+  columns: z8.array(FormLayoutColumnDefinitionSchema)
 });
-var FormLayoutConfigDefinitionSchema = z7.object({
-  type: z7.literal("form"),
-  rows: z7.array(FormLayoutRowDefinitionSchema)
+var FormLayoutConfigDefinitionSchema = z8.object({
+  type: z8.literal("form"),
+  rows: z8.array(FormLayoutRowDefinitionSchema)
 });
 var InputComponentDefinitionSchema = FormV2StylePropsSchema.extend({
-  component: z7.literal("Input"),
-  props: z7.object({
-    label: z7.string().optional(),
-    placeholder: z7.string().optional(),
-    helpText: z7.string().optional(),
-    type: z7.enum(["text", "number", "email", "password", "tel", "url", "hidden"]).optional(),
-    required: z7.boolean().optional(),
-    disabled: z7.boolean().optional(),
-    value: z7.union([z7.string(), z7.number()]).optional()
+  component: z8.literal("Input"),
+  props: z8.object({
+    label: z8.string().optional(),
+    placeholder: z8.string().optional(),
+    helpText: z8.string().optional(),
+    type: z8.enum(["text", "number", "email", "password", "tel", "url", "hidden"]).optional(),
+    required: z8.boolean().optional(),
+    disabled: z8.boolean().optional(),
+    value: z8.union([z8.string(), z8.number()]).optional()
   })
 });
 var TextareaComponentDefinitionSchema = FormV2StylePropsSchema.extend({
-  component: z7.literal("Textarea"),
-  props: z7.object({
-    label: z7.string().optional(),
-    placeholder: z7.string().optional(),
-    helpText: z7.string().optional(),
-    required: z7.boolean().optional(),
-    disabled: z7.boolean().optional(),
-    value: z7.string().optional()
+  component: z8.literal("Textarea"),
+  props: z8.object({
+    label: z8.string().optional(),
+    placeholder: z8.string().optional(),
+    helpText: z8.string().optional(),
+    required: z8.boolean().optional(),
+    disabled: z8.boolean().optional(),
+    value: z8.string().optional()
   })
 });
 var SelectComponentDefinitionSchema = FormV2StylePropsSchema.extend({
-  component: z7.literal("Select"),
-  props: z7.object({
-    label: z7.string().optional(),
-    placeholder: z7.string().optional(),
-    helpText: z7.string().optional(),
+  component: z8.literal("Select"),
+  props: z8.object({
+    label: z8.string().optional(),
+    placeholder: z8.string().optional(),
+    helpText: z8.string().optional(),
     /** Static items array (will be populated by iterable if using dynamic items) */
-    items: z7.union([z7.array(z7.object({ value: z7.string(), label: z7.string() })), z7.string()]).optional(),
-    value: z7.string().optional(),
-    isDisabled: z7.boolean().optional(),
-    required: z7.boolean().optional()
+    items: z8.union([z8.array(z8.object({ value: z8.string(), label: z8.string() })), z8.string()]).optional(),
+    value: z8.string().optional(),
+    isDisabled: z8.boolean().optional(),
+    required: z8.boolean().optional()
   }),
   relationship: RelationshipExtensionSchema.optional(),
   /** For dynamic items using iterable pattern (e.g., 'system.models') */
-  iterable: z7.string().optional(),
+  iterable: z8.string().optional(),
   /** Template for each item in the iterable */
-  itemTemplate: z7.object({
-    value: z7.string(),
-    label: z7.string()
+  itemTemplate: z8.object({
+    value: z8.string(),
+    label: z8.string()
   }).optional()
 });
 var ComboboxComponentDefinitionSchema = FormV2StylePropsSchema.extend({
-  component: z7.literal("Combobox"),
-  props: z7.object({
-    label: z7.string().optional(),
-    placeholder: z7.string().optional(),
-    helpText: z7.string().optional(),
-    items: z7.array(z7.object({ value: z7.string(), label: z7.string() })).optional(),
-    value: z7.string().optional()
+  component: z8.literal("Combobox"),
+  props: z8.object({
+    label: z8.string().optional(),
+    placeholder: z8.string().optional(),
+    helpText: z8.string().optional(),
+    items: z8.array(z8.object({ value: z8.string(), label: z8.string() })).optional(),
+    value: z8.string().optional()
   }),
   relationship: RelationshipExtensionSchema.optional()
 });
 var CheckboxComponentDefinitionSchema = FormV2StylePropsSchema.extend({
-  component: z7.literal("Checkbox"),
-  props: z7.object({
-    label: z7.string().optional(),
-    helpText: z7.string().optional(),
-    checked: z7.boolean().optional(),
-    disabled: z7.boolean().optional()
+  component: z8.literal("Checkbox"),
+  props: z8.object({
+    label: z8.string().optional(),
+    helpText: z8.string().optional(),
+    checked: z8.boolean().optional(),
+    disabled: z8.boolean().optional()
   })
 });
 var DatePickerComponentDefinitionSchema = FormV2StylePropsSchema.extend({
-  component: z7.literal("DatePicker"),
-  props: z7.object({
-    label: z7.string().optional(),
-    helpText: z7.string().optional(),
-    value: z7.union([z7.string(), z7.date()]).optional(),
-    disabled: z7.boolean().optional()
+  component: z8.literal("DatePicker"),
+  props: z8.object({
+    label: z8.string().optional(),
+    helpText: z8.string().optional(),
+    value: z8.union([z8.string(), z8.date()]).optional(),
+    disabled: z8.boolean().optional()
   })
 });
 var TimePickerComponentDefinitionSchema = FormV2StylePropsSchema.extend({
-  component: z7.literal("TimePicker"),
-  props: z7.object({
-    label: z7.string().optional(),
-    helpText: z7.string().optional(),
-    value: z7.string().optional(),
-    disabled: z7.boolean().optional()
+  component: z8.literal("TimePicker"),
+  props: z8.object({
+    label: z8.string().optional(),
+    helpText: z8.string().optional(),
+    value: z8.string().optional(),
+    disabled: z8.boolean().optional()
   })
 });
 var ImageSettingComponentDefinitionSchema = FormV2StylePropsSchema.extend({
-  component: z7.literal("ImageSetting"),
-  props: z7.object({
-    label: z7.string().optional(),
-    description: z7.string().optional(),
-    helpText: z7.string().optional(),
-    accept: z7.string().optional()
+  component: z8.literal("ImageSetting"),
+  props: z8.object({
+    label: z8.string().optional(),
+    description: z8.string().optional(),
+    helpText: z8.string().optional(),
+    accept: z8.string().optional()
   })
 });
 var FileSettingComponentDefinitionSchema = FormV2StylePropsSchema.extend({
-  component: z7.literal("FileSetting"),
-  props: z7.object({
-    label: z7.string().optional(),
-    description: z7.string().optional(),
-    helpText: z7.string().optional(),
-    accept: z7.string().optional(),
-    required: z7.boolean().optional(),
-    button: z7.object({
-      label: z7.string().optional(),
-      variant: z7.enum(["default", "outline", "ghost", "link"]).optional(),
-      size: z7.enum(["sm", "md", "lg"]).optional()
+  component: z8.literal("FileSetting"),
+  props: z8.object({
+    label: z8.string().optional(),
+    description: z8.string().optional(),
+    helpText: z8.string().optional(),
+    accept: z8.string().optional(),
+    required: z8.boolean().optional(),
+    button: z8.object({
+      label: z8.string().optional(),
+      variant: z8.enum(["default", "outline", "ghost", "link"]).optional(),
+      size: z8.enum(["sm", "md", "lg"]).optional()
     }).optional()
   })
 });
-var ListItemTemplateSchema = z7.object({
-  component: z7.string(),
-  span: z7.number().optional(),
-  mdSpan: z7.number().optional(),
-  lgSpan: z7.number().optional(),
-  props: z7.record(z7.string(), z7.unknown())
+var ListItemTemplateSchema = z8.object({
+  component: z8.string(),
+  span: z8.number().optional(),
+  mdSpan: z8.number().optional(),
+  lgSpan: z8.number().optional(),
+  props: z8.record(z8.string(), z8.unknown())
 });
 var ListComponentDefinitionSchema = FormV2StylePropsSchema.extend({
-  component: z7.literal("List"),
-  props: z7.object({
-    title: z7.string().optional(),
-    items: z7.array(z7.object({
-      id: z7.string(),
-      label: z7.string(),
-      description: z7.string().optional()
+  component: z8.literal("List"),
+  props: z8.object({
+    title: z8.string().optional(),
+    items: z8.array(z8.object({
+      id: z8.string(),
+      label: z8.string(),
+      description: z8.string().optional()
     })).optional(),
-    emptyMessage: z7.string().optional()
+    emptyMessage: z8.string().optional()
   }),
-  model: z7.string().optional(),
-  labelField: z7.string().optional(),
-  descriptionField: z7.string().optional(),
-  icon: z7.string().optional(),
+  model: z8.string().optional(),
+  labelField: z8.string().optional(),
+  descriptionField: z8.string().optional(),
+  icon: z8.string().optional(),
   /** Context variable name to iterate over (e.g., 'phone_numbers') */
-  iterable: z7.string().optional(),
+  iterable: z8.string().optional(),
   /** Template for each item - use {{ item.xyz }} for field values */
   itemTemplate: ListItemTemplateSchema.optional()
 });
 var EmptyFormComponentDefinitionSchema = FormV2StylePropsSchema.extend({
-  component: z7.literal("EmptyForm"),
-  props: z7.object({
-    title: z7.string().optional(),
-    description: z7.string().optional(),
-    icon: z7.string().optional()
+  component: z8.literal("EmptyForm"),
+  props: z8.object({
+    title: z8.string().optional(),
+    description: z8.string().optional(),
+    icon: z8.string().optional()
   })
 });
 var AlertComponentDefinitionSchema = FormV2StylePropsSchema.extend({
-  component: z7.literal("Alert"),
-  props: z7.object({
-    title: z7.string(),
-    description: z7.string(),
-    icon: z7.string().optional(),
-    variant: z7.enum(["default", "destructive"]).optional()
+  component: z8.literal("Alert"),
+  props: z8.object({
+    title: z8.string(),
+    description: z8.string(),
+    icon: z8.string().optional(),
+    variant: z8.enum(["default", "destructive"]).optional()
   })
 });
 var EventWiringPanelComponentDefinitionSchema = FormV2StylePropsSchema.extend({
-  component: z7.literal("EventWiringPanel"),
-  props: z7.object({
-    eventTypes: z7.array(
-      z7.object({
-        type: z7.string(),
-        label: z7.string(),
-        glofoxType: z7.string().optional(),
-        description: z7.string().optional(),
-        icon: z7.string().optional()
+  component: z8.literal("EventWiringPanel"),
+  props: z8.object({
+    eventTypes: z8.array(
+      z8.object({
+        type: z8.string(),
+        label: z8.string(),
+        glofoxType: z8.string().optional(),
+        description: z8.string().optional(),
+        icon: z8.string().optional()
       })
     ),
-    recommendedWorkflowHandle: z7.string().optional()
+    recommendedWorkflowHandle: z8.string().optional()
   })
 });
-var ModalFormDefinitionSchema = z7.object({
+var ModalFormDefinitionSchema = z8.object({
   header: PageFormHeaderSchema,
-  handler: z7.string(),
+  handler: z8.string(),
   /** Named dialog template to use instead of inline fields */
-  template: z7.string().optional(),
+  template: z8.string().optional(),
   /** Template-specific params to pass to the dialog */
-  templateParams: z7.record(z7.string(), z7.unknown()).optional(),
+  templateParams: z8.record(z8.string(), z8.unknown()).optional(),
   /** Inline field definitions (used when template is not specified) */
-  fields: z7.lazy(() => z7.array(FormV2ComponentDefinitionSchema)).optional(),
+  fields: z8.lazy(() => z8.array(FormV2ComponentDefinitionSchema)).optional(),
   layout: FormLayoutConfigDefinitionSchema.optional(),
-  actions: z7.array(PageActionDefinitionSchema).optional()
+  actions: z8.array(PageActionDefinitionSchema).optional()
 });
 var FieldSettingComponentDefinitionSchema = FormV2StylePropsSchema.extend({
-  component: z7.literal("FieldSetting"),
-  props: z7.object({
-    label: z7.string(),
-    description: z7.string().optional(),
-    helpText: z7.string().optional(),
-    mode: z7.enum(["field", "setting"]).optional(),
+  component: z8.literal("FieldSetting"),
+  props: z8.object({
+    label: z8.string(),
+    description: z8.string().optional(),
+    helpText: z8.string().optional(),
+    mode: z8.enum(["field", "setting"]).optional(),
     /** Status indicator - can be literal or Liquid template */
-    status: z7.string().optional(),
+    status: z8.string().optional(),
     /** Text to display alongside status badge - can be Liquid template */
-    statusText: z7.string().optional(),
+    statusText: z8.string().optional(),
     button: FieldSettingButtonPropsSchema
   }),
   modalForm: ModalFormDefinitionSchema.optional()
 });
-var FormV2ComponentDefinitionSchema = z7.discriminatedUnion("component", [
+var FormV2ComponentDefinitionSchema = z8.discriminatedUnion("component", [
   InputComponentDefinitionSchema,
   TextareaComponentDefinitionSchema,
   SelectComponentDefinitionSchema,
@@ -1537,82 +1649,82 @@ var FormV2ComponentDefinitionSchema = z7.discriminatedUnion("component", [
   AlertComponentDefinitionSchema,
   EventWiringPanelComponentDefinitionSchema
 ]);
-var FormV2PropsDefinitionSchema = z7.object({
-  formVersion: z7.literal("v2"),
-  id: z7.string().optional(),
-  fields: z7.array(FormV2ComponentDefinitionSchema),
+var FormV2PropsDefinitionSchema = z8.object({
+  formVersion: z8.literal("v2"),
+  id: z8.string().optional(),
+  fields: z8.array(FormV2ComponentDefinitionSchema),
   layout: FormLayoutConfigDefinitionSchema,
   /** Optional actions that trigger MCP tool calls */
-  actions: z7.array(PageActionDefinitionSchema).optional()
+  actions: z8.array(PageActionDefinitionSchema).optional()
 });
-var CardBlockHeaderSchema = z7.object({
-  title: z7.string(),
-  description: z7.string().optional(),
-  descriptionHref: z7.string().optional()
+var CardBlockHeaderSchema = z8.object({
+  title: z8.string(),
+  description: z8.string().optional(),
+  descriptionHref: z8.string().optional()
 });
-var CardBlockDefinitionSchema = z7.object({
-  type: z7.literal("card"),
-  restructurable: z7.boolean().optional(),
+var CardBlockDefinitionSchema = z8.object({
+  type: z8.literal("card"),
+  restructurable: z8.boolean().optional(),
   header: CardBlockHeaderSchema.optional(),
   form: FormV2PropsDefinitionSchema,
-  actions: z7.array(PageActionDefinitionSchema).optional(),
-  secondaryActions: z7.array(PageActionDefinitionSchema).optional(),
-  primaryActions: z7.array(PageActionDefinitionSchema).optional()
+  actions: z8.array(PageActionDefinitionSchema).optional(),
+  secondaryActions: z8.array(PageActionDefinitionSchema).optional(),
+  primaryActions: z8.array(PageActionDefinitionSchema).optional()
 });
-var PageFieldDefinitionBaseSchema = z7.object({
-  handle: z7.string(),
+var PageFieldDefinitionBaseSchema = z8.object({
+  handle: z8.string(),
   type: PageFieldTypeSchema,
-  label: z7.string(),
-  description: z7.string().optional(),
-  required: z7.boolean().optional(),
-  handler: z7.string().optional(),
+  label: z8.string(),
+  description: z8.string().optional(),
+  required: z8.boolean().optional(),
+  handler: z8.string().optional(),
   source: PageFieldSourceSchema.optional(),
-  options: z7.array(z7.object({ value: z7.string(), label: z7.string() })).optional(),
-  accept: z7.string().optional(),
-  model: z7.string().optional()
+  options: z8.array(z8.object({ value: z8.string(), label: z8.string() })).optional(),
+  accept: z8.string().optional(),
+  model: z8.string().optional()
 });
 var PageFieldDefinitionSchema = PageFieldDefinitionBaseSchema.extend({
   header: PageFormHeaderSchema.optional(),
-  fields: z7.lazy(() => z7.array(PageFieldDefinitionSchema)).optional(),
-  actions: z7.lazy(() => z7.array(PageActionDefinitionSchema)).optional()
-});
-var LegacyFormBlockDefinitionSchema = z7.object({
-  type: z7.enum(["form", "spreadsheet", "kanban", "calendar", "link"]),
-  title: z7.string().optional(),
-  fields: z7.array(PageFieldDefinitionSchema).optional(),
-  readonly: z7.boolean().optional()
-});
-var ListBlockDefinitionSchema = z7.object({
-  type: z7.literal("list"),
-  title: z7.string().optional(),
-  model: z7.string(),
-  labelField: z7.string().optional(),
-  descriptionField: z7.string().optional(),
-  icon: z7.string().optional(),
-  emptyMessage: z7.string().optional()
-});
-var ModelMapperBlockDefinitionSchema = z7.object({
-  type: z7.literal("model_mapper"),
+  fields: z8.lazy(() => z8.array(PageFieldDefinitionSchema)).optional(),
+  actions: z8.lazy(() => z8.array(PageActionDefinitionSchema)).optional()
+});
+var LegacyFormBlockDefinitionSchema = z8.object({
+  type: z8.enum(["form", "spreadsheet", "kanban", "calendar", "link"]),
+  title: z8.string().optional(),
+  fields: z8.array(PageFieldDefinitionSchema).optional(),
+  readonly: z8.boolean().optional()
+});
+var ListBlockDefinitionSchema = z8.object({
+  type: z8.literal("list"),
+  title: z8.string().optional(),
+  model: z8.string(),
+  labelField: z8.string().optional(),
+  descriptionField: z8.string().optional(),
+  icon: z8.string().optional(),
+  emptyMessage: z8.string().optional()
+});
+var ModelMapperBlockDefinitionSchema = z8.object({
+  type: z8.literal("model_mapper"),
   /** The SHARED model handle from install config (e.g., "client", "patient") */
-  model: z7.string()
+  model: z8.string()
 });
-var PageBlockDefinitionSchema = z7.union([
+var PageBlockDefinitionSchema = z8.union([
   CardBlockDefinitionSchema,
   LegacyFormBlockDefinitionSchema,
   ListBlockDefinitionSchema,
   ModelMapperBlockDefinitionSchema
 ]);
-var PageContextModeSchema = z7.enum(["first", "many", "count", "all"]).transform((val) => val === "all" ? "many" : val);
-var PageContextFiltersSchema = z7.record(
-  z7.string(),
-  z7.record(
-    z7.string(),
-    z7.union([PrimitiveSchema, z7.array(PrimitiveSchema), z7.string()])
+var PageContextModeSchema = z8.enum(["first", "many", "count", "all"]).transform((val) => val === "all" ? "many" : val);
+var PageContextFiltersSchema = z8.record(
+  z8.string(),
+  z8.record(
+    z8.string(),
+    z8.union([PrimitiveSchema, z8.array(PrimitiveSchema), z8.string()])
   )
 );
-var PageContextItemDefinitionSchema = z7.object({
+var PageContextItemDefinitionSchema = z8.object({
   /** Model handle to fetch data from */
-  model: z7.string(),
+  model: z8.string(),
   /** Fetch mode: 'first' returns single object, 'many' returns array, 'count' returns number */
   mode: PageContextModeSchema,
   /**
@@ -1622,69 +1734,69 @@ var PageContextItemDefinitionSchema = z7.object({
    */
   filters: PageContextFiltersSchema.optional(),
   /** Optional limit for 'many' mode */
-  limit: z7.number().optional()
+  limit: z8.number().optional()
 });
-var PageContextToolItemDefinitionSchema = z7.object({
+var PageContextToolItemDefinitionSchema = z8.object({
   /** Tool name to invoke for fetching context data */
-  tool: z7.string()
+  tool: z8.string()
 });
-var PageContextDefinitionSchema = z7.record(
-  z7.string(),
-  z7.union([PageContextItemDefinitionSchema, PageContextToolItemDefinitionSchema])
+var PageContextDefinitionSchema = z8.record(
+  z8.string(),
+  z8.union([PageContextItemDefinitionSchema, PageContextToolItemDefinitionSchema])
 );
-var PageInstanceFilterSchema = z7.object({
-  model: z7.string(),
-  where: z7.record(z7.string(), z7.unknown()).optional()
+var PageInstanceFilterSchema = z8.object({
+  model: z8.string(),
+  where: z8.record(z8.string(), z8.unknown()).optional()
 });
-var NavigationItemSchema = z7.object({
+var NavigationItemSchema = z8.object({
   /** Display label (supports Liquid templates) */
-  label: z7.string(),
+  label: z8.string(),
   /** URL href (supports Liquid templates with path_params and context) */
-  href: z7.string(),
+  href: z8.string(),
   /** Optional icon name */
-  icon: z7.string().optional(),
+  icon: z8.string().optional(),
   /** When true, item is omitted from rendered navigation (supports Liquid templates) */
-  hidden: z7.union([z7.boolean(), z7.string()]).optional()
+  hidden: z8.union([z8.boolean(), z8.string()]).optional()
 });
-var NavigationSectionSchema = z7.object({
+var NavigationSectionSchema = z8.object({
   /** Section title (supports Liquid templates) */
-  title: z7.string().optional(),
+  title: z8.string().optional(),
   /** Navigation items in this section */
-  items: z7.array(NavigationItemSchema)
+  items: z8.array(NavigationItemSchema)
 });
-var NavigationSidebarSchema = z7.object({
+var NavigationSidebarSchema = z8.object({
   /** Sections to display in the sidebar */
-  sections: z7.array(NavigationSectionSchema)
+  sections: z8.array(NavigationSectionSchema)
 });
-var BreadcrumbItemSchema = z7.object({
+var BreadcrumbItemSchema = z8.object({
   /** Display label (supports Liquid templates) */
-  label: z7.string(),
+  label: z8.string(),
   /** Optional href - if not provided, item is not clickable */
-  href: z7.string().optional()
+  href: z8.string().optional()
 });
-var NavigationBreadcrumbSchema = z7.object({
+var NavigationBreadcrumbSchema = z8.object({
   /** Breadcrumb items from left to right */
-  items: z7.array(BreadcrumbItemSchema)
+  items: z8.array(BreadcrumbItemSchema)
 });
-var NavigationConfigSchema = z7.object({
+var NavigationConfigSchema = z8.object({
   /** Sidebar navigation */
   sidebar: NavigationSidebarSchema.optional(),
   /** Breadcrumb navigation */
   breadcrumb: NavigationBreadcrumbSchema.optional()
 });
-var PageAudienceSchema = z7.enum(["install", "developer", "both"]);
-var PageDefinitionSchema = z7.object({
+var PageAudienceSchema = z8.enum(["install", "developer", "both"]);
+var PageDefinitionSchema = z8.object({
   /** Unique identifier within the app (snake_case) */
-  handle: z7.string().optional(),
+  handle: z8.string().optional(),
   /** Human-readable display name */
-  label: z7.string(),
+  label: z8.string(),
   /** Optional description for documentation/UI */
-  description: z7.string().optional(),
+  description: z8.string().optional(),
   type: PageTypeSchema,
   /** URL path for this page (e.g., '/phone-numbers' or '/phone-numbers/[id]' for dynamic segments) */
-  path: z7.string(),
+  path: z8.string(),
   /** When true, this page is the default landing page for the app installation */
-  default: z7.boolean().optional(),
+  default: z8.boolean().optional(),
   /**
    * Page audience:
    * - 'install': Visible only to app installers (default)
@@ -1698,115 +1810,171 @@ var PageDefinitionSchema = z7.object({
    * - string: Liquid template that evaluates to true/false
    * - NavigationConfigSchema: full navigation override for this page (replaces base navigation)
    */
-  navigation: z7.union([z7.boolean(), z7.string(), NavigationConfigSchema]).optional().default(true),
-  blocks: z7.array(PageBlockDefinitionSchema),
-  actions: z7.array(PageActionDefinitionSchema).optional(),
+  navigation: z8.union([z8.boolean(), z8.string(), NavigationConfigSchema]).optional().default(true),
+  blocks: z8.array(PageBlockDefinitionSchema),
+  actions: z8.array(PageActionDefinitionSchema).optional(),
   /** Context data to load for Liquid templates. appInstallationId filtering is automatic. */
   context: PageContextDefinitionSchema.optional(),
   /** @deprecated Use context instead */
   filter: PageInstanceFilterSchema.optional()
 });
-var WebhookHttpMethodSchema = z7.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]);
-var WebhookTypeSchema = z7.enum(["WEBHOOK", "CALLBACK"]);
-var WebhookHandlerDefinitionSchema = z7.object({
-  description: z7.string().optional(),
-  methods: z7.array(WebhookHttpMethodSchema).optional(),
+var WebhookHttpMethodSchema = z8.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]);
+var WebhookTypeSchema = z8.enum(["WEBHOOK", "CALLBACK"]);
+var WebhookHandlerDefinitionSchema = z8.object({
+  description: z8.string().optional(),
+  methods: z8.array(WebhookHttpMethodSchema).optional(),
   /** Invocation type: WEBHOOK (fire-and-forget) or CALLBACK (waits for response). Defaults to WEBHOOK. */
   type: WebhookTypeSchema.optional(),
-  handler: z7.unknown()
+  handler: z8.unknown()
 });
-var WebhooksSchema = z7.record(z7.string(), WebhookHandlerDefinitionSchema);
-var AgentDefinitionSchema = z7.object({
+var WebhooksSchema = z8.record(z8.string(), WebhookHandlerDefinitionSchema);
+var AgentDefinitionSchema = z8.object({
   /** Unique identifier within the app (used for upserts) */
-  handle: z7.string().regex(/^[a-z0-9_-]+$/, "Handle must be lowercase alphanumeric with dashes/underscores"),
+  handle: z8.string().regex(/^[a-z0-9_-]+$/, "Handle must be lowercase alphanumeric with dashes/underscores"),
   /** Display name */
-  name: z7.string().min(1),
+  name: z8.string().min(1),
   /** Description of what the agent does */
-  description: z7.string(),
+  description: z8.string(),
   /** System prompt (static, no templating) */
-  system: z7.string(),
+  system: z8.string(),
   /** Tool names to bind (can be empty for orchestrator agents) */
-  tools: z7.array(z7.string()),
+  tools: z8.array(z8.string()),
   /** Optional LLM model override */
-  llmModelId: z7.string().optional(),
+  llmModelId: z8.string().optional(),
   /** Parent agent that can call this agent ('composer' or another agent handle) */
-  parentAgent: z7.string().optional()
+  parentAgent: z8.string().optional()
 });
-var InstallConfigSchema = z7.object({
+var InstallConfigSchema = z8.object({
   env: EnvSchemaSchema.optional(),
   /** SHARED model definitions (mapped to user's existing data during installation) */
-  models: z7.array(ModelDefinitionSchema).optional(),
+  models: z8.array(ModelDefinitionSchema).optional(),
   /** Relationship definitions between SHARED models */
-  relationships: z7.array(RelationshipDefinitionSchema).optional()
+  relationships: z8.array(RelationshipDefinitionSchema).optional()
 });
-var ProvisionConfigSchema = z7.object({
+var ProvisionConfigSchema = z8.object({
   env: EnvSchemaSchema.optional(),
   /** INTERNAL model definitions (app-owned, not visible to users) */
-  models: z7.array(ModelDefinitionSchema).optional(),
+  models: z8.array(ModelDefinitionSchema).optional(),
   /** Relationship definitions between INTERNAL models */
-  relationships: z7.array(RelationshipDefinitionSchema).optional(),
-  channels: z7.array(ChannelDefinitionSchema).optional(),
-  workflows: z7.array(WorkflowDefinitionSchema).optional(),
+  relationships: z8.array(RelationshipDefinitionSchema).optional(),
+  channels: z8.array(ChannelDefinitionSchema).optional(),
+  workflows: z8.array(WorkflowDefinitionSchema).optional(),
   /** Base navigation configuration for all pages (can be overridden per page) */
   navigation: NavigationConfigSchema.optional(),
-  pages: z7.array(PageDefinitionSchema).optional()
+  pages: z8.array(PageDefinitionSchema).optional()
 });
-var SkedyulConfigSchema = z7.object({
-  name: z7.string(),
-  version: z7.string().optional(),
-  description: z7.string().optional(),
+var SkedyulConfigSchema = z8.object({
+  name: z8.string(),
+  version: z8.string().optional(),
+  description: z8.string().optional(),
   computeLayer: ComputeLayerTypeSchema.optional(),
-  tools: z7.unknown().optional(),
-  webhooks: z7.unknown().optional(),
-  provision: z7.union([ProvisionConfigSchema, z7.unknown()]).optional(),
-  agents: z7.array(AgentDefinitionSchema).optional()
+  tools: z8.unknown().optional(),
+  webhooks: z8.unknown().optional(),
+  provision: z8.union([ProvisionConfigSchema, z8.unknown()]).optional(),
+  agents: z8.array(AgentDefinitionSchema).optional()
 });
 function safeParseConfig(data) {
   const result = SkedyulConfigSchema.safeParse(data);
   return result.success ? result.data : null;
 }
-var MessageSendChannelSchema = z7.object({
-  id: z7.string(),
-  handle: z7.string(),
-  identifierValue: z7.string()
-});
-var MessageSendSubscriptionSchema = z7.object({
-  id: z7.string(),
-  identifierValue: z7.string()
-});
-var MessageSendContactSchema = z7.object({
-  id: z7.string(),
-  name: z7.string().optional()
-});
-var MessageSendRecipientSchema = z7.object({
-  address: z7.string(),
-  name: z7.string().optional(),
-  participantId: z7.string().optional(),
-  contactId: z7.string().optional()
-});
-var MessageSendAttachmentSchema = z7.object({
-  filename: z7.string(),
-  url: z7.string(),
-  mimeType: z7.string(),
-  size: z7.number()
-});
-var MessageSendMessageSchema = z7.object({
-  id: z7.string(),
-  content: z7.string(),
-  contentRaw: z7.string().optional(),
-  title: z7.string().optional(),
-  attachments: z7.array(MessageSendAttachmentSchema).optional()
-});
-var MessageSendInputSchema = z7.object({
+var MessageSendChannelSchema = z8.object({
+  id: z8.string(),
+  handle: z8.string(),
+  identifierValue: z8.string()
+});
+var MessageSendSubscriptionSchema = z8.object({
+  id: z8.string(),
+  identifierValue: z8.string()
+});
+var MessageSendContactSchema = z8.object({
+  id: z8.string(),
+  name: z8.string().optional()
+});
+var MessageSendRecipientSchema = z8.object({
+  address: z8.string(),
+  name: z8.string().optional(),
+  participantId: z8.string().optional(),
+  contactId: z8.string().optional()
+});
+var MessageSendAttachmentSchema = z8.object({
+  filename: z8.string(),
+  url: z8.string(),
+  mimeType: z8.string(),
+  size: z8.number()
+});
+var MessageSendMessageSchema = z8.object({
+  id: z8.string(),
+  content: z8.string(),
+  contentRaw: z8.string().optional(),
+  title: z8.string().optional(),
+  attachments: z8.array(MessageSendAttachmentSchema).optional()
+});
+var MessageSendInputSchema = z8.object({
   channel: MessageSendChannelSchema,
   subscription: MessageSendSubscriptionSchema.optional(),
   contact: MessageSendContactSchema.optional(),
   recipient: MessageSendRecipientSchema.optional(),
   message: MessageSendMessageSchema
 });
-var MessageSendOutputSchema = z7.object({
-  status: z7.enum(["sent", "queued", "failed"]),
-  remoteId: z7.string().optional()
+var MessageSendOutputSchema = z8.object({
+  status: z8.enum(["sent", "queued", "failed"]),
+  remoteId: z8.string().optional()
+});
+var MessageBulkRecipientSchema = z8.object({
+  address: z8.string(),
+  renderedBody: z8.string(),
+  instanceId: z8.string().optional(),
+  threadId: z8.string().optional(),
+  messageId: z8.string().optional(),
+  contactId: z8.string().optional()
+});
+var MessageBulkSendInputSchema = z8.object({
+  channel: MessageSendChannelSchema,
+  recipients: z8.array(MessageBulkRecipientSchema).min(1).max(1e4),
+  schedule: z8.object({ at: z8.string() }).optional()
+});
+var MessageBulkSendOutputSchema = z8.object({
+  status: z8.enum(["accepted", "failed"]),
+  operationId: z8.string().optional(),
+  acceptedCount: z8.number().int().nonnegative(),
+  rejectedCount: z8.number().int().nonnegative().optional()
+});
+var MessageBulkStatusMessageSchema = z8.object({
+  address: z8.string(),
+  status: z8.string(),
+  messageId: z8.string().optional(),
+  errorCode: z8.union([z8.string(), z8.number()]).optional(),
+  errorMessage: z8.string().optional()
+});
+var MessageBulkStatusStatsSchema = z8.object({
+  total: z8.number().int().nonnegative().optional(),
+  recipients: z8.number().int().nonnegative().optional(),
+  attempts: z8.number().int().nonnegative().optional(),
+  unaddressable: z8.number().int().nonnegative().optional(),
+  queued: z8.number().int().nonnegative().optional(),
+  sent: z8.number().int().nonnegative().optional(),
+  scheduled: z8.number().int().nonnegative().optional(),
+  delivered: z8.number().int().nonnegative().optional(),
+  read: z8.number().int().nonnegative().optional(),
+  undelivered: z8.number().int().nonnegative().optional(),
+  failed: z8.number().int().nonnegative().optional(),
+  canceled: z8.number().int().nonnegative().optional()
+});
+var MessageBulkStatusInputSchema = z8.object({
+  channel: MessageSendChannelSchema,
+  operationId: z8.string().min(1)
+});
+var MessageBulkStatusOutputSchema = z8.object({
+  operationId: z8.string(),
+  status: z8.string(),
+  complete: z8.boolean(),
+  /**
+   * When true, the provider skipped real delivery (e.g. MOCK_OUTBOUND_MESSAGES).
+   * Core should mark all recipients in the operation as sent without per-message rows.
+   */
+  mock: z8.boolean().optional(),
+  stats: MessageBulkStatusStatsSchema.optional(),
+  messages: z8.array(MessageBulkStatusMessageSchema)
 });
 function isModelDependency(dep) {
   return "model" in dep;
@@ -1820,7 +1988,7 @@ function isWorkflowDependency(dep) {
 
 // src/server/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import * as z10 from "zod";
+import * as z11 from "zod";
 
 // src/core/service.ts
 var CoreApiService = class {
@@ -1929,17 +2097,20 @@ function getQueueConfigWithRetry(queueName) {
 }
 
 // src/server/utils/schema.ts
-import * as z8 from "zod";
+import * as z9 from "zod";
 function normalizeBilling(billing) {
-  if (!billing || typeof billing.credits !== "number") {
+  if (!billing || typeof billing !== "object") {
     return { credits: 0 };
   }
+  if (typeof billing.credits !== "number") {
+    return { ...billing, credits: 0 };
+  }
   return billing;
 }
 function toJsonSchema(schema) {
   if (!schema) return void 0;
   try {
-    return z8.toJSONSchema(schema, {
+    return z9.toJSONSchema(schema, {
       unrepresentable: "any"
       // Handle z.date(), z.bigint() etc gracefully
     });
@@ -1950,12 +2121,12 @@ function toJsonSchema(schema) {
 }
 function isToolSchemaWithJson(schema) {
   return Boolean(
-    schema && typeof schema === "object" && "zod" in schema && schema.zod instanceof z8.ZodType
+    schema && typeof schema === "object" && "zod" in schema && schema.zod instanceof z9.ZodType
   );
 }
 function getZodSchema(schema) {
   if (!schema) return void 0;
-  if (schema instanceof z8.ZodType) {
+  if (schema instanceof z9.ZodType) {
     return schema;
   }
   if (isToolSchemaWithJson(schema)) {
@@ -2102,7 +2273,7 @@ function buildToolCallErrorOutput(result) {
 
 // src/core/client.ts
 import { AsyncLocalStorage } from "async_hooks";
-import { z as z9 } from "zod/v4";
+import { z as z10 } from "zod/v4";
 var requestConfigStorage = new AsyncLocalStorage();
 var globalConfig = {
   baseUrl: process.env.SKEDYUL_API_URL ?? process.env.SKEDYUL_NODE_URL ?? "",
@@ -3082,7 +3253,7 @@ var resource = {
   }
 };
 function zodSchemaToJsonSchema(schema) {
-  return z9.toJSONSchema(schema);
+  return z10.toJSONSchema(schema);
 }
 var ai = {
   /**
@@ -3308,10 +3479,27 @@ function getActiveQueuedOperation() {
 function getActiveQueuedOperationStack() {
   return activeOperationStackStorage.getStore() ?? [];
 }
-function isInsidePetbooqzCalendarBookingMutex() {
-  return getActiveQueuedOperationStack().some(
-    (operation) => operation.resolved.name === "petbooqz_calendar_booking" && operation.lease !== null
-  );
+function getActiveMutexQueueNames() {
+  const names = /* @__PURE__ */ new Set();
+  for (const operation of getActiveQueuedOperationStack()) {
+    if (operation.lease === null) {
+      continue;
+    }
+    const config = getQueueConfigWithRetry(operation.resolved.name);
+    if (config?.mutex === true) {
+      names.add(operation.resolved.name);
+    }
+  }
+  return [...names];
+}
+function shouldSkipNestedAcquire(queueName) {
+  for (const mutexQueueName of getActiveMutexQueueNames()) {
+    const config = getQueueConfigWithRetry(mutexQueueName);
+    if (config?.suppressesQueues?.includes(queueName)) {
+      return true;
+    }
+  }
+  return false;
 }
 function setActiveQueuedOperationLease(lease) {
   const op = activeOperationStorage.getStore();
@@ -3548,6 +3736,7 @@ function buildToolMetadata(registry) {
     const timeout = typeof rawTimeout === "number" && rawTimeout > 0 ? rawTimeout : 1e4;
     const retries = typeof rawRetries === "number" && rawRetries >= 1 ? rawRetries : 1;
     const queueTouchPoints = tool.queueTouchPoints ?? toolConfig.queueTouchPoints;
+    const rateLimitHandoff = tool.rateLimitHandoff ?? toolConfig.rateLimitHandoff;
     return {
       name: tool.name,
       displayName: tool.label || tool.name,
@@ -3558,11 +3747,13 @@ function buildToolMetadata(registry) {
       timeout,
       retries,
       queueTouchPoints,
+      rateLimitHandoff,
       config: {
         timeout,
         retries,
         completionHints: toolConfig.completionHints,
-        queueTouchPoints
+        queueTouchPoints,
+        rateLimitHandoff
       }
     };
   });
@@ -3604,7 +3795,8 @@ function createCallToolHandler(registry, state, onMaxRequests) {
     }
     const fn = tool.handler;
     const args = toolArgsInput ?? {};
-    const estimateMode = args.estimate === true;
+    const rawContextForMode = args.context ?? {};
+    const estimateMode = args.estimate === true || rawContextForMode.mode === "estimate";
     if (!estimateMode) {
       state.incrementRequestCount();
       if (state.shouldShutdown()) {
@@ -4091,7 +4283,8 @@ function serializeConfig(config) {
       // Read timeout/retries from top-level first, then fallback to config
       timeout: tool.timeout ?? tool.config?.timeout,
       retries: tool.retries ?? tool.config?.retries,
-      queueTouchPoints: tool.queueTouchPoints ?? tool.config?.queueTouchPoints
+      queueTouchPoints: tool.queueTouchPoints ?? tool.config?.queueTouchPoints,
+      rateLimitHandoff: tool.rateLimitHandoff ?? tool.config?.rateLimitHandoff
     })) : [],
     webhooks: webhookRegistry ? Object.values(webhookRegistry).map((w) => ({
       name: w.name,
@@ -4786,11 +4979,12 @@ async function handleMcpRoute(req, ctx) {
 async function handleMcpToolsCall(params, id, ctx) {
   const toolName = params?.name;
   const rawArgs = params?.arguments ?? {};
-  const hasSkedyulFormat = "inputs" in rawArgs || "env" in rawArgs || "context" in rawArgs || "invocation" in rawArgs;
+  const hasSkedyulFormat = "inputs" in rawArgs || "env" in rawArgs || "context" in rawArgs || "invocation" in rawArgs || "estimate" in rawArgs;
   const toolInputs = hasSkedyulFormat ? rawArgs.inputs ?? {} : rawArgs;
   const toolContext = hasSkedyulFormat ? rawArgs.context : void 0;
   const toolEnv = hasSkedyulFormat ? rawArgs.env : void 0;
   const toolInvocation = hasSkedyulFormat ? rawArgs.invocation : void 0;
+  const estimate = hasSkedyulFormat && rawArgs.estimate === true;
   const found = findToolInRegistry(ctx.registry, toolName);
   if (!found) {
     return {
@@ -4815,7 +5009,8 @@ async function handleMcpToolsCall(params, id, ctx) {
       inputs: validatedInputs,
       context: toolContext,
       env: toolEnv,
-      invocation: toolInvocation
+      invocation: toolInvocation,
+      estimate
     });
     let result;
     const isFailure2 = isToolCallFailure(toolResult);
@@ -5273,12 +5468,12 @@ function createSkedyulServer(config) {
     const toolDisplayName = tool.label || toolName;
     const inputZodSchema = getZodSchema(tool.inputSchema);
     const outputZodSchema = getZodSchema(tool.outputSchema);
-    const wrappedInputSchema = z10.object({
-      inputs: inputZodSchema ?? z10.record(z10.string(), z10.unknown()).optional(),
-      context: z10.record(z10.string(), z10.unknown()).optional(),
-      env: z10.record(z10.string(), z10.string()).optional(),
-      invocation: z10.record(z10.string(), z10.unknown()).optional(),
-      estimate: z10.boolean().optional()
+    const wrappedInputSchema = z11.object({
+      inputs: inputZodSchema ?? z11.record(z11.string(), z11.unknown()).optional(),
+      context: z11.record(z11.string(), z11.unknown()).optional(),
+      env: z11.record(z11.string(), z11.string()).optional(),
+      invocation: z11.record(z11.string(), z11.unknown()).optional(),
+      estimate: z11.boolean().optional()
     }).passthrough();
     mcpServer.registerTool(
       toolName,
@@ -5987,7 +6182,7 @@ async function executeWithRetries(operation, maxRetries) {
     operation.resolved.queueKey,
     rateLimitCtx
   );
-  if (operation.resolved.name === "petbooqz_api" && isInsidePetbooqzCalendarBookingMutex()) {
+  if (shouldSkipNestedAcquire(operation.resolved.name)) {
     return operation.fn();
   }
   if (preAcquired) {
@@ -6091,86 +6286,86 @@ async function queuedFetchResponse(queueInput, url, init) {
 }
 
 // src/triggers/types.ts
-import { z as z11 } from "zod/v4";
-var CRMDataSchema = z11.object({
-  model: z11.string(),
-  instanceId: z11.string(),
-  data: z11.record(z11.string(), z11.unknown())
+import { z as z12 } from "zod/v4";
+var CRMDataSchema = z12.object({
+  model: z12.string(),
+  instanceId: z12.string(),
+  data: z12.record(z12.string(), z12.unknown())
 });
-var SenderContextSchema2 = z11.object({
+var SenderContextSchema2 = z12.object({
   kind: ParticipantKindSchema,
-  displayName: z11.string().optional(),
+  displayName: z12.string().optional(),
   crm: CRMDataSchema.optional()
 });
-var ThreadContextItemSchema2 = z11.object({
-  handle: z11.string(),
-  model: z11.string(),
-  instanceId: z11.string(),
-  data: z11.record(z11.string(), z11.unknown()).optional()
+var ThreadContextItemSchema2 = z12.object({
+  handle: z12.string(),
+  model: z12.string(),
+  instanceId: z12.string(),
+  data: z12.record(z12.string(), z12.unknown()).optional()
 });
-var ParticipantContextSchema = z11.object({
-  id: z11.string(),
+var ParticipantContextSchema = z12.object({
+  id: z12.string(),
   kind: ParticipantKindSchema,
-  displayName: z11.string().optional(),
-  contactId: z11.string().optional(),
-  memberId: z11.string().optional(),
-  agentId: z11.string().optional(),
-  workflowId: z11.string().optional()
+  displayName: z12.string().optional(),
+  contactId: z12.string().optional(),
+  memberId: z12.string().optional(),
+  agentId: z12.string().optional(),
+  workflowId: z12.string().optional()
 });
-var TriggerContextSchema = z11.object({
+var TriggerContextSchema = z12.object({
   // The event that triggered this
-  event: z11.object({
+  event: z12.object({
     type: EventTypeSchema,
-    payload: z11.record(z11.string(), z11.unknown()),
+    payload: z12.record(z12.string(), z12.unknown()),
     participant: ParticipantContextSchema.optional()
   }),
   // Thread information
-  thread: z11.object({
-    id: z11.string(),
-    title: z11.string().optional(),
-    status: z11.string().optional(),
+  thread: z12.object({
+    id: z12.string(),
+    title: z12.string().optional(),
+    status: z12.string().optional(),
     sender: SenderContextSchema2.optional(),
-    context: z11.record(z11.string(), CRMDataSchema).optional(),
-    participants: z11.array(ParticipantContextSchema).optional()
+    context: z12.record(z12.string(), CRMDataSchema).optional(),
+    participants: z12.array(ParticipantContextSchema).optional()
   }),
   // Workplace info
-  workplace: z11.object({
-    id: z11.string(),
-    name: z11.string().optional(),
-    settings: z11.record(z11.string(), z11.unknown()).optional()
+  workplace: z12.object({
+    id: z12.string(),
+    name: z12.string().optional(),
+    settings: z12.record(z12.string(), z12.unknown()).optional()
   })
 });
-var InputMappingSchema = z11.record(z11.string(), z11.string());
-var EventConditionsSchema = z11.record(z11.string(), z11.string());
-var TriggerConfigSchema = z11.object({
-  id: z11.string(),
-  workflowId: z11.string(),
-  workflowVersionId: z11.string().optional(),
-  workplaceId: z11.string(),
-  handle: z11.string(),
+var InputMappingSchema = z12.record(z12.string(), z12.string());
+var EventConditionsSchema = z12.record(z12.string(), z12.string());
+var TriggerConfigSchema = z12.object({
+  id: z12.string(),
+  workflowId: z12.string(),
+  workflowVersionId: z12.string().optional(),
+  workplaceId: z12.string(),
+  handle: z12.string(),
   // Input mappings: how to resolve workflow inputs from thread context
   inputMappings: InputMappingSchema.optional(),
   // Event conditions: additional workplace-specific conditions
   eventConditions: EventConditionsSchema.optional(),
   // Workplace-specific config overrides
-  config: z11.record(z11.string(), z11.unknown()).optional(),
+  config: z12.record(z12.string(), z12.unknown()).optional(),
   // Trigger type and status
-  type: z11.string().optional(),
-  isEnabled: z11.boolean().optional()
+  type: z12.string().optional(),
+  isEnabled: z12.boolean().optional()
 });
-var ResolvedTriggerSchema = z11.object({
+var ResolvedTriggerSchema = z12.object({
   trigger: TriggerConfigSchema,
-  workflow: z11.object({
-    id: z11.string(),
-    handle: z11.string(),
-    name: z11.string().optional(),
-    inputs: z11.record(z11.string(), z11.unknown()).optional(),
-    events: z11.object({
-      subscribes: z11.array(EventTypeSchema).optional(),
-      condition: z11.string().optional()
+  workflow: z12.object({
+    id: z12.string(),
+    handle: z12.string(),
+    name: z12.string().optional(),
+    inputs: z12.record(z12.string(), z12.unknown()).optional(),
+    events: z12.object({
+      subscribes: z12.array(EventTypeSchema).optional(),
+      condition: z12.string().optional()
     }).optional()
   }),
-  inputs: z11.record(z11.string(), z11.unknown()),
+  inputs: z12.record(z12.string(), z12.unknown()),
   context: TriggerContextSchema
 });
 var TriggerResolutionError = class extends Error {
@@ -6181,13 +6376,13 @@ var TriggerResolutionError = class extends Error {
     this.name = "TriggerResolutionError";
   }
 };
-var WorkflowInputDefinitionSchema = z11.object({
-  type: z11.string(),
-  required: z11.boolean().optional(),
-  description: z11.string().optional(),
-  default: z11.unknown().optional()
+var WorkflowInputDefinitionSchema = z12.object({
+  type: z12.string(),
+  required: z12.boolean().optional(),
+  description: z12.string().optional(),
+  default: z12.unknown().optional()
 });
-var WorkflowInputSchemaSchema = z11.record(z11.string(), WorkflowInputDefinitionSchema);
+var WorkflowInputSchemaSchema = z12.record(z12.string(), WorkflowInputDefinitionSchema);
 
 // src/triggers/resolver.ts
 function evaluateTemplate(template, context) {
@@ -6269,67 +6464,67 @@ function matchesTrigger(trigger, eventType, context) {
 }
 
 // src/workflows/types.ts
-import { z as z12 } from "zod/v4";
+import { z as z13 } from "zod/v4";
 var WORKFLOW_SCHEMA_VERSION = "https://skedyul.com/schemas/workflow/v1";
-var WorkflowInputSchema = z12.object({
-  type: z12.string(),
-  required: z12.boolean().optional().default(false),
-  description: z12.string().optional(),
-  default: z12.unknown().optional()
-});
-var WorkflowStepInputSchema = z12.union([z12.string(), z12.number(), z12.boolean(), z12.record(z12.string(), z12.unknown())]);
-var WorkflowStepSchema = z12.object({
+var WorkflowInputSchema = z13.object({
+  type: z13.string(),
+  required: z13.boolean().optional().default(false),
+  description: z13.string().optional(),
+  default: z13.unknown().optional()
+});
+var WorkflowStepInputSchema = z13.union([z13.string(), z13.number(), z13.boolean(), z13.record(z13.string(), z13.unknown())]);
+var WorkflowStepSchema = z13.object({
   // Service and command
-  service: z12.string(),
-  cmd: z12.string(),
+  service: z13.string(),
+  cmd: z13.string(),
   // Dependencies
-  needs: z12.array(z12.string()).optional(),
+  needs: z13.array(z13.string()).optional(),
   // Inputs (Liquid templates supported)
-  inputs: z12.record(z12.string(), WorkflowStepInputSchema).optional(),
+  inputs: z13.record(z13.string(), WorkflowStepInputSchema).optional(),
   // Conditional execution
-  condition: z12.string().optional(),
+  condition: z13.string().optional(),
   // Retry configuration
-  retry: z12.object({
-    attempts: z12.number().optional(),
-    backoff: z12.enum(["linear", "exponential"]).optional()
+  retry: z13.object({
+    attempts: z13.number().optional(),
+    backoff: z13.enum(["linear", "exponential"]).optional()
   }).optional(),
   // Timeout
-  timeout: z12.string().optional()
-});
-var WorkflowRuntimeSchema = z12.object({
-  durable: z12.boolean().optional().default(true),
-  timeout: z12.string().optional(),
-  retry: z12.object({
-    attempts: z12.number().optional(),
-    backoff: z12.enum(["linear", "exponential"]).optional()
+  timeout: z13.string().optional()
+});
+var WorkflowRuntimeSchema = z13.object({
+  durable: z13.boolean().optional().default(true),
+  timeout: z13.string().optional(),
+  retry: z13.object({
+    attempts: z13.number().optional(),
+    backoff: z13.enum(["linear", "exponential"]).optional()
   }).optional()
 });
-var WorkflowYAMLSchema = z12.object({
+var WorkflowYAMLSchema = z13.object({
   // Schema version
-  $schema: z12.string().optional(),
+  $schema: z13.string().optional(),
   // Identity
-  handle: z12.string(),
-  name: z12.string(),
-  version: z12.string().optional(),
-  description: z12.string().optional(),
+  handle: z13.string(),
+  name: z13.string(),
+  version: z13.string().optional(),
+  description: z13.string().optional(),
   // Inputs this workflow needs (portable, declared in YAML)
-  inputs: z12.record(z12.string(), WorkflowInputSchema).optional(),
+  inputs: z13.record(z13.string(), WorkflowInputSchema).optional(),
   // Event subscriptions and conditions
   events: EventsConfigSchema.optional(),
   // Deterministic steps
-  steps: z12.record(z12.string(), WorkflowStepSchema),
+  steps: z13.record(z13.string(), WorkflowStepSchema),
   // Runtime configuration
   runtime: WorkflowRuntimeSchema.optional()
 });
-var WorkflowMetadataSchema = z12.object({
-  handle: z12.string(),
-  name: z12.string(),
-  version: z12.string().optional(),
-  description: z12.string().optional(),
-  inputs: z12.record(z12.string(), WorkflowInputDefinitionSchema).optional(),
+var WorkflowMetadataSchema = z13.object({
+  handle: z13.string(),
+  name: z13.string(),
+  version: z13.string().optional(),
+  description: z13.string().optional(),
+  inputs: z13.record(z13.string(), WorkflowInputDefinitionSchema).optional(),
   events: EventsConfigSchema.optional()
 });
-var WorkflowExecutionStatusSchema = z12.enum([
+var WorkflowExecutionStatusSchema = z13.enum([
   "PENDING",
   "RUNNING",
   "COMPLETED",
@@ -6337,14 +6532,14 @@ var WorkflowExecutionStatusSchema = z12.enum([
   "CANCELLED",
   "WAITING"
 ]);
-var WorkflowExecutionResultSchema = z12.object({
+var WorkflowExecutionResultSchema = z13.object({
   status: WorkflowExecutionStatusSchema,
-  outputs: z12.record(z12.string(), z12.unknown()).optional(),
-  error: z12.string().optional(),
-  startedAt: z12.string().datetime().optional(),
-  completedAt: z12.string().datetime().optional(),
-  cancelledAt: z12.string().datetime().optional(),
-  cancelReason: z12.string().optional()
+  outputs: z13.record(z13.string(), z13.unknown()).optional(),
+  error: z13.string().optional(),
+  startedAt: z13.string().datetime().optional(),
+  completedAt: z13.string().datetime().optional(),
+  cancelledAt: z13.string().datetime().optional(),
+  cancelReason: z13.string().optional()
 });
 function defineWorkflowYAML(workflow) {
   return WorkflowYAMLSchema.parse(workflow);
@@ -6422,8 +6617,8 @@ function getAssociationByModel(context, model) {
 }
 
 // src/memory/types.ts
-import { z as z13 } from "zod/v4";
-var MemoryEntryTypeSchema = z13.enum([
+import { z as z14 } from "zod/v4";
+var MemoryEntryTypeSchema = z14.enum([
   "WORKING",
   // Current conversation context
   "OBSERVATION",
@@ -6433,80 +6628,80 @@ var MemoryEntryTypeSchema = z13.enum([
   "SEMANTIC"
   // Semantic memory for retrieval
 ]);
-var MemoryEntrySchema = z13.object({
-  id: z13.string(),
+var MemoryEntrySchema = z14.object({
+  id: z14.string(),
   type: MemoryEntryTypeSchema,
-  key: z13.string(),
-  value: z13.unknown(),
-  metadata: z13.record(z13.string(), z13.unknown()).optional(),
-  expiresAt: z13.string().datetime().optional(),
-  createdAt: z13.string().datetime(),
-  updatedAt: z13.string().datetime()
-});
-var WorkingMemoryConfigSchema2 = z13.object({
-  strategy: z13.enum(["full", "rolling_summary", "sliding_window"]).default("rolling_summary"),
-  maxTokens: z13.number().default(8e3),
-  summarizeAt: z13.number().optional(),
-  ttl: z13.string().optional()
-});
-var SemanticMemoryConfigSchema2 = z13.object({
-  enabled: z13.boolean().default(false),
-  topK: z13.number().default(5),
-  scope: z13.enum(["thread", "instance", "workspace"]).default("thread"),
-  minScore: z13.number().default(0.7)
-});
-var ExternalMemoryConfigSchema2 = z13.object({
-  namespace: z13.string(),
-  ttl: z13.string().optional()
-});
-var MemoryConfigSchema = z13.object({
+  key: z14.string(),
+  value: z14.unknown(),
+  metadata: z14.record(z14.string(), z14.unknown()).optional(),
+  expiresAt: z14.string().datetime().optional(),
+  createdAt: z14.string().datetime(),
+  updatedAt: z14.string().datetime()
+});
+var WorkingMemoryConfigSchema2 = z14.object({
+  strategy: z14.enum(["full", "rolling_summary", "sliding_window"]).default("rolling_summary"),
+  maxTokens: z14.number().default(8e3),
+  summarizeAt: z14.number().optional(),
+  ttl: z14.string().optional()
+});
+var SemanticMemoryConfigSchema2 = z14.object({
+  enabled: z14.boolean().default(false),
+  topK: z14.number().default(5),
+  scope: z14.enum(["thread", "instance", "workspace"]).default("thread"),
+  minScore: z14.number().default(0.7)
+});
+var ExternalMemoryConfigSchema2 = z14.object({
+  namespace: z14.string(),
+  ttl: z14.string().optional()
+});
+var MemoryConfigSchema = z14.object({
   working: WorkingMemoryConfigSchema2.optional(),
   semantic: SemanticMemoryConfigSchema2.optional(),
   external: ExternalMemoryConfigSchema2.optional(),
-  persistent: z13.object({
-    namespace: z13.string()
+  persistent: z14.object({
+    namespace: z14.string()
   }).optional()
 });
-var MemoryScopeSchema = z13.object({
-  threadId: z13.string().optional(),
-  participantId: z13.string().optional(),
-  agentId: z13.string().optional(),
-  workplaceId: z13.string().optional(),
-  namespace: z13.string().optional()
-});
-var MemoryQueryOptionsSchema = z13.object({
-  types: z13.array(MemoryEntryTypeSchema).optional(),
-  keys: z13.array(z13.string()).optional(),
-  limit: z13.number().default(100),
-  includeExpired: z13.boolean().default(false)
-});
-var ConversationSummarySchema = z13.object({
-  summary: z13.string(),
-  keyPoints: z13.array(z13.string()),
-  entities: z13.array(z13.object({
-    name: z13.string(),
-    type: z13.string(),
-    relevance: z13.number()
+var MemoryScopeSchema = z14.object({
+  threadId: z14.string().optional(),
+  participantId: z14.string().optional(),
+  agentId: z14.string().optional(),
+  workplaceId: z14.string().optional(),
+  namespace: z14.string().optional()
+});
+var MemoryQueryOptionsSchema = z14.object({
+  types: z14.array(MemoryEntryTypeSchema).optional(),
+  keys: z14.array(z14.string()).optional(),
+  limit: z14.number().default(100),
+  includeExpired: z14.boolean().default(false)
+});
+var ConversationSummarySchema = z14.object({
+  summary: z14.string(),
+  keyPoints: z14.array(z14.string()),
+  entities: z14.array(z14.object({
+    name: z14.string(),
+    type: z14.string(),
+    relevance: z14.number()
   })),
-  lastMessageId: z13.string().optional(),
-  messageCount: z13.number(),
-  tokenCount: z13.number(),
-  createdAt: z13.string().datetime()
-});
-var AgentObservationSchema = z13.object({
-  observation: z13.string(),
-  confidence: z13.number().min(0).max(1),
-  source: z13.enum(["inference", "explicit", "tool_result"]),
-  context: z13.record(z13.string(), z13.unknown()).optional(),
-  createdAt: z13.string().datetime()
-});
-var ExternalDataCacheSchema = z13.object({
-  source: z13.string(),
-  endpoint: z13.string().optional(),
-  data: z13.unknown(),
-  fetchedAt: z13.string().datetime(),
-  expiresAt: z13.string().datetime().optional(),
-  metadata: z13.record(z13.string(), z13.unknown()).optional()
+  lastMessageId: z14.string().optional(),
+  messageCount: z14.number(),
+  tokenCount: z14.number(),
+  createdAt: z14.string().datetime()
+});
+var AgentObservationSchema = z14.object({
+  observation: z14.string(),
+  confidence: z14.number().min(0).max(1),
+  source: z14.enum(["inference", "explicit", "tool_result"]),
+  context: z14.record(z14.string(), z14.unknown()).optional(),
+  createdAt: z14.string().datetime()
+});
+var ExternalDataCacheSchema = z14.object({
+  source: z14.string(),
+  endpoint: z14.string().optional(),
+  data: z14.unknown(),
+  fetchedAt: z14.string().datetime(),
+  expiresAt: z14.string().datetime().optional(),
+  metadata: z14.record(z14.string(), z14.unknown()).optional()
 });
 
 // src/memory/service.ts
@@ -7097,16 +7292,16 @@ function estimateTokens(agent, skills) {
 }
 
 // src/scheduling/types.ts
-import { z as z14 } from "zod/v4";
-var TimeStampSchema = z14.union([
-  z14.number().describe("Hour of day (0-23)"),
-  z14.object({
-    hour: z14.number(),
-    minute: z14.number().optional().default(0),
-    second: z14.number().optional().default(0)
+import { z as z15 } from "zod/v4";
+var TimeStampSchema = z15.union([
+  z15.number().describe("Hour of day (0-23)"),
+  z15.object({
+    hour: z15.number(),
+    minute: z15.number().optional().default(0),
+    second: z15.number().optional().default(0)
   })
 ]);
-var DayOfWeekSchema = z14.enum([
+var DayOfWeekSchema = z15.enum([
   "monday",
   "tuesday",
   "wednesday",
@@ -7115,13 +7310,13 @@ var DayOfWeekSchema = z14.enum([
   "saturday",
   "sunday"
 ]);
-var TimeWindowSlotSchema = z14.object({
+var TimeWindowSlotSchema = z15.object({
   startTime: TimeStampSchema,
   endTime: TimeStampSchema,
-  days: z14.array(DayOfWeekSchema),
-  timezone: z14.string().optional()
+  days: z15.array(DayOfWeekSchema),
+  timezone: z15.string().optional()
 });
-var WaitUnitSchema = z14.enum([
+var WaitUnitSchema = z15.enum([
   "second",
   "seconds",
   "minute",
@@ -7137,17 +7332,17 @@ var WaitUnitSchema = z14.enum([
   "year",
   "years"
 ]);
-var WaitInputRelativeSchema = z14.object({
-  mode: z14.literal("relative"),
-  amount: z14.number(),
+var WaitInputRelativeSchema = z15.object({
+  mode: z15.literal("relative"),
+  amount: z15.number(),
   unit: WaitUnitSchema,
-  windows: z14.array(TimeWindowSlotSchema).optional()
+  windows: z15.array(TimeWindowSlotSchema).optional()
 });
-var WaitInputAbsoluteSchema = z14.object({
-  mode: z14.literal("absolute"),
-  scheduleAt: z14.union([z14.string(), z14.number()])
+var WaitInputAbsoluteSchema = z15.object({
+  mode: z15.literal("absolute"),
+  scheduleAt: z15.union([z15.string(), z15.number()])
 });
-var WaitInputSchema = z14.union([
+var WaitInputSchema = z15.union([
   WaitInputRelativeSchema,
   WaitInputAbsoluteSchema
 ]);
@@ -7457,8 +7652,62 @@ function isTimeInPolicy(date, policy) {
   return false;
 }
 
+// src/tools/sms/gsm7.ts
+var GSM7_BASIC = `@\xA3$\xA5\xE8\xE9\xF9\xEC\xF2\xC7
+\xD8\xF8\r\xC5\xE5\u0394_\u03A6\u0393\u039B\u03A9\u03A0\u03A8\u03A3\u0398\u039E\xC6\xE6\xDF\xC9 !"#\xA4%&'()*+,-./0123456789:;<=>?\xA1ABCDEFGHIJKLMNOPQRSTUVWXYZ\xC4\xD6\xD1\xDC\xA7\xBFabcdefghijklmnopqrstuvwxyz\xE4\xF6\xF1\xFC\xE0`;
+var GSM7_EXTENDED = "^{}\\[~]|\u20AC";
+var GSM7_BASIC_SET = new Set(GSM7_BASIC.split(""));
+var GSM7_EXTENDED_SET = new Set(GSM7_EXTENDED.split(""));
+function toGsm7(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  const str = String(value);
+  let result = "";
+  for (const char of str) {
+    if (GSM7_BASIC_SET.has(char) || GSM7_EXTENDED_SET.has(char)) {
+      result += char;
+    }
+  }
+  return result;
+}
+function isGsm7Character(char) {
+  return GSM7_BASIC_SET.has(char) || GSM7_EXTENDED_SET.has(char);
+}
+function countGsm7Septets(text) {
+  let septets = 0;
+  for (const char of text) {
+    septets += GSM7_EXTENDED_SET.has(char) ? 2 : 1;
+  }
+  return septets;
+}
+function estimateSmsSegments(text) {
+  const normalized = text ?? "";
+  const characters = [...normalized].length;
+  if (characters === 0) {
+    return { encoding: "GSM-7", characters: 0, septets: 0, segments: 0 };
+  }
+  const isGsm7 = [...normalized].every(isGsm7Character);
+  if (isGsm7) {
+    const septets = countGsm7Septets(normalized);
+    const segments2 = septets <= 160 ? 1 : Math.ceil(septets / 153);
+    return {
+      encoding: "GSM-7",
+      characters,
+      septets,
+      segments: segments2
+    };
+  }
+  const segments = characters <= 70 ? 1 : Math.ceil(characters / 67);
+  return {
+    encoding: "UCS-2",
+    characters,
+    segments
+  };
+}
+
 // src/index.ts
-var src_default = { z: z15 };
+var src_default = { z: z16 };
 export {
   AgentContextSchema,
   AgentDefinitionSchema,
@@ -7488,6 +7737,7 @@ export {
   CRMSchemaZ,
   CardBlockDefinitionSchema,
   CardBlockHeaderSchema,
+  ChannelBatchCapabilitySchema,
   ChannelCapabilitySchema,
   ChannelCapabilityTypeSchema,
   ChannelDefinitionSchema,
@@ -7514,6 +7764,8 @@ export {
   EnvSchemaSchema,
   EnvVariableDefinitionSchema,
   EnvVisibilitySchema,
+  EstimationSchema,
+  EstimationSkippedBreakdownSchema,
   EventConditionsSchema,
   EventSubscriptionSchema,
   EventTypeSchema,
@@ -7555,6 +7807,13 @@ export {
   MemoryQueryOptionsSchema,
   MemoryScopeSchema,
   MemoryService,
+  MessageBulkRecipientSchema,
+  MessageBulkSendInputSchema,
+  MessageBulkSendOutputSchema,
+  MessageBulkStatusInputSchema,
+  MessageBulkStatusMessageSchema,
+  MessageBulkStatusOutputSchema,
+  MessageBulkStatusStatsSchema,
   MessageEventPayloadSchema,
   MessageSendAttachmentSchema,
   MessageSendChannelSchema,
@@ -7573,6 +7832,7 @@ export {
   ModelDependencySchema,
   ModelFieldDefinitionSchema,
   ModelMapperBlockDefinitionSchema,
+  MoneyMinorRangeSchema,
   NavigationBreadcrumbSchema,
   NavigationConfigSchema,
   NavigationItemSchema,
@@ -7676,15 +7936,18 @@ export {
   communicationChannel,
   compileAgent,
   compileWorkflow,
+  computeSkewedExpectedMinorUnits,
   configure,
   createAuthError,
   createConflictError,
   createContextLogger,
   createErrorResponse,
+  createEstimation,
   createExternalError,
   createInMemoryService,
   createInstanceClient,
   createListResponse,
+  createMoneyMinorRange,
   createNotFoundError,
   createPermissionError,
   createQueueHandle,
@@ -7710,11 +7973,14 @@ export {
   defineSkill,
   defineWorkflow,
   defineWorkflowYAML,
+  estimateSmsSegments,
   evaluateCondition,
   evaluateTemplate,
   event,
   file,
   formatContextForPrompt,
+  formatMoneyMinorEstimate,
+  formatMoneyMinorRange,
   formatSkillInstructions,
   getAllEnvKeys,
   getAssociationByModel,
@@ -7740,6 +8006,7 @@ export {
   isWorkflowDependency,
   matchesTrigger,
   parseCRMSchema,
+  parseEstimationFromBilling,
   queuedFetch,
   queuedFetchResponse,
   registerQueueConfig,
@@ -7753,11 +8020,12 @@ export {
   safeParseCRMSchema,
   safeParseConfig,
   server,
+  toGsm7,
   token,
   validateCRMSchema,
   validateSkillYAML,
   validateWorkflowYAML,
   webhook,
   workplace,
-  z15 as z
+  z16 as z
 };