@kadoa/mcp 0.7.0-rc.1 → 0.7.0

package/dist/index.js

@@ -17,7 +17,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@kadoa/mcp",
-    version: "0.7.0-rc.1",
+    version: "0.7.0",
     description: "Kadoa MCP Server — manage workflows from Claude Desktop, Cursor, and other MCP clients",
     type: "module",
     main: "dist/index.js",
@@ -104,6 +104,11 @@ function createKadoaClient(auth) {
 var MCP_SCRAPE_REQUEST_TIMEOUT_MS = 310000;
 var init_client = () => {};
 
+// src/default-product.ts
+function parseDefaultProductType(value) {
+  return value === "realtime" || value === "workflow" ? value : undefined;
+}
+
 // src/error-summary.ts
 function redactCredentialText(value) {
   return value.replace(/Bearer\s+[^\s,;]+/gi, "Bearer [redacted]").replace(/\b(?:kcs_|tk-)[A-Za-z0-9._~-]+\b/g, "[redacted]").replace(/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g, "[redacted]");
@@ -207,19 +212,252 @@ function withVariableDashboardUrl(variable) {
   return { ...variable, dashboardUrl: variableSettingsDashboardUrl() };
 }
 
+// src/tools/shared/output-schemas.ts
+import { z } from "zod";
+var apiField, nullableString, PaginationOutput, WorkflowRowOutput, ListWorkflowsOutput, GetWorkflowOutput, FetchDataOutput, ASSISTANT_ACTIVITIES, WorkflowAssistantOutput, AssistantTimelineOutput, AssistantAnswerOutput, AssistantControlOutput, WorkflowStrategyOutput;
+var init_output_schemas = __esm(() => {
+  apiField = z.unknown().optional();
+  nullableString = z.string().nullable();
+  PaginationOutput = z.object({
+    totalCount: z.number().optional(),
+    hasMore: z.boolean(),
+    limit: z.number().optional(),
+    skip: z.number().optional(),
+    offset: z.number().optional(),
+    page: z.number().optional(),
+    totalPages: z.number().optional(),
+    nextCursor: nullableString.optional(),
+    next: z.record(z.string(), z.unknown()).optional()
+  }).loose();
+  WorkflowRowOutput = z.object({
+    id: apiField,
+    name: apiField,
+    dashboardUrl: z.string(),
+    status: z.string(),
+    state: nullableString,
+    displayState: nullableString,
+    runState: nullableString,
+    urls: apiField,
+    totalRecords: apiField,
+    startedAt: apiField,
+    finishedAt: apiField,
+    createdAt: apiField,
+    assistant: z.object({
+      eligible: z.boolean(),
+      dataStale: z.boolean(),
+      session: z.object({ id: z.string(), threadId: apiField, status: apiField }).loose().nullable()
+    }).loose(),
+    template: z.object({ id: z.string(), pinnedVersion: apiField, latestVersion: apiField, isOutdated: z.boolean() }).loose().nullable(),
+    realtime: z.object({ enabled: z.boolean(), lastDataChangedAt: apiField, health: apiField }).loose(),
+    awaitingUserInput: apiField
+  }).loose();
+  ListWorkflowsOutput = z.object({ workflows: z.array(WorkflowRowOutput), pagination: PaginationOutput }).loose();
+  GetWorkflowOutput = z.object({
+    id: z.string(),
+    name: apiField,
+    dashboardUrl: z.string(),
+    description: apiField,
+    status: z.string(),
+    state: nullableString,
+    displayState: nullableString,
+    runState: nullableString,
+    urls: apiField,
+    prompt: nullableString,
+    intentSource: z.enum(["extraction_spec", "legacy_prompt"]).nullable(),
+    extractionSpec: apiField,
+    entity: apiField,
+    schema: apiField,
+    navigationMode: apiField,
+    dataStale: apiField,
+    assistantEligible: z.boolean(),
+    assistantSessionId: apiField,
+    assistantThreadId: apiField,
+    assistantSessionStatus: apiField,
+    assistant: z.object({ eligible: z.boolean(), sessionId: apiField, threadId: apiField, sessionStatus: apiField }).loose(),
+    template: z.object({
+      id: apiField,
+      name: apiField,
+      version: apiField,
+      controlledParts: z.array(z.string()),
+      hasSchemaValidationRules: apiField
+    }).loose().nullable(),
+    updateInterval: apiField,
+    schedules: apiField,
+    scheduleTimezone: apiField,
+    nextInvocation: apiField,
+    location: apiField,
+    limit: apiField,
+    tags: apiField,
+    totalRecords: apiField,
+    job: z.object({ id: apiField }).loose().nullable(),
+    startedAt: apiField,
+    finishedAt: apiField,
+    estimatedFinishedAtUtc: apiField,
+    errors: apiField,
+    createdAt: apiField,
+    notificationConfig: apiField,
+    channelCounts: apiField,
+    dataValidation: apiField,
+    validationStatistics: apiField,
+    realtime: z.object({ lastDataChangedAt: apiField, observerHealth: apiField }).loose().nullable()
+  }).loose();
+  FetchDataOutput = z.object({
+    data: z.array(z.record(z.string(), z.unknown())),
+    pagination: PaginationOutput,
+    totalCount: z.number().optional(),
+    hint: z.string().optional()
+  }).loose();
+  ASSISTANT_ACTIVITIES = [
+    "unsupported",
+    "not_started",
+    "working",
+    "waiting_for_input",
+    "idle",
+    "interrupted",
+    "failed",
+    "closed",
+    "unknown"
+  ];
+  WorkflowAssistantOutput = z.object({
+    workflowId: z.string(),
+    assistantEligible: z.boolean(),
+    sessionId: nullableString,
+    threadId: apiField,
+    sessionStatus: apiField,
+    activity: z.enum(ASSISTANT_ACTIVITIES),
+    canAcceptUpdate: z.boolean(),
+    isTerminal: z.boolean(),
+    paused: apiField,
+    pause: apiField,
+    pendingQuestion: apiField
+  }).loose();
+  AssistantTimelineOutput = z.object({
+    workflowId: z.string(),
+    sessionId: apiField,
+    items: z.array(z.unknown()),
+    pagination: PaginationOutput,
+    dashboardUrl: z.string()
+  }).loose();
+  AssistantAnswerOutput = z.object({
+    success: z.literal(true),
+    workflowId: z.string(),
+    sessionId: z.string(),
+    threadId: apiField,
+    questionId: z.string(),
+    message: z.string()
+  }).loose();
+  AssistantControlOutput = z.object({
+    success: z.boolean(),
+    status: z.literal("accepted"),
+    action: z.enum(["interrupt", "resume", "stop"]),
+    workflowId: z.string(),
+    sessionId: z.string(),
+    delivery: apiField,
+    jobId: apiField,
+    message: z.string()
+  }).loose();
+  WorkflowStrategyOutput = z.object({
+    workflowId: z.string(),
+    sessionId: nullableString,
+    source: z.enum(["assistant_build", "workflow_metadata"]).nullable(),
+    status: z.enum(["ready", "building", "unavailable"]),
+    strategy: apiField,
+    message: z.string().optional()
+  }).loose();
+});
+
+// src/tools/shared/pagination.ts
+import { z as z2 } from "zod";
+function limitInput(options) {
+  const range = `limit must be a whole number from 1 to ${options.max}`;
+  const overMax = `${range}. ${options.overMaxHint ?? "Page with pagination.next."}`;
+  return z2.preprocess(coerceNumber(), z2.number().int(range).min(1, range).max(options.max, overMax)).optional().describe(`${options.noun} per page, 1-${options.max} (default ${options.defaultLimit})`);
+}
+function offsetInput(param, noun) {
+  const range = `${param} must be a whole number from 0 to ${MAX_OFFSET}`;
+  return z2.preprocess(coerceNumber(), z2.number().int(range).min(0, range).max(MAX_OFFSET, range)).optional().describe(`Number of ${noun} to skip (default 0)`);
+}
+function pageInput() {
+  const range = `page must be a whole number from 1 to ${MAX_PAGE}`;
+  return z2.preprocess(coerceNumber(), z2.number().int(range).min(1, range).max(MAX_PAGE, range)).optional().describe("Page number, 1-based (default 1)");
+}
+function nextArgs(args, patch) {
+  const next = {};
+  for (const [key, value] of Object.entries({ ...args, ...patch })) {
+    if (value !== undefined)
+      next[key] = value;
+  }
+  return next;
+}
+function withTotal(totalCount, hasMore) {
+  return totalCount !== undefined ? { totalCount, hasMore } : { hasMore };
+}
+function offsetPage(options) {
+  const nextOffset = options.offset + options.returned;
+  const more = options.hasMore ?? (options.totalCount !== undefined ? nextOffset < options.totalCount : options.returned >= options.limit);
+  const hasMore = options.returned > 0 && more;
+  const meta = withTotal(options.totalCount, hasMore);
+  meta.limit = options.limit;
+  meta[options.param] = options.offset;
+  if (hasMore)
+    meta.next = nextArgs(options.args, { [options.param]: nextOffset, limit: options.limit });
+  return meta;
+}
+function numberedPage(options) {
+  const more = options.totalPages !== undefined ? options.page < options.totalPages : options.totalCount !== undefined ? options.page * options.limit < options.totalCount : options.returned >= options.limit;
+  const hasMore = options.returned > 0 && more;
+  const meta = withTotal(options.totalCount, hasMore);
+  meta.limit = options.limit;
+  meta.page = options.page;
+  if (options.totalPages !== undefined)
+    meta.totalPages = options.totalPages;
+  if (hasMore)
+    meta.next = nextArgs(options.args, { page: options.page + 1, limit: options.limit });
+  return meta;
+}
+function cursorPage(options) {
+  const cursor = typeof options.nextCursor === "string" && options.nextCursor.length > 0 ? options.nextCursor : null;
+  const meta = { hasMore: options.hasMore && cursor !== null, nextCursor: cursor };
+  if (meta.hasMore)
+    meta.next = nextArgs(options.args, { cursor });
+  return meta;
+}
+function completeList(totalCount) {
+  return { totalCount, hasMore: false };
+}
+var MAX_OFFSET = 1e6, MAX_PAGE = 1e5;
+var init_pagination = () => {};
+
 // src/tools/shared/results.ts
+function asStructuredObject(data) {
+  return data !== null && !Array.isArray(data) ? data : { result: data };
+}
+function structuredResult(data, extra = []) {
+  const structuredContent = asStructuredObject(data);
+  return {
+    structuredContent,
+    content: [{ type: "text", text: JSON.stringify(structuredContent) }, ...extra]
+  };
+}
 function jsonResult(data) {
-  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+  return structuredResult(data);
+}
+function textOnlyResult(data, extra = []) {
+  const structuredContent = asStructuredObject(data);
+  return { content: [{ type: "text", text: JSON.stringify(structuredContent) }, ...extra] };
 }
-function errorResult(message) {
+function errorResult(message, details = {}) {
   return {
-    content: [{ type: "text", text: JSON.stringify({ error: message }, null, 2) }],
+    content: [{ type: "text", text: JSON.stringify({ error: message, ...details }) }],
     isError: true
   };
 }
+function withExtraContent(result, ...blocks) {
+  return { ...result, content: [...result.content, ...blocks] };
+}
 
 // src/tools/shared/schemas.ts
-import { z } from "zod";
+import { z as z3 } from "zod";
 function isPlainObject(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -281,7 +519,7 @@ function stampSchemaValidationRules(rules, attribution, previous) {
   return Object.fromEntries(Object.entries(rules).map(([name, field]) => [name, stampField(field, previousFields[name])]));
 }
 function strictSchema(shape) {
-  return z.object(shape).strict();
+  return z3.object(shape).strict();
 }
 function withoutDefIds(schema) {
   const jsonSchema = schema["~standard"].jsonSchema;
@@ -317,7 +555,7 @@ function normalizeDataFilters(val, ctx) {
         code: "custom",
         message: "Grouped filters ({logicalOperator, conditions}) are not supported. Send a flat array of " + "{field, operator, value} filters instead; multiple filters are combined with OR."
       });
-      return z.NEVER;
+      return z3.NEVER;
     }
     return [v];
   }
@@ -325,7 +563,7 @@ function normalizeDataFilters(val, ctx) {
 }
 var UpdateIntervalSchema, NOTIFICATION_EVENT_TYPES, NotificationEventTypeSchema, SchemaFieldDataTypeSchema, SchemaFieldShape, SchemaValidationPresenceRule, SchemaValidationUniquenessRule, SchemaValidationBoundRule, SchemaValidationStringFormatRule, SchemaValidationFieldRulesSchema, SchemaValidationRulesSchema, SCHEMA_VALIDATION_ATTRIBUTION_KEYS, LocationSchema, MonitoringValueOperators, MonitoringValuelessOperators, MonitoringConditionOperatorSchema, MonitoringConditionSchema, MonitoringSchema, urlInputShape, extractionPromptInput, extractionInputShape, webhookAuthShape, notificationChannelsSchema, notificationsInputShape, requiredNotificationsInputShape, DATA_FILTER_OPERATORS, DATA_FILTER_VALUELESS_OPERATORS, DATA_FILTER_LIST_OPERATORS, DataFilterSchema, dataFiltersInput;
 var init_schemas = __esm(() => {
-  UpdateIntervalSchema = z.enum([
+  UpdateIntervalSchema = z3.enum([
     "ONLY_ONCE",
     "EVERY_10_MINUTES",
     "HALF_HOURLY",
@@ -359,8 +597,8 @@ var init_schemas = __esm(() => {
     "credits_low",
     "free_trial_ending"
   ];
-  NotificationEventTypeSchema = z.enum(NOTIFICATION_EVENT_TYPES);
-  SchemaFieldDataTypeSchema = z.enum([
+  NotificationEventTypeSchema = z3.enum(NOTIFICATION_EVENT_TYPES);
+  SchemaFieldDataTypeSchema = z3.enum([
     "STRING",
     "NUMBER",
     "BOOLEAN",
@@ -373,61 +611,61 @@ var init_schemas = __esm(() => {
     "ARRAY"
   ]);
   SchemaFieldShape = {
-    name: z.string().describe("Field name"),
-    description: z.string().optional().describe("What this field contains"),
-    example: z.string().describe("Example value"),
+    name: z3.string().describe("Field name"),
+    description: z3.string().optional().describe("What this field contains"),
+    example: z3.string().describe("Example value"),
     dataType: SchemaFieldDataTypeSchema.optional().describe("Data type for the field"),
-    isKey: z.preprocess(coerceBoolean(), z.boolean()).optional().describe("Marks this field as a key field - the stable identity used to match records across runs. Change detection diffs records by their key fields, so a monitored or real-time workflow without one cannot tell an updated record from a new one. Set it on whatever uniquely identifies a row (a detail URL, an ID, a ticker).")
+    isKey: z3.preprocess(coerceBoolean(), z3.boolean()).optional().describe("Marks this field as a key field - the stable identity used to match records across runs. Change detection diffs records by their key fields, so a monitored or real-time workflow without one cannot tell an updated record from a new one. Set it on whatever uniquely identifies a row (a detail URL, an ID, a ticker).")
   };
-  SchemaValidationPresenceRule = z.object({
-    target: z.number().int().min(0).max(100).step(20).describe("Expected percentage of rows with a value")
+  SchemaValidationPresenceRule = z3.object({
+    target: z3.number().int().min(0).max(100).step(20).describe("Expected percentage of rows with a value")
   }).strict().meta({ id: "PresenceRule" });
-  SchemaValidationUniquenessRule = z.object({
-    target: z.number().int().min(0).max(100).step(20).describe("Expected percentage of rows with a unique value")
+  SchemaValidationUniquenessRule = z3.object({
+    target: z3.number().int().min(0).max(100).step(20).describe("Expected percentage of rows with a unique value")
   }).strict().meta({ id: "UniquenessRule" });
-  SchemaValidationBoundRule = z.object({
-    value: z.number().int().min(0).describe("Length or count bound")
+  SchemaValidationBoundRule = z3.object({
+    value: z3.number().int().min(0).describe("Length or count bound")
   }).strict().meta({ id: "BoundRule" });
-  SchemaValidationStringFormatRule = z.discriminatedUnion("kind", [
-    z.object({
-      kind: z.literal("FREE_TEXT"),
-      charset: z.discriminatedUnion("kind", [
-        z.object({
-          kind: z.literal("PRESET"),
-          preset: z.enum(["natural_language", "alphanumeric", "alpha"])
+  SchemaValidationStringFormatRule = z3.discriminatedUnion("kind", [
+    z3.object({
+      kind: z3.literal("FREE_TEXT"),
+      charset: z3.discriminatedUnion("kind", [
+        z3.object({
+          kind: z3.literal("PRESET"),
+          preset: z3.enum(["natural_language", "alphanumeric", "alpha"])
         }).strict()
       ])
     }).strict(),
-    z.object({
-      kind: z.literal("FORMAT"),
-      source: z.discriminatedUnion("kind", [
-        z.object({
-          kind: z.literal("PRESET"),
-          preset: z.enum(["url", "email", "phone", "date", "datetime", "time", "uuid", "slug"])
+    z3.object({
+      kind: z3.literal("FORMAT"),
+      source: z3.discriminatedUnion("kind", [
+        z3.object({
+          kind: z3.literal("PRESET"),
+          preset: z3.enum(["url", "email", "phone", "date", "datetime", "time", "uuid", "slug"])
         }).strict(),
-        z.object({
-          kind: z.literal("CUSTOM"),
-          pattern: z.string().min(1).describe("Regular expression pattern")
+        z3.object({
+          kind: z3.literal("CUSTOM"),
+          pattern: z3.string().min(1).describe("Regular expression pattern")
         }).strict()
       ])
     }).strict(),
-    z.object({
-      kind: z.literal("LIST"),
-      source: z.discriminatedUnion("kind", [
-        z.object({
-          kind: z.literal("PRESET"),
-          preset: z.enum(["language2", "country2", "country3", "currency3", "month3", "usState2"])
+    z3.object({
+      kind: z3.literal("LIST"),
+      source: z3.discriminatedUnion("kind", [
+        z3.object({
+          kind: z3.literal("PRESET"),
+          preset: z3.enum(["language2", "country2", "country3", "currency3", "month3", "usState2"])
         }).strict(),
-        z.object({
-          kind: z.literal("CUSTOM"),
-          values: z.array(z.string().min(1)).min(1).describe("Allowed string values")
+        z3.object({
+          kind: z3.literal("CUSTOM"),
+          values: z3.array(z3.string().min(1)).min(1).describe("Allowed string values")
         }).strict()
       ])
     }).strict()
   ]);
-  SchemaValidationFieldRulesSchema = z.lazy(() => z.discriminatedUnion("kind", [
-    z.object({
-      kind: z.literal("STRING"),
+  SchemaValidationFieldRulesSchema = z3.lazy(() => z3.discriminatedUnion("kind", [
+    z3.object({
+      kind: z3.literal("STRING"),
       presence: SchemaValidationPresenceRule.optional(),
       uniqueness: SchemaValidationUniquenessRule.optional(),
       minLength: SchemaValidationBoundRule.optional(),
@@ -436,27 +674,27 @@ var init_schemas = __esm(() => {
       maxHtmlElements: SchemaValidationBoundRule.optional(),
       format: SchemaValidationStringFormatRule.optional()
     }).strict(),
-    z.object({
-      kind: z.literal("NUMBER"),
+    z3.object({
+      kind: z3.literal("NUMBER"),
       presence: SchemaValidationPresenceRule.optional(),
       uniqueness: SchemaValidationUniquenessRule.optional(),
-      minimum: z.object({ value: z.number().describe("Minimum numeric value") }).strict().optional(),
-      maximum: z.object({ value: z.number().describe("Maximum numeric value") }).strict().optional(),
-      maxDecimalPlaces: z.object({ value: z.number().int().min(0).max(16) }).strict().optional()
+      minimum: z3.object({ value: z3.number().describe("Minimum numeric value") }).strict().optional(),
+      maximum: z3.object({ value: z3.number().describe("Maximum numeric value") }).strict().optional(),
+      maxDecimalPlaces: z3.object({ value: z3.number().int().min(0).max(16) }).strict().optional()
     }).strict(),
-    z.object({
-      kind: z.literal("OTHER"),
+    z3.object({
+      kind: z3.literal("OTHER"),
       presence: SchemaValidationPresenceRule.optional(),
       uniqueness: SchemaValidationUniquenessRule.optional()
     }).strict(),
-    z.object({
-      kind: z.literal("OBJECT"),
+    z3.object({
+      kind: z3.literal("OBJECT"),
       presence: SchemaValidationPresenceRule.optional(),
       uniqueness: SchemaValidationUniquenessRule.optional(),
-      properties: z.record(z.string(), SchemaValidationFieldRulesSchema)
+      properties: z3.record(z3.string(), SchemaValidationFieldRulesSchema)
     }).strict(),
-    z.object({
-      kind: z.literal("ARRAY"),
+    z3.object({
+      kind: z3.literal("ARRAY"),
       presence: SchemaValidationPresenceRule.optional(),
       uniqueness: SchemaValidationUniquenessRule.optional(),
       minItems: SchemaValidationBoundRule.optional(),
@@ -464,21 +702,21 @@ var init_schemas = __esm(() => {
       items: SchemaValidationFieldRulesSchema.optional()
     }).strict()
   ]));
-  SchemaValidationRulesSchema = z.record(z.string(), SchemaValidationFieldRulesSchema);
+  SchemaValidationRulesSchema = z3.record(z3.string(), SchemaValidationFieldRulesSchema);
   SCHEMA_VALIDATION_ATTRIBUTION_KEYS = new Set(["editedBy", "editedByLabel", "editedAt"]);
-  LocationSchema = z.object({
-    type: z.enum(["auto", "manual"]),
-    isoCode: z.string().trim().min(2).optional()
+  LocationSchema = z3.object({
+    type: z3.enum(["auto", "manual"]),
+    isoCode: z3.string().trim().min(2).optional()
   }).strict().superRefine((location, ctx) => {
     if (location.type === "manual" && !location.isoCode) {
       ctx.addIssue({
-        code: z.ZodIssueCode.custom,
+        code: z3.ZodIssueCode.custom,
         path: ["isoCode"],
         message: "isoCode is required for manual location"
       });
     }
     if (location.type === "auto" && location.isoCode) {
-      ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["isoCode"], message: "omit isoCode for auto location" });
+      ctx.addIssue({ code: z3.ZodIssueCode.custom, path: ["isoCode"], message: "omit isoCode for auto location" });
     }
   });
   MonitoringValueOperators = [
@@ -500,81 +738,81 @@ var init_schemas = __esm(() => {
     "WITHIN_LAST_DAYS"
   ];
   MonitoringValuelessOperators = ["IS_NULL", "IS_NOT_NULL", "IS_EMPTY", "IS_NOT_EMPTY"];
-  MonitoringConditionOperatorSchema = z.enum([...MonitoringValueOperators, ...MonitoringValuelessOperators]);
-  MonitoringConditionSchema = z.object({
-    type: z.enum(["SINGLE", "ANY"]),
-    field: z.string().trim().min(1).optional(),
+  MonitoringConditionOperatorSchema = z3.enum([...MonitoringValueOperators, ...MonitoringValuelessOperators]);
+  MonitoringConditionSchema = z3.object({
+    type: z3.enum(["SINGLE", "ANY"]),
+    field: z3.string().trim().min(1).optional(),
     operator: MonitoringConditionOperatorSchema,
-    value: z.union([z.string(), z.number(), z.boolean()]).optional()
+    value: z3.union([z3.string(), z3.number(), z3.boolean()]).optional()
   }).strict().superRefine((condition, ctx) => {
     if (condition.type === "SINGLE" && !condition.field) {
       ctx.addIssue({
-        code: z.ZodIssueCode.custom,
+        code: z3.ZodIssueCode.custom,
         path: ["field"],
         message: "field is required for SINGLE conditions"
       });
     }
     const needsValue = MonitoringValueOperators.includes(condition.operator);
     if (needsValue && condition.value === undefined) {
-      ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["value"], message: `${condition.operator} requires a value` });
+      ctx.addIssue({ code: z3.ZodIssueCode.custom, path: ["value"], message: `${condition.operator} requires a value` });
     }
     if (!needsValue && condition.value !== undefined) {
       ctx.addIssue({
-        code: z.ZodIssueCode.custom,
+        code: z3.ZodIssueCode.custom,
         path: ["value"],
         message: `${condition.operator} does not accept a value`
       });
     }
   });
-  MonitoringSchema = z.object({
-    fields: z.preprocess(coerceArray(), z.array(z.object({
-      fieldName: z.string().trim().min(1),
-      operator: z.enum(["changed", "added", "removed"]),
-      isKeyField: z.preprocess(coerceBoolean(), z.boolean()).optional()
+  MonitoringSchema = z3.object({
+    fields: z3.preprocess(coerceArray(), z3.array(z3.object({
+      fieldName: z3.string().trim().min(1),
+      operator: z3.enum(["changed", "added", "removed"]),
+      isKeyField: z3.preprocess(coerceBoolean(), z3.boolean()).optional()
     }).strict()).min(1)),
-    conditions: z.object({
-      logicalOperator: z.enum(["AND", "OR"]),
-      conditions: z.preprocess(coerceArray(), z.array(MonitoringConditionSchema).min(1))
+    conditions: z3.object({
+      logicalOperator: z3.enum(["AND", "OR"]),
+      conditions: z3.preprocess(coerceArray(), z3.array(MonitoringConditionSchema).min(1))
     }).strict().optional()
   }).strict();
   urlInputShape = {
-    url: z.string().optional().describe("Single URL - prefer using 'urls' instead. If both are provided, 'urls' takes precedence."),
-    urls: z.preprocess(coerceArray(true), z.array(z.string()).min(1)).optional().describe("Starting URLs for the workflow (array of strings). Also accepts a single URL string.")
+    url: z3.string().optional().describe("Single URL - prefer using 'urls' instead. If both are provided, 'urls' takes precedence."),
+    urls: z3.preprocess(coerceArray(true), z3.array(z3.string()).min(1)).optional().describe("Starting URLs for the workflow (array of strings). Also accepts a single URL string.")
   };
-  extractionPromptInput = z.string().optional();
+  extractionPromptInput = z3.string().optional();
   extractionInputShape = {
-    name: z.string().optional().describe("Optional name for the workflow"),
-    entity: z.string().optional().describe("Entity name for extraction (e.g., 'Product', 'Job Posting')"),
-    schema: z.preprocess(coerceArray(), z.array(z.object(SchemaFieldShape).strict())).optional().describe("Extraction schema fields. If omitted, the AI agent auto-detects the schema. When you do supply fields, mark the one that identifies a record with isKey - change detection needs it.")
+    name: z3.string().optional().describe("Optional name for the workflow"),
+    entity: z3.string().optional().describe("Entity name for extraction (e.g., 'Product', 'Job Posting')"),
+    schema: z3.preprocess(coerceArray(), z3.array(z3.object(SchemaFieldShape).strict())).optional().describe("Extraction schema fields. If omitted, the AI agent auto-detects the schema. When you do supply fields, mark the one that identifies a record with isKey - change detection needs it.")
   };
-  webhookAuthShape = z.object({
-    type: z.enum(["bearer", "basic", "header"]).describe("Authentication type"),
-    token: z.string().optional().describe("Bearer token (required for 'bearer' type)"),
-    username: z.string().optional().describe("Username (required for 'basic' type)"),
-    password: z.string().optional().describe("Password (required for 'basic' type)"),
-    headers: z.object({}).passthrough().optional().describe("Custom headers as key-value pairs (required for 'header' type)")
+  webhookAuthShape = z3.object({
+    type: z3.enum(["bearer", "basic", "header"]).describe("Authentication type"),
+    token: z3.string().optional().describe("Bearer token (required for 'bearer' type)"),
+    username: z3.string().optional().describe("Username (required for 'basic' type)"),
+    password: z3.string().optional().describe("Password (required for 'basic' type)"),
+    headers: z3.object({}).passthrough().optional().describe("Custom headers as key-value pairs (required for 'header' type)")
   }).optional().describe("Authentication configuration for the webhook endpoint");
-  notificationChannelsSchema = z.object({
-    email: z.object({
-      recipients: z.array(z.string().email()).optional().describe("Email addresses to notify. Omit to use account default email.")
+  notificationChannelsSchema = z3.object({
+    email: z3.object({
+      recipients: z3.array(z3.string().email()).optional().describe("Email addresses to notify. Omit to use account default email.")
     }).optional().describe("Send email notifications. Pass {} for account default email, or {recipients: [...]} for custom addresses."),
-    webhook: z.object({
-      url: z.string().url().describe("Webhook endpoint URL"),
-      httpMethod: z.enum(["POST", "GET", "PUT", "PATCH"]).optional().describe("HTTP method (defaults to POST)"),
+    webhook: z3.object({
+      url: z3.string().url().describe("Webhook endpoint URL"),
+      httpMethod: z3.enum(["POST", "GET", "PUT", "PATCH"]).optional().describe("HTTP method (defaults to POST)"),
       auth: webhookAuthShape
     }).optional().describe("Send notifications via HTTP webhook"),
-    slack: z.object({
-      webhookUrl: z.string().url().optional().describe("Slack incoming webhook URL (legacy)"),
-      slackChannelId: z.string().optional().describe("Slack channel ID from OAuth integration (e.g. C01ABCDEF)"),
-      slackChannelName: z.string().optional().describe("Slack channel name (e.g. #alerts)")
+    slack: z3.object({
+      webhookUrl: z3.string().url().optional().describe("Slack incoming webhook URL (legacy)"),
+      slackChannelId: z3.string().optional().describe("Slack channel ID from OAuth integration (e.g. C01ABCDEF)"),
+      slackChannelName: z3.string().optional().describe("Slack channel name (e.g. #alerts)")
     }).optional().describe("Send notifications to a Slack channel. Use slackChannelId/slackChannelName for OAuth integration, or webhookUrl for legacy incoming webhooks."),
-    websocket: z.boolean().optional().describe("Enable WebSocket notifications for programmatic real-time consumption")
+    websocket: z3.boolean().optional().describe("Enable WebSocket notifications for programmatic real-time consumption")
   });
   notificationsInputShape = {
-    notifications: z.preprocess(coerceJson(), notificationChannelsSchema.optional()).optional().describe("Optional notification channels to alert when data changes.")
+    notifications: z3.preprocess(coerceJson(), notificationChannelsSchema.optional()).optional().describe("Optional notification channels to alert when data changes.")
   };
   requiredNotificationsInputShape = {
-    notifications: z.preprocess(coerceJson(), notificationChannelsSchema).describe("Notification channels to alert when data changes.")
+    notifications: z3.preprocess(coerceJson(), notificationChannelsSchema).describe("Notification channels to alert when data changes.")
   };
   DATA_FILTER_OPERATORS = [
     "EQUALS",
@@ -599,10 +837,10 @@ var init_schemas = __esm(() => {
   ];
   DATA_FILTER_VALUELESS_OPERATORS = new Set(["IS_NULL", "IS_NOT_NULL", "IS_EMPTY", "IS_NOT_EMPTY"]);
   DATA_FILTER_LIST_OPERATORS = new Set(["IN", "NOT_IN"]);
-  DataFilterSchema = z.object({
-    field: z.string().trim().min(1).describe("Field name from the workflow schema; one nested level is allowed, e.g. classification.match"),
-    operator: z.preprocess((val) => typeof val === "string" ? val.trim().toUpperCase() : val, z.enum(DATA_FILTER_OPERATORS)),
-    value: z.union([z.string(), z.number(), z.boolean(), z.array(z.union([z.string(), z.number()]))]).optional().describe("Omit for IS_NULL, IS_NOT_NULL, IS_EMPTY, IS_NOT_EMPTY; an array for IN/NOT_IN; days for WITHIN_LAST_DAYS")
+  DataFilterSchema = z3.object({
+    field: z3.string().trim().min(1).describe("Field name from the workflow schema; one nested level is allowed, e.g. classification.match"),
+    operator: z3.preprocess((val) => typeof val === "string" ? val.trim().toUpperCase() : val, z3.enum(DATA_FILTER_OPERATORS)),
+    value: z3.union([z3.string(), z3.number(), z3.boolean(), z3.array(z3.union([z3.string(), z3.number()]))]).optional().describe("Omit for IS_NULL, IS_NOT_NULL, IS_EMPTY, IS_NOT_EMPTY; an array for IN/NOT_IN; days for WITHIN_LAST_DAYS")
   }).strict().superRefine((filter, ctx) => {
     if (DATA_FILTER_VALUELESS_OPERATORS.has(filter.operator)) {
       if (filter.value !== undefined) {
@@ -627,12 +865,12 @@ var init_schemas = __esm(() => {
       });
     }
   });
-  dataFiltersInput = z.preprocess(normalizeDataFilters, z.array(DataFilterSchema).optional()).optional().describe('Row filters, e.g. [{"field":"title","operator":"CONTAINS","value":"Manager"}]. Multiple filters are combined with OR. BEFORE, AFTER and WITHIN_LAST_DAYS only apply to DATE/DATETIME fields.');
+  dataFiltersInput = z3.preprocess(normalizeDataFilters, z3.array(DataFilterSchema).optional()).optional().describe('Row filters, e.g. [{"field":"title","operator":"CONTAINS","value":"Manager"}]. Multiple filters are combined with OR. BEFORE, AFTER and WITHIN_LAST_DAYS only apply to DATE/DATETIME fields.');
 });
 
 // src/tools/assistant.ts
 import { FREEFORM_ASSISTANT_ANSWER_KEY } from "@kadoa/node-sdk";
-import { z as z2 } from "zod";
+import { z as z4 } from "zod";
 function isAssistantSessionResumable(status) {
   return status != null && RESUMABLE_ASSISTANT_STATUSES.has(status);
 }
@@ -700,8 +938,9 @@ function registerAssistantTools(server, ctx, helpers) {
     title: "Get Workflow Assistant",
     description: "Get the current Assistant lifecycle for a workflow, including whether it is working, waiting for input, idle, interrupted, or closed and any pending customer question. Works for one-time or scheduled extraction workflows and realtime monitoring workflows.",
     inputSchema: strictSchema({
-      workflowId: z2.string().min(1).describe("The workflow ID")
+      workflowId: z4.string().min(1).describe("The workflow ID")
     }),
+    outputSchema: WorkflowAssistantOutput,
     annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("get_workflow_assistant", async (args) => {
     const workflow = await ctx.client.workflow.get(args.workflowId);
@@ -733,10 +972,11 @@ function registerAssistantTools(server, ctx, helpers) {
     title: "Get Workflow Assistant Timeline",
     description: "Read the customer-visible conversation history for a workflow Assistant, including user messages, Assistant messages, and clarification questions with answers. " + "Use this when the user asks what the Assistant said or asked, how a clarification was answered, or to show the latest conversation for a workflow. " + "Supports one-time or scheduled extraction workflows and realtime monitoring workflows. Use get_workflow_history instead for configuration revisions. " + "Results are chronological within each page; use nextCursor to request older items when hasMore is true.",
     inputSchema: strictSchema({
-      workflowId: z2.string().min(1).describe("The workflow ID"),
-      cursor: z2.string().min(1).optional().describe("Opaque nextCursor from the previous page"),
-      limit: z2.preprocess(coerceNumber(), z2.number().int().min(1).max(100)).optional().describe("Maximum history items to return (default: 50, maximum: 100)")
+      workflowId: z4.string().min(1).describe("The workflow ID"),
+      cursor: z4.string().min(1).optional().describe("Opaque nextCursor from the previous page"),
+      limit: limitInput({ noun: "History items", defaultLimit: 50, max: 100 })
     }),
+    outputSchema: AssistantTimelineOutput,
     annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("get_workflow_assistant_timeline", async (args) => {
     const timeline = await ctx.client.assistant.getTimeline(args.workflowId, {
@@ -749,8 +989,12 @@ function registerAssistantTools(server, ctx, helpers) {
     return jsonResult({
       workflowId: timeline.workflowId,
       sessionId: timeline.sessionId,
-      items: timeline.items,
-      pagination: timeline.pagination,
+      items: timeline.items ?? [],
+      pagination: cursorPage({
+        args,
+        nextCursor: timeline.pagination?.nextCursor,
+        hasMore: timeline.pagination?.hasMore === true
+      }),
       dashboardUrl: workflowDashboardUrl(timeline.workflowId)
     });
   }));
@@ -758,11 +1002,12 @@ function registerAssistantTools(server, ctx, helpers) {
     title: "Answer Assistant Question",
     description: "Answer the workflow Assistant's currently pending clarification question and resume it. " + "Use `answer` for a freeform response, or `answers` for the structured key/value response described by get_workflow_assistant. Provide exactly one. The question ID must still be current.",
     inputSchema: strictSchema({
-      workflowId: z2.string().min(1).describe("The workflow ID"),
-      questionId: z2.string().min(1).describe("The pending question ID returned by get_workflow_assistant"),
-      answer: z2.string().min(1).optional().describe("Freeform answer"),
-      answers: z2.preprocess(coerceJson(), z2.record(z2.string(), z2.string())).optional().describe("Structured answer map; keys identify questions and values contain the selected/freeform answers")
+      workflowId: z4.string().min(1).describe("The workflow ID"),
+      questionId: z4.string().min(1).describe("The pending question ID returned by get_workflow_assistant"),
+      answer: z4.string().min(1).optional().describe("Freeform answer"),
+      answers: z4.preprocess(coerceJson(), z4.record(z4.string(), z4.string())).optional().describe("Structured answer map; keys identify questions and values contain the selected/freeform answers")
     }),
+    outputSchema: AssistantAnswerOutput,
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
   }, withErrorHandling("answer_workflow_assistant_question", async (args) => {
     const hasFreeform = args.answer != null;
@@ -804,8 +1049,9 @@ function registerAssistantTools(server, ctx, helpers) {
     title: "Interrupt Workflow Assistant",
     description: "Safely interrupt the active Assistant working on a workflow. This pauses Assistant reasoning/update work; it does not pause the workflow's extraction schedule. Use pause_workflow for scheduling instead.",
     inputSchema: strictSchema({
-      workflowId: z2.string().min(1).describe("Workflow whose Assistant session should be interrupted")
+      workflowId: z4.string().min(1).describe("Workflow whose Assistant session should be interrupted")
     }),
+    outputSchema: AssistantControlOutput,
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }
   }, withErrorHandling("interrupt_workflow_assistant", async (args) => {
     const workflow = await ctx.client.workflow.get(args.workflowId);
@@ -838,8 +1084,9 @@ function registerAssistantTools(server, ctx, helpers) {
     title: "Resume Workflow Assistant",
     description: "Resume an idle or interrupted workflow Assistant using the role and conversation persisted on its session. Works for one-time or scheduled extraction workflows and realtime monitoring workflows. This does not resume a paused workflow schedule; use approve_workflow for that.",
     inputSchema: strictSchema({
-      workflowId: z2.string().min(1).describe("Workflow whose Assistant session should resume")
+      workflowId: z4.string().min(1).describe("Workflow whose Assistant session should resume")
     }),
+    outputSchema: AssistantControlOutput,
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
   }, withErrorHandling("resume_workflow_assistant", async (args) => {
     const workflow = await ctx.client.workflow.get(args.workflowId);
@@ -872,8 +1119,9 @@ function registerAssistantTools(server, ctx, helpers) {
     title: "Stop Workflow Assistant",
     description: "Stop the active Assistant update for a workflow. This cancels Assistant work but does not delete, pause, or replace the workflow and does not change workflowId. Use pause_workflow separately to stop scheduled extraction runs.",
     inputSchema: strictSchema({
-      workflowId: z2.string().min(1).describe("Workflow whose active Assistant session should stop")
+      workflowId: z4.string().min(1).describe("Workflow whose active Assistant session should stop")
     }),
+    outputSchema: AssistantControlOutput,
     annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false }
   }, withErrorHandling("stop_workflow_assistant", async (args) => {
     const workflow = await ctx.client.workflow.get(args.workflowId);
@@ -905,8 +1153,9 @@ function registerAssistantTools(server, ctx, helpers) {
     title: "Get Workflow Strategy",
     description: "Get the current customer-safe extraction/build strategy for a workflow: source approach, endpoints, interaction style, selectors, and realtime interval when applicable. Returns building rather than an error when an Assistant session has no build strategy yet.",
     inputSchema: strictSchema({
-      workflowId: z2.string().min(1).describe("The workflow ID")
+      workflowId: z4.string().min(1).describe("The workflow ID")
     }),
+    outputSchema: WorkflowStrategyOutput,
     annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("get_workflow_strategy", async (args) => {
     const workflow = await ctx.client.workflow.get(args.workflowId);
@@ -937,6 +1186,8 @@ function registerAssistantTools(server, ctx, helpers) {
 }
 var RESUMABLE_ASSISTANT_STATUSES, ACTIVE_ASSISTANT_STATUSES, IDLE_ASSISTANT_STATUSES, CLOSED_ASSISTANT_STATUSES;
 var init_assistant = __esm(() => {
+  init_output_schemas();
+  init_pagination();
   init_schemas();
   RESUMABLE_ASSISTANT_STATUSES = new Set(["pending", "created", "active", "idle", "inactive", "interrupted"]);
   ACTIVE_ASSISTANT_STATUSES = new Set(["pending", "created", "active"]);
@@ -945,6 +1196,7 @@ var init_assistant = __esm(() => {
 });
 
 // src/notification-channels.ts
+import { createHash } from "node:crypto";
 function recipientKey(recipients) {
   return [...new Set(recipients.map((r) => r.trim().toLowerCase()))].sort().join(",");
 }
@@ -968,6 +1220,14 @@ function destinationOf(channelType, rawConfig) {
     return `url:${webhookUrl}`;
   return null;
 }
+function mcpChannelName(channelType, config) {
+  const name = `mcp-${channelType.toLowerCase()}`;
+  const slackName = config.slackChannelName;
+  const destination = destinationOf(channelType, config) ?? (channelType === "SLACK" && typeof slackName === "string" && slackName.trim() ? `slack-name:${slackName.trim().toLowerCase()}` : null);
+  if (destination === null)
+    return name;
+  return `${name}-${createHash("sha256").update(destination).digest("hex").slice(0, 8)}`;
+}
 function findReusableChannel(channels, channelType, config) {
   const wanted = destinationOf(channelType, config);
   if (wanted === null)
@@ -1012,16 +1272,23 @@ function redactChannelConfig(config) {
     ...auth !== undefined && { auth: redactAuth(auth) }
   };
 }
+function redactChannelRefs(channels) {
+  return channels?.map((channel) => {
+    const { config } = channel;
+    return config === undefined ? channel : { ...channel, config: redactChannelConfig(config) };
+  });
+}
+var init_notification_channels = () => {};
 
 // src/tools/notifications.ts
-import { z as z3 } from "zod";
+import { z as z5 } from "zod";
 function registerNotificationChannelTools(server, ctx, helpers) {
   const { withErrorHandling } = helpers;
   server.registerTool("list_notification_channels", {
     title: "List Notification Channels",
     description: "List notification channels configured for a workflow or across the workspace. Channels are destinations (email, Slack, webhook, websocket) where notifications are sent.",
     inputSchema: strictSchema({
-      workflowId: z3.string().optional().describe("Filter channels linked to a specific workflow. Omit to list all workspace channels.")
+      workflowId: z5.string().optional().describe("Filter channels linked to a specific workflow. Omit to list all workspace channels.")
     }),
     annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("list_notification_channels", async (args) => {
@@ -1036,27 +1303,28 @@ function registerNotificationChannelTools(server, ctx, helpers) {
         createdAt: ch.createdAt,
         dashboardUrl: notificationSettingsDashboardUrl()
       })),
-      total: channels.length
+      total: channels.length,
+      pagination: completeList(channels.length)
     });
   }));
   server.registerTool("create_notification_channel", {
     title: "Create Notification Channel",
     description: "Create a notification channel (email, webhook, slack, or websocket). If a channel of the same type already delivers to that destination it is reused and returned with reused=true, rather than creating a duplicate. The channel can then be linked to notification settings for specific events. " + "For SLACK: use slackChannelId + slackChannelName for OAuth integration, or webhookUrl for legacy incoming webhooks. " + "For WEBHOOK: auth is optional and supports bearer, basic, or header authentication.",
     inputSchema: strictSchema({
-      channelType: z3.enum(["EMAIL", "WEBHOOK", "SLACK", "WEBSOCKET"]).describe("Type of notification channel"),
-      name: z3.string().optional().describe("Name for the channel (defaults to 'default')"),
-      config: z3.object({
-        recipients: z3.array(z3.string()).optional().describe("Email recipients (required for EMAIL channels)"),
-        webhookUrl: z3.string().optional().describe("Webhook/Slack endpoint URL (required for WEBHOOK, optional for SLACK)"),
-        httpMethod: z3.enum(["POST", "GET", "PUT", "PATCH"]).optional().describe("HTTP method for WEBHOOK channels (defaults to POST)"),
-        slackChannelId: z3.string().optional().describe("Slack channel ID from OAuth integration (for SLACK channels, e.g. C01ABCDEF)"),
-        slackChannelName: z3.string().optional().describe("Slack channel name (for SLACK channels, e.g. #alerts)"),
-        auth: z3.object({
-          type: z3.enum(["bearer", "basic", "header"]).describe("Authentication type"),
-          token: z3.string().optional().describe("Bearer token (for 'bearer' type)"),
-          username: z3.string().optional().describe("Username (for 'basic' type)"),
-          password: z3.string().optional().describe("Password (for 'basic' type)"),
-          headers: z3.object({}).passthrough().optional().describe("Custom headers as key-value pairs (for 'header' type)")
+      channelType: z5.enum(["EMAIL", "WEBHOOK", "SLACK", "WEBSOCKET"]).describe("Type of notification channel"),
+      name: z5.string().optional().describe("Name for the channel (defaults to 'default')"),
+      config: z5.object({
+        recipients: z5.array(z5.string()).optional().describe("Email recipients (required for EMAIL channels)"),
+        webhookUrl: z5.string().optional().describe("Webhook/Slack endpoint URL (required for WEBHOOK, optional for SLACK)"),
+        httpMethod: z5.enum(["POST", "GET", "PUT", "PATCH"]).optional().describe("HTTP method for WEBHOOK channels (defaults to POST)"),
+        slackChannelId: z5.string().optional().describe("Slack channel ID from OAuth integration (for SLACK channels, e.g. C01ABCDEF)"),
+        slackChannelName: z5.string().optional().describe("Slack channel name (for SLACK channels, e.g. #alerts)"),
+        auth: z5.object({
+          type: z5.enum(["bearer", "basic", "header"]).describe("Authentication type"),
+          token: z5.string().optional().describe("Bearer token (for 'bearer' type)"),
+          username: z5.string().optional().describe("Username (for 'basic' type)"),
+          password: z5.string().optional().describe("Password (for 'basic' type)"),
+          headers: z5.object({}).passthrough().optional().describe("Custom headers as key-value pairs (for 'header' type)")
         }).optional().describe("Authentication for WEBHOOK channels")
       }).optional().describe("Channel-specific configuration. " + "EMAIL: provide recipients. " + "WEBHOOK: provide webhookUrl, httpMethod, and optionally auth. " + "SLACK: provide slackChannelId + slackChannelName (OAuth) or webhookUrl (legacy). " + "WEBSOCKET: no config needed.")
     }),
@@ -1103,8 +1371,8 @@ function registerNotificationSettingsTools(server, ctx, helpers) {
     title: "Delete Notification Channel",
     description: "Delete a notification channel by ID. " + "Call first without confirmed=true to preview, then with confirmed=true after user agrees.",
     inputSchema: strictSchema({
-      channelId: z3.string().min(1).describe("The channel ID to delete"),
-      confirmed: z3.preprocess(coerceBoolean(), z3.boolean()).optional().describe("Set to true only after the user has explicitly confirmed deletion.")
+      channelId: z5.string().min(1).describe("The channel ID to delete"),
+      confirmed: z5.preprocess(coerceBoolean(), z5.boolean()).optional().describe("Set to true only after the user has explicitly confirmed deletion.")
     }),
     annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("delete_notification_channel", async (args) => {
@@ -1125,7 +1393,7 @@ function registerNotificationSettingsTools(server, ctx, helpers) {
     title: "List Notification Settings",
     description: "List notification settings (event-to-channel mappings) for a workflow or workspace. Shows which events trigger notifications and through which channels.",
     inputSchema: strictSchema({
-      workflowId: z3.string().optional().describe("Filter settings for a specific workflow. Omit to list workspace-level settings."),
+      workflowId: z5.string().optional().describe("Filter settings for a specific workflow. Omit to list workspace-level settings."),
       eventType: NotificationEventTypeSchema.optional().describe("Filter by event type")
     }),
     annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
@@ -1142,33 +1410,34 @@ function registerNotificationSettingsTools(server, ctx, helpers) {
         workflowId: s.workflowId,
         eventType: s.eventType,
         enabled: s.enabled,
-        channels: s.channels,
+        channels: redactChannelRefs(s.channels),
         createdAt: s.createdAt
       })),
-      total: settings.length
+      total: settings.length,
+      pagination: completeList(settings.length)
     });
   }));
   server.registerTool("configure_notifications", {
     title: "Configure Notifications",
     description: "Set up notifications for a workflow or workspace. Creates channels and settings in one step. " + "Specify which events to listen for and which channels to deliver to (email, webhook, slack, websocket).",
     inputSchema: strictSchema({
-      workflowId: z3.string().optional().describe("Workflow ID to configure notifications for. Omit for workspace-level notifications."),
-      events: z3.preprocess(coerceList(), z3.array(z3.enum(["all", ...NOTIFICATION_EVENT_TYPES])).min(1)).describe('Event types to notify on. Pass ["all"] for every event type, or list specific event types.'),
-      channels: z3.object({
-        email: z3.object({
-          recipients: z3.array(z3.string().email()).optional().describe("Email addresses to notify. Omit to use the account default email.")
+      workflowId: z5.string().optional().describe("Workflow ID to configure notifications for. Omit for workspace-level notifications."),
+      events: z5.preprocess(coerceList(), z5.array(z5.enum(["all", ...NOTIFICATION_EVENT_TYPES])).min(1)).describe('Event types to notify on. Pass ["all"] for every event type, or list specific event types.'),
+      channels: z5.object({
+        email: z5.object({
+          recipients: z5.array(z5.string().email()).optional().describe("Email addresses to notify. Omit to use the account default email.")
         }).optional().describe("Send email notifications. Pass {} for default email or {recipients: [...]} for custom addresses."),
-        webhook: z3.object({
-          url: z3.string().url().describe("Webhook endpoint URL"),
-          httpMethod: z3.enum(["POST", "GET", "PUT", "PATCH"]).optional().describe("HTTP method (defaults to POST)"),
+        webhook: z5.object({
+          url: z5.string().url().describe("Webhook endpoint URL"),
+          httpMethod: z5.enum(["POST", "GET", "PUT", "PATCH"]).optional().describe("HTTP method (defaults to POST)"),
           auth: webhookAuthShape
         }).optional().describe("Send via HTTP webhook"),
-        slack: z3.object({
-          webhookUrl: z3.string().url().optional().describe("Slack incoming webhook URL (legacy)"),
-          slackChannelId: z3.string().optional().describe("Slack channel ID from OAuth integration (e.g. C01ABCDEF)"),
-          slackChannelName: z3.string().optional().describe("Slack channel name (e.g. #alerts)")
+        slack: z5.object({
+          webhookUrl: z5.string().url().optional().describe("Slack incoming webhook URL (legacy)"),
+          slackChannelId: z5.string().optional().describe("Slack channel ID from OAuth integration (e.g. C01ABCDEF)"),
+          slackChannelName: z5.string().optional().describe("Slack channel name (e.g. #alerts)")
         }).optional().describe("Send to Slack channel. Use slackChannelId/slackChannelName for OAuth integration, or webhookUrl for legacy incoming webhooks."),
-        websocket: z3.boolean().optional().describe("Enable WebSocket notifications")
+        websocket: z5.boolean().optional().describe("Enable WebSocket notifications")
       }).describe("At least one channel must be specified")
     }),
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
@@ -1178,7 +1447,7 @@ function registerNotificationSettingsTools(server, ctx, helpers) {
     const ch = args.channels;
     if (ch.email) {
       if (ch.email.recipients?.length) {
-        channelSetup.EMAIL = { name: "mcp-email", recipients: ch.email.recipients };
+        channelSetup.EMAIL = { name: mcpChannelName("EMAIL", ch.email), recipients: ch.email.recipients };
       } else {
         channelSetup.EMAIL = true;
       }
@@ -1187,7 +1456,7 @@ function registerNotificationSettingsTools(server, ctx, helpers) {
       channelSetup.WEBSOCKET = true;
     if (ch.webhook) {
       const webhookChannel = {
-        name: "mcp-webhook",
+        name: mcpChannelName("WEBHOOK", { webhookUrl: ch.webhook.url }),
         webhookUrl: ch.webhook.url,
         httpMethod: ch.webhook.httpMethod || "POST"
       };
@@ -1196,7 +1465,7 @@ function registerNotificationSettingsTools(server, ctx, helpers) {
       channelSetup.WEBHOOK = webhookChannel;
     }
     if (ch.slack) {
-      const slackChannel = { name: "mcp-slack" };
+      const slackChannel = { name: mcpChannelName("SLACK", ch.slack) };
       if (ch.slack.webhookUrl)
         slackChannel.webhookUrl = ch.slack.webhookUrl;
       if (ch.slack.slackChannelId)
@@ -1222,7 +1491,7 @@ function registerNotificationSettingsTools(server, ctx, helpers) {
         id: s.id,
         eventType: s.eventType,
         enabled: s.enabled,
-        channels: s.channels
+        channels: redactChannelRefs(s.channels)
       }))
     });
   }));
@@ -1230,8 +1499,8 @@ function registerNotificationSettingsTools(server, ctx, helpers) {
     title: "Delete Notification Setting",
     description: "Delete a notification setting by ID. This removes the event-to-channel mapping but does not delete the channels themselves. " + "Call first without confirmed=true to preview, then with confirmed=true after user agrees.",
     inputSchema: strictSchema({
-      settingId: z3.string().min(1).describe("The notification setting ID to delete (the id from list_notification_settings)"),
-      confirmed: z3.preprocess(coerceBoolean(), z3.boolean()).optional().describe("Set to true only after the user has explicitly confirmed deletion.")
+      settingId: z5.string().min(1).describe("The notification setting ID to delete (the id from list_notification_settings)"),
+      confirmed: z5.preprocess(coerceBoolean(), z5.boolean()).optional().describe("Set to true only after the user has explicitly confirmed deletion.")
     }),
     annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("delete_notification_setting", async (args) => {
@@ -1250,17 +1519,14 @@ function registerNotificationSettingsTools(server, ctx, helpers) {
   }));
 }
 var init_notifications = __esm(() => {
+  init_notification_channels();
+  init_pagination();
   init_schemas();
 });
 
 // src/tools/observability.ts
 import { KadoaSdkException as KadoaSdkException2 } from "@kadoa/node-sdk";
-import { z as z4 } from "zod";
-function boundActivityLimit(limit) {
-  if (limit === undefined || Number.isNaN(limit))
-    return ACTIVITY_DEFAULT_LIMIT;
-  return Math.min(Math.max(Math.trunc(limit), 1), ACTIVITY_MAX_LIMIT);
-}
+import { z as z6 } from "zod";
 function mapActivityEvent(event, includeDetails) {
   const details = event.details ?? {};
   const summary = details._changeSummary;
@@ -1333,10 +1599,10 @@ function registerObservabilityTools(server, ctx, helpers) {
     title: "Get Observability Metrics",
     description: "Workflow health for the active team over a window of days (default 30): overall uptime in percent, " + "successful and failed runs, mean time to recovery in minutes, records delivered, counts of healthy, " + "degraded, down, and idle workflows, the same numbers for the previous window, and an 'attention' list " + "of down and degraded workflows ranked worst first. This is the data behind the Observability page. " + "Use for 'how healthy are my workflows', 'what is my uptime', 'which workflows are down or failing', " + "'how fast do we recover', 'how did this month compare to last'. " + "Do NOT use it to explain why one workflow failed: call list_workflow_runs (errors per run) or " + "get_workflow for that. For what needs the user's action right now use list_workflows with " + "statusFilters group:attention. " + "Health comes from each workflow's last run in the window: healthy means the last run finished, down " + "means the last run failed, idle means no finished or failed run. uptimePercentage is null when no runs " + "happened. mttrMinutes is null when nothing failed and then recovered. openSupportRequests is a count " + "only. " + "Output is bounded: pass includeWorkflows for every workflow ranked by severity (up to limit, default " + "25, max 200) and includeDailySeries for the team-level daily uptime series; per-workflow daily series " + "are never returned. Quote workflows by name; ids are stripped from customer-facing text. Large teams " + "can take up to 90 seconds; prefer 30 or 90 days over 365.",
     inputSchema: strictSchema({
-      days: z4.preprocess(coerceNumber(), z4.number().int().min(1).max(365)).optional().describe("Window length in days, 1 to 365 (default 30). The dashboard offers 30, 90, and 365."),
-      includeWorkflows: z4.preprocess(coerceBoolean(), z4.boolean()).optional().describe("Also return every workflow ranked by severity, not only the down and degraded ones (default false)."),
-      includeDailySeries: z4.preprocess(coerceBoolean(), z4.boolean()).optional().describe("Also return the team-level daily series of successful runs, failed runs, and uptime (default false)."),
-      limit: z4.preprocess(coerceNumber(), z4.number().int().min(1).max(OBSERVABILITY_MAX_LIMIT)).optional().describe("Maximum workflows in the attention list and in workflows (default 25, max 200).")
+      days: z6.preprocess(coerceNumber(), z6.number().int().min(1).max(365)).optional().describe("Window length in days, 1 to 365 (default 30). The dashboard offers 30, 90, and 365."),
+      includeWorkflows: z6.preprocess(coerceBoolean(), z6.boolean()).optional().describe("Also return every workflow ranked by severity, not only the down and degraded ones (default false)."),
+      includeDailySeries: z6.preprocess(coerceBoolean(), z6.boolean()).optional().describe("Also return the team-level daily series of successful runs, failed runs, and uptime (default false)."),
+      limit: z6.preprocess(coerceNumber(), z6.number().int().min(1).max(OBSERVABILITY_MAX_LIMIT)).optional().describe("Maximum workflows in the attention list and in workflows (default 25, max 200).")
     }),
     annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("get_observability", async (args) => {
@@ -1392,22 +1658,23 @@ function registerObservabilityTools(server, ctx, helpers) {
     title: "List Activity",
     description: "List the team's Activity log (audit trail): who did what, when, and from which interface, across " + "every workflow and resource in the active team. Each event carries the actor's email, the resource " + "name and type, the action (CREATED, UPDATED, DELETED, APPROVED, FINISHED, FAILED, DATA_CHANGED, ...), " + "the interface label, and a changeSummary when the backend recorded one. Use it for team-wide questions " + "such as 'who changed anything last week?', 'what did alice do yesterday?', or 'which workflows were " + "deleted this month?'. For one workflow's configuration revisions with field-level before/after diffs " + "(prompt, schema, schedule), use get_workflow_history instead. Newest events come first. Refer to " + "people by email and resources by name in answers; ids are for follow-up tool calls.",
     inputSchema: strictSchema({
-      limit: z4.preprocess(coerceNumber(), z4.number()).optional().describe(`Events per page (default ${ACTIVITY_DEFAULT_LIMIT}, max ${ACTIVITY_MAX_LIMIT})`),
-      offset: z4.preprocess(coerceNumber(), z4.number()).optional().describe("Number of events to skip (default 0)"),
-      workflowId: z4.string().optional().describe("Only events about this workflow (runs, config changes, data changes, notifications)"),
-      userId: z4.string().optional().describe("Only events by this user id. Resolve an email to an id from a previous list_activity result."),
-      startDate: z4.string().optional().describe("ISO 8601 lower bound. Ignored when relativeTime is set."),
-      endDate: z4.string().optional().describe("ISO 8601 upper bound. Ignored when relativeTime is set."),
-      relativeTime: z4.string().regex(/^\d+(m|h|d|w)$/i, "Use <number><unit> with unit m, h, d or w, e.g. 6h or 2w").optional().describe("Window counted back from now, e.g. 30m, 6h, 1d, 2w. Preferred for 'last week' style questions."),
-      eventTypes: z4.preprocess(coerceList({ upperCase: true }), z4.array(z4.enum(ACTIVITY_EVENT_TYPES))).optional().describe("Actions to keep. Workflow run outcomes (FINISHED, FAILED, ...) count as actions."),
-      interfaces: z4.preprocess(coerceList({ upperCase: true }), z4.array(z4.enum(ACTIVITY_INTERFACES))).optional().describe("Interfaces the action came from"),
-      resourceTypes: z4.preprocess(coerceList({ upperCase: true }), z4.array(z4.enum(ACTIVITY_RESOURCE_TYPES))).optional().describe("Resource types to keep"),
-      includeDetails: z4.preprocess(coerceBoolean(), z4.boolean()).optional().describe("Include sanitized previousValue/newValue snapshots per event (default false; large)")
+      limit: limitInput({ noun: "Events", defaultLimit: ACTIVITY_DEFAULT_LIMIT, max: ACTIVITY_MAX_LIMIT }),
+      offset: offsetInput("offset", "events"),
+      workflowId: z6.string().optional().describe("Only events about this workflow (runs, config changes, data changes, notifications)"),
+      userId: z6.string().optional().describe("Only events by this user id. Resolve an email to an id from a previous list_activity result."),
+      startDate: z6.string().optional().describe("ISO 8601 lower bound. Ignored when relativeTime is set."),
+      endDate: z6.string().optional().describe("ISO 8601 upper bound. Ignored when relativeTime is set."),
+      relativeTime: z6.string().regex(/^\d+(m|h|d|w)$/i, "Use <number><unit> with unit m, h, d or w, e.g. 6h or 2w").optional().describe("Window counted back from now, e.g. 30m, 6h, 1d, 2w. Preferred for 'last week' style questions."),
+      eventTypes: z6.preprocess(coerceList({ upperCase: true }), z6.array(z6.enum(ACTIVITY_EVENT_TYPES))).optional().describe("Actions to keep. Workflow run outcomes (FINISHED, FAILED, ...) count as actions."),
+      interfaces: z6.preprocess(coerceList({ upperCase: true }), z6.array(z6.enum(ACTIVITY_INTERFACES))).optional().describe("Interfaces the action came from"),
+      resourceTypes: z6.preprocess(coerceList({ upperCase: true }), z6.array(z6.enum(ACTIVITY_RESOURCE_TYPES))).optional().describe("Resource types to keep"),
+      includeDetails: z6.preprocess(coerceBoolean(), z6.boolean()).optional().describe("Include sanitized previousValue/newValue snapshots per event (default false; large)")
     }),
     annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("list_activity", async (args) => {
+    const limit = args.limit ?? ACTIVITY_DEFAULT_LIMIT;
     const result = await ctx.client.activity.list({
-      limit: boundActivityLimit(args.limit),
+      limit,
       offset: args.offset,
       workflowId: args.workflowId,
       userId: args.userId,
@@ -1421,7 +1688,15 @@ function registerObservabilityTools(server, ctx, helpers) {
     const events = result.events.map((event) => mapActivityEvent(event, args.includeDetails === true));
     return jsonResult({
       events,
-      pagination: result.pagination,
+      pagination: offsetPage({
+        args,
+        param: "offset",
+        offset: args.offset ?? 0,
+        limit,
+        returned: events.length,
+        totalCount: result.pagination?.total,
+        hasMore: result.pagination?.hasMore
+      }),
       ...events.length === 0 ? {
         hint: "No activity matched these filters. Widen relativeTime or drop a filter before concluding nothing happened."
       } : {}
@@ -1430,6 +1705,7 @@ function registerObservabilityTools(server, ctx, helpers) {
 }
 var ACTIVITY_DEFAULT_LIMIT = 25, ACTIVITY_MAX_LIMIT = 200, ACTIVITY_EVENT_TYPES, ACTIVITY_INTERFACES, ACTIVITY_RESOURCE_TYPES, HEALTH_SEVERITY;
 var init_observability = __esm(() => {
+  init_pagination();
   init_schemas();
   ACTIVITY_EVENT_TYPES = [
     "CREATED",
@@ -1470,30 +1746,174 @@ var init_observability = __esm(() => {
   HEALTH_SEVERITY = { down: 0, degraded: 1, idle: 2, healthy: 3 };
 });
 
+// src/tools/shared/budget.ts
+function jsonBytes(value) {
+  const text = JSON.stringify(value);
+  return text === undefined ? 0 : Buffer.byteLength(text, "utf8");
+}
+function truncateUtf8(text, maxBytes) {
+  if (Buffer.byteLength(text, "utf8") <= maxBytes)
+    return text;
+  const { read } = new TextEncoder().encodeInto(text, new Uint8Array(Math.max(0, maxBytes)));
+  return text.slice(0, read);
+}
+function previewValue(value, maxBytes = VALUE_PREVIEW_BYTES) {
+  if (value === undefined || value === null)
+    return null;
+  const bytes = Buffer.byteLength(JSON.stringify(value), "utf8");
+  if (bytes <= maxBytes)
+    return value;
+  if (typeof value === "string")
+    return `${truncateUtf8(value, maxBytes)}… [cut, ${bytes} bytes]`;
+  if (Array.isArray(value))
+    return `[array of ${value.length} items, ${bytes} bytes]`;
+  return `[${typeof value}, ${bytes} bytes]`;
+}
+function fitItems(options) {
+  const budget = options.budgetBytes ?? RESULT_BUDGET_BYTES;
+  const all = [...options.items];
+  if (jsonBytes(options.build(all)) <= budget)
+    return { kept: all, omitted: 0, truncated: false };
+  const limit = budget - TRUNCATION_RESERVE_BYTES - (options.reserveBytes ?? 0);
+  let lo = 0;
+  let hi = all.length - 1;
+  while (lo < hi) {
+    const mid = Math.ceil((lo + hi) / 2);
+    if (jsonBytes(options.build(all.slice(0, mid))) <= limit)
+      lo = mid;
+    else
+      hi = mid - 1;
+  }
+  return { kept: all.slice(0, lo), omitted: all.length - lo, truncated: true };
+}
+function truncationNotice(options) {
+  const budgetBytes = options.budgetBytes ?? RESULT_BUDGET_BYTES;
+  const total = options.kept + options.omitted;
+  return {
+    truncated: true,
+    truncation: { kept: options.kept, omitted: options.omitted, budgetBytes },
+    hint: `Result cut to ${options.kept} of ${total} ${options.noun} to stay under ${Math.round(budgetBytes / 1000)} KB. ${options.hint}`
+  };
+}
+function highlyDivisibleFloor(n) {
+  if (n <= 0)
+    return 0;
+  if (n >= 10)
+    return Math.floor(n / 10) * 10;
+  let p = 1;
+  while (p * 2 <= n)
+    p *= 2;
+  return p;
+}
+function alignedKeep(offset, fit) {
+  if (offset === 0)
+    return highlyDivisibleFloor(fit);
+  for (let keep = fit;keep >= 1; keep--) {
+    if (offset % keep === 0 && offset / keep + 2 <= MAX_PAGE)
+      return keep;
+  }
+  return 0;
+}
+function resumeNumberedPage(meta, options) {
+  const { next: _replaced, totalPages: _droppedTotalPages, ...rest } = meta;
+  if (options.kept === 0)
+    return { ...rest, hasMore: false };
+  const offset = (options.page - 1) * options.limit;
+  return {
+    ...rest,
+    hasMore: true,
+    next: nextArgs(options.args, { page: offset / options.kept + 2, limit: options.kept })
+  };
+}
+function budgetNumberedPage(options) {
+  const offset = (options.page - 1) * options.limit;
+  const fit = fitItems({
+    items: options.items,
+    build: (kept) => options.build(kept, options.pagination),
+    reserveBytes: jsonBytes({ pagination: { next: options.args } })
+  });
+  if (!fit.truncated)
+    return options.build([...options.items], options.pagination);
+  const buildCut = (fitCount) => {
+    const keep = alignedKeep(offset, fitCount);
+    const alignmentImpossible = keep === 0 && fitCount > 0;
+    const pagination = resumeNumberedPage(options.pagination, {
+      args: options.args,
+      page: options.page,
+      limit: options.limit,
+      kept: keep
+    });
+    const hint = keep > 0 ? options.resumeHint : alignmentImpossible ? options.alignmentImpossibleHint ?? DEFAULT_ALIGNMENT_IMPOSSIBLE_HINT : options.emptyHint;
+    const result = {
+      ...options.build(options.items.slice(0, keep), pagination),
+      ...truncationNotice({ kept: keep, omitted: options.items.length - keep, noun: options.noun, hint })
+    };
+    return { result, keep };
+  };
+  let fitCount = fit.kept.length;
+  let { result, keep } = buildCut(fitCount);
+  while (jsonBytes(result) > RESULT_BUDGET_BYTES && keep > 0) {
+    fitCount = keep - 1;
+    ({ result, keep } = buildCut(fitCount));
+  }
+  return result;
+}
+var RESULT_BUDGET_BYTES = 80000, TRUNCATION_RESERVE_BYTES = 1024, SCRAPE_CONTENT_BUDGET_BYTES = 70000, VALUE_PREVIEW_BYTES = 1000, DEFAULT_ALIGNMENT_IMPOSSIBLE_HINT = "Page offset too deep to resume inline at this limit; retry with a smaller limit or from an earlier page.";
+var init_budget = __esm(() => {
+  init_pagination();
+});
+
 // src/tools/scrape.ts
-import { z as z5 } from "zod";
-function registerScrapeTools(server, ctx, helpers) {
+import { z as z7 } from "zod";
+function scrapeResult(response, format) {
+  const { content, ...metadata } = response;
+  if (typeof content !== "string" || content.length === 0)
+    return textOnlyResult(metadata);
+  const contentBytes = Buffer.byteLength(content, "utf8");
+  if (response.isBase64) {
+    return textOnlyResult({
+      ...metadata,
+      contentBytes,
+      contentOmitted: "binary",
+      hint: `The URL returned binary content (${response.contentType ?? "unknown type"}), which scrape does not return inline.`
+    });
+  }
+  const text = truncateUtf8(content, SCRAPE_CONTENT_BUDGET_BYTES);
+  const keptBytes = Buffer.byteLength(text, "utf8");
+  const cut = keptBytes < contentBytes;
+  const hint = format === "html" ? "Page HTML was cut at 70 KB. Retry with format markdown (much smaller), or use create_workflow to extract structured data from the whole page." : "Page markdown was cut at 70 KB. Use create_workflow to extract structured data from the whole page.";
+  const meta = {
+    ...metadata,
+    contentBytes,
+    ...cut && {
+      truncated: true,
+      truncation: { keptBytes, omittedBytes: contentBytes - keptBytes, budgetBytes: SCRAPE_CONTENT_BUDGET_BYTES },
+      hint
+    }
+  };
+  return withExtraContent(textOnlyResult(meta), { type: "text", text });
+}
+function registerScrapeTools(server, ctx, helpers, defaultProductType) {
   const { withErrorHandling } = helpers;
   server.registerTool("scrape", {
     title: "Scrape URL",
-    description: "Immediately fetch one URL as LLM-friendly markdown or raw HTML without creating a workflow. " + "Markdown is the default. Routing is fully automatic: it starts cheap and escalates through stealth tiers on its own when a site blocks bots, and remembers the working method per host. " + "Use create_workflow instead for structured extraction, recurring runs, monitoring, or navigation-heavy jobs.",
+    description: "Immediately fetch one URL as LLM-friendly markdown or raw HTML without creating a workflow. " + "Markdown is the default. Routing is fully automatic: it starts cheap and escalates through stealth tiers on its own when a site blocks bots, and remembers the working method per host. " + (defaultProductType === "realtime" ? "Use create_realtime_monitor for monitoring, and create_workflow for one-time or scheduled structured extraction or navigation-heavy jobs. " : "Use create_workflow instead for structured extraction, recurring runs, monitoring, or navigation-heavy jobs. ") + "The result is a JSON metadata block followed by the page text as its own block, capped at 70 KB.",
     inputSchema: strictSchema({
-      url: z5.url().refine((value) => {
+      url: z7.url().refine((value) => {
         const protocol = new URL(value).protocol;
         return protocol === "http:" || protocol === "https:";
       }, "URL must use HTTP or HTTPS").describe("HTTP or HTTPS URL to fetch"),
-      format: z5.enum(["html", "markdown"]).optional().describe("Output format. Defaults to markdown for compact LLM consumption; use html for raw source.")
+      format: z7.enum(["html", "markdown"]).optional().describe("Output format. Defaults to markdown for compact LLM consumption; use html for raw source.")
     }),
     annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
   }, withErrorHandling("scrape", async (args) => {
-    const response = await ctx.client.scrape.fetch({
-      url: args.url,
-      format: args.format ?? "markdown"
-    });
-    return jsonResult(response);
+    const format = args.format ?? "markdown";
+    const response = await ctx.client.scrape.fetch({ url: args.url, format });
+    return scrapeResult(response, format);
   }));
 }
 var init_scrape = __esm(() => {
+  init_budget();
   init_schemas();
 });
 
@@ -1649,7 +2069,7 @@ var init_errors = () => {};
 
 // src/tools/support.ts
 import { KadoaHttpException as KadoaHttpException2 } from "@kadoa/node-sdk";
-import { z as z6 } from "zod";
+import { z as z8 } from "zod";
 function supportTicketSkipMessage(reason) {
   return (reason && SUPPORT_TICKET_SKIP_MESSAGES[reason]) ?? "No support ticket was filed because this workflow isn't eligible for a support ticket right now.";
 }
@@ -1673,11 +2093,11 @@ function registerSupportTools(server, ctx, helpers) {
     title: "Create Support Ticket",
     description: "File a support ticket for one workflow so the Kadoa team investigates it. " + "Only file after the user has agreed. If the workflow already has an open ticket, that ticket is " + "returned instead of a duplicate. Filing never pauses the workflow.",
     inputSchema: strictSchema({
-      workflowId: z6.string().min(1).describe("The workflow the problem is about"),
-      title: z6.string().describe("One-line summary of the problem"),
-      description: z6.string().describe("What is wrong, what was observed, and what was already tried"),
-      category: z6.enum(["bug", "feature", "workflow_issue", "template_issue", "integration", "billing", "data_diff"]).optional().describe("Support category; defaults to a workflow issue"),
-      jobId: z6.string().optional().describe("The failing run's id (from list_workflow_runs). Required when filing from the Kadoa Assistant.")
+      workflowId: z8.string().min(1).describe("The workflow the problem is about"),
+      title: z8.string().describe("One-line summary of the problem"),
+      description: z8.string().describe("What is wrong, what was observed, and what was already tried"),
+      category: z8.enum(["bug", "feature", "workflow_issue", "template_issue", "integration", "billing", "data_diff"]).optional().describe("Support category; defaults to a workflow issue"),
+      jobId: z8.string().optional().describe("The failing run's id (from list_workflow_runs). Required when filing from the Kadoa Assistant.")
     }),
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }
   }, withErrorHandling("create_support_ticket", async (args) => {
@@ -1741,29 +2161,36 @@ var init_support = __esm(() => {
 });
 
 // src/tools/team.ts
-import { z as z7 } from "zod";
+import { z as z9 } from "zod";
 function registerWhoamiTool(server, ctx, helpers) {
   const { withErrorHandling } = helpers;
   server.registerTool("whoami", {
     title: "Show Current User",
-    description: "Show current user details: email, authentication method, and team memberships",
+    description: "Show current user details: email, authentication method, team memberships, and the team's default product",
     inputSchema: strictSchema({}),
     annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("whoami", async () => {
+    const defaultProductTypePromise = ctx.client.user.getFeatures().then((features) => parseDefaultProductType(features.defaultProductType), () => {
+      return;
+    });
     if (ctx.principal.connector) {
-      const teams = await ctx.client.listTeams();
+      const [teams, defaultProductType] = await Promise.all([
+        ctx.client.listTeams(),
+        defaultProductTypePromise
+      ]);
       const activeTeam = teams.find((team) => team.id === ctx.principal.teamId);
       if (!activeTeam) {
         throw new Error("The active team is unavailable for this credential. Reconnect and choose a team.");
       }
       return jsonResult({
         authMethod: "Shared organization service account",
-        team: { name: activeTeam.name }
+        team: { name: activeTeam.name, ...defaultProductType ? { defaultProductType } : {} }
       });
     }
-    const [user, teams] = await Promise.all([
+    const [user, teams, defaultProductType] = await Promise.all([
       ctx.client.user.getCurrentUser(),
-      ctx.client.listTeams()
+      ctx.client.listTeams(),
+      defaultProductTypePromise
     ]);
     const activeTeam = teams.find((team) => team.id === ctx.principal.teamId);
     if (!activeTeam) {
@@ -1774,7 +2201,8 @@ function registerWhoamiTool(server, ctx, helpers) {
       authMethod: ctx.principal.actor ? `Kadoa Assistant (delegated via ${ctx.principal.actor.sub})` : "Kadoa access token",
       team: {
         name: activeTeam.name,
-        ...activeTeam.memberRole ? { memberRole: activeTeam.memberRole } : {}
+        ...activeTeam.memberRole ? { memberRole: activeTeam.memberRole } : {},
+        ...defaultProductType ? { defaultProductType } : {}
       },
       scopes: ctx.principal.scopes
     });
@@ -1803,7 +2231,7 @@ function registerTeamTools(server, ctx, helpers) {
     title: "Switch Team",
     description: "Switch the active team by name or ID. After switching, all subsequent API calls will use the new team context.",
     inputSchema: strictSchema({
-      teamIdentifier: z7.string().min(1).describe("Team name or team ID to switch to")
+      teamIdentifier: z9.string().min(1).describe("Team name or team ID to switch to")
     }),
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("team_switch", async () => errorResult("team_switch is not available for this credential. Reconnect and choose the team at sign-in.")));
@@ -1814,7 +2242,7 @@ var init_team = __esm(() => {
 });
 
 // src/tools/templates.ts
-import { z as z8 } from "zod";
+import { z as z10 } from "zod";
 function normalizeTemplateSchemaField(val) {
   if (val === null || typeof val !== "object" || Array.isArray(val))
     return val;
@@ -1844,6 +2272,7 @@ function registerTemplateTools(server, ctx, helpers) {
     return jsonResult({
       templates: templates.map(withTemplateDashboardUrl),
       count: templates.length,
+      pagination: completeList(templates.length),
       instructions: "To instantiate a listed template, call create_workflow with the matching templateId, source URLs, optional templateVersion, and optional prompt containing only workflow-specific additional instructions. Do not copy the template prompt, entity, or schema into the call."
     });
   }));
@@ -1851,7 +2280,7 @@ function registerTemplateTools(server, ctx, helpers) {
     title: "Get Template",
     description: "Get a template by ID, including all published versions and their schemas. After inspecting it, instantiate the template with create_workflow using templateId, source URLs, optional templateVersion, and optional prompt containing only workflow-specific additional instructions. Never copy the returned prompt, entity, or schema into the call - those shared values are inherited when templateId is passed.",
     inputSchema: strictSchema({
-      templateId: z8.string().min(1).describe("The template ID")
+      templateId: z10.string().min(1).describe("The template ID")
     }),
     annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("get_template", async (args) => {
@@ -1865,8 +2294,8 @@ function registerTemplateTools(server, ctx, helpers) {
     title: "Create Template",
     description: "Create a new template. After creation, use create_template_version to publish a version with prompt, schema, and notifications.",
     inputSchema: strictSchema({
-      name: z8.string().describe("Template name (1-255 chars)"),
-      description: z8.string().optional().describe("Template description (max 2000 chars)")
+      name: z10.string().describe("Template name (1-255 chars)"),
+      description: z10.string().optional().describe("Template description (max 2000 chars)")
     }),
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }
   }, withErrorHandling("create_template", async (args) => {
@@ -1886,9 +2315,9 @@ function registerTemplateTools(server, ctx, helpers) {
 
 ` + "This tool CANNOT change what linked workflows inherit - prompt, schema, validation rules, notifications and frequency all live in template *versions*, which are immutable snapshots. " + "To change any of those, publish a new version with `create_template_version` (the version IS the edit), then roll it out to linked workflows with `apply_template_version`. " + "There is no in-place edit of a published version, and never report a prompt or schema change as impossible - versioning is the supported path.",
     inputSchema: strictSchema({
-      templateId: z8.string().min(1).describe("The template ID to update"),
-      name: z8.preprocess(coerceNull(), z8.string().optional()).optional().describe("New template name"),
-      description: z8.preprocess(coerceNull(), z8.string().optional()).optional().describe("New template description")
+      templateId: z10.string().min(1).describe("The template ID to update"),
+      name: z10.preprocess(coerceNull(), z10.string().optional()).optional().describe("New template name"),
+      description: z10.preprocess(coerceNull(), z10.string().optional()).optional().describe("New template description")
     }),
     annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("update_template", async (args) => {
@@ -1904,8 +2333,8 @@ function registerTemplateTools(server, ctx, helpers) {
     title: "Delete Template",
     description: "Delete (archive) a template. " + "You MUST first call this tool without confirmed=true to preview what will be deleted, " + "then show the user the template name and ask for confirmation, " + "then call again with confirmed=true only after the user explicitly agrees.",
     inputSchema: strictSchema({
-      templateId: z8.string().min(1).describe("The template ID to delete"),
-      confirmed: z8.preprocess(coerceBoolean(), z8.boolean()).optional().describe("Set to true only after the user has explicitly confirmed deletion. Omit or set to false for the initial preview call.")
+      templateId: z10.string().min(1).describe("The template ID to delete"),
+      confirmed: z10.preprocess(coerceBoolean(), z10.boolean()).optional().describe("Set to true only after the user has explicitly confirmed deletion. Omit or set to false for the initial preview call.")
     }),
     annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("delete_template", async (args) => {
@@ -1929,15 +2358,15 @@ function registerTemplateTools(server, ctx, helpers) {
     });
   }));
   const TemplateSchemaFieldShape = {
-    name: z8.string().describe("Field name"),
-    description: z8.string().optional().describe("Field description"),
-    fieldType: z8.enum(["SCHEMA", "CLASSIFICATION"]).optional().describe("Field role: SCHEMA (default) for extracted data, CLASSIFICATION for a field with predefined categories"),
-    example: z8.string().optional().describe("Example value"),
+    name: z10.string().describe("Field name"),
+    description: z10.string().optional().describe("Field description"),
+    fieldType: z10.enum(["SCHEMA", "CLASSIFICATION"]).optional().describe("Field role: SCHEMA (default) for extracted data, CLASSIFICATION for a field with predefined categories"),
+    example: z10.string().optional().describe("Example value"),
     dataType: SchemaFieldDataTypeSchema.optional().describe("Data type for SCHEMA fields"),
-    isKey: z8.preprocess(coerceBoolean(), z8.boolean()).optional().describe("Whether the field is a key field"),
-    categories: z8.preprocess(coerceArray(), z8.array(z8.object({
-      title: z8.string().describe("Short title/label of the category"),
-      definition: z8.string().describe("Full definition/description of the category")
+    isKey: z10.preprocess(coerceBoolean(), z10.boolean()).optional().describe("Whether the field is a key field"),
+    categories: z10.preprocess(coerceArray(), z10.array(z10.object({
+      title: z10.string().describe("Short title/label of the category"),
+      definition: z10.string().describe("Full definition/description of the category")
     }))).optional().describe("Predefined categories for a CLASSIFICATION field ({title, definition}[]). Required for fieldType=CLASSIFICATION; omitted otherwise.")
   };
   async function latestTemplateVersionRules(templateId) {
@@ -1962,25 +2391,25 @@ function registerTemplateTools(server, ctx, helpers) {
 
 ` + "THIS IS HOW YOU EDIT A TEMPLATE'S PROMPT OR SCHEMA. Published versions are immutable, so 'changing the template prompt' means publishing a new version here and then calling `apply_template_version` to push it onto linked workflows. " + "`update_template` only renames a template; it cannot touch prompt or schema.",
     inputSchema: withoutDefIds(strictSchema({
-      templateId: z8.string().min(1).describe("The template ID to publish a version for"),
-      prompt: z8.string().optional().describe("User prompt to copy into workflow config"),
-      schemaId: z8.string().optional().describe("Existing schema ID to reference (mutually exclusive with schemaFields)"),
-      schemaFields: z8.preprocess(coerceArray(), z8.array(z8.preprocess(normalizeTemplateSchemaField, z8.object(TemplateSchemaFieldShape).strict()))).optional().describe("Inline schema fields to create a new schema (mutually exclusive with schemaId)"),
-      schemaEntity: z8.string().optional().describe("Entity name for the inline schema"),
-      schemaValidationRules: z8.preprocess((val) => stripSchemaValidationAttribution(coerceJson()(val)), SchemaValidationRulesSchema).optional().describe('Per-field schema validation rules keyed by field name. Each rule uses kind STRING, NUMBER, OTHER, OBJECT, or ARRAY and nested rules are supported. Edit attribution is stamped server-side, so send only rule values. Example: { "price": { "kind": "NUMBER", "minimum": { "value": 0 } } }. Not inherited from prior versions - omitting this on a new version drops any rules the previous version had.'),
-      notifications: z8.preprocess(coerceArray(), z8.array(z8.object({
-        eventType: z8.string().describe("Notification event type"),
-        eventConfiguration: z8.preprocess(coerceJson(), z8.record(z8.string(), z8.unknown())).optional(),
-        enabled: z8.preprocess(coerceBoolean(), z8.boolean()).optional(),
-        channelIds: z8.preprocess(coerceArray(), z8.array(z8.string().min(1))).optional(),
-        channels: z8.preprocess(coerceArray(), z8.array(z8.object({ channelId: z8.string() }))).optional()
+      templateId: z10.string().min(1).describe("The template ID to publish a version for"),
+      prompt: z10.string().optional().describe("User prompt to copy into workflow config"),
+      schemaId: z10.string().optional().describe("Existing schema ID to reference (mutually exclusive with schemaFields)"),
+      schemaFields: z10.preprocess(coerceArray(), z10.array(z10.preprocess(normalizeTemplateSchemaField, z10.object(TemplateSchemaFieldShape).strict()))).optional().describe("Inline schema fields to create a new schema (mutually exclusive with schemaId)"),
+      schemaEntity: z10.string().optional().describe("Entity name for the inline schema"),
+      schemaValidationRules: z10.preprocess((val) => stripSchemaValidationAttribution(coerceJson()(val)), SchemaValidationRulesSchema).optional().describe('Per-field schema validation rules keyed by field name. Each rule uses kind STRING, NUMBER, OTHER, OBJECT, or ARRAY and nested rules are supported. Edit attribution is stamped server-side, so send only rule values. Example: { "price": { "kind": "NUMBER", "minimum": { "value": 0 } } }. Not inherited from prior versions - omitting this on a new version drops any rules the previous version had.'),
+      notifications: z10.preprocess(coerceArray(), z10.array(z10.object({
+        eventType: z10.string().describe("Notification event type"),
+        eventConfiguration: z10.preprocess(coerceJson(), z10.record(z10.string(), z10.unknown())).optional(),
+        enabled: z10.preprocess(coerceBoolean(), z10.boolean()).optional(),
+        channelIds: z10.preprocess(coerceArray(), z10.array(z10.string().min(1))).optional(),
+        channels: z10.preprocess(coerceArray(), z10.array(z10.object({ channelId: z10.string() }))).optional()
       }))).optional().describe("Notification configuration for this version"),
-      frequency: z8.preprocess(coerceJson(), z8.object({
-        interval: z8.enum([...UpdateIntervalSchema.options, "REAL_TIME"]).optional().describe("Scheduling interval the template controls for linked workflows. Use CUSTOM with 'schedules' for cron."),
-        schedules: z8.preprocess(coerceArray(), z8.array(z8.object({
-          type: z8.enum(["repeat", "cron"]).describe("'repeat' (interval token) or 'cron' (cron expressions)"),
-          interval: z8.string().optional().describe("Repeat token (e.g. '1h', '1d') when type='repeat'"),
-          expressions: z8.preprocess(coerceArray(true), z8.array(z8.string())).optional().describe("Cron expressions when type='cron' (e.g. '0 8 * * 2')")
+      frequency: z10.preprocess(coerceJson(), z10.object({
+        interval: z10.enum([...UpdateIntervalSchema.options, "REAL_TIME"]).optional().describe("Scheduling interval the template controls for linked workflows. Use CUSTOM with 'schedules' for cron."),
+        schedules: z10.preprocess(coerceArray(), z10.array(z10.object({
+          type: z10.enum(["repeat", "cron"]).describe("'repeat' (interval token) or 'cron' (cron expressions)"),
+          interval: z10.string().optional().describe("Repeat token (e.g. '1h', '1d') when type='repeat'"),
+          expressions: z10.preprocess(coerceArray(true), z10.array(z10.string())).optional().describe("Cron expressions when type='cron' (e.g. '0 8 * * 2')")
         }))).optional().describe("Schedule specs. Required when interval='CUSTOM'.")
       })).optional().describe("Template-controlled scheduling for linked workflows ({interval, schedules}). Linked workflows inherit and cannot override this when set.")
     })),
@@ -2010,11 +2439,11 @@ function registerTemplateTools(server, ctx, helpers) {
     title: "Save Workflow as Template",
     description: "Create a template from an existing workflow's configuration (prompt, schema, notifications). " + "Provide 'name' to create a new template, or 'templateId' to add a new version to an existing template. " + "Use 'includeParts' to save only specific parts of the configuration.",
     inputSchema: strictSchema({
-      workflowId: z8.string().min(1).describe("Source workflow ID to extract config from"),
-      name: z8.string().optional().describe("Name for the new template (required if templateId is not set)"),
-      description: z8.string().optional().describe("Description for the new template"),
-      templateId: z8.string().optional().describe("Existing template ID to add a new version to (mutually exclusive with name)"),
-      includeParts: z8.preprocess(coerceArray(), z8.array(z8.enum(["prompt", "schema", "schemaValidationRules", "notifications", "frequency"])).optional()).describe("Which parts of the workflow config to include: prompt, schema, schemaValidationRules, notifications, frequency. Omit to include all. At least 1 required if provided.")
+      workflowId: z10.string().min(1).describe("Source workflow ID to extract config from"),
+      name: z10.string().optional().describe("Name for the new template (required if templateId is not set)"),
+      description: z10.string().optional().describe("Description for the new template"),
+      templateId: z10.string().optional().describe("Existing template ID to add a new version to (mutually exclusive with name)"),
+      includeParts: z10.preprocess(coerceArray(), z10.array(z10.enum(["prompt", "schema", "schemaValidationRules", "notifications", "frequency"])).optional()).describe("Which parts of the workflow config to include: prompt, schema, schemaValidationRules, notifications, frequency. Omit to include all. At least 1 required if provided.")
     }),
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }
   }, withErrorHandling("save_workflow_as_template", async (args) => {
@@ -2035,20 +2464,20 @@ function registerTemplateTools(server, ctx, helpers) {
     title: "List Template Schemas",
     description: "List schemas associated with a template.",
     inputSchema: strictSchema({
-      templateId: z8.string().min(1).describe("The template ID")
+      templateId: z10.string().min(1).describe("The template ID")
     }),
     annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("list_template_schemas", async (args) => {
     const schemas = await ctx.client.template.listSchemas(args.templateId);
-    return jsonResult({ schemas, count: schemas.length });
+    return jsonResult({ schemas, count: schemas.length, pagination: completeList(schemas.length) });
   }));
   server.registerTool("link_template_to_workflows", {
     title: "Link Template to Workflows",
     description: "Link one or more EXISTING workflows to a template in a single call. " + "This is the bulk equivalent of creating a workflow with `templateId`: linked workflows adopt the template's configuration (prompt, schema, notifications) and stay in sync with it. " + "The template ENFORCES its schema on linked workflows - their extracted output conforms to the template's declared field names, so this is the way to make many workflows produce a consistent, canonical schema. " + "Use `list_templates`/`get_template` to find the template, and `list_workflows` to find the workflow IDs. " + "Set `force: true` to relink workflows already linked to a different template.",
     inputSchema: strictSchema({
-      templateId: z8.string().min(1).describe("The template ID to link workflows to"),
-      workflowIds: z8.preprocess(coerceArray(true), z8.array(z8.string().min(1)).min(1)).describe("Workflow IDs to link to the template (array of strings). Also accepts a single ID string."),
-      force: z8.preprocess(coerceBoolean(), z8.boolean()).optional().describe("If true, relink workflows that are already linked to another template. Defaults to false.")
+      templateId: z10.string().min(1).describe("The template ID to link workflows to"),
+      workflowIds: z10.preprocess(coerceArray(true), z10.array(z10.string().min(1)).min(1)).describe("Workflow IDs to link to the template (array of strings). Also accepts a single ID string."),
+      force: z10.preprocess(coerceBoolean(), z10.boolean()).optional().describe("If true, relink workflows that are already linked to another template. Defaults to false.")
     }),
     annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("link_template_to_workflows", async (args) => {
@@ -2075,9 +2504,9 @@ function registerTemplateTools(server, ctx, helpers) {
     title: "Apply Template Version",
     description: "Push a template version onto its linked workflows. Updates the given workflows to the template's `targetVersion`, applying the template-controlled parts (prompt, schema, validation rules, notifications, frequency). " + "Use this after publishing a new template version to bring linked workflows up to date (see list_template_workflows for which workflows are outdated). " + "Returns how many workflows were updated and which parts the template controls.",
     inputSchema: strictSchema({
-      templateId: z8.string().min(1).describe("The template ID whose version to apply"),
-      targetVersion: z8.preprocess(coerceNumber(), z8.number()).describe("The template version number to apply to the workflows"),
-      workflowIds: z8.preprocess(coerceArray(true), z8.array(z8.string().min(1)).min(1)).describe("Workflow IDs to update to the target version (array of strings). Also accepts a single ID string.")
+      templateId: z10.string().min(1).describe("The template ID whose version to apply"),
+      targetVersion: z10.preprocess(coerceNumber(), z10.number()).describe("The template version number to apply to the workflows"),
+      workflowIds: z10.preprocess(coerceArray(true), z10.array(z10.string().min(1)).min(1)).describe("Workflow IDs to update to the target version (array of strings). Also accepts a single ID string.")
     }),
     annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("apply_template_version", async (args) => {
@@ -2097,19 +2526,19 @@ function registerTemplateTools(server, ctx, helpers) {
     title: "List Template Workflows",
     description: "List the workflows linked to a template, with each workflow's pinned template version and an `isOutdated` flag (true when a newer template version exists). " + "Use this to verify which workflows are bound to a template and to find ones that need apply_template_version.",
     inputSchema: strictSchema({
-      templateId: z8.string().min(1).describe("The template ID")
+      templateId: z10.string().min(1).describe("The template ID")
     }),
     annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("list_template_workflows", async (args) => {
     const workflows = await ctx.client.template.getLinkedWorkflows(args.templateId);
-    return jsonResult({ workflows, count: workflows.length });
+    return jsonResult({ workflows, count: workflows.length, pagination: completeList(workflows.length) });
   }));
   server.registerTool("unlink_template_from_workflows", {
     title: "Unlink Template from Workflows",
     description: "Unlink one or more workflows from a template in a single call. " + "Unlinked workflows keep their current configuration but stop tracking the template (future template version changes no longer apply to them).",
     inputSchema: strictSchema({
-      templateId: z8.string().min(1).describe("The template ID to unlink workflows from"),
-      workflowIds: z8.preprocess(coerceArray(true), z8.array(z8.string().min(1)).min(1)).describe("Workflow IDs to unlink from the template (array of strings). Also accepts a single ID string.")
+      templateId: z10.string().min(1).describe("The template ID to unlink workflows from"),
+      workflowIds: z10.preprocess(coerceArray(true), z10.array(z10.string().min(1)).min(1)).describe("Workflow IDs to unlink from the template (array of strings). Also accepts a single ID string.")
     }),
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("unlink_template_from_workflows", async (args) => {
@@ -2126,21 +2555,22 @@ function registerTemplateTools(server, ctx, helpers) {
 }
 var LEGACY_DATA_TYPE_ALIASES;
 var init_templates = __esm(() => {
+  init_pagination();
   init_schemas();
   LEGACY_DATA_TYPE_ALIASES = { TEXT: "STRING", URL: "LINK" };
 });
 
 // src/tools/variables.ts
-import { z as z9 } from "zod";
+import { z as z11 } from "zod";
 function registerVariableTools(server, ctx, helpers) {
   const { withErrorHandling } = helpers;
   server.registerTool("create_variable", {
     title: "Create Variable",
     description: "Create a new variable. Variables are key-value pairs that can be referenced in workflow prompts using @variableKey syntax. Keys must be unique within the team scope.",
     inputSchema: strictSchema({
-      key: z9.string().describe("Variable key (must be unique within scope). Referenced in prompts as @key."),
-      value: z9.string().describe("Variable value"),
-      dataType: z9.enum(["STRING", "SECRET", "OBJECT", "ARRAY"]).optional().describe("Data type of the value (defaults to STRING)")
+      key: z11.string().describe("Variable key (must be unique within scope). Referenced in prompts as @key."),
+      value: z11.string().describe("Variable value"),
+      dataType: z11.enum(["STRING", "SECRET", "OBJECT", "ARRAY"]).optional().describe("Data type of the value (defaults to STRING)")
     }),
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }
   }, withErrorHandling("create_variable", async (args) => {
@@ -2164,14 +2594,15 @@ function registerVariableTools(server, ctx, helpers) {
     const variables = await ctx.client.variable.list();
     return jsonResult({
       variables: variables.map(withVariableDashboardUrl),
-      count: variables.length
+      count: variables.length,
+      pagination: completeList(variables.length)
     });
   }));
   server.registerTool("get_variable", {
     title: "Get Variable",
     description: "Get a specific variable by its ID.",
     inputSchema: strictSchema({
-      variableId: z9.string().min(1).describe("The variable ID")
+      variableId: z11.string().min(1).describe("The variable ID")
     }),
     annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("get_variable", async (args) => {
@@ -2182,10 +2613,10 @@ function registerVariableTools(server, ctx, helpers) {
     title: "Update Variable",
     description: "Update an existing variable. At least one field must be provided. If the variable key is referenced in workflow prompts (@variableKey), those workflows will automatically use the new value on next run.",
     inputSchema: strictSchema({
-      variableId: z9.string().min(1).describe("The variable ID to update"),
-      key: z9.string().optional().describe("New variable key"),
-      value: z9.string().optional().describe("New variable value"),
-      dataType: z9.enum(["STRING", "SECRET", "OBJECT", "ARRAY"]).optional().describe("New data type")
+      variableId: z11.string().min(1).describe("The variable ID to update"),
+      key: z11.string().optional().describe("New variable key"),
+      value: z11.string().optional().describe("New variable value"),
+      dataType: z11.enum(["STRING", "SECRET", "OBJECT", "ARRAY"]).optional().describe("New data type")
     }),
     annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("update_variable", async (args) => {
@@ -2201,8 +2632,8 @@ function registerVariableTools(server, ctx, helpers) {
     title: "Delete Variable",
     description: "Delete a variable permanently. This is irreversible. " + "You MUST first call this tool without confirmed=true to preview what will be deleted, " + "then show the user the variable key and ask for confirmation, " + "then call again with confirmed=true only after the user explicitly agrees.",
     inputSchema: strictSchema({
-      variableId: z9.string().min(1).describe("The variable ID to delete"),
-      confirmed: z9.preprocess(coerceBoolean(), z9.boolean()).optional().describe("Set to true only after the user has explicitly confirmed deletion. Omit or set to false for the initial preview call.")
+      variableId: z11.string().min(1).describe("The variable ID to delete"),
+      confirmed: z11.preprocess(coerceBoolean(), z11.boolean()).optional().describe("Set to true only after the user has explicitly confirmed deletion. Omit or set to false for the initial preview call.")
     }),
     annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("delete_variable", async (args) => {
@@ -2227,12 +2658,13 @@ function registerVariableTools(server, ctx, helpers) {
   }));
 }
 var init_variables = __esm(() => {
+  init_pagination();
   init_schemas();
 });
 
 // src/tools/workflows.ts
 import { WorkflowStatusFilter } from "@kadoa/node-sdk";
-import { z as z10 } from "zod";
+import { z as z12 } from "zod";
 function isRealTimeInterval(interval) {
   return interval?.toUpperCase().replace("-", "_") === "REAL_TIME";
 }
@@ -2289,6 +2721,49 @@ function mapRunStatus(state) {
       return state ?? "unknown";
   }
 }
+function changeResult(change) {
+  const build = (data, differences) => ({
+    id: change.id,
+    workflowId: change.workflowId,
+    url: change.url,
+    summary: change.summary,
+    screenshotUrl: change.screenshotUrl,
+    data,
+    differences,
+    createdAt: change.createdAt
+  });
+  const full = build(change.data, change.differences);
+  if (jsonBytes(full) <= RESULT_BUDGET_BYTES)
+    return full;
+  const rows = change.data ?? [];
+  const exportHint = `For the full current dataset use export_data with workflowId ${change.workflowId}.`;
+  if (jsonBytes(build([], change.differences)) <= RESULT_BUDGET_BYTES - TRUNCATION_RESERVE_BYTES) {
+    const fit = fitItems({ items: rows, build: (kept) => build(kept, change.differences) });
+    if (!fit.truncated)
+      return build(fit.kept, change.differences);
+    return {
+      ...build(fit.kept, change.differences),
+      ...truncationNotice({
+        kept: fit.kept.length,
+        omitted: fit.omitted,
+        noun: "data rows",
+        hint: `differences is complete. ${exportHint}`
+      })
+    };
+  }
+  const fit = fitItems({ items: change.differences ?? [], build: (kept) => build([], kept) });
+  if (!fit.truncated)
+    return build([], fit.kept);
+  return {
+    ...build([], fit.kept),
+    ...truncationNotice({
+      kept: fit.kept.length,
+      omitted: fit.omitted,
+      noun: "differences",
+      hint: `All ${rows.length} data rows omitted. ${exportHint}`
+    })
+  };
+}
 function jsonEq(a, b) {
   return JSON.stringify(a) === JSON.stringify(b);
 }
@@ -2302,13 +2777,32 @@ function diffWorkflowAuditEntry(entry) {
     if (!jsonEq(prev[key], next[key]))
       changed.push(key);
   }
-  const prevPrompt = prev["additionalData"]?.["userPrompt"];
-  const nextPrompt = next["additionalData"]?.["userPrompt"];
-  if (!jsonEq(prevPrompt, nextPrompt))
+  if (!jsonEq(auditFieldValue(prev, "additionalData.userPrompt"), auditFieldValue(next, "additionalData.userPrompt"))) {
     changed.push("additionalData.userPrompt");
+  }
   return changed;
 }
-function registerWorkflowCoreTools(server, ctx, helpers) {
+function auditFieldValue(snapshot, field) {
+  if (field === "additionalData.userPrompt") {
+    return snapshot["additionalData"]?.["userPrompt"];
+  }
+  return snapshot[field];
+}
+function summarizeWorkflowAuditEntry(entry) {
+  const changedFields = diffWorkflowAuditEntry(entry);
+  const prev = entry.previousValue ?? {};
+  const next = entry.newValue ?? {};
+  const changes = changedFields.map((field) => ({
+    field,
+    before: previewValue(auditFieldValue(prev, field)),
+    after: previewValue(auditFieldValue(next, field))
+  }));
+  return { changedFields, changes };
+}
+function historyEmptyHint(includeSnapshots) {
+  return includeSnapshots ? "A single entry is too large to return inline. Retry without includeSnapshots for the diff summary." : "A single entry is too large to return inline even without snapshots. Retry with a narrower page (e.g. limit=1) or fewer fields.";
+}
+function registerWorkflowCoreTools(server, ctx, helpers, defaultProductType) {
   const { withErrorHandling } = helpers;
   function resolveUrls(args) {
     const urls = args.urls ?? (args.url ? [args.url] : []);
@@ -2359,7 +2853,7 @@ function registerWorkflowCoreTools(server, ctx, helpers) {
     const channels = {};
     if (n.email) {
       if (typeof n.email === "object" && n.email.recipients?.length) {
-        channels.EMAIL = { name: "mcp-email", recipients: n.email.recipients };
+        channels.EMAIL = { name: mcpChannelName("EMAIL", n.email), recipients: n.email.recipients };
       } else {
         channels.EMAIL = true;
       }
@@ -2368,7 +2862,7 @@ function registerWorkflowCoreTools(server, ctx, helpers) {
       channels.WEBSOCKET = true;
     if (n.webhook) {
       const webhookChannel = {
-        name: "mcp-webhook",
+        name: mcpChannelName("WEBHOOK", { webhookUrl: n.webhook.url }),
         webhookUrl: n.webhook.url,
         httpMethod: n.webhook.httpMethod || "POST"
       };
@@ -2377,7 +2871,7 @@ function registerWorkflowCoreTools(server, ctx, helpers) {
       channels.WEBHOOK = webhookChannel;
     }
     if (n.slack) {
-      const slackChannel = { name: "mcp-slack" };
+      const slackChannel = { name: mcpChannelName("SLACK", n.slack) };
       if (n.slack.webhookUrl)
         slackChannel.webhookUrl = n.slack.webhookUrl;
       if (n.slack.slackChannelId)
@@ -2416,18 +2910,18 @@ function registerWorkflowCoreTools(server, ctx, helpers) {
 
 ` + "Create a data extraction workflow using agentic navigation. Supports one-time or scheduled runs. " + "If entity and schema are provided, they guide the extraction; otherwise the AI agent auto-detects the schema from the page. " + "The workflow runs asynchronously and may take several minutes. Do NOT poll or sleep-wait for completion. " + `Return the workflow ID to the user and let them check back later with get_workflow or fetch_data.
 
-` + "PREFER TEMPLATES: If the user's request matches an existing template, instantiate it via `templateId` instead of writing a fresh prompt/schema. " + "Use `list_templates` to discover available templates and `get_template` to inspect schemas before deciding. " + "When creating from a template, call this tool with the template's `templateId`, the source `urls`, optional `templateVersion`, and optional `prompt` containing only workflow-specific additional instructions. Never copy the template prompt, entity, or schema into the call, and never silently match or rewrite inline configuration.\n\n" + "NOTE: This tool is for one-time or scheduled extraction ONLY. " + "For continuous realtime monitoring that watches a page for data changes and sends alerts, use the create_realtime_monitor tool instead.",
+` + "PREFER TEMPLATES: If the user's request matches an existing template, instantiate it via `templateId` instead of writing a fresh prompt/schema. " + "Use `list_templates` to discover available templates and `get_template` to inspect schemas before deciding. " + "When creating from a template, call this tool with the template's `templateId`, the source `urls`, optional `templateVersion`, and optional `prompt` containing only workflow-specific additional instructions. Never copy the template prompt, entity, or schema into the call, and never silently match or rewrite inline configuration.\n\n" + "NOTE: This tool is for one-time or scheduled extraction ONLY. " + (defaultProductType === "realtime" ? `This team's default product is realtime monitoring. Do not call this tool unless the user explicitly asked for a one-time run (e.g. "once", "just the current list") or a schedule (e.g. "daily"). A request to get, extract, or scrape data that names no frequency is not explicit: call create_realtime_monitor instead.` : "For continuous realtime monitoring that watches a page for data changes and sends alerts, use the create_realtime_monitor tool instead."),
     inputSchema: strictSchema({
       prompt: extractionPromptInput.describe('Natural language description of what to extract (e.g., "Extract product prices and names"). Required unless templateId is provided. With templateId, use it only for workflow-specific instructions to add to the template prompt.'),
       ...extractionInputShape,
       ...urlInputShape,
-      templateId: z10.string().optional().describe("Instantiate this workflow from a published template. Pass the templateId, source urls, optional templateVersion, and optional prompt with workflow-specific additional instructions. Do not copy the template's shared prompt, entity, or schema into this call - they are inherited from the published template version, and the workflow's output conforms to its declared schema. Discover templates via list_templates and get_template."),
-      templateVersion: z10.preprocess(coerceNumber(), z10.number()).optional().describe("Specific published template version (integer) to instantiate. Defaults to the latest published version when templateId is set."),
-      description: z10.string().max(500).optional().describe("Description of what this workflow does (max 500 characters)"),
-      tags: z10.preprocess(coerceArray(true), z10.array(z10.string())).optional().describe("Tags for organizing workflows"),
-      limit: z10.preprocess(coerceNumber(), z10.number()).optional().describe("Maximum number of records to extract per run. Useful for limiting scope or cost control."),
+      templateId: z12.string().optional().describe("Instantiate this workflow from a published template. Pass the templateId, source urls, optional templateVersion, and optional prompt with workflow-specific additional instructions. Do not copy the template's shared prompt, entity, or schema into this call - they are inherited from the published template version, and the workflow's output conforms to its declared schema. Discover templates via list_templates and get_template."),
+      templateVersion: z12.preprocess(coerceNumber(), z12.number()).optional().describe("Specific published template version (integer) to instantiate. Defaults to the latest published version when templateId is set."),
+      description: z12.string().max(500).optional().describe("Description of what this workflow does (max 500 characters)"),
+      tags: z12.preprocess(coerceArray(true), z12.array(z12.string())).optional().describe("Tags for organizing workflows"),
+      limit: z12.preprocess(coerceNumber(), z12.number()).optional().describe("Maximum number of records to extract per run. Useful for limiting scope or cost control."),
       updateInterval: UpdateIntervalSchema.optional().describe("How often the workflow runs. Defaults to ONLY_ONCE. Use CUSTOM with the 'schedules' field for cron-based scheduling."),
-      schedules: z10.preprocess(coerceArray(true), z10.array(z10.string())).optional().describe("Cron expressions for CUSTOM updateInterval (e.g. '0 8 * * 2' for Tuesdays at 8am UTC). Requires updateInterval='CUSTOM'."),
+      schedules: z12.preprocess(coerceArray(true), z12.array(z12.string())).optional().describe("Cron expressions for CUSTOM updateInterval (e.g. '0 8 * * 2' for Tuesdays at 8am UTC). Requires updateInterval='CUSTOM'."),
       ...notificationsInputShape
     }),
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
@@ -2441,13 +2935,25 @@ function registerWorkflowCoreTools(server, ctx, helpers) {
     }
     const n = args.notifications;
     const hasNotifications = !!(n && (n.email || n.webhook || n.slack || n.websocket));
+    async function createOrUnknown(create) {
+      try {
+        return await create();
+      } catch (error) {
+        if (!isAmbiguousFailure(error))
+          throw error;
+        console.error("[Tool Error] create_workflow:", safeErrorSummary(error));
+        return {
+          outcomeUnknown: errorResult(`Workflow creation failed (${shortErrorReason(error)}). It is unknown whether the workflow was created. Check list_workflows for it before retrying, and do NOT create it again if it exists.`)
+        };
+      }
+    }
     let workflowId;
     const warnings = [];
     if (args.templateId) {
       if (args.entity || args.schema) {
         return errorResult("When 'templateId' is set, 'entity' and 'schema' must NOT be supplied - they are inherited from the template version. Use 'prompt' only for workflow-specific additional instructions.");
       }
-      const { id } = await ctx.client.workflow.create({
+      const created = await createOrUnknown(() => ctx.client.workflow.create({
         urls,
         name: args.name || "Untitled Workflow",
         description: args.description,
@@ -2458,8 +2964,10 @@ function registerWorkflowCoreTools(server, ctx, helpers) {
         templateId: args.templateId,
         templateVersion: args.templateVersion,
         userPrompt: args.prompt
-      });
-      workflowId = id;
+      }));
+      if ("outcomeUnknown" in created)
+        return created.outcomeUnknown;
+      workflowId = created.id;
     } else {
       if (!args.prompt) {
         return errorResult("'prompt' is required unless 'templateId' is provided.");
@@ -2473,7 +2981,9 @@ function registerWorkflowCoreTools(server, ctx, helpers) {
         description: args.description,
         schedules: args.schedules
       });
-      const workflow = await builder.create();
+      const workflow = await createOrUnknown(() => builder.create());
+      if ("outcomeUnknown" in workflow)
+        return workflow.outcomeUnknown;
       workflowId = workflow.workflowId;
       const needsUpdate = args.limit !== undefined || args.tags && args.tags.length > 0;
       if (needsUpdate) {
@@ -2546,31 +3056,22 @@ function registerWorkflowCoreTools(server, ctx, helpers) {
     } else {
       text = `${cause}. The realtime monitor was not created. ${channels} Delete one with delete_notification_channel only after confirming via list_notification_settings that no other workflow uses it.`;
     }
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({
-            error: text,
-            notificationChannelIds,
-            ...workflowId ? { workflowId, dashboardUrl: workflowDashboardUrl(workflowId) } : {}
-          }, null, 2)
-        }
-      ],
-      isError: true
-    };
+    return errorResult(text, {
+      notificationChannelIds,
+      ...workflowId ? { workflowId, dashboardUrl: workflowDashboardUrl(workflowId) } : {}
+    });
   }
   server.registerTool("create_realtime_monitor", {
     title: "Create Realtime Monitor",
-    description: "Create a realtime monitoring workflow that continuously watches a page for data changes and sends alerts. " + "Use this when the user wants to monitor, track, or watch a page in realtime. " + "At least one notification channel (email, webhook, slack, or websocket) is required; notification settings are persisted before Assistant creation is dispatched. " + `Realtime monitors CANNOT be converted to/from one-time or scheduled extraction workflows after creation.
+    description: "Create a realtime monitoring workflow that continuously watches a page for data changes and sends alerts. " + (defaultProductType === "realtime" ? "This team's default product is realtime monitoring: use this tool whenever the user asks to monitor, track, or watch a page, or to get or extract data from it, unless they explicitly ask for a one-time run or a schedule. A request that names no frequency counts as realtime. " : "Use this when the user wants to monitor, track, or watch a page in realtime. ") + "At least one notification channel (email, webhook, slack, or websocket) is required; notification settings are persisted before Assistant creation is dispatched. " + `Realtime monitors CANNOT be converted to/from one-time or scheduled extraction workflows after creation.
 
 ` + "If entity and schema are provided, they guide what the Assistant should monitor; otherwise the Assistant determines what to watch. " + "Creation is asynchronous and the response includes workflow, session, thread, and job IDs plus a dashboard URL. " + "Use generic workflow Assistant tools (get_workflow_assistant, answer_workflow_assistant_question, interrupt_workflow_assistant, resume_workflow_assistant, stop_workflow_assistant) for follow-up status, questions, and controls. " + "Do NOT poll or sleep-wait for completion.",
     inputSchema: strictSchema({
       prompt: extractionPromptInput.describe("Optional natural language instructions describing what to monitor and which changes matter. If omitted, the Assistant determines what to watch."),
       ...extractionInputShape,
       ...urlInputShape,
-      description: z10.string().max(500).optional().describe("Description of what this monitor watches (max 500 characters)"),
-      tags: z10.preprocess(coerceArray(true), z10.array(z10.string())).optional().describe("Tags for organizing monitors"),
+      description: z12.string().max(500).optional().describe("Description of what this monitor watches (max 500 characters)"),
+      tags: z12.preprocess(coerceArray(true), z12.array(z12.string())).optional().describe("Tags for organizing monitors"),
       ...requiredNotificationsInputShape
     }),
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
@@ -2621,20 +3122,27 @@ function registerWorkflowCoreTools(server, ctx, helpers) {
     title: "List Workflows",
     description: `List workflows with customer-visible status, raw workflow and run states, Assistant session availability, template version drift, realtime freshness or health, and awaitingUserInput when the requesting user must act. Uses one paginated list request; use get_workflow only when you need full details for a selected workflow. To answer "what needs my attention", pass statusFilters: ["group:attention"]; this returns exactly the dashboard's "Needs your attention" group. In group:attention, a row with awaitingUserInput.prompt is an Assistant question: use get_workflow_assistant then answer_workflow_assistant_question. A row with awaitingUserInput but no prompt is a setup the user left unfinished: use get_workflow_assistant to see where it stopped, then resume_workflow_assistant or request_workflow_update. A row with displayState PREVIEW and no awaitingUserInput is preview data: use approve_workflow. Workflows with an open support ticket are excluded from group:attention and appear under group:support.`,
     inputSchema: strictSchema({
-      limit: z10.preprocess(coerceNumber(), z10.number()).optional().describe("Maximum number of workflows to return"),
-      skip: z10.preprocess(coerceNumber(), z10.number()).optional().describe("Number of workflows to skip (pagination offset; pairs with limit)"),
-      state: z10.enum(["ACTIVE", "FAILED", "PAUSED", "PREVIEW"]).optional().describe("Filter by state (ACTIVE, FAILED, PAUSED, PREVIEW)"),
-      search: z10.string().optional().describe("Free-text filter matching workflow name, URL, or workflow ID"),
-      tags: z10.array(z10.string()).optional().describe("Filter to workflows having any of these tags"),
-      monitoring: z10.preprocess(coerceBoolean(), z10.boolean()).optional().describe("Filter by monitoring/real-time status"),
-      updateInterval: z10.enum(["HOURLY", "DAILY", "WEEKLY", "MONTHLY", "REAL_TIME"]).optional().describe("Filter by scheduled update frequency or realtime workflows"),
-      templateId: z10.string().optional().describe("Filter to workflows instantiated from this template ID"),
-      statusFilters: z10.array(z10.enum(Object.values(WorkflowStatusFilter))).optional().describe("Dashboard category filters. group:attention = workflows waiting on the requesting user (Assistant question, unfinished setup, or preview approval). Other groups: working, support, failed, active, complete, paused.")
+      limit: limitInput({
+        noun: "Workflows",
+        defaultLimit: LIST_WORKFLOWS_DEFAULT_LIMIT,
+        max: LIST_WORKFLOWS_MAX_LIMIT
+      }),
+      skip: offsetInput("skip", "workflows"),
+      state: z12.enum(["ACTIVE", "FAILED", "PAUSED", "PREVIEW"]).optional().describe("Filter by state (ACTIVE, FAILED, PAUSED, PREVIEW)"),
+      search: z12.string().optional().describe("Free-text filter matching workflow name, URL, or workflow ID"),
+      tags: z12.array(z12.string()).optional().describe("Filter to workflows having any of these tags"),
+      monitoring: z12.preprocess(coerceBoolean(), z12.boolean()).optional().describe("Filter by monitoring/real-time status"),
+      updateInterval: z12.enum(["HOURLY", "DAILY", "WEEKLY", "MONTHLY", "REAL_TIME"]).optional().describe("Filter by scheduled update frequency or realtime workflows"),
+      templateId: z12.string().optional().describe("Filter to workflows instantiated from this template ID"),
+      statusFilters: z12.array(z12.enum(Object.values(WorkflowStatusFilter))).optional().describe("Dashboard category filters. group:attention = workflows waiting on the requesting user (Assistant question, unfinished setup, or preview approval). Other groups: working, support, failed, active, complete, paused.")
     }),
+    outputSchema: ListWorkflowsOutput,
     annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("list_workflows", async (args) => {
-    const workflows = await ctx.client.workflow.list({
-      limit: args.limit || 50,
+    const limit = args.limit ?? LIST_WORKFLOWS_DEFAULT_LIMIT;
+    const skip = args.skip ?? 0;
+    const rows = await ctx.client.workflow.list({
+      limit: limit + 1,
       state: args.state,
       ...args.skip !== undefined && { skip: args.skip },
       ...args.search !== undefined && { search: args.search },
@@ -2644,6 +3152,7 @@ function registerWorkflowCoreTools(server, ctx, helpers) {
       ...args.templateId !== undefined && { templateId: args.templateId },
       ...args.statusFilters !== undefined && { statusFilters: args.statusFilters }
     });
+    const workflows = rows.slice(0, limit);
     return jsonResult({
       workflows: workflows.map((w) => ({
         id: w.id,
@@ -2680,15 +3189,23 @@ function registerWorkflowCoreTools(server, ctx, helpers) {
         },
         awaitingUserInput: w.awaitingUserInput ?? null
       })),
-      total: workflows.length
+      pagination: offsetPage({
+        args,
+        param: "skip",
+        offset: skip,
+        limit,
+        returned: workflows.length,
+        hasMore: rows.length > limit
+      })
     });
   }));
   server.registerTool("get_workflow", {
     title: "Get Workflow",
     description: "Get canonical workflow details, including Assistant/session linkage, extraction intent, template-controlled parts, stale-data state, job/run state, schedule timezone, location, monitoring, validation, and realtime health. For Assistant-built workflows, extractionSpec - not the legacy prompt - is authoritative.",
     inputSchema: strictSchema({
-      workflowId: z10.string().min(1).describe("The workflow ID")
+      workflowId: z12.string().min(1).describe("The workflow ID")
     }),
+    outputSchema: GetWorkflowOutput,
     annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("get_workflow", async (args) => {
     const workflow = await ctx.client.workflow.get(args.workflowId);
@@ -2705,9 +3222,9 @@ function registerWorkflowCoreTools(server, ctx, helpers) {
     const hasTemplate = workflow.templateId != null || workflow.templateVersion != null;
     const isRealtime = workflow.isRealTime === true || isRealTimeInterval(workflow.updateInterval);
     return jsonResult({
-      id: workflow.id,
+      id: workflow.id ?? args.workflowId,
       name: workflow.name,
-      dashboardUrl: workflowDashboardUrl(workflow.id),
+      dashboardUrl: workflowDashboardUrl(workflow.id ?? args.workflowId),
       description: workflow.description,
       status: deriveStatusLabel(workflow),
       state: workflow.state ?? null,
@@ -2775,9 +3292,9 @@ function registerWorkflowCoreTools(server, ctx, helpers) {
     title: "Request Workflow Update",
     description: "Request an Assistant-driven change to an existing workflow while preserving its workflowId. " + "Use for extraction intent, navigation, pagination, data sourcing, generated-script changes, and repair after a site redesign. " + "Use update_workflow instead for deterministic metadata such as name, schedule, location, tags, and limits. " + "For template-controlled prompt or schema changes, create and apply a template version instead. " + "The update is asynchronous: do not poll or sleep-wait; use get_workflow_assistant later. Never delete and recreate the workflow as a workaround.",
     inputSchema: strictSchema({
-      workflowId: z10.string().min(1).describe("The existing workflow ID; it will not change"),
-      instructions: z10.string().min(1).describe("Natural-language instructions for the workflow Assistant"),
-      threadId: z10.string().optional().describe("Optional Assistant thread ID to continue")
+      workflowId: z12.string().min(1).describe("The existing workflow ID; it will not change"),
+      instructions: z12.string().min(1).describe("Natural-language instructions for the workflow Assistant"),
+      threadId: z12.string().optional().describe("Optional Assistant thread ID to continue")
     }),
     annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true }
   }, withErrorHandling("request_workflow_update", async (args) => {
@@ -2805,69 +3322,102 @@ function registerWorkflowHistoryTools(server, ctx, helpers) {
   const { withErrorHandling } = helpers;
   server.registerTool("get_workflow_history", {
     title: "Get Workflow History",
-    description: "Get the configuration revision history (audit log) for a workflow. Each entry captures who changed the workflow, when, from which channel (UI/API/SDK/MCP/CLI/SYSTEM), and a `changedFields` list summarizing what changed between revisions. Use this to answer questions like 'did this workflow's prompt or schema change, when, and from what to what?'. Note: CREATE entries return null `previousValue`/`newValue` and an empty `changedFields` (no initial-state snapshot is captured).",
+    description: "Get the configuration revision history (audit log) for a workflow. Each entry captures who changed the workflow, when, from which channel (UI/API/SDK/MCP/CLI/SYSTEM), a `changedFields` list, and `changes` with the before/after value of each changed field (values over 1 KB are summarized). Use this to answer questions like 'did this workflow's prompt or schema change, when, and from what to what?'. Pass includeSnapshots: true only when you need the full previousValue/newValue workflow snapshots (large). Note: CREATE entries have empty `changedFields`/`changes` and null snapshots (no initial-state snapshot is captured).",
     inputSchema: strictSchema({
-      workflowId: z10.string().min(1).describe("The workflow ID"),
-      page: z10.preprocess(coerceNumber(), z10.number()).optional().describe("Page number, 1-based (default: 1)"),
-      limit: z10.preprocess(coerceNumber(), z10.number()).optional().describe("Entries per page (default: 25)")
+      workflowId: z12.string().min(1).describe("The workflow ID"),
+      page: pageInput(),
+      limit: limitInput({
+        noun: "Entries",
+        defaultLimit: WORKFLOW_HISTORY_DEFAULT_LIMIT,
+        max: WORKFLOW_HISTORY_MAX_LIMIT
+      }),
+      includeSnapshots: z12.preprocess(coerceBoolean(), z12.boolean()).optional().describe("Include full previousValue/newValue workflow snapshots per entry (default false; large)")
     }),
     annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("get_workflow_history", async (args) => {
-    const response = await ctx.client.workflow.getAuditLog(args.workflowId, {
-      page: args.page,
-      limit: args.limit
-    });
-    const entries = (response.logEntries ?? []).map((e) => ({
-      id: e.id,
-      operationType: e.operationType,
-      createdAt: e.createdAt,
-      userEmail: e.userEmail,
-      userId: e.userId,
-      requestSource: e.requestSource,
-      authMethod: e.authMethod,
-      changedFields: diffWorkflowAuditEntry({
+    const page = args.page ?? 1;
+    const limit = args.limit ?? WORKFLOW_HISTORY_DEFAULT_LIMIT;
+    const response = await ctx.client.workflow.getAuditLog(args.workflowId, { page, limit });
+    const includeSnapshots = args.includeSnapshots === true;
+    const entries = (response.logEntries ?? []).map((e) => {
+      const summary = summarizeWorkflowAuditEntry({
         previousValue: e.previousValue,
         newValue: e.newValue
-      }),
-      previousValue: e.previousValue,
-      newValue: e.newValue
-    }));
-    return jsonResult({
-      workflowId: response.id,
-      totalCount: response.pagination?.totalCount ?? response.logEntriesCount ?? entries.length,
-      page: response.pagination?.page ?? 1,
-      totalPages: response.pagination?.totalPages ?? 1,
-      entries
+      });
+      return {
+        id: e.id,
+        operationType: e.operationType,
+        createdAt: e.createdAt,
+        userEmail: e.userEmail,
+        userId: e.userId,
+        requestSource: e.requestSource,
+        authMethod: e.authMethod,
+        changedFields: summary.changedFields,
+        changes: summary.changes,
+        ...includeSnapshots && { previousValue: e.previousValue ?? null, newValue: e.newValue ?? null }
+      };
+    });
+    const totalCount = response.pagination?.totalCount ?? response.logEntriesCount;
+    const totalPages = response.pagination?.totalPages;
+    const result = budgetNumberedPage({
+      items: entries,
+      pagination: numberedPage({ args, page, limit, returned: entries.length, totalCount, totalPages }),
+      args,
+      page,
+      limit,
+      noun: "entries",
+      resumeHint: includeSnapshots ? "Call again with pagination.next for the following entries, or drop includeSnapshots to get diff summaries only." : "Call again with pagination.next for the following entries.",
+      emptyHint: historyEmptyHint(includeSnapshots),
+      build: (kept, meta) => ({
+        workflowId: response.id,
+        ...totalCount !== undefined && { totalCount },
+        page,
+        ...totalPages !== undefined && kept.length === entries.length && { totalPages },
+        entries: kept,
+        pagination: meta
+      })
     });
+    return jsonResult(result);
   }));
   server.registerTool("list_workflow_runs", {
     title: "List Workflow Runs",
     description: "List a workflow's execution run history - each run's status, start/finish time, " + "record count, and errors. Use to answer 'when did this last succeed?' " + "(status='success', limit=1) or 'recent success/failure pattern?'. Distinct from " + "get_workflow_history, which is the config audit log. `status` is normally " + "success | failed | in_progress; a run whose backend state this server does not " + "recognize reports that raw state verbatim, so treat any other value as unknown " + "rather than as a failure.",
     inputSchema: strictSchema({
-      workflowId: z10.string().min(1).describe("The workflow ID"),
-      status: z10.enum(["success", "failed", "in_progress"]).optional().describe("Filter runs by outcome"),
-      page: z10.preprocess(coerceNumber(), z10.number()).optional().describe("Page number, 1-based (default: 1)"),
-      limit: z10.preprocess(coerceNumber(), z10.number()).optional().describe("Runs per page (default: 25)")
+      workflowId: z12.string().min(1).describe("The workflow ID"),
+      status: z12.enum(["success", "failed", "in_progress"]).optional().describe("Filter runs by outcome"),
+      page: pageInput(),
+      limit: limitInput({ noun: "Runs", defaultLimit: WORKFLOW_RUNS_DEFAULT_LIMIT, max: WORKFLOW_RUNS_MAX_LIMIT })
     }),
     annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("list_workflow_runs", async (args) => {
+    const page = args.page ?? 1;
+    const limit = args.limit ?? WORKFLOW_RUNS_DEFAULT_LIMIT;
     const response = await ctx.client.workflow.listWorkflowRuns(args.workflowId, {
-      page: args.page,
-      limit: args.limit,
+      page,
+      limit,
       status: args.status
     });
+    const runs = (response.workflowRuns ?? []).map((r) => ({
+      id: r.id,
+      status: mapRunStatus(r.state),
+      startedAt: r.startedAt,
+      finishedAt: r.finishedAt,
+      records: r.records,
+      errors: r.errors
+    }));
+    const totalCount = response.totalCount ?? response.pagination?.totalCount;
     return jsonResult({
       workflowId: response.workflowId,
-      runs: (response.workflowRuns ?? []).map((r) => ({
-        id: r.id,
-        status: mapRunStatus(r.state),
-        startedAt: r.startedAt,
-        finishedAt: r.finishedAt,
-        records: r.records,
-        errors: r.errors
-      })),
-      totalCount: response.totalCount,
-      pagination: response.pagination
+      runs,
+      ...totalCount !== undefined && { totalCount },
+      pagination: numberedPage({
+        args,
+        page,
+        limit,
+        returned: runs.length,
+        totalCount,
+        totalPages: response.pagination?.totalPages
+      })
     });
   }));
 }
@@ -2877,8 +3427,8 @@ function registerWorkflowRunTools(server, ctx, helpers) {
     title: "Run Workflow",
     description: "Run a workflow to extract fresh data, including retrying a failed one-time or scheduled workflow. Preserve the existing workflow ID and configuration - do not delete and recreate the workflow solely to retry it. The run is asynchronous and may take several minutes. Do NOT poll or sleep-wait for completion. Return the workflow ID to the user and let them check status with get_workflow or fetch results later with fetch_data. Realtime workflows cannot be manually run.",
     inputSchema: strictSchema({
-      workflowId: z10.string().min(1).describe("The workflow ID to run"),
-      limit: z10.preprocess(coerceNumber(), z10.number()).optional().describe("Maximum number of records to extract (default: 1000)")
+      workflowId: z12.string().min(1).describe("The workflow ID to run"),
+      limit: z12.preprocess(coerceNumber(), z12.number()).optional().describe("Maximum number of records to extract (default: 1000)")
     }),
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
   }, withErrorHandling("run_workflow", async (args) => {
@@ -2901,49 +3451,72 @@ function registerWorkflowRunTools(server, ctx, helpers) {
     title: "Fetch Workflow Data",
     description: "Get a PAGE of extracted data from a workflow. Use ONLY for previews, sorted/filtered slices, or explicit 'first N rows' / 'top N' queries (capped at 500 rows per call). Do NOT use this to retrieve a full dataset, 'all rows', or anything the user wants to analyze in Excel / pandas / duckdb - use export_data for those. Data is only available after the workflow run has completed (status is no longer 'Running' or 'Validating'). Do NOT poll or sleep-wait for completion.",
     inputSchema: strictSchema({
-      workflowId: z10.string().min(1).describe("The workflow ID"),
-      limit: z10.preprocess(coerceNumber(), z10.number()).optional().describe(`Maximum number of records to return. Default ${FETCH_DATA_DEFAULT_LIMIT}, max ${FETCH_DATA_MAX_LIMIT}.`),
-      page: z10.preprocess(coerceNumber(), z10.number()).optional().describe("Page number for pagination (1-based)"),
+      workflowId: z12.string().min(1).describe("The workflow ID"),
+      limit: limitInput({
+        noun: "Rows",
+        defaultLimit: FETCH_DATA_DEFAULT_LIMIT,
+        max: FETCH_DATA_MAX_LIMIT,
+        overMaxHint: "Use export_data for full datasets."
+      }),
+      page: pageInput(),
       filters: dataFiltersInput,
-      sortBy: z10.string().optional().describe("Field name to sort by"),
-      order: z10.enum(["asc", "desc"]).optional().describe("Sort order: asc or desc")
+      sortBy: z12.string().optional().describe("Field name to sort by"),
+      order: z12.enum(["asc", "desc"]).optional().describe("Sort order: asc or desc")
     }),
+    outputSchema: FetchDataOutput,
     annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("fetch_data", async (args) => {
-    const requestedLimit = args.limit ?? FETCH_DATA_DEFAULT_LIMIT;
-    if (requestedLimit > FETCH_DATA_MAX_LIMIT) {
-      return errorResult(`limit ${requestedLimit} exceeds max ${FETCH_DATA_MAX_LIMIT}. Use export_data for full datasets.`);
-    }
+    const limit = args.limit ?? FETCH_DATA_DEFAULT_LIMIT;
+    const page = args.page ?? 1;
     const data = await ctx.client.extraction.fetchData({
       workflowId: args.workflowId,
-      limit: requestedLimit,
-      page: args.page || 1,
+      limit,
+      page,
       filters: args.filters === undefined ? undefined : JSON.stringify(args.filters),
       sortBy: args.sortBy,
       order: args.order
     });
-    const totalCount = data.pagination?.totalCount ?? data.data.length;
-    const result = {
-      data: data.data,
-      pagination: data.pagination,
-      totalCount
-    };
-    if (data.data.length < totalCount) {
-      result.hint = `Showing ${data.data.length} of ${totalCount} rows. Use export_data for the full dataset.`;
-    }
+    const totalCount = data.pagination?.totalCount;
+    const pagination = numberedPage({
+      args,
+      page,
+      limit,
+      returned: data.data.length,
+      totalCount,
+      totalPages: data.pagination?.totalPages
+    });
+    const result = budgetNumberedPage({
+      items: data.data,
+      pagination,
+      args,
+      page,
+      limit,
+      noun: "rows",
+      resumeHint: "Call fetch_data again with pagination.next for the following rows, or use export_data for the full dataset.",
+      emptyHint: "Rows are too large to return inline. Use export_data for this data.",
+      alignmentImpossibleHint: "Page offset too deep to resume inline; use export_data instead.",
+      build: (rows, meta) => ({
+        data: rows,
+        pagination: meta,
+        ...totalCount !== undefined && { totalCount },
+        ...totalCount !== undefined && rows.length < totalCount && {
+          hint: `Showing ${rows.length} of ${totalCount} rows. Use export_data for the full dataset.`
+        }
+      })
+    });
     return jsonResult(result);
   }));
   server.registerTool("export_data", {
     title: "Export Workflow Data",
     description: "PREFERRED tool for retrieving a workflow's FULL dataset. Materializes the data to object storage and returns a signed download URL. Use this whenever the user wants 'all rows', 'the full dataset', 'everything', an export, or anything destined for Excel / pandas / duckdb / a CSV file - even for small workflows. The URL is self-authenticating (open with `fetch(url)`, no Authorization header). Use fetch_data ONLY when the user explicitly asks for a small preview slice (e.g., 'first 10', 'top N sorted by X').",
     inputSchema: strictSchema({
-      workflowId: z10.string().min(1).describe("The workflow ID"),
-      format: z10.enum(["csv", "json"]).optional().describe("Export format. Default 'csv'."),
-      runId: z10.string().optional().describe("Specific run ID to export. Defaults to the latest completed run."),
+      workflowId: z12.string().min(1).describe("The workflow ID"),
+      format: z12.enum(["csv", "json"]).optional().describe("Export format. Default 'csv'."),
+      runId: z12.string().optional().describe("Specific run ID to export. Defaults to the latest completed run."),
       filters: dataFiltersInput,
-      sortBy: z10.string().optional().describe("Field name to sort by"),
-      order: z10.enum(["asc", "desc"]).optional().describe("Sort order: asc or desc"),
-      rowIds: z10.preprocess(coerceList(), z10.array(z10.string().trim().min(1)).max(1000)).optional().describe("Row ids to include (max 1000)")
+      sortBy: z12.string().optional().describe("Field name to sort by"),
+      order: z12.enum(["asc", "desc"]).optional().describe("Sort order: asc or desc"),
+      rowIds: z12.preprocess(coerceList(), z12.array(z12.string().trim().min(1)).max(1000)).optional().describe("Row ids to include (max 1000)")
     }),
     annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("export_data", async (args) => {
@@ -2956,7 +3529,7 @@ function registerWorkflowRunTools(server, ctx, helpers) {
       order: args.order,
       rowIds: joinList(args.rowIds)
     });
-    return jsonResult({
+    return withExtraContent(jsonResult({
       url: result.url,
       rowCount: result.rowCount,
       format: result.format,
@@ -2964,26 +3537,34 @@ function registerWorkflowRunTools(server, ctx, helpers) {
       workflowId: result.workflowId,
       runId: result.runId,
       hint: `Full dataset ready at the URL above. Open in Excel via 'Get Data from Web' (no auth needed), ` + `or load with code execution (pandas.read_csv(url) / pandas.read_json(url) / duckdb.read_csv(url)). ` + `URL expires ${result.expiresAt}.`
+    }), {
+      type: "resource_link",
+      uri: result.url,
+      name: `${result.workflowId}-${result.runId}.${result.format}`,
+      title: `Workflow export (${result.rowCount} rows)`,
+      mimeType: result.format === "json" ? "application/json" : "text/csv",
+      description: `Signed download URL, no auth needed. Expires ${result.expiresAt}.`
     });
   }));
   server.registerTool("list_changes", {
     title: "List Detected Changes",
     description: "List detected data changes across one or more realtime monitoring workflows. " + "Returns structured diffs showing added, removed, and changed records. " + "Only works for workflows with realtime monitoring enabled.",
     inputSchema: strictSchema({
-      workflowIds: z10.preprocess(coerceArray(true), z10.array(z10.string().min(1))).optional().describe("Workflow IDs to filter by. If omitted, returns changes for all ACTIVE monitoring workflows."),
-      startDate: z10.string().optional().describe("Start date filter (ISO format, e.g. 2025-01-01)"),
-      endDate: z10.string().optional().describe("End date filter (ISO format, e.g. 2025-12-31)"),
-      skip: z10.preprocess(coerceNumber(), z10.number()).optional().describe("Number of records to skip for pagination"),
-      limit: z10.preprocess(coerceNumber(), z10.number()).optional().describe("Maximum number of changes to return")
+      workflowIds: z12.preprocess(coerceArray(true), z12.array(z12.string().min(1))).optional().describe("Workflow IDs to filter by. If omitted, returns changes for all ACTIVE monitoring workflows."),
+      startDate: z12.string().optional().describe("Start date filter (ISO format, e.g. 2025-01-01)"),
+      endDate: z12.string().optional().describe("End date filter (ISO format, e.g. 2025-12-31)"),
+      skip: offsetInput("skip", "changes"),
+      limit: limitInput({ noun: "Changes", defaultLimit: LIST_CHANGES_DEFAULT_LIMIT, max: LIST_CHANGES_MAX_LIMIT })
     }),
     annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("list_changes", async (args) => {
+    const limit = args.limit ?? LIST_CHANGES_DEFAULT_LIMIT;
     const result = await ctx.client.changes.list({
       workflowIds: args.workflowIds?.join(","),
       startDate: args.startDate,
       endDate: args.endDate,
       skip: args.skip,
-      limit: args.limit ?? 25
+      limit
     });
     return jsonResult({
       changes: result.changes.map((c) => ({
@@ -2994,36 +3575,34 @@ function registerWorkflowRunTools(server, ctx, helpers) {
         differences: c.differences,
         createdAt: c.createdAt
       })),
-      pagination: result.pagination,
+      pagination: offsetPage({
+        args,
+        param: "skip",
+        offset: args.skip ?? 0,
+        limit,
+        returned: result.changes.length,
+        totalCount: result.pagination?.totalCount
+      }),
       changesCount: result.changesCount
     });
   }));
   server.registerTool("get_change", {
     title: "Get Detected Change",
-    description: "Get detailed information about a specific detected change, including the full data snapshot and diff.",
+    description: "Get detailed information about a specific detected change, including the data snapshot and diff. Results over ~80 KB are cut to whole rows and marked truncated.",
     inputSchema: strictSchema({
-      changeId: z10.string().min(1).describe("The change ID")
+      changeId: z12.string().min(1).describe("The change ID")
     }),
     annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("get_change", async (args) => {
     const change = await ctx.client.changes.get(args.changeId);
-    return jsonResult({
-      id: change.id,
-      workflowId: change.workflowId,
-      url: change.url,
-      summary: change.summary,
-      screenshotUrl: change.screenshotUrl,
-      data: change.data,
-      differences: change.differences,
-      createdAt: change.createdAt
-    });
+    return jsonResult(changeResult(change));
   }));
   server.registerTool("delete_workflow", {
     title: "Delete Workflow",
     description: "Delete a workflow permanently. This is irreversible. " + "You MUST first call this tool without confirmed=true to preview what will be deleted, " + "then show the user the workflow name and ask for confirmation, " + "then call again with confirmed=true only after the user explicitly agrees.",
     inputSchema: strictSchema({
-      workflowId: z10.string().min(1).describe("The workflow ID to delete"),
-      confirmed: z10.preprocess(coerceBoolean(), z10.boolean()).optional().describe("Set to true only after the user has explicitly confirmed deletion. Omit or set to false for the initial preview call.")
+      workflowId: z12.string().min(1).describe("The workflow ID to delete"),
+      confirmed: z12.preprocess(coerceBoolean(), z12.boolean()).optional().describe("Set to true only after the user has explicitly confirmed deletion. Omit or set to false for the initial preview call.")
     }),
     annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("delete_workflow", async (args) => {
@@ -3053,7 +3632,7 @@ function registerWorkflowRunTools(server, ctx, helpers) {
     title: "Approve Workflow",
     description: "Approve and activate a workflow that is in PREVIEW, PAUSED, or ERROR state. Transitions the workflow to ACTIVE so it can be run.",
     inputSchema: strictSchema({
-      workflowId: z10.string().min(1).describe("The workflow ID to approve/activate")
+      workflowId: z12.string().min(1).describe("The workflow ID to approve/activate")
     }),
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
   }, withErrorHandling("approve_workflow", async (args) => {
@@ -3068,7 +3647,7 @@ function registerWorkflowRunTools(server, ctx, helpers) {
     title: "Pause Workflow",
     description: "Pause an ACTIVE workflow so it stops running on its schedule. Requires the workflow to be in ACTIVE state - pausing a workflow that is currently running, already paused, or in PREVIEW will return an error. Use approve_workflow to resume a paused workflow.",
     inputSchema: strictSchema({
-      workflowId: z10.string().min(1).describe("The workflow ID to pause")
+      workflowId: z12.string().min(1).describe("The workflow ID to pause")
     }),
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }
   }, withErrorHandling("pause_workflow", async (args) => {
@@ -3087,20 +3666,20 @@ function registerWorkflowRunTools(server, ctx, helpers) {
 
 ` + "ASSISTANT-OWNED INTENT: Use request_workflow_update - not `userPrompt` - for Assistant-built workflow changes to extraction intent, navigation, pagination, data sourcing, repair, or generated scripts. The API may reject `userPrompt` because these workflows' canonical intent is owned by the Assistant. " + "Call get_workflow first. If its template.controlledParts contains the setting, create and apply a template version instead of overriding the workflow directly. NEVER delete and recreate a workflow to work around an update limitation - that changes workflowId, breaks downstream tables/connectors, and discards history.",
     inputSchema: strictSchema({
-      workflowId: z10.string().min(1).describe("The workflow ID to update"),
-      name: z10.string().optional().describe("New name for the workflow"),
-      urls: z10.preprocess(coerceArray(true), z10.array(z10.string()).min(1)).optional().describe("New target URLs for the workflow (array of strings). Also accepts a single URL string."),
-      entity: z10.string().optional().describe("Entity name for extraction (e.g., 'Product', 'Job Posting')"),
-      schema: z10.preprocess(coerceArray(), z10.array(z10.object(SchemaFieldShape).strict())).optional().describe("New extraction schema fields. This REPLACES the whole schema - list every field you want to keep, each with its isKey flag, or the omitted ones and their flags are lost. Call get_workflow first and edit the schema it returns."),
-      description: z10.string().max(500).optional().describe("Workflow description (max 500 characters)"),
-      tags: z10.preprocess(coerceArray(true), z10.array(z10.string())).optional().describe("Tags for organizing workflows"),
-      userPrompt: z10.string().optional().describe("Navigation prompt for agentic-navigation mode (10-5000 characters)"),
+      workflowId: z12.string().min(1).describe("The workflow ID to update"),
+      name: z12.string().optional().describe("New name for the workflow"),
+      urls: z12.preprocess(coerceArray(true), z12.array(z12.string()).min(1)).optional().describe("New target URLs for the workflow (array of strings). Also accepts a single URL string."),
+      entity: z12.string().optional().describe("Entity name for extraction (e.g., 'Product', 'Job Posting')"),
+      schema: z12.preprocess(coerceArray(), z12.array(z12.object(SchemaFieldShape).strict())).optional().describe("New extraction schema fields. This REPLACES the whole schema - list every field you want to keep, each with its isKey flag, or the omitted ones and their flags are lost. Call get_workflow first and edit the schema it returns."),
+      description: z12.string().max(500).optional().describe("Workflow description (max 500 characters)"),
+      tags: z12.preprocess(coerceArray(true), z12.array(z12.string())).optional().describe("Tags for organizing workflows"),
+      userPrompt: z12.string().optional().describe("Navigation prompt for agentic-navigation mode (10-5000 characters)"),
       updateInterval: UpdateIntervalSchema.optional().describe("How often the workflow should run. CUSTOM requires schedules. Note: REAL_TIME is NOT allowed here - realtime workflows must be created via create_realtime_monitor."),
-      schedules: z10.preprocess(coerceArray(true), z10.array(z10.string())).optional().describe("Cron expressions for CUSTOM update interval"),
-      timezone: z10.string().min(1).optional().describe("IANA timezone for cron schedules, for example America/New_York. A timezone-only update preserves existing cron expressions."),
-      location: z10.preprocess(coerceJson(), LocationSchema).optional().describe("Scraping location: {type:'auto'} or {type:'manual', isoCode:'US'}"),
-      monitoring: z10.preprocess(coerceJson(), MonitoringSchema).optional().describe("Complete monitoring replacement: fields to monitor and optional AND/OR conditions. Call get_workflow first because this replaces the existing monitoring configuration."),
-      limit: z10.preprocess(coerceNumber(), z10.number().positive().nullable()).optional().describe("Maximum records per run. Pass null to clear the limit and extract all rows.")
+      schedules: z12.preprocess(coerceArray(true), z12.array(z12.string())).optional().describe("Cron expressions for CUSTOM update interval"),
+      timezone: z12.string().min(1).optional().describe("IANA timezone for cron schedules, for example America/New_York. A timezone-only update preserves existing cron expressions."),
+      location: z12.preprocess(coerceJson(), LocationSchema).optional().describe("Scraping location: {type:'auto'} or {type:'manual', isoCode:'US'}"),
+      monitoring: z12.preprocess(coerceJson(), MonitoringSchema).optional().describe("Complete monitoring replacement: fields to monitor and optional AND/OR conditions. Call get_workflow first because this replaces the existing monitoring configuration."),
+      limit: z12.preprocess(coerceNumber(), z12.number().positive().nullable()).optional().describe("Maximum records per run. Pass null to clear the limit and extract all rows.")
     }),
     annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("update_workflow", async (args) => {
@@ -3136,9 +3715,13 @@ function registerWorkflowRunTools(server, ctx, helpers) {
     });
   }));
 }
-var WORKFLOW_AUDIT_WATCHED_KEYS;
+var WORKFLOW_AUDIT_WATCHED_KEYS, LIST_WORKFLOWS_DEFAULT_LIMIT = 50, LIST_WORKFLOWS_MAX_LIMIT = 100, LIST_CHANGES_DEFAULT_LIMIT = 25, LIST_CHANGES_MAX_LIMIT = 100, WORKFLOW_HISTORY_DEFAULT_LIMIT = 25, WORKFLOW_HISTORY_MAX_LIMIT = 50, WORKFLOW_RUNS_DEFAULT_LIMIT = 25, WORKFLOW_RUNS_MAX_LIMIT = 100;
 var init_workflows = __esm(() => {
+  init_notification_channels();
+  init_budget();
   init_errors();
+  init_output_schemas();
+  init_pagination();
   init_schemas();
   WORKFLOW_AUDIT_WATCHED_KEYS = [
     "name",
@@ -3157,9 +3740,9 @@ var init_workflows = __esm(() => {
 function registerTools(server, ctx, capabilities) {
   const helpers = { withErrorHandling: createWithErrorHandling(ctx) };
   if (capabilities.scrape)
-    registerScrapeTools(server, ctx, helpers);
+    registerScrapeTools(server, ctx, helpers, capabilities.defaultProductType);
   registerWhoamiTool(server, ctx, helpers);
-  registerWorkflowCoreTools(server, ctx, helpers);
+  registerWorkflowCoreTools(server, ctx, helpers, capabilities.defaultProductType);
   registerAssistantTools(server, ctx, helpers);
   registerWorkflowHistoryTools(server, ctx, helpers);
   registerObservabilityTools(server, ctx, helpers);
@@ -3843,12 +4426,41 @@ var init_request_log = __esm(() => {
 
 // src/server.ts
 import { McpServer as McpServer2 } from "@modelcontextprotocol/server";
+function lifecycleInstruction2(defaultProductType) {
+  return defaultProductType === "realtime" ? "For one-time or scheduled workflows, the lifecycle is create_workflow → get_workflow (check status) → fetch_data (get results). Workflows run asynchronously - never poll or sleep-wait." : "Workflow lifecycle: create_workflow → get_workflow (check status) → fetch_data (get results). Workflows run asynchronously - never poll or sleep-wait.";
+}
+function routingInstructions2(defaultProductType) {
+  if (defaultProductType === "realtime") {
+    return [
+      `This team's default product is realtime monitoring. Use create_realtime_monitor whenever the user asks to monitor, track, or watch a page, or to get or extract data from it, unless they explicitly ask for a one-time run (e.g. "once") or a schedule (e.g. "daily"). A request that names no frequency is not explicit: default to realtime without asking the user to choose. It first persists notification channels, then asynchronously returns workflow/session/thread/job IDs; use the workflow Assistant tools for follow-up status, questions, and controls.`,
+      "Use create_workflow only when the user explicitly asks for a one-time run or a schedule. Use scrape for an immediate raw HTML or markdown fetch from one URL."
+    ];
+  }
+  return [
+    "Use create_realtime_monitor only when the user wants continuous realtime change detection with alerts. It first persists notification channels, then asynchronously returns workflow/session/thread/job IDs; use the workflow Assistant tools for follow-up status, questions, and controls.",
+    "For one-time or scheduled extraction, use create_workflow. Use scrape for an immediate raw HTML or markdown fetch from one URL. Use create_workflow for structured extraction, recurring runs, monitoring, or navigation-heavy jobs."
+  ];
+}
 async function createServer3(auth, options) {
   const ctx = {
     client: createKadoaClient(auth),
     principal: auth.principal,
     teamId: auth.principal.teamId
   };
+  let capabilities = options?.capabilities;
+  if (!capabilities) {
+    try {
+      const response = await ctx.client.user.getFeatures();
+      capabilities = {
+        scrape: response.features.scrape,
+        defaultProductType: parseDefaultProductType(response.defaultProductType)
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "unknown error";
+      console.error(`[CAPABILITIES] Failed to resolve team capabilities; gated tools will be hidden: ${message}`);
+      capabilities = { scrape: false };
+    }
+  }
   const server = new McpServer2({ name: "kadoa", version: package_default.version }, {
     instructions: [
       "IMPORTANT: One workflow = one source. A single workflow can extract many different fields, tables, and sections from the same URL(s) using a rich schema.",
@@ -3857,12 +4469,13 @@ async function createServer3(auth, options) {
       "Kadoa workflows use agentic navigation: the AI agent can browse pages, click buttons, fill forms, select dropdowns, paginate, open detail pages, and handle multi-step interactions.",
       "Describe the full navigation steps in the prompt (e.g., 'select year 2022 from the dropdown, click Search, extract the table, then repeat for 2023').",
       "",
-      "Workflow lifecycle: create_workflow → get_workflow (check status) → fetch_data (get results). Workflows run asynchronously - never poll or sleep-wait.",
+      lifecycleInstruction2(capabilities.defaultProductType),
       "",
-      "Use create_realtime_monitor only when the user wants continuous realtime change detection with alerts. It first persists notification channels, then asynchronously returns workflow/session/thread/job IDs; use the workflow Assistant tools for follow-up status, questions, and controls.",
-      "For one-time or scheduled extraction, use create_workflow. Use scrape for an immediate raw HTML or markdown fetch from one URL. Use create_workflow for structured extraction, recurring runs, monitoring, or navigation-heavy jobs.",
+      ...routingInstructions2(capabilities.defaultProductType),
       "If a one-time or scheduled workflow fails, retry it with run_workflow using the existing workflow ID. Do NOT delete and recreate the workflow just to retry it - preserve its workflow ID and configuration. Realtime workflows cannot be manually run.",
       "Use list_changes and get_change to retrieve detected diffs from realtime monitoring workflows.",
+      "List tools, plus fetch_data, get_workflow_history, and get_workflow_assistant_timeline, all return pagination {totalCount?, hasMore, next?}. When hasMore is true, call the same tool again with pagination.next as its arguments to get the next page. totalCount is present only when the total is known; never treat the page size as the total.",
+      "Large results (fetch_data, get_workflow_history, get_change) are cut to whole rows or entries under about 80 KB and marked truncated: true with a hint; follow pagination.next, narrow the filters, or use export_data, and never conclude the data ends there.",
       "When the user asks what needs their attention, call list_workflows with statusFilters group:attention. A row with awaitingUserInput.prompt is the Assistant's pending question: answer it with get_workflow_assistant then answer_workflow_assistant_question. A row with awaitingUserInput but no prompt is a setup the user left unfinished: use get_workflow_assistant to see where it stopped, then resume_workflow_assistant or request_workflow_update. A row with displayState PREVIEW and no awaitingUserInput is preview data to review or approve with approve_workflow. Workflows with an open support ticket are excluded from group:attention and appear under group:support.",
       "",
       "Schema tips: Use descriptive field names and examples. Group related data under one entity.",
@@ -3872,17 +4485,6 @@ async function createServer3(auth, options) {
     ].join(`
 `)
   });
-  let capabilities = options?.capabilities;
-  if (!capabilities) {
-    try {
-      const response = await ctx.client.user.getFeatures();
-      capabilities = { scrape: response.features.scrape };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "unknown error";
-      console.error(`[CAPABILITIES] Failed to resolve team capabilities; gated tools will be hidden: ${message}`);
-      capabilities = { scrape: false };
-    }
-  }
   registerTools(server, ctx, capabilities);
   server.server.onerror = (error) => console.error("[MCP Error]", safeErrorSummary(error));
   return server;
@@ -3962,7 +4564,7 @@ async function requestNeedsCapabilityLookup(request) {
       return false;
     }
   }
-  return method === "tools/list" || method === "tools/call" && name === "scrape";
+  return method === "initialize" || method === "server/discover" || method === "tools/list" || method === "tools/call" && name === "scrape";
 }
 function isClientCausedHandlerError(error) {
   if (error instanceof ProtocolError)
@@ -4302,12 +4904,41 @@ init_package();
 init_client();
 init_tools();
 import { McpServer } from "@modelcontextprotocol/server";
+function lifecycleInstruction(defaultProductType) {
+  return defaultProductType === "realtime" ? "For one-time or scheduled workflows, the lifecycle is create_workflow → get_workflow (check status) → fetch_data (get results). Workflows run asynchronously - never poll or sleep-wait." : "Workflow lifecycle: create_workflow → get_workflow (check status) → fetch_data (get results). Workflows run asynchronously - never poll or sleep-wait.";
+}
+function routingInstructions(defaultProductType) {
+  if (defaultProductType === "realtime") {
+    return [
+      `This team's default product is realtime monitoring. Use create_realtime_monitor whenever the user asks to monitor, track, or watch a page, or to get or extract data from it, unless they explicitly ask for a one-time run (e.g. "once") or a schedule (e.g. "daily"). A request that names no frequency is not explicit: default to realtime without asking the user to choose. It first persists notification channels, then asynchronously returns workflow/session/thread/job IDs; use the workflow Assistant tools for follow-up status, questions, and controls.`,
+      "Use create_workflow only when the user explicitly asks for a one-time run or a schedule. Use scrape for an immediate raw HTML or markdown fetch from one URL."
+    ];
+  }
+  return [
+    "Use create_realtime_monitor only when the user wants continuous realtime change detection with alerts. It first persists notification channels, then asynchronously returns workflow/session/thread/job IDs; use the workflow Assistant tools for follow-up status, questions, and controls.",
+    "For one-time or scheduled extraction, use create_workflow. Use scrape for an immediate raw HTML or markdown fetch from one URL. Use create_workflow for structured extraction, recurring runs, monitoring, or navigation-heavy jobs."
+  ];
+}
 async function createServer(auth, options) {
   const ctx = {
     client: createKadoaClient(auth),
     principal: auth.principal,
     teamId: auth.principal.teamId
   };
+  let capabilities = options?.capabilities;
+  if (!capabilities) {
+    try {
+      const response = await ctx.client.user.getFeatures();
+      capabilities = {
+        scrape: response.features.scrape,
+        defaultProductType: parseDefaultProductType(response.defaultProductType)
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "unknown error";
+      console.error(`[CAPABILITIES] Failed to resolve team capabilities; gated tools will be hidden: ${message}`);
+      capabilities = { scrape: false };
+    }
+  }
   const server = new McpServer({ name: "kadoa", version: package_default.version }, {
     instructions: [
       "IMPORTANT: One workflow = one source. A single workflow can extract many different fields, tables, and sections from the same URL(s) using a rich schema.",
@@ -4316,12 +4947,13 @@ async function createServer(auth, options) {
       "Kadoa workflows use agentic navigation: the AI agent can browse pages, click buttons, fill forms, select dropdowns, paginate, open detail pages, and handle multi-step interactions.",
       "Describe the full navigation steps in the prompt (e.g., 'select year 2022 from the dropdown, click Search, extract the table, then repeat for 2023').",
       "",
-      "Workflow lifecycle: create_workflow → get_workflow (check status) → fetch_data (get results). Workflows run asynchronously - never poll or sleep-wait.",
+      lifecycleInstruction(capabilities.defaultProductType),
       "",
-      "Use create_realtime_monitor only when the user wants continuous realtime change detection with alerts. It first persists notification channels, then asynchronously returns workflow/session/thread/job IDs; use the workflow Assistant tools for follow-up status, questions, and controls.",
-      "For one-time or scheduled extraction, use create_workflow. Use scrape for an immediate raw HTML or markdown fetch from one URL. Use create_workflow for structured extraction, recurring runs, monitoring, or navigation-heavy jobs.",
+      ...routingInstructions(capabilities.defaultProductType),
       "If a one-time or scheduled workflow fails, retry it with run_workflow using the existing workflow ID. Do NOT delete and recreate the workflow just to retry it - preserve its workflow ID and configuration. Realtime workflows cannot be manually run.",
       "Use list_changes and get_change to retrieve detected diffs from realtime monitoring workflows.",
+      "List tools, plus fetch_data, get_workflow_history, and get_workflow_assistant_timeline, all return pagination {totalCount?, hasMore, next?}. When hasMore is true, call the same tool again with pagination.next as its arguments to get the next page. totalCount is present only when the total is known; never treat the page size as the total.",
+      "Large results (fetch_data, get_workflow_history, get_change) are cut to whole rows or entries under about 80 KB and marked truncated: true with a hint; follow pagination.next, narrow the filters, or use export_data, and never conclude the data ends there.",
       "When the user asks what needs their attention, call list_workflows with statusFilters group:attention. A row with awaitingUserInput.prompt is the Assistant's pending question: answer it with get_workflow_assistant then answer_workflow_assistant_question. A row with awaitingUserInput but no prompt is a setup the user left unfinished: use get_workflow_assistant to see where it stopped, then resume_workflow_assistant or request_workflow_update. A row with displayState PREVIEW and no awaitingUserInput is preview data to review or approve with approve_workflow. Workflows with an open support ticket are excluded from group:attention and appear under group:support.",
       "",
       "Schema tips: Use descriptive field names and examples. Group related data under one entity.",
@@ -4331,17 +4963,6 @@ async function createServer(auth, options) {
     ].join(`
 `)
   });
-  let capabilities = options?.capabilities;
-  if (!capabilities) {
-    try {
-      const response = await ctx.client.user.getFeatures();
-      capabilities = { scrape: response.features.scrape };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "unknown error";
-      console.error(`[CAPABILITIES] Failed to resolve team capabilities; gated tools will be hidden: ${message}`);
-      capabilities = { scrape: false };
-    }
-  }
   registerTools(server, ctx, capabilities);
   server.server.onerror = (error) => console.error("[MCP Error]", safeErrorSummary(error));
   return server;