@zapier/zapier-sdk 0.84.2 → 0.84.3

package/dist/index.mjs

@@ -201,7 +201,8 @@ function getCoreErrorCause(value) {
 var CURSOR_VERSION = 1;
 var CURSOR_SOURCE = {
   API: "api",
-  SDK: "sdk"
+  SDK: "sdk",
+  CONCAT: "concat"
 };
 function encodeBase64(str) {
   return btoa(
@@ -385,10 +386,32 @@ async function* paginateBuffered(pageFunction, pageOptions) {
   }
 }
 var paginate = paginateBuffered;
+function encodeConcatCursor(index, cursor) {
+  const envelope = {
+    v: CURSOR_VERSION,
+    source: CURSOR_SOURCE.CONCAT,
+    index,
+    cursor
+  };
+  return encodeBase64(JSON.stringify(envelope));
+}
+function decodeConcatCursor(incoming) {
+  if (!incoming) {
+    return { index: 0, cursor: void 0 };
+  }
+  try {
+    const envelope = JSON.parse(decodeBase64(incoming));
+    if (envelope.v === CURSOR_VERSION && envelope.source === CURSOR_SOURCE.CONCAT && typeof envelope.index === "number") {
+      return { index: envelope.index, cursor: envelope.cursor };
+    }
+  } catch {
+  }
+  return { index: 0, cursor: incoming };
+}
 function concatPaginated({
   sources,
-  dedupe,
-  pageSize = 100
+  pageSize = 100,
+  cursor
 }) {
   if (sources.length === 0) {
     const empty = { data: [] };
@@ -398,40 +421,24 @@ function concatPaginated({
       }
     });
   }
-  let sourceIndex = 0;
-  let currentIterator = null;
-  const seen = /* @__PURE__ */ new Set();
-  const pageFunction = async (_options) => {
-    while (sourceIndex < sources.length) {
-      if (!currentIterator) {
-        const result = sources[sourceIndex]();
-        currentIterator = result[Symbol.asyncIterator]();
-      }
-      const next = await currentIterator.next();
-      if (next.done) {
-        sourceIndex++;
-        currentIterator = null;
+  const pageFunction = async (options) => {
+    let { index, cursor: sourceCursor } = decodeConcatCursor(options.cursor);
+    while (index < sources.length) {
+      const page = await sources[index]({ cursor: sourceCursor });
+      const hasMoreInSource = page.nextCursor != null;
+      if (page.data.length === 0 && !hasMoreInSource) {
+        index++;
+        sourceCursor = void 0;
         continue;
       }
-      let items = next.value.data;
-      if (dedupe) {
-        if (sourceIndex > 0) {
-          items = items.filter((item) => !seen.has(dedupe(item)));
-        }
-        for (const item of items) {
-          seen.add(dedupe(item));
-        }
-      }
-      const hasMoreInSource = next.value.nextCursor != null;
-      const hasMoreSources = sourceIndex < sources.length - 1;
       return {
-        data: items,
-        nextCursor: hasMoreInSource || hasMoreSources ? "__has_more__" : void 0
+        data: page.data,
+        nextCursor: hasMoreInSource ? encodeConcatCursor(index, page.nextCursor) : index < sources.length - 1 ? encodeConcatCursor(index + 1, void 0) : void 0
       };
     }
     return { data: [] };
   };
-  const iterator = paginateBuffered(pageFunction, { pageSize });
+  const iterator = paginateBuffered(pageFunction, { pageSize, cursor });
   const firstPagePromise = iterator.next().then((result) => {
     if (result.done) {
       return { data: [] };
@@ -1283,6 +1290,7 @@ function defineResolver(config) {
         getContext: config.getContext,
         listItems: config.listItems,
         prompt: config.prompt,
+        validate: config.validate,
         tryResolveWithoutPrompt: config.tryResolveWithoutPrompt,
         tryResolveFromSearch: config.tryResolveFromSearch
       };
@@ -1928,6 +1936,7 @@ function bindResolver(resolver, plugins) {
       const {
         getContext: getContext2,
         listItems,
+        validate,
         tryResolveWithoutPrompt,
         tryResolveFromSearch
       } = resolver;
@@ -1941,6 +1950,9 @@ function bindResolver(resolver, plugins) {
       };
       if (getContext2)
         bound.getContext = ({ input }) => getContext2({ imports, input });
+      if (validate) {
+        bound.validate = ({ value, input, context }) => validate({ imports, value, input, context });
+      }
       if (tryResolveWithoutPrompt) {
         bound.tryResolveWithoutPrompt = ({ input }) => tryResolveWithoutPrompt({ imports, input });
       }
@@ -2609,14 +2621,14 @@ function coerce(leaf, raw) {
 }
 async function validationError(leaf, value, state) {
   if (leaf.resolver?.type !== "dynamic") return null;
+  const validate = leaf.resolver.validate;
+  if (!validate) return null;
   const context = await resolveContext(leaf, state.resolved);
-  const config = leaf.resolver.prompt?.({
-    items: state.listing?.items ?? [],
+  const verdict = await validate({
+    value,
     input: mergeInput(state.resolved, leaf.extraInput),
     context
   });
-  if (!config?.validate) return null;
-  const verdict = config.validate(value);
   if (verdict === true) return null;
   return typeof verdict === "string" ? verdict : `${leaf.name}: invalid value`;
 }
@@ -2742,20 +2754,36 @@ async function resolveContext(leaf, input) {
     input: mergeInput(input, leaf.extraInput)
   });
 }
-async function fetchListing(leaf, input, opts = {}) {
+function firstPagePosition(opts = {}) {
+  return {
+    ...opts.search !== void 0 ? { search: opts.search } : {},
+    pageCursor: null,
+    previousCursors: [],
+    generation: opts.generation ?? 0
+  };
+}
+async function fetchListing(leaf, input, position, context) {
+  if (leaf.resolver?.type === "dynamic" && leaf.resolver.inputType === "search" && position.search === void 0) {
+    return { position, items: [] };
+  }
   const page = await firstPage(
     leaf.resolver?.type === "dynamic" ? leaf.resolver.listItems({
       input: mergeInput(input, leaf.extraInput),
-      context: opts.context,
-      search: opts.search,
-      cursor: opts.cursor
+      context,
+      search: position.search,
+      cursor: position.pageCursor ?? void 0
     }) : void 0
   );
   return {
-    items: [...opts.priorItems ?? [], ...page.data],
-    cursor: page.nextCursor,
-    search: opts.search,
-    exhausted: page.nextCursor == null
+    position,
+    items: page.data,
+    ...page.nextCursor != null ? { nextCursor: page.nextCursor } : {}
+  };
+}
+function toPagination(page) {
+  return {
+    position: page.position,
+    ...page.nextCursor !== void 0 ? { nextCursor: page.nextCursor } : {}
   };
 }
 function toChoice(c) {
@@ -2775,23 +2803,32 @@ var AFFORDANCE = {
     description: "Filter the options by a search term",
     supply: "term"
   },
-  more: { action: "more", description: "Load more options" },
+  nextPage: {
+    action: "next_page",
+    description: "Fetch the next page of options"
+  },
+  previousPage: {
+    action: "previous_page",
+    description: "Return to the previous page of options"
+  },
   skip: { action: "skip", description: "Omit this optional parameter" },
   add: { action: "add", description: "Add another item" },
   done: { action: "done", description: "Finish the list" },
   retry: { action: "retry", description: "Retry loading the options" },
   cancel: { action: "cancel", description: "Cancel resolution" }
 };
-function selectActions(leaf, listing, multiple) {
+function selectActions(leaf, page, multiple) {
   const searchMode = leaf.resolver?.type === "dynamic" && leaf.resolver.inputType === "search";
-  if (searchMode && listing.search === void 0 && listing.items.length === 0) {
+  if (searchMode && page.position.search === void 0 && page.items.length === 0) {
     const actions2 = multiple ? [AFFORDANCE.search] : [AFFORDANCE.search, AFFORDANCE.custom];
     if (!leaf.required) actions2.push(AFFORDANCE.skip);
     return actions2;
   }
   const actions = multiple ? [AFFORDANCE.choose] : [AFFORDANCE.choose, AFFORDANCE.custom];
   if (searchMode) actions.push(AFFORDANCE.search);
-  if (listing.cursor) actions.push(AFFORDANCE.more);
+  if (page.nextCursor) actions.push(AFFORDANCE.nextPage);
+  if (page.position.previousCursors.length > 0)
+    actions.push(AFFORDANCE.previousPage);
   if (!leaf.required) actions.push(AFFORDANCE.skip);
   return actions;
 }
@@ -2799,16 +2836,17 @@ function labeledMessage(leaf) {
   if (!leaf.label) return void 0;
   return `${leaf.label} (${leaf.required ? "required" : "optional"}):`;
 }
-function selectQuestion(leaf, input, listing, context) {
+function selectQuestion(leaf, path, input, page, context) {
   const resolver = leaf.resolver?.type === "dynamic" ? leaf.resolver : void 0;
   const config = resolver?.prompt?.({
-    items: listing.items,
+    items: page.items,
     input: mergeInput(input, leaf.extraInput),
     context
   });
   const multiple = config?.type === "checkbox";
   return {
     type: "select",
+    path,
     // A labeled field's title beats the resolver's message: per-field
     // resolvers are shared across fields (one choices-fetcher for every
     // field), so only the leaf knows which field is being asked.
@@ -2816,9 +2854,13 @@ function selectQuestion(leaf, input, listing, context) {
     choices: (config?.choices ?? []).map(toChoice),
     ...multiple ? { multiple: true } : {},
     ...config?.notes?.length ? { notes: config.notes } : {},
-    ...listing.search !== void 0 ? { search: listing.search } : {},
+    ...page.position.search !== void 0 ? { search: page.position.search } : {},
     ...resolver?.placeholder ? { placeholder: resolver.placeholder } : {},
-    actions: selectActions(leaf, listing, multiple)
+    page: {
+      generation: page.position.generation,
+      index: page.position.previousCursors.length
+    },
+    actions: selectActions(leaf, page, multiple)
   };
 }
 function toControllerError(error) {
@@ -2840,6 +2882,7 @@ function failedResult(state, name, error) {
       error: toControllerError(error),
       question: {
         type: "select",
+        path: state.current ?? [],
         message: `Could not load options for ${name}.`,
         choices: [],
         actions: [AFFORDANCE.retry, AFFORDANCE.cancel]
@@ -2847,27 +2890,15 @@ function failedResult(state, name, error) {
     }
   };
 }
-async function buildQuestion(leaf, input) {
+async function buildQuestion(leaf, path, input) {
   const optional = !leaf.required;
   const resolver = leaf.resolver;
   if (resolver?.type === "dynamic") {
     const context = await resolveContext(leaf, input);
-    if (resolver.inputType === "search") {
-      const listing2 = {
-        items: [],
-        cursor: void 0,
-        search: void 0,
-        exhausted: true
-      };
-      return {
-        question: selectQuestion(leaf, input, listing2, context),
-        listing: listing2
-      };
-    }
-    const listing = await fetchListing(leaf, input, { context });
+    const page = await fetchListing(leaf, input, firstPagePosition(), context);
     return {
-      question: selectQuestion(leaf, input, listing, context),
-      listing
+      question: selectQuestion(leaf, path, input, page, context),
+      pagination: toPagination(page)
     };
   }
   if (leaf.staticChoices) {
@@ -2876,6 +2907,7 @@ async function buildQuestion(leaf, input) {
     return {
       question: {
         type: "select",
+        path,
         message: `Select ${leaf.name}:`,
         choices: leaf.staticChoices,
         actions: actions2
@@ -2889,6 +2921,7 @@ async function buildQuestion(leaf, input) {
   return {
     question: {
       type: "input",
+      path,
       // The optional marker makes Enter-to-pass discoverable on a bare
       // parameter; a labeled field carries its marker via labeledMessage.
       message: labeledMessage(leaf) ?? `Enter ${leaf.name}${optional ? " (optional)" : ""}:`,
@@ -2903,6 +2936,7 @@ function collectionQuestion(t) {
   if (t.count >= t.min) actions.push(AFFORDANCE.done);
   return {
     type: "collection",
+    path: t.path,
     message: `Add ${t.path[t.path.length - 1]}[${t.count}]?`,
     container: "array",
     count: t.count,
@@ -2916,6 +2950,7 @@ function collectionQuestion(t) {
 function objectGateQuestion(path) {
   return {
     type: "collection",
+    path,
     message: `Add ${path[path.length - 1]}?`,
     container: "object",
     actions: [
@@ -2927,9 +2962,10 @@ function objectGateQuestion(path) {
     ]
   };
 }
-function optionalsGateQuestion(pending) {
+function optionalsGateQuestion(path, pending) {
   return {
     type: "collection",
+    path,
     // The prompt and its context ride separately so a host renders the info
     // line above the confirm without composing any text of its own.
     message: "Would you like to configure optional fields?",
@@ -3077,8 +3113,12 @@ async function askLeaf(state, path, leaf, opts = {}) {
   state.current = path;
   delete state.gate;
   try {
-    const { question, listing } = await buildQuestion(leaf, state.resolved);
-    state.listing = listing;
+    const { question, pagination } = await buildQuestion(
+      leaf,
+      path,
+      state.resolved
+    );
+    state.pagination = pagination;
     return {
       state,
       result: {
@@ -3088,7 +3128,7 @@ async function askLeaf(state, path, leaf, opts = {}) {
       }
     };
   } catch (error) {
-    state.listing = { items: [], exhausted: false };
+    state.pagination = failedPagination(void 0, firstPagePosition());
     return failedResult(state, leaf.name, error);
   }
 }
@@ -3098,13 +3138,13 @@ async function advance(ctx, state) {
     if (!target) {
       delete state.current;
       delete state.gate;
-      delete state.listing;
+      delete state.pagination;
       return { state, result: finalize(ctx, state.resolved) };
     }
     if (target.kind === "array") {
       state.current = target.path;
       state.gate = "array";
-      delete state.listing;
+      delete state.pagination;
       return {
         state,
         result: { status: "ask", question: collectionQuestion(target) }
@@ -3113,7 +3153,7 @@ async function advance(ctx, state) {
     if (target.kind === "object") {
       state.current = target.path;
       state.gate = "entry";
-      delete state.listing;
+      delete state.pagination;
       return {
         state,
         result: { status: "ask", question: objectGateQuestion(target.path) }
@@ -3122,12 +3162,12 @@ async function advance(ctx, state) {
     if (target.kind === "optionals") {
       state.current = target.path;
       state.gate = "optionals";
-      delete state.listing;
+      delete state.pagination;
       return {
         state,
         result: {
           status: "ask",
-          question: optionalsGateQuestion(target.pending)
+          question: optionalsGateQuestion(target.path, target.pending)
         }
       };
     }
@@ -3178,13 +3218,13 @@ async function step(ctx, prior, action) {
   if (action.type === "cancel") {
     delete state.current;
     delete state.gate;
-    delete state.listing;
+    delete state.pagination;
     return { state, result: { status: "cancelled" } };
   }
   const path = state.current;
   if (!path) throw new Error("step called with no outstanding question");
   const leaf = await leafAt(ctx, path, state.resolved);
-  if (leaf && (action.type === "search" || action.type === "more" || action.type === "retry")) {
+  if (leaf && (action.type === "search" || action.type === "next_page" || action.type === "previous_page" || action.type === "retry")) {
     return refine(ctx, state, leaf, path, action);
   }
   if (action.type === "add" || action.type === "done") {
@@ -3196,7 +3236,7 @@ async function step(ctx, prior, action) {
     }
     delete state.current;
     delete state.gate;
-    delete state.listing;
+    delete state.pagination;
     if (action.type === "done") {
       settle(state, path);
       return advance(ctx, state);
@@ -3225,23 +3265,44 @@ async function step(ctx, prior, action) {
     case "choose":
     case "custom": {
       if (leaf) {
-        const error = await validationError(leaf, action.value, state);
+        let error;
+        try {
+          error = await validationError(leaf, action.value, state);
+        } catch (thrown) {
+          return failedResult(state, leaf.name, thrown);
+        }
         if (error) {
-          if (state.listing && leaf.resolver?.type === "dynamic") {
-            const context = await resolveContext(leaf, state.resolved);
-            return {
-              state,
-              result: {
-                status: "ask",
-                question: selectQuestion(
-                  leaf,
-                  state.resolved,
-                  state.listing,
-                  context
-                ),
-                error
-              }
-            };
+          if (state.pagination && leaf.resolver?.type === "dynamic") {
+            try {
+              const context = await resolveContext(leaf, state.resolved);
+              const page = await fetchListing(
+                leaf,
+                state.resolved,
+                state.pagination.position,
+                context
+              );
+              state.pagination = toPagination(page);
+              return {
+                state,
+                result: {
+                  status: "ask",
+                  question: selectQuestion(
+                    leaf,
+                    path,
+                    state.resolved,
+                    page,
+                    context
+                  ),
+                  error
+                }
+              };
+            } catch (fetchError) {
+              state.pagination = failedPagination(
+                state.pagination,
+                state.pagination.position
+              );
+              return failedResult(state, leaf.name, fetchError);
+            }
           }
           return askLeaf(state, path, leaf, { error });
         }
@@ -3260,15 +3321,11 @@ async function step(ctx, prior, action) {
       throw new Error(`action "${action.type}" is not supported here`);
   }
   delete state.current;
-  delete state.listing;
+  delete state.pagination;
   return advance(ctx, state);
 }
 async function refine(ctx, state, leaf, path, action) {
-  const attempt = action.type === "search" ? { search: action.term, cursor: void 0, priorItems: [] } : {
-    search: state.listing?.search,
-    cursor: state.listing?.cursor,
-    priorItems: state.listing?.items ?? []
-  };
+  const position = positionAfter(state.pagination, action);
   try {
     if (action.type === "search") {
       const exact = leaf.resolver?.type === "dynamic" ? await leaf.resolver.tryResolveFromSearch?.({
@@ -3278,32 +3335,62 @@ async function refine(ctx, state, leaf, path, action) {
       if (exact) {
         setAtPath(state.resolved, path, coerce(leaf, exact.resolvedValue));
         delete state.current;
-        delete state.listing;
+        delete state.pagination;
         return advance(ctx, state);
       }
     }
     const context = await resolveContext(leaf, state.resolved);
-    state.listing = await fetchListing(leaf, state.resolved, {
-      ...attempt,
-      context
-    });
+    const page = await fetchListing(leaf, state.resolved, position, context);
+    state.pagination = toPagination(page);
     return {
       state,
       result: {
         status: "ask",
-        question: selectQuestion(leaf, state.resolved, state.listing, context)
+        question: selectQuestion(leaf, path, state.resolved, page, context)
       }
     };
   } catch (error) {
-    state.listing = {
-      items: attempt.priorItems,
-      search: attempt.search,
-      cursor: attempt.cursor,
-      exhausted: false
-    };
+    state.pagination = failedPagination(state.pagination, position);
     return failedResult(state, leaf.name, error);
   }
 }
+function failedPagination(pagination, retryPosition) {
+  return {
+    position: pagination?.position ?? firstPagePosition(),
+    ...pagination?.nextCursor !== void 0 ? { nextCursor: pagination.nextCursor } : {},
+    retryPosition
+  };
+}
+function positionAfter(pagination, action) {
+  const current = pagination?.position ?? firstPagePosition();
+  switch (action.type) {
+    case "search":
+      return firstPagePosition({
+        search: action.term,
+        generation: current.generation + 1
+      });
+    case "next_page": {
+      if (pagination?.nextCursor == null) return current;
+      return {
+        ...current.search !== void 0 ? { search: current.search } : {},
+        pageCursor: pagination.nextCursor,
+        previousCursors: [...current.previousCursors, current.pageCursor],
+        generation: current.generation
+      };
+    }
+    case "previous_page": {
+      if (current.previousCursors.length === 0) return current;
+      return {
+        ...current.search !== void 0 ? { search: current.search } : {},
+        pageCursor: current.previousCursors[current.previousCursors.length - 1],
+        previousCursors: current.previousCursors.slice(0, -1),
+        generation: current.generation
+      };
+    }
+    case "retry":
+      return pagination?.retryPosition ?? current;
+  }
+}
 function toJsonSchema(schema) {
   if (!schema) return void 0;
   try {
@@ -5340,7 +5427,7 @@ function parseDeprecationDate(value) {
 }
 
 // src/sdk-version.ts
-var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.84.2" : void 0) || "unknown";
+var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.84.3" : void 0) || "unknown";
 
 // src/utils/open-url.ts
 var nodePrefix = "node:";
@@ -8077,8 +8164,9 @@ var appKeyResolver = defineResolver({
   },
   listItems: ({
     imports,
-    search
-  }) => imports.listApps({ search }),
+    search,
+    cursor
+  }) => imports.listApps({ search, cursor }),
   prompt: ({ items }) => ({
     type: "list",
     message: "Select app:",
@@ -8099,9 +8187,11 @@ var actionTypeResolver = defineResolver({
     imports,
     input
   }) => {
-    const { data } = await imports.listActions({ app: input.app });
-    const types = [...new Set(data.map((action) => action.action_type))];
-    return { data: types.map((type) => ({ key: type, name: type })) };
+    const types = /* @__PURE__ */ new Set();
+    for await (const action of imports.listActions({ app: input.app }).items()) {
+      types.add(action.action_type);
+    }
+    return { data: [...types].map((type) => ({ key: type, name: type })) };
   },
   prompt: ({ items }) => ({
     type: "list",
@@ -8117,13 +8207,15 @@ var actionKeyResolver = defineResolver({
   requireParameters: ["app", "actionType"],
   listItems: async ({
     imports,
-    input
+    input,
+    cursor
   }) => {
-    const { data } = await imports.listActions({ app: input.app });
+    const page = await imports.listActions({ app: input.app, cursor });
     return {
-      data: data.filter(
+      data: page.data.filter(
         (action) => action.action_type === input.actionType && !action.is_hidden
-      )
+      ),
+      nextCursor: page.nextCursor
     };
   },
   prompt: ({ items }) => ({
@@ -8240,9 +8332,10 @@ var connectionIdResolver = defineResolver({
     }
     return null;
   },
-  listItems: ({ imports, input, context }) => imports.listConnections({
+  listItems: ({ imports, input, context, cursor }) => imports.listConnections({
     app: input.app,
-    includeShared: context?.canIncludeShared || void 0
+    includeShared: context?.canIncludeShared || void 0,
+    cursor
   }),
   prompt: ({ items, input, context }) => buildConnectionPrompt(
     items,
@@ -8258,9 +8351,10 @@ var connectionIdGenericResolver = defineResolver({
     );
     return { canIncludeShared: canIncludeShared ?? false };
   },
-  listItems: ({ imports, input, context }) => imports.listConnections({
+  listItems: ({ imports, input, context, cursor }) => imports.listConnections({
     app: input.app,
-    includeShared: context?.canIncludeShared || void 0
+    includeShared: context?.canIncludeShared || void 0,
+    cursor
   }),
   prompt: ({ items, input, context }) => buildConnectionPrompt(
     items,
@@ -8288,12 +8382,13 @@ var listActionInputFieldChoicesRef = declareMethod({ id: "listActionInputFieldCh
 var choiceResolver = defineResolver({
   imports: [listActionInputFieldChoicesRef],
   requireParameters: ["app", "action", "actionType"],
-  listItems: ({ imports, input }) => imports.listActionInputFieldChoices({
+  listItems: ({ imports, input, cursor }) => imports.listActionInputFieldChoices({
     app: input.app,
     action: input.action,
     actionType: input.actionType,
     connection: input.connection,
-    inputField: input.inputField
+    inputField: input.inputField,
+    cursor
   }),
   prompt: ({ items }) => ({
     type: "list",
@@ -8452,7 +8547,7 @@ var clientCredentialsNameResolver = defineResolver({
 var listClientCredentialsRef = declareMethod({ id: "listClientCredentials" });
 var clientIdResolver = defineResolver({
   imports: [listClientCredentialsRef],
-  listItems: ({ imports }) => imports.listClientCredentials({}),
+  listItems: ({ imports, cursor }) => imports.listClientCredentials({ cursor }),
   prompt: ({ items }) => ({
     type: "list",
     message: "Select client credentials to delete:",
@@ -8464,9 +8559,9 @@ var clientIdResolver = defineResolver({
 });
 
 // src/resolvers/tableId.ts
-var listTablesRef = declareMethod({ id: "listTables" });
+var listTablesInternalRef = declareMethod({ id: "listTablesInternal" });
 var tableIdResolver = defineResolver({
-  imports: [listTablesRef, capabilitiesPluginRef],
+  imports: [listTablesInternalRef, capabilitiesPluginRef],
   getContext: async ({ imports }) => {
     const includeShared = await imports.capabilities.hasCapability?.(
       "canIncludeSharedTables"
@@ -8474,27 +8569,36 @@ var tableIdResolver = defineResolver({
     return { includeShared: includeShared ?? false };
   },
   // Unlike connections, the tables API does not return personal tables first,
-  // so we use concatPaginated to hoist own tables above shared.
-  listItems: ({ imports, context }) => {
+  // so we concatenate personal-only and shared-only slices to hoist own
+  // tables above shared. The slices are disjoint by construction, so the
+  // concatenation paginates with stateless cursors and needs no dedupe.
+  listItems: ({ imports, context, cursor }) => {
     const includeShared = context?.includeShared;
     if (includeShared) {
       return concatPaginated({
         sources: [
-          () => imports.listTables({}),
-          () => imports.listTables({ includeShared: true })
+          ({ cursor: sourceCursor }) => imports.listTablesInternal({ cursor: sourceCursor }),
+          ({ cursor: sourceCursor }) => imports.listTablesInternal({
+            includeShared: true,
+            includePersonal: false,
+            cursor: sourceCursor
+          })
         ],
-        dedupe: (table) => table.id
+        cursor
       });
     }
-    return imports.listTables({});
+    return imports.listTablesInternal({ cursor });
   },
-  prompt: ({ items }) => ({
+  prompt: ({ items, context }) => ({
     type: "list",
     message: "Select a table:",
     choices: items.map((table) => ({
       label: table.name,
       value: table.id
-    }))
+    })),
+    // The capability hint the legacy picker showed as a fake disabled row:
+    // without it, a gated account just sees fewer tables with no explanation.
+    ...context?.includeShared ? {} : { notes: ["Shared tables are hidden for this account."] }
   })
 });
 
@@ -8502,7 +8606,7 @@ var tableIdResolver = defineResolver({
 var listTriggerInboxesRef = declareMethod({ id: "listTriggerInboxes" });
 var triggerInboxResolver = defineResolver({
   imports: [listTriggerInboxesRef],
-  listItems: ({ imports }) => imports.listTriggerInboxes({}),
+  listItems: ({ imports, cursor }) => imports.listTriggerInboxes({ cursor }),
   prompt: ({ items }) => ({
     type: "list",
     message: "Select a trigger inbox:",
@@ -8520,7 +8624,7 @@ var triggerInboxResolver = defineResolver({
 var listWorkflowsRef = declareMethod({ id: "listWorkflows" });
 var workflowIdResolver = defineResolver({
   imports: [listWorkflowsRef],
-  listItems: ({ imports }) => imports.listWorkflows({}),
+  listItems: ({ imports, cursor }) => imports.listWorkflows({ cursor }),
   prompt: ({ items }) => ({
     type: "list",
     message: "Select a workflow:",
@@ -8536,7 +8640,7 @@ var workflowIdResolver = defineResolver({
 var listDurableRunsRef = declareMethod({ id: "listDurableRuns" });
 var durableRunIdResolver = defineResolver({
   imports: [listDurableRunsRef],
-  listItems: ({ imports }) => imports.listDurableRuns({}),
+  listItems: ({ imports, cursor }) => imports.listDurableRuns({ cursor }),
   prompt: ({ items }) => ({
     type: "list",
     message: "Select a run:",
@@ -8553,7 +8657,14 @@ var listWorkflowVersionsRef = declareMethod({ id: "listWorkflowVersions" });
 var workflowVersionIdResolver = defineResolver({
   imports: [listWorkflowVersionsRef],
   requireParameters: ["workflow"],
-  listItems: ({ imports, input }) => imports.listWorkflowVersions({ workflow: input.workflow }),
+  listItems: ({
+    imports,
+    input,
+    cursor
+  }) => imports.listWorkflowVersions({
+    workflow: input.workflow,
+    cursor
+  }),
   prompt: ({ items }) => ({
     type: "list",
     message: "Select a workflow version:",
@@ -8569,7 +8680,11 @@ var listWorkflowRunsRef = declareMethod({ id: "listWorkflowRuns" });
 var workflowRunIdResolver = defineResolver({
   imports: [listWorkflowRunsRef],
   requireParameters: ["workflow"],
-  listItems: ({ imports, input }) => imports.listWorkflowRuns({ workflow: input.workflow }),
+  listItems: ({
+    imports,
+    input,
+    cursor
+  }) => imports.listWorkflowRuns({ workflow: input.workflow, cursor }),
   prompt: ({ items }) => ({
     type: "list",
     message: "Select a workflow run:",
@@ -8587,8 +8702,9 @@ var triggerMessagesResolver = defineResolver({
   requireParameters: ["inbox"],
   listItems: ({
     imports,
-    input
-  }) => imports.listTriggerInboxMessages({ inbox: input.inbox }),
+    input,
+    cursor
+  }) => imports.listTriggerInboxMessages({ inbox: input.inbox, cursor }),
   prompt: ({ items }) => ({
     type: "checkbox",
     message: "Select messages:",
@@ -8861,9 +8977,10 @@ function recordChoices(records) {
 var tableRecordIdResolver = defineResolver({
   imports: [listTableRecordsRef],
   requireParameters: ["table"],
-  listItems: ({ imports, input }) => imports.listTableRecords({
+  listItems: ({ imports, input, cursor }) => imports.listTableRecords({
     table: input.table,
-    keyMode: "names"
+    keyMode: "names",
+    cursor
   }),
   prompt: ({ items }) => ({
     type: "list",
@@ -8874,16 +8991,17 @@ var tableRecordIdResolver = defineResolver({
 var tableRecordIdsResolver = defineResolver({
   imports: [listTableRecordsRef],
   requireParameters: ["table"],
-  listItems: ({ imports, input }) => imports.listTableRecords({
+  listItems: ({ imports, input, cursor }) => imports.listTableRecords({
     table: input.table,
-    keyMode: "names"
+    keyMode: "names",
+    cursor
   }),
   prompt: ({ items }) => ({
     type: "checkbox",
     message: "Select records to delete:",
-    choices: recordChoices(items),
-    validate: (value) => Array.isArray(value) && value.length > 0 ? true : "Select at least one record"
-  })
+    choices: recordChoices(items)
+  }),
+  validate: ({ value }) => Array.isArray(value) && value.length > 0 ? true : "Select at least one record"
 });
 
 // src/resolvers/tableFieldIds.ts
@@ -8891,6 +9009,8 @@ var listTableFieldsRef = declareMethod({ id: "listTableFields" });
 var tableFieldIdsResolver = defineResolver({
   imports: [listTableFieldsRef],
   requireParameters: ["table"],
+  // No cursor forwarding: the fields API is unpaginated (no cursor on the
+  // response), so the listing is always exhausted after one page.
   listItems: ({ imports, input }) => imports.listTableFields({ table: input.table }),
   prompt: ({ items }) => ({
     type: "checkbox",
@@ -8899,9 +9019,9 @@ var tableFieldIdsResolver = defineResolver({
       label: field.name,
       hint: [field.id, field.type],
       value: field.id
-    })),
-    validate: (value) => Array.isArray(value) && value.length > 0 ? true : "Select at least one field"
-  })
+    }))
+  }),
+  validate: ({ value }) => Array.isArray(value) && value.length > 0 ? true : "Select at least one field"
 });
 
 // src/resolvers/tableName.ts
@@ -13145,27 +13265,31 @@ var ListTablesOptionsSchema = z.object({
   maxItems: z.number().min(1).optional().describe("Maximum total items to return across all pages"),
   cursor: z.string().optional().describe("Cursor to start from")
 }).describe("List tables available to the authenticated user");
+var ListTablesInternalOptionsSchema = ListTablesOptionsSchema.extend({
+  includePersonal: z.boolean().optional().describe(
+    "Include your own tables (default true). Set false with includeShared to list only tables shared with you."
+  )
+});
 
-// src/plugins/tables/shared.ts
-var tableCategories = ["table"];
-
-// src/plugins/tables/listTables/index.ts
-var listTablesPlugin = defineMethod({
-  name: "listTables",
+// src/plugins/tables/listTables/internal.ts
+var listTablesInternalPlugin = defineMethod({
+  name: "listTablesInternal",
   imports: [apiPluginRef, capabilitiesPluginRef],
-  categories: tableCategories,
-  itemType: "Table",
-  inputSchema: ListTablesOptionsSchema,
-  outputSchema: TableItemSchema,
+  inputSchema: ListTablesInternalOptionsSchema,
   output: {
     type: "list",
     adaptPage: adaptZapierPage,
     defaultPageSize: DEFAULT_PAGE_SIZE
   },
   run: async ({ imports, input }) => {
-    if (input.includeShared) {
+    const includePersonal = input.includePersonal ?? true;
+    const includeShared = input.includeShared ?? false;
+    if (includeShared) {
       await imports.capabilities.checkCapability("canIncludeSharedTables");
     }
+    if (!includePersonal && !includeShared) {
+      return { data: [] };
+    }
     const api = imports.api;
     const searchParams = {};
     if (input.pageSize !== void 0) {
@@ -13181,23 +13305,18 @@ var listTablesPlugin = defineMethod({
     if (input.search) {
       searchParams.q = input.search;
     }
-    if (input.owner && input.owner !== "me" && !input.includeShared) {
+    if (input.owner && input.owner !== "me" && !includeShared) {
       throw new ZapierValidationError(
         'The "owner" option requires "includeShared" to be true. Without includeShared, only your own tables are returned.'
       );
     }
-    const owner = input.includeShared ? input.owner : "me";
+    const owner = includeShared ? input.owner : "me";
+    const needsProfileId = owner === "me" || !includePersonal && includeShared;
+    const profileId = needsProfileId ? (await api.get("/zapier/api/v4/profile/", {
+      authRequired: true
+    })).id : void 0;
     if (owner) {
-      if (owner === "me") {
-        const profile = await api.get("/zapier/api/v4/profile/", {
-          authRequired: true
-        });
-        searchParams.owner_customuser_id = String(
-          profile.id
-        );
-      } else {
-        searchParams.owner_customuser_id = owner;
-      }
+      searchParams.owner_customuser_id = owner === "me" ? String(profileId) : owner;
     }
     if (input.cursor) {
       searchParams.offset = input.cursor;
@@ -13207,12 +13326,35 @@ var listTablesPlugin = defineMethod({
       authRequired: true
     });
     const response = ListTablesApiResponseSchema.parse(rawResponse);
+    const apiItems = includePersonal ? response.data : response.data.filter(
+      (item) => item.owner_zapier_customuser_id !== profileId
+    );
     return {
-      data: response.data.map(transformTableItem),
+      data: apiItems.map(transformTableItem),
       links: response.links
     };
   }
 });
+
+// src/plugins/tables/shared.ts
+var tableCategories = ["table"];
+
+// src/plugins/tables/listTables/index.ts
+var listTablesPlugin = defineMethod({
+  name: "listTables",
+  imports: [listTablesInternalPlugin],
+  categories: tableCategories,
+  itemType: "Table",
+  inputSchema: ListTablesOptionsSchema,
+  outputSchema: TableItemSchema,
+  output: "list",
+  run: async ({ imports, input }) => {
+    return await imports.listTablesInternal({
+      ...input,
+      includePersonal: void 0
+    });
+  }
+});
 var GetTableApiResponseSchema = z.object({
   data: TableApiItemSchema
 });