@kadoa/mcp 0.7.1 → 0.7.2

package/README.md

@@ -578,7 +578,7 @@ CLI and MCP both call **identical** SDK domain methods. A new feature added to t
      - Description string written **for the LLM**: when to call it, what inputs mean, what the response shape is.
      - Implementation calls `ctx.client.<thing>.<action>(...)` — never raw HTTP.
    - Add a unit test under `tests/unit/`.
-   - If the change intentionally alters a tool's name, title, description, schema, outputSchema or annotations, regenerate the snapshot: `UPDATE_TOOLS_SNAPSHOT=1 BUN_TEST=1 bun test tests/unit/tools-list-snapshot.test.ts`, then `./node_modules/.bin/biome format --write tests/unit/fixtures/tools-list.snapshot.json`.
+   - If the change intentionally alters a tool's name, title, description, schema, outputSchema or annotations, regenerate the snapshot: `UPDATE_TOOLS_SNAPSHOT=1 BUN_TEST=1 bun test tests/unit/tools-list-snapshot.test.ts`, then `./node_modules/.bin/biome format --write tests/unit/fixtures/tools-list.snapshot.json`. Advertised input and output schemas are normalised by `src/tools/shared/portable-schema.ts` (no `$ref`/`$defs`, `const`, `oneOf`, `additionalProperties`, `$schema`, etc.), so strict clients such as Gemini accept them; zod validation is unchanged.
    - Use a Conventional Commit message (`feat(mcp): ...`, `fix(mcp): ...`). Release Please will cut the next version on merge to `main`.
 
 4. **CLI** (`kadoa-cli`), if the feature is user-facing on the command line: mirror the MCP step in `src/commands/<thing>.ts`. Same SDK call, different UX.

package/dist/index.js

@@ -17,7 +17,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@kadoa/mcp",
-    version: "0.7.1",
+    version: "0.7.2",
     description: "Kadoa MCP Server — manage workflows from Claude Desktop, Cursor, and other MCP clients",
     type: "module",
     main: "dist/index.js",
@@ -212,257 +212,187 @@ function withVariableDashboardUrl(variable) {
   return { ...variable, dashboardUrl: variableSettingsDashboardUrl() };
 }
 
-// src/tools/shared/output-schemas.ts
-import { z } from "zod";
-var apiField, nullableString, PaginationOutput, workflowStatusFields, 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();
-  workflowStatusFields = {
-    status: z.string(),
-    badges: z.array(z.object({ kind: z.string(), status: z.string(), label: z.string() }).loose()),
-    group: nullableString,
-    reviewReason: z.object({ code: z.string(), explanation: z.string() }).loose().nullable(),
-    execution: apiField,
-    assistantState: apiField,
-    workspaceActivity: apiField
-  };
-  WorkflowRowOutput = z.object({
-    id: apiField,
-    name: apiField,
-    dashboardUrl: z.string(),
-    ...workflowStatusFields,
-    state: nullableString,
-    displayState: nullableString,
-    runState: nullableString,
-    urls: apiField,
-    totalRecords: apiField,
-    startedAt: apiField,
-    finishedAt: apiField,
-    createdAt: apiField,
-    assistant: z.object({
-      eligible: 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,
-    ...workflowStatusFields,
-    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,
-    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,
-    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;
+// src/tools/shared/portable-schema.ts
+function lookupRef(ref, defs) {
+  if (typeof ref !== "string")
+    return;
+  const match = /^#\/(?:\$defs|definitions)\/(.+)$/.exec(ref);
+  if (!match)
+    return;
+  const name = match[1].replace(/~1/g, "/").replace(/~0/g, "~");
+  const def = defs[name];
+  return isObject(def) ? { name, def } : undefined;
+}
+function mergeSchemas(base, extra) {
+  const merged = { ...extra, ...base };
+  if (isObject(base.properties) || isObject(extra.properties)) {
+    merged.properties = {
+      ...isObject(extra.properties) ? extra.properties : {},
+      ...isObject(base.properties) ? base.properties : {}
+    };
   }
-  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 structuredResult(data);
-}
-function textOnlyResult(data, extra = []) {
-  const structuredContent = asStructuredObject(data);
-  return { content: [{ type: "text", text: JSON.stringify(structuredContent) }, ...extra] };
+  if (Array.isArray(base.required) || Array.isArray(extra.required)) {
+    const required = [
+      ...Array.isArray(extra.required) ? extra.required : [],
+      ...Array.isArray(base.required) ? base.required : []
+    ];
+    merged.required = [...new Set(required)];
+  }
+  return merged;
+}
+function walk(node, defs, refCounts, io) {
+  if (!isObject(node))
+    return node;
+  let current = { ...node };
+  let counts = refCounts;
+  while ("$ref" in current) {
+    const { $ref, ...site } = current;
+    const target = lookupRef($ref, defs);
+    if (!target) {
+      current = site;
+      break;
+    }
+    const seen = counts.get(target.name) ?? 0;
+    counts = new Map(counts).set(target.name, seen + 1);
+    if (seen >= MAX_REF_DEPTH) {
+      const description = typeof target.def.description === "string" ? target.def.description : STUB_DESCRIPTION;
+      const type = typeof target.def.type === "string" ? target.def.type : io === "input" ? "object" : undefined;
+      current = { ...type ? { type } : {}, description, ...site };
+      break;
+    }
+    current = { ...target.def, ...site };
+  }
+  for (const keyword of DROPPED_KEYWORDS)
+    delete current[keyword];
+  if ("const" in current) {
+    const { const: value, ...rest } = current;
+    current = typeof value === "string" ? { ...rest, enum: [value] } : rest;
+    if (current.type === undefined && ["string", "number", "boolean"].includes(typeof value)) {
+      current.type = typeof value;
+    }
+  }
+  if (typeof current.exclusiveMinimum === "number") {
+    const bound = current.exclusiveMinimum;
+    current.minimum = typeof current.minimum === "number" ? Math.max(current.minimum, bound) : bound;
+  }
+  if (typeof current.exclusiveMaximum === "number") {
+    const bound = current.exclusiveMaximum;
+    current.maximum = typeof current.maximum === "number" ? Math.min(current.maximum, bound) : bound;
+  }
+  delete current.exclusiveMinimum;
+  delete current.exclusiveMaximum;
+  if (io === "input" && Array.isArray(current.enum) && Array.isArray(current.type) && current.type.includes("null")) {
+    current.enum = current.enum.filter((member) => member !== null);
+  }
+  if (Array.isArray(current.enum) && current.enum.some((member) => typeof member !== "string")) {
+    delete current.enum;
+  }
+  if (Array.isArray(current.prefixItems)) {
+    const { prefixItems, ...rest } = current;
+    current = rest;
+    if (current.items === undefined && prefixItems.length > 0) {
+      current.items = prefixItems.length === 1 ? prefixItems[0] : { anyOf: prefixItems };
+    }
+  }
+  if (isObject(current.properties)) {
+    current.properties = Object.fromEntries(Object.entries(current.properties).map(([name, value]) => [name, walk(value, defs, counts, io)]));
+  }
+  if (isObject(current.items))
+    current.items = walk(current.items, defs, counts, io);
+  if (Array.isArray(current.oneOf)) {
+    current.anyOf = [...Array.isArray(current.anyOf) ? current.anyOf : [], ...current.oneOf];
+    delete current.oneOf;
+  }
+  if (Array.isArray(current.anyOf))
+    current.anyOf = current.anyOf.map((member) => walk(member, defs, counts, io));
+  if (Array.isArray(current.allOf)) {
+    const { allOf, ...rest } = current;
+    current = rest;
+    for (const member of allOf) {
+      const walked = walk(member, defs, counts, io);
+      if (isObject(walked))
+        current = mergeSchemas(current, walked);
+    }
+  }
+  if (Array.isArray(current.type)) {
+    const types = current.type.filter((entry) => entry !== "null");
+    const nullable = types.length !== current.type.length;
+    if (types.length === 0) {
+      current.type = "null";
+    } else if (types.length === 1 && !(nullable && io === "output")) {
+      current.type = types[0];
+      if (nullable)
+        current.nullable = true;
+    } else {
+      const members = current.type.map((type) => ({ type }));
+      delete current.type;
+      current.anyOf = members;
+    }
+  }
+  if (Array.isArray(current.anyOf) && current.anyOf.some(isNullSchema)) {
+    const members = current.anyOf.filter((member) => !isNullSchema(member));
+    const { anyOf: _anyOf, ...rest } = current;
+    if (members.length === 0) {
+      current = { ...rest, type: "null" };
+    } else if (io === "input" && members.length === 1 && isObject(members[0])) {
+      const merged = mergeSchemas(rest, members[0]);
+      if (typeof merged.type === "string")
+        current = { ...merged, nullable: true };
+    }
+  }
+  return current;
 }
-function errorResult(message, details = {}) {
-  return {
-    content: [{ type: "text", text: JSON.stringify({ error: message, ...details }) }],
-    isError: true
+function toPortableJsonSchema(schema, options = {}) {
+  const io = options.io ?? "input";
+  const defs = {
+    ...isObject(schema.definitions) ? schema.definitions : {},
+    ...isObject(schema.$defs) ? schema.$defs : {}
   };
-}
-function withExtraContent(result, ...blocks) {
-  return { ...result, content: [...result.content, ...blocks] };
-}
+  return walk(schema, defs, new Map, io);
+}
+var NON_PORTABLE_KEYWORDS, DROPPED_KEYWORDS, MAX_REF_DEPTH = 3, STUB_DESCRIPTION = "Nested value of the same shape", isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value), isNullSchema = (schema) => isObject(schema) && schema.type === "null";
+var init_portable_schema = __esm(() => {
+  NON_PORTABLE_KEYWORDS = new Set([
+    "$ref",
+    "$defs",
+    "definitions",
+    "const",
+    "oneOf",
+    "allOf",
+    "exclusiveMinimum",
+    "exclusiveMaximum",
+    "prefixItems",
+    "$schema",
+    "additionalProperties",
+    "propertyNames",
+    "multipleOf",
+    "uniqueItems",
+    "id",
+    "$id",
+    "contentEncoding",
+    "contentMediaType",
+    "dependentRequired",
+    "patternProperties"
+  ]);
+  DROPPED_KEYWORDS = [
+    "$schema",
+    "$id",
+    "id",
+    "$defs",
+    "definitions",
+    "additionalProperties",
+    "propertyNames",
+    "patternProperties",
+    "multipleOf",
+    "uniqueItems",
+    "contentEncoding",
+    "contentMediaType",
+    "dependentRequired"
+  ];
+});
 
 // src/tools/shared/schemas.ts
-import { z as z3 } from "zod";
+import { z } from "zod";
 function isPlainObject(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -524,18 +454,14 @@ function stampSchemaValidationRules(rules, attribution, previous) {
   return Object.fromEntries(Object.entries(rules).map(([name, field]) => [name, stampField(field, previousFields[name])]));
 }
 function strictSchema(shape) {
-  return z3.object(shape).strict();
+  return portable(z.object(shape).strict());
 }
-function withoutDefIds(schema) {
+function portable(schema) {
   const jsonSchema = schema["~standard"].jsonSchema;
   const emitInput = jsonSchema.input;
-  jsonSchema.input = (params) => {
-    const result = emitInput(params);
-    const defs = result.$defs;
-    for (const def of Object.values(defs ?? {}))
-      delete def.id;
-    return result;
-  };
+  const emitOutput = jsonSchema.output;
+  jsonSchema.input = (params) => toPortableJsonSchema(emitInput(params), { io: "input" });
+  jsonSchema.output = (params) => toPortableJsonSchema(emitOutput(params), { io: "output" });
   return schema;
 }
 function normalizeDataFilters(val, ctx) {
@@ -560,7 +486,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 z3.NEVER;
+      return z.NEVER;
     }
     return [v];
   }
@@ -568,7 +494,8 @@ 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 = z3.enum([
+  init_portable_schema();
+  UpdateIntervalSchema = z.enum([
     "ONLY_ONCE",
     "EVERY_10_MINUTES",
     "HALF_HOURLY",
@@ -602,8 +529,8 @@ var init_schemas = __esm(() => {
     "credits_low",
     "free_trial_ending"
   ];
-  NotificationEventTypeSchema = z3.enum(NOTIFICATION_EVENT_TYPES);
-  SchemaFieldDataTypeSchema = z3.enum([
+  NotificationEventTypeSchema = z.enum(NOTIFICATION_EVENT_TYPES);
+  SchemaFieldDataTypeSchema = z.enum([
     "STRING",
     "NUMBER",
     "BOOLEAN",
@@ -616,61 +543,61 @@ var init_schemas = __esm(() => {
     "ARRAY"
   ]);
   SchemaFieldShape = {
-    name: z3.string().describe("Field name"),
-    description: z3.string().optional().describe("What this field contains"),
-    example: z3.string().describe("Example value"),
+    name: z.string().describe("Field name"),
+    description: z.string().optional().describe("What this field contains"),
+    example: z.string().describe("Example value"),
     dataType: SchemaFieldDataTypeSchema.optional().describe("Data type for the field"),
-    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).")
+    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).")
   };
-  SchemaValidationPresenceRule = z3.object({
-    target: z3.number().int().min(0).max(100).step(20).describe("Expected percentage of rows with a value")
+  SchemaValidationPresenceRule = z.object({
+    target: z.number().int().min(0).max(100).step(20).describe("Expected percentage of rows with a value")
   }).strict().meta({ id: "PresenceRule" });
-  SchemaValidationUniquenessRule = z3.object({
-    target: z3.number().int().min(0).max(100).step(20).describe("Expected percentage of rows with a unique value")
+  SchemaValidationUniquenessRule = z.object({
+    target: z.number().int().min(0).max(100).step(20).describe("Expected percentage of rows with a unique value")
   }).strict().meta({ id: "UniquenessRule" });
-  SchemaValidationBoundRule = z3.object({
-    value: z3.number().int().min(0).describe("Length or count bound")
+  SchemaValidationBoundRule = z.object({
+    value: z.number().int().min(0).describe("Length or count bound")
   }).strict().meta({ id: "BoundRule" });
-  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"])
+  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"])
         }).strict()
       ])
     }).strict(),
-    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"])
+    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"])
         }).strict(),
-        z3.object({
-          kind: z3.literal("CUSTOM"),
-          pattern: z3.string().min(1).describe("Regular expression pattern")
+        z.object({
+          kind: z.literal("CUSTOM"),
+          pattern: z.string().min(1).describe("Regular expression pattern")
         }).strict()
       ])
     }).strict(),
-    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"])
+    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"])
         }).strict(),
-        z3.object({
-          kind: z3.literal("CUSTOM"),
-          values: z3.array(z3.string().min(1)).min(1).describe("Allowed string values")
+        z.object({
+          kind: z.literal("CUSTOM"),
+          values: z.array(z.string().min(1)).min(1).describe("Allowed string values")
         }).strict()
       ])
     }).strict()
   ]);
-  SchemaValidationFieldRulesSchema = z3.lazy(() => z3.discriminatedUnion("kind", [
-    z3.object({
-      kind: z3.literal("STRING"),
+  SchemaValidationFieldRulesSchema = z.lazy(() => z.discriminatedUnion("kind", [
+    z.object({
+      kind: z.literal("STRING"),
       presence: SchemaValidationPresenceRule.optional(),
       uniqueness: SchemaValidationUniquenessRule.optional(),
       minLength: SchemaValidationBoundRule.optional(),
@@ -679,27 +606,27 @@ var init_schemas = __esm(() => {
       maxHtmlElements: SchemaValidationBoundRule.optional(),
       format: SchemaValidationStringFormatRule.optional()
     }).strict(),
-    z3.object({
-      kind: z3.literal("NUMBER"),
+    z.object({
+      kind: z.literal("NUMBER"),
       presence: SchemaValidationPresenceRule.optional(),
       uniqueness: SchemaValidationUniquenessRule.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()
+      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()
     }).strict(),
-    z3.object({
-      kind: z3.literal("OTHER"),
+    z.object({
+      kind: z.literal("OTHER"),
       presence: SchemaValidationPresenceRule.optional(),
       uniqueness: SchemaValidationUniquenessRule.optional()
     }).strict(),
-    z3.object({
-      kind: z3.literal("OBJECT"),
+    z.object({
+      kind: z.literal("OBJECT"),
       presence: SchemaValidationPresenceRule.optional(),
       uniqueness: SchemaValidationUniquenessRule.optional(),
-      properties: z3.record(z3.string(), SchemaValidationFieldRulesSchema)
+      properties: z.record(z.string(), SchemaValidationFieldRulesSchema)
     }).strict(),
-    z3.object({
-      kind: z3.literal("ARRAY"),
+    z.object({
+      kind: z.literal("ARRAY"),
       presence: SchemaValidationPresenceRule.optional(),
       uniqueness: SchemaValidationUniquenessRule.optional(),
       minItems: SchemaValidationBoundRule.optional(),
@@ -707,21 +634,21 @@ var init_schemas = __esm(() => {
       items: SchemaValidationFieldRulesSchema.optional()
     }).strict()
   ]));
-  SchemaValidationRulesSchema = z3.record(z3.string(), SchemaValidationFieldRulesSchema);
+  SchemaValidationRulesSchema = z.record(z.string(), SchemaValidationFieldRulesSchema);
   SCHEMA_VALIDATION_ATTRIBUTION_KEYS = new Set(["editedBy", "editedByLabel", "editedAt"]);
-  LocationSchema = z3.object({
-    type: z3.enum(["auto", "manual"]),
-    isoCode: z3.string().trim().min(2).optional()
+  LocationSchema = z.object({
+    type: z.enum(["auto", "manual"]),
+    isoCode: z.string().trim().min(2).optional()
   }).strict().superRefine((location, ctx) => {
     if (location.type === "manual" && !location.isoCode) {
       ctx.addIssue({
-        code: z3.ZodIssueCode.custom,
+        code: z.ZodIssueCode.custom,
         path: ["isoCode"],
         message: "isoCode is required for manual location"
       });
     }
     if (location.type === "auto" && location.isoCode) {
-      ctx.addIssue({ code: z3.ZodIssueCode.custom, path: ["isoCode"], message: "omit isoCode for auto location" });
+      ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["isoCode"], message: "omit isoCode for auto location" });
     }
   });
   MonitoringValueOperators = [
@@ -743,81 +670,81 @@ var init_schemas = __esm(() => {
     "WITHIN_LAST_DAYS"
   ];
   MonitoringValuelessOperators = ["IS_NULL", "IS_NOT_NULL", "IS_EMPTY", "IS_NOT_EMPTY"];
-  MonitoringConditionOperatorSchema = z3.enum([...MonitoringValueOperators, ...MonitoringValuelessOperators]);
-  MonitoringConditionSchema = z3.object({
-    type: z3.enum(["SINGLE", "ANY"]),
-    field: z3.string().trim().min(1).optional(),
+  MonitoringConditionOperatorSchema = z.enum([...MonitoringValueOperators, ...MonitoringValuelessOperators]);
+  MonitoringConditionSchema = z.object({
+    type: z.enum(["SINGLE", "ANY"]),
+    field: z.string().trim().min(1).optional(),
     operator: MonitoringConditionOperatorSchema,
-    value: z3.union([z3.string(), z3.number(), z3.boolean()]).optional()
+    value: z.union([z.string(), z.number(), z.boolean()]).optional()
   }).strict().superRefine((condition, ctx) => {
     if (condition.type === "SINGLE" && !condition.field) {
       ctx.addIssue({
-        code: z3.ZodIssueCode.custom,
+        code: z.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: z3.ZodIssueCode.custom, path: ["value"], message: `${condition.operator} requires a value` });
+      ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["value"], message: `${condition.operator} requires a value` });
     }
     if (!needsValue && condition.value !== undefined) {
       ctx.addIssue({
-        code: z3.ZodIssueCode.custom,
+        code: z.ZodIssueCode.custom,
         path: ["value"],
         message: `${condition.operator} does not accept a value`
       });
     }
   });
-  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()
+  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()
     }).strict()).min(1)),
-    conditions: z3.object({
-      logicalOperator: z3.enum(["AND", "OR"]),
-      conditions: z3.preprocess(coerceArray(), z3.array(MonitoringConditionSchema).min(1))
+    conditions: z.object({
+      logicalOperator: z.enum(["AND", "OR"]),
+      conditions: z.preprocess(coerceArray(), z.array(MonitoringConditionSchema).min(1))
     }).strict().optional()
   }).strict();
   urlInputShape = {
-    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.")
+    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.")
   };
-  extractionPromptInput = z3.string().optional();
+  extractionPromptInput = z.string().optional();
   extractionInputShape = {
-    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.")
+    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.")
   };
-  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)")
+  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)")
   }).optional().describe("Authentication configuration for the webhook endpoint");
-  notificationChannelsSchema = z3.object({
-    email: z3.object({
-      recipients: z3.array(z3.string().email()).optional().describe("Email addresses to notify. Omit to use account default email.")
+  notificationChannelsSchema = z.object({
+    email: z.object({
+      recipients: z.array(z.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: 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: z.object({
+      url: z.string().url().describe("Webhook endpoint URL"),
+      httpMethod: z.enum(["POST", "GET", "PUT", "PATCH"]).optional().describe("HTTP method (defaults to POST)"),
       auth: webhookAuthShape
     }).optional().describe("Send notifications 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: 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)")
     }).optional().describe("Send notifications to a Slack channel. Use slackChannelId/slackChannelName for OAuth integration, or webhookUrl for legacy incoming webhooks."),
-    websocket: z3.boolean().optional().describe("Enable WebSocket notifications for programmatic real-time consumption")
+    websocket: z.boolean().optional().describe("Enable WebSocket notifications for programmatic real-time consumption")
   });
   notificationsInputShape = {
-    notifications: z3.preprocess(coerceJson(), notificationChannelsSchema.optional()).optional().describe("Optional notification channels to alert when data changes.")
+    notifications: z.preprocess(coerceJson(), notificationChannelsSchema.optional()).optional().describe("Optional notification channels to alert when data changes.")
   };
   requiredNotificationsInputShape = {
-    notifications: z3.preprocess(coerceJson(), notificationChannelsSchema).describe("Notification channels to alert when data changes.")
+    notifications: z.preprocess(coerceJson(), notificationChannelsSchema).describe("Notification channels to alert when data changes.")
   };
   DATA_FILTER_OPERATORS = [
     "EQUALS",
@@ -842,10 +769,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 = 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")
+  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")
   }).strict().superRefine((filter, ctx) => {
     if (DATA_FILTER_VALUELESS_OPERATORS.has(filter.operator)) {
       if (filter.value !== undefined) {
@@ -870,9 +797,259 @@ var init_schemas = __esm(() => {
       });
     }
   });
-  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.');
+  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.');
+});
+
+// src/tools/shared/output-schemas.ts
+import { z as z2 } from "zod";
+var apiField, nullableString, PaginationOutput, workflowStatusFields, WorkflowRowOutput, ListWorkflowsOutput, GetWorkflowOutput, FetchDataOutput, ASSISTANT_ACTIVITIES, WorkflowAssistantOutput, AssistantTimelineOutput, AssistantAnswerOutput, AssistantControlOutput, WorkflowStrategyOutput;
+var init_output_schemas = __esm(() => {
+  init_schemas();
+  apiField = z2.unknown().optional();
+  nullableString = z2.string().nullable();
+  PaginationOutput = portable(z2.object({
+    totalCount: z2.number().optional(),
+    hasMore: z2.boolean(),
+    limit: z2.number().optional(),
+    skip: z2.number().optional(),
+    offset: z2.number().optional(),
+    page: z2.number().optional(),
+    totalPages: z2.number().optional(),
+    nextCursor: nullableString.optional(),
+    next: z2.record(z2.string(), z2.unknown()).optional()
+  }).loose());
+  workflowStatusFields = {
+    status: z2.string(),
+    badges: z2.array(z2.object({ kind: z2.string(), status: z2.string(), label: z2.string() }).loose()),
+    group: nullableString,
+    reviewReason: z2.object({ code: z2.string(), explanation: z2.string() }).loose().nullable(),
+    execution: apiField,
+    assistantState: apiField,
+    workspaceActivity: apiField
+  };
+  WorkflowRowOutput = z2.object({
+    id: apiField,
+    name: apiField,
+    dashboardUrl: z2.string(),
+    ...workflowStatusFields,
+    state: nullableString,
+    displayState: nullableString,
+    runState: nullableString,
+    urls: apiField,
+    totalRecords: apiField,
+    startedAt: apiField,
+    finishedAt: apiField,
+    createdAt: apiField,
+    assistant: z2.object({
+      eligible: z2.boolean(),
+      session: z2.object({ id: z2.string(), threadId: apiField, status: apiField }).loose().nullable()
+    }).loose(),
+    template: z2.object({ id: z2.string(), pinnedVersion: apiField, latestVersion: apiField, isOutdated: z2.boolean() }).loose().nullable(),
+    realtime: z2.object({ enabled: z2.boolean(), lastDataChangedAt: apiField, health: apiField }).loose(),
+    awaitingUserInput: apiField
+  }).loose();
+  ListWorkflowsOutput = portable(z2.object({ workflows: z2.array(WorkflowRowOutput), pagination: PaginationOutput }).loose());
+  GetWorkflowOutput = portable(z2.object({
+    id: z2.string(),
+    name: apiField,
+    dashboardUrl: z2.string(),
+    description: apiField,
+    ...workflowStatusFields,
+    state: nullableString,
+    displayState: nullableString,
+    runState: nullableString,
+    urls: apiField,
+    prompt: nullableString,
+    intentSource: z2.enum(["extraction_spec", "legacy_prompt"]).nullable(),
+    extractionSpec: apiField,
+    entity: apiField,
+    schema: apiField,
+    navigationMode: apiField,
+    assistantEligible: z2.boolean(),
+    assistantSessionId: apiField,
+    assistantThreadId: apiField,
+    assistantSessionStatus: apiField,
+    assistant: z2.object({ eligible: z2.boolean(), sessionId: apiField, threadId: apiField, sessionStatus: apiField }).loose(),
+    template: z2.object({
+      id: apiField,
+      name: apiField,
+      version: apiField,
+      controlledParts: z2.array(z2.string()),
+      hasSchemaValidationRules: apiField
+    }).loose().nullable(),
+    updateInterval: apiField,
+    schedules: apiField,
+    scheduleTimezone: apiField,
+    nextInvocation: apiField,
+    location: apiField,
+    limit: apiField,
+    tags: apiField,
+    totalRecords: apiField,
+    job: z2.object({ id: apiField }).loose().nullable(),
+    startedAt: apiField,
+    finishedAt: apiField,
+    estimatedFinishedAtUtc: apiField,
+    errors: apiField,
+    createdAt: apiField,
+    notificationConfig: apiField,
+    channelCounts: apiField,
+    realtime: z2.object({ lastDataChangedAt: apiField, observerHealth: apiField }).loose().nullable()
+  }).loose());
+  FetchDataOutput = portable(z2.object({
+    data: z2.array(z2.record(z2.string(), z2.unknown())),
+    pagination: PaginationOutput,
+    totalCount: z2.number().optional(),
+    hint: z2.string().optional()
+  }).loose());
+  ASSISTANT_ACTIVITIES = [
+    "unsupported",
+    "not_started",
+    "working",
+    "waiting_for_input",
+    "idle",
+    "interrupted",
+    "failed",
+    "closed",
+    "unknown"
+  ];
+  WorkflowAssistantOutput = portable(z2.object({
+    workflowId: z2.string(),
+    assistantEligible: z2.boolean(),
+    sessionId: nullableString,
+    threadId: apiField,
+    sessionStatus: apiField,
+    activity: z2.enum(ASSISTANT_ACTIVITIES),
+    canAcceptUpdate: z2.boolean(),
+    isTerminal: z2.boolean(),
+    paused: apiField,
+    pause: apiField,
+    pendingQuestion: apiField
+  }).loose());
+  AssistantTimelineOutput = portable(z2.object({
+    workflowId: z2.string(),
+    sessionId: apiField,
+    items: z2.array(z2.unknown()),
+    pagination: PaginationOutput,
+    dashboardUrl: z2.string()
+  }).loose());
+  AssistantAnswerOutput = portable(z2.object({
+    success: z2.literal(true),
+    workflowId: z2.string(),
+    sessionId: z2.string(),
+    threadId: apiField,
+    questionId: z2.string(),
+    message: z2.string()
+  }).loose());
+  AssistantControlOutput = portable(z2.object({
+    success: z2.boolean(),
+    status: z2.literal("accepted"),
+    action: z2.enum(["interrupt", "resume", "stop"]),
+    workflowId: z2.string(),
+    sessionId: z2.string(),
+    delivery: apiField,
+    jobId: apiField,
+    message: z2.string()
+  }).loose());
+  WorkflowStrategyOutput = portable(z2.object({
+    workflowId: z2.string(),
+    sessionId: nullableString,
+    source: z2.enum(["assistant_build", "workflow_metadata"]).nullable(),
+    status: z2.enum(["ready", "building", "unavailable"]),
+    strategy: apiField,
+    message: z2.string().optional()
+  }).loose());
 });
 
+// src/tools/shared/pagination.ts
+import { z as z3 } 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 z3.preprocess(coerceNumber(), z3.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 z3.preprocess(coerceNumber(), z3.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 z3.preprocess(coerceNumber(), z3.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 structuredResult(data);
+}
+function textOnlyResult(data, extra = []) {
+  const structuredContent = asStructuredObject(data);
+  return { content: [{ type: "text", text: JSON.stringify(structuredContent) }, ...extra] };
+}
+function errorResult(message, details = {}) {
+  return {
+    content: [{ type: "text", text: JSON.stringify({ error: message, ...details }) }],
+    isError: true
+  };
+}
+function withExtraContent(result, ...blocks) {
+  return { ...result, content: [...result.content, ...blocks] };
+}
+
 // src/tools/assistant.ts
 import { FREEFORM_ASSISTANT_ANSWER_KEY } from "@kadoa/node-sdk";
 import { z as z4 } from "zod";
@@ -2395,13 +2572,13 @@ function registerTemplateTools(server, ctx, helpers) {
     description: `Publish a new version of a template. Versions capture the full workflow config: prompt, schema, and notifications. All fields are optional - include only what this version should set.
 
 ` + "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({
+    inputSchema: strictSchema({
       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.'),
+      schemaValidationRules: z10.preprocess((val) => stripSchemaValidationAttribution(coerceJson()(val)), SchemaValidationRulesSchema).optional().describe("Per-field schema validation rules keyed by field name. Each value is an object with a required `kind` and optional rules for that kind; unknown keys are rejected. " + "Every kind accepts presence and uniqueness, each { target: integer 0-100 in steps of 20 } (expected percentage of rows with a value / a unique value). " + "STRING: minLength, maxLength, minHtmlElements, maxHtmlElements, each { value: integer >= 0 }; format, one of " + '{ kind: "FORMAT", source: { kind: "PRESET", preset: url | email | phone | date | datetime | time | uuid | slug } or { kind: "CUSTOM", pattern: regex string } }, ' + '{ kind: "FREE_TEXT", charset: { kind: "PRESET", preset: natural_language | alphanumeric | alpha } }, or ' + '{ kind: "LIST", source: { kind: "PRESET", preset: language2 | country2 | country3 | currency3 | month3 | usState2 } or { kind: "CUSTOM", values: [non-empty strings] } }. ' + "NUMBER: minimum and maximum, each { value: number }; maxDecimalPlaces { value: integer 0-16 }. " + "OTHER: only presence and uniqueness. " + "OBJECT: properties (required), a map of nested field name to rule. " + "ARRAY: minItems, maxItems, each { value: integer >= 0 }; items, the rule for each element. " + 'Examples: { "price": { "kind": "NUMBER", "minimum": { "value": 0 } } }; { "email": { "kind": "STRING", "format": { "kind": "FORMAT", "source": { "kind": "PRESET", "preset": "email" } } } }. ' + "Edit attribution is stamped server-side, so send only rule values. 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(),
@@ -2417,7 +2594,7 @@ function registerTemplateTools(server, ctx, helpers) {
           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.")
-    })),
+    }),
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }
   }, withErrorHandling("create_template_version", async (args) => {
     const { templateId, schemaValidationRules, ...rest } = args;
@@ -3747,7 +3924,7 @@ function registerWorkflowRunTools(server, ctx, helpers) {
       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.")
+      limit: z12.preprocess(coerceNumber(), z12.number().positive().nullable()).optional().describe("Maximum records per run; must be positive (greater than 0). Pass null to clear the limit and extract all rows.")
     }),
     annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("update_workflow", async (args) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kadoa/mcp",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "description": "Kadoa MCP Server — manage workflows from Claude Desktop, Cursor, and other MCP clients",
   "type": "module",
   "main": "dist/index.js",