@zapier/kitcore 0.8.0 → 0.9.0

package/dist/index.mjs

@@ -1,6 +1,3 @@
-// src/registry.ts
-import { z } from "zod";
-
 // src/utils/string-utils.ts
 function toTitleCase(input) {
   return input.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_\-]+/g, " ").replace(/\s+/g, " ").trim().split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
@@ -24,6 +21,65 @@ function pluralizeLastWord(title) {
   return [...words.slice(0, -1), pluralize(words[words.length - 1])].join(" ");
 }
 
+// src/utils/schema-utils.ts
+import { z } from "zod";
+function canonicalInputSchema(schema) {
+  if (schema instanceof z.ZodUnion) {
+    return schema.options[0];
+  }
+  return schema;
+}
+function getOutputSchema(inputSchema) {
+  return inputSchema._zod.def.outputSchema;
+}
+function withOutputSchema(inputSchema, outputSchema) {
+  Object.assign(inputSchema._zod.def, {
+    outputSchema
+  });
+  return inputSchema;
+}
+function withResolver(schema, config) {
+  schema._zod.def.resolverMeta = config;
+  return schema;
+}
+function getSchemaDescription(schema) {
+  return schema.description;
+}
+function getFieldDescriptions(schema) {
+  const descriptions = {};
+  const shape = schema.shape;
+  for (const [key, fieldSchema] of Object.entries(shape)) {
+    if (fieldSchema instanceof z.ZodType && fieldSchema.description) {
+      descriptions[key] = fieldSchema.description;
+    }
+  }
+  return descriptions;
+}
+function withPositional(schema) {
+  Object.assign(schema._zod.def, {
+    positionalMeta: { positional: true }
+  });
+  return schema;
+}
+function schemaHasPositionalMeta(schema) {
+  return "positionalMeta" in schema._zod.def;
+}
+function isPositional(schema) {
+  if (schemaHasPositionalMeta(schema) && schema._zod.def.positionalMeta?.positional) {
+    return true;
+  }
+  if (schema instanceof z.ZodOptional) {
+    return isPositional(schema._zod.def.innerType);
+  }
+  if (schema instanceof z.ZodDefault) {
+    return isPositional(schema._zod.def.innerType);
+  }
+  return false;
+}
+function openEnum(values, description) {
+  return z.union([z.enum(values), z.string()]).describe(description);
+}
+
 // src/registry.ts
 function resolveCategoryDefinition(ref) {
   const def = typeof ref === "string" ? { key: ref } : ref;
@@ -34,30 +90,25 @@ function resolveCategoryDefinition(ref) {
     titlePlural: def.titlePlural ?? pluralizeLastWord(title)
   };
 }
-function canonicalInputSchema(schema) {
-  if (schema instanceof z.ZodUnion) {
-    return schema.options[0];
-  }
-  return schema;
-}
 function buildRegistry({
   sdk,
   meta,
   formatters,
-  boundResolvers,
+  resolvers,
   positional,
+  skipInputValidation,
   packageFilter
 }) {
   const definitionsByKey = /* @__PURE__ */ new Map();
   const objectDeclaredKeys = /* @__PURE__ */ new Set();
   for (const m of Object.values(meta)) {
     for (const ref of m.categories ?? []) {
-      const key2 = typeof ref === "string" ? ref : ref.key;
+      const key = typeof ref === "string" ? ref : ref.key;
       if (typeof ref === "object") {
-        objectDeclaredKeys.add(key2);
-        definitionsByKey.set(key2, resolveCategoryDefinition(ref));
-      } else if (!objectDeclaredKeys.has(key2)) {
-        definitionsByKey.set(key2, resolveCategoryDefinition(ref));
+        objectDeclaredKeys.add(key);
+        definitionsByKey.set(key, resolveCategoryDefinition(ref));
+      } else if (!objectDeclaredKeys.has(key)) {
+        definitionsByKey.set(key, resolveCategoryDefinition(ref));
       }
     }
   }
@@ -65,30 +116,29 @@ function buildRegistry({
     definitionsByKey.set("other", resolveCategoryDefinition("other"));
   }
   const knownCategories = Array.from(definitionsByKey.keys());
-  const functions = Object.keys(meta).filter((key2) => {
-    const property = sdk[key2];
+  const functions = Object.keys(meta).filter((key) => {
+    const property = sdk[key];
     if (typeof property === "function") return true;
-    const [rootKey] = key2.split(".");
+    const [rootKey] = key.split(".");
     const rootProperty = sdk[rootKey];
     return typeof rootProperty === "object" && rootProperty !== null;
-  }).map((key2) => {
-    const m = meta[key2];
+  }).map((key) => {
+    const m = meta[key];
     return {
-      name: key2,
+      name: key,
       description: m.description,
       type: m.type,
       itemType: m.itemType,
       returnType: m.returnType,
       inputSchema: canonicalInputSchema(m.inputSchema),
-      inputParameters: m.inputParameters,
       outputSchema: m.outputSchema,
-      positional: positional?.[key2],
+      positional: positional?.[key],
+      skipInputValidation: skipInputValidation?.[key],
       categories: (m.categories ?? []).map(
         (c) => typeof c === "string" ? c : c.key
       ),
-      resolvers: m.resolvers,
-      boundResolvers: boundResolvers?.[key2],
-      formatter: formatters?.[key2],
+      resolvers: resolvers?.[key],
+      formatter: formatters?.[key],
       experimental: m.experimental,
       packages: m.packages,
       confirm: m.confirm ?? (m.type === "delete" ? "delete" : void 0),
@@ -577,6 +627,52 @@ function runInMethodScope(fn) {
 var runWithTelemetryContext = runInMethodScope;
 var isTelemetryNested = isNestedMethodCall;
 
+// src/utils/call-context.ts
+var CALL_CONTEXT_BRAND = Symbol("kitcore.callContext");
+function isCallContext(value) {
+  return typeof value === "object" && value !== null && value[CALL_CONTEXT_BRAND] === true;
+}
+function generateCallId() {
+  try {
+    const webCrypto = globalThis.crypto;
+    if (webCrypto?.randomUUID) {
+      return webCrypto.randomUUID();
+    }
+    if (webCrypto?.getRandomValues) {
+      const bytes = webCrypto.getRandomValues(new Uint8Array(16));
+      const hex = Array.from(bytes, (byte, i) => {
+        const value = i === 6 ? byte & 15 | 64 : i === 8 ? byte & 63 | 128 : byte;
+        return value.toString(16).padStart(2, "0");
+      });
+      return [
+        hex.slice(0, 4).join(""),
+        hex.slice(4, 6).join(""),
+        hex.slice(6, 8).join(""),
+        hex.slice(8, 10).join(""),
+        hex.slice(10, 16).join("")
+      ].join("-");
+    }
+  } catch {
+  }
+  return null;
+}
+function rootCallContext() {
+  return {
+    callId: generateCallId(),
+    depth: 0,
+    annotations: {},
+    [CALL_CONTEXT_BRAND]: true
+  };
+}
+function childCallContext(parent) {
+  return {
+    callId: parent.callId,
+    depth: parent.depth + 1,
+    annotations: {},
+    [CALL_CONTEXT_BRAND]: true
+  };
+}
+
 // src/utils/core-options.ts
 function defaultLogDeprecation({
   methodName,
@@ -595,6 +691,9 @@ function resolveCoreOptions(context) {
   return context.core;
 }
 var INTERNAL_CALL = Symbol("kitcore.internalCall");
+function resolveCallContext(secondArg) {
+  return isCallContext(secondArg) ? secondArg : rootCallContext();
+}
 function signalDeprecation(context, methodName, getDeprecation) {
   if (isInsideObserver()) return;
   const deprecation = getDeprecation?.();
@@ -624,14 +723,16 @@ function createFunction(coreFn, options) {
   const functionName = name || coreFn.name;
   const namedFunctions = {
     [functionName]: async function(callOptions) {
-      if (arguments[1] !== INTERNAL_CALL) {
+      const internal = arguments[1];
+      const context = resolveCallContext(internal);
+      if (!isCallContext(internal) && internal !== INTERNAL_CALL) {
         signalDeprecation(sdk.context, functionName, getDeprecation);
       }
       return runInMethodScope(async () => {
         const startTime = Date.now();
         const normalizedOptions = callOptions ?? {};
         const args = [normalizedOptions];
-        const depth = getCurrentDepth();
+        const depth = Math.max(context.depth, getCurrentDepth());
         const hooks = isInsideObserver() ? void 0 : sdk.context.hooks;
         const adaptError = resolveCoreOptions(sdk.context)?.adaptError;
         hooks?.onMethodStart?.({
@@ -650,12 +751,15 @@ function createFunction(coreFn, options) {
                 adaptError
               }
             );
-            result = await coreFn({
-              ...normalizedOptions,
-              ...validatedOptions
-            });
+            result = await coreFn(
+              {
+                ...normalizedOptions,
+                ...validatedOptions
+              },
+              context
+            );
           } else {
-            result = await coreFn(normalizedOptions);
+            result = await coreFn(normalizedOptions, context);
           }
           hooks?.onMethodEnd?.({
             methodName: functionName,
@@ -685,17 +789,19 @@ function createFunction(coreFn, options) {
 function createRawFunction(coreFn, options) {
   const { sdk, name, schema, positional, getDeprecation } = options;
   return function(rawInput) {
-    if (arguments[1] !== INTERNAL_CALL) {
+    const internal = arguments[1];
+    const context = resolveCallContext(internal);
+    if (!isCallContext(internal) && internal !== INTERNAL_CALL) {
       signalDeprecation(sdk.context, name, getDeprecation);
     }
     return runInMethodScope(() => {
       const startTime = Date.now();
-      const depth = getCurrentDepth();
+      const depth = Math.max(context.depth, getCurrentDepth());
       const hooks = isInsideObserver() ? void 0 : sdk.context.hooks;
       const adaptError = resolveCoreOptions(sdk.context)?.adaptError;
       const input = schema ? rawInput ?? {} : rawInput;
       const record = input;
-      const args = positional ? positional.filter((key2) => record?.[key2] !== void 0).map((key2) => record?.[key2]) : [input];
+      const args = positional ? positional.filter((key) => record?.[key] !== void 0).map((key) => record?.[key]) : [input];
       hooks?.onMethodStart?.({
         methodName: name,
         args,
@@ -714,7 +820,7 @@ function createRawFunction(coreFn, options) {
       };
       try {
         const parsed = schema ? validateOptions(schema, input, { adaptError }) : input;
-        const result = coreFn(parsed);
+        const result = coreFn(parsed, context);
         if (result !== null && typeof result === "object" && typeof result.then === "function") {
           return result.then(
             (value) => {
@@ -753,9 +859,9 @@ function createPageFunction(coreFn, {
 }) {
   const functionName = coreFn.name + "Page";
   const namedFunctions = {
-    [functionName]: async function(options) {
+    [functionName]: async function(options, callContext) {
       try {
-        const response = await coreFn(options);
+        const response = await coreFn(options, callContext);
         const page = adaptPage ? adaptPage(response) : response;
         if (!isSdkPage(page)) {
           throw new Error(
@@ -779,14 +885,16 @@ function createPaginatedFunction(coreFn, options) {
   const functionName = name || coreFn.name;
   const namedFunctions = {
     [functionName]: function(callOptions) {
-      if (arguments[1] !== INTERNAL_CALL) {
+      const internal = arguments[1];
+      const context = resolveCallContext(internal);
+      if (!isCallContext(internal) && internal !== INTERNAL_CALL) {
         signalDeprecation(sdk.context, functionName, getDeprecation);
       }
       return runInMethodScope(() => {
         const startTime = Date.now();
         const normalizedOptions = callOptions ?? {};
         const args = [normalizedOptions];
-        const depth = getCurrentDepth();
+        const depth = Math.max(context.depth, getCurrentDepth());
         const hooks = isInsideObserver() ? void 0 : sdk.context.hooks;
         const adaptError = resolveCoreOptions(sdk.context)?.adaptError;
         hooks?.onMethodStart?.({
@@ -805,7 +913,11 @@ function createPaginatedFunction(coreFn, options) {
             ...validatedOptions,
             pageSize
           };
-          const iterator = paginate(pageFunction, optimizedOptions);
+          const iterator = paginate(
+            (pageOptions) => pageFunction(pageOptions, context),
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            optimizedOptions
+          );
           const firstPagePromise = iterator.next().then((result) => {
             if (result.done) {
               throw new Error("Paginate should always iterate at least once");
@@ -956,11 +1068,11 @@ var RESERVED_ROOT_KEYS = /* @__PURE__ */ new Set([
   "context",
   "getRegistry"
 ]);
-function hasOwn(obj, key2) {
-  return Object.prototype.hasOwnProperty.call(obj, key2);
+function hasOwn(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
 }
-function setOwn(target, key2, value) {
-  Object.defineProperty(target, key2, {
+function setOwn(target, key, value) {
+  Object.defineProperty(target, key, {
     value,
     enumerable: true,
     configurable: true,
@@ -972,31 +1084,31 @@ function checkCollisions(target, source, kind, callerLabel, override) {
     checkRootKeyCollisions(target, Object.keys(source), override, callerLabel);
     return;
   }
-  for (const key2 of Object.keys(source)) {
-    if (!override && hasOwn(target, key2)) {
+  for (const key of Object.keys(source)) {
+    if (!override && hasOwn(target, key)) {
       throw new Error(
-        `${callerLabel}: duplicate ${kind} "${key2}". If the override is intentional, pass { override: true } in the options.`
+        `${callerLabel}: duplicate ${kind} "${key}". If the override is intentional, pass { override: true } in the options.`
       );
     }
   }
 }
 function checkRootKeyCollisions(target, keys, override, callerLabel) {
-  for (const key2 of keys) {
-    if (RESERVED_ROOT_KEYS.has(key2)) {
+  for (const key of keys) {
+    if (RESERVED_ROOT_KEYS.has(key)) {
       throw new Error(
-        `${callerLabel}: plugin attempted to register reserved root key "${key2}". The SDK uses this key for its own accessor; rename the plugin's method.`
+        `${callerLabel}: plugin attempted to register reserved root key "${key}". The SDK uses this key for its own accessor; rename the plugin's method.`
       );
     }
-    if (!override && hasOwn(target, key2)) {
+    if (!override && hasOwn(target, key)) {
       throw new Error(
-        `${callerLabel}: duplicate root key "${key2}". If the override is intentional, pass { override: true } in the options.`
+        `${callerLabel}: duplicate root key "${key}". If the override is intentional, pass { override: true } in the options.`
       );
     }
   }
 }
 function applyOwnProperties(target, source) {
-  for (const key2 of Object.keys(source)) {
-    setOwn(target, key2, source[key2]);
+  for (const key of Object.keys(source)) {
+    setOwn(target, key, source[key]);
   }
 }
 function createPluginAccumulator(initialProperties = {}, initialContext = {}) {
@@ -1214,7 +1326,6 @@ var LEAF_META_KEYS = [
   "itemType",
   "returnType",
   "outputSchema",
-  "inputParameters",
   "packages",
   "experimental",
   "confirm",
@@ -1254,8 +1365,8 @@ function normalizeImports(deps) {
 }
 function collectLeafMeta(config) {
   let meta;
-  for (const key2 of LEAF_META_KEYS) {
-    if (config[key2] !== void 0) (meta ?? (meta = {}))[key2] = config[key2];
+  for (const key of LEAF_META_KEYS) {
+    if (config[key] !== void 0) (meta ?? (meta = {}))[key] = config[key];
   }
   return meta;
 }
@@ -1338,7 +1449,8 @@ function defineResolver(config) {
         type: "object",
         properties: config.properties,
         definitions: config.definitions,
-        getProperties: config.getProperties
+        getProperties: config.getProperties,
+        additionalKeys: config.additionalKeys
       };
     case "array":
       return {
@@ -1650,7 +1762,7 @@ function normalizeFormatter(entry, sdk) {
   const legacy = entry.meta?.formatter;
   return legacy ? adaptLegacyFormatter(legacy, sdk) : void 0;
 }
-function normalizeBoundResolvers(entry) {
+function normalizeResolvers(entry) {
   if (entry.pluginType !== "method") return void 0;
   return entry.resolvers;
 }
@@ -1691,17 +1803,20 @@ function collectSurfaceProjection(context, formatterSdk) {
     foldDynamicMembers(entry, surfaceBindings, meta);
   }
   const formatters = {};
-  const boundResolvers = {};
+  const resolvers = {};
   const positional = {};
+  const skipInputValidation = {};
   for (const [binding, entry] of Object.entries(entries)) {
     const f = normalizeFormatter(entry, formatterSdk);
     if (f) formatters[binding] = f;
-    const r = normalizeBoundResolvers(entry);
-    if (r) boundResolvers[binding] = r;
+    const r = normalizeResolvers(entry);
+    if (r) resolvers[binding] = r;
     const p = methodPositional(entry);
     if (p) positional[binding] = p;
+    if (entry.pluginType === "method" && entry.skipInputValidation)
+      skipInputValidation[binding] = true;
   }
-  return { meta, formatters, boundResolvers, positional };
+  return { meta, formatters, resolvers, positional, skipInputValidation };
 }
 function buildSurfaceRegistry(context, packageFilter) {
   const surface = {};
@@ -1758,6 +1873,11 @@ function nestedResolvers(resolver) {
     for (const field of Object.values(resolver.properties ?? {})) {
       if (!isResolverRef(field.resolver)) out.push(field.resolver);
     }
+    const ak = resolver.additionalKeys;
+    if (ak) {
+      if (!isResolverRef(ak.values)) out.push(ak.values);
+      if (ak.keys && !isResolverRef(ak.keys)) out.push(ak.keys);
+    }
     out.push(...Object.values(resolver.definitions ?? {}));
   } else if (resolver.type === "array") {
     if (!isResolverRef(resolver.items)) out.push(resolver.items);
@@ -1882,16 +2002,16 @@ function collectPlugins(root, materialized = /* @__PURE__ */ new Set(), configur
   }
   return byId;
 }
-function bindValue(target, key2, entry, callType = "surface") {
+function bindValue(target, key, entry, callType = "surface", ctx) {
   if (entry.pluginType === "property" && entry.getValue) {
-    Object.defineProperty(target, key2, {
+    Object.defineProperty(target, key, {
       get: entry.getValue,
       enumerable: true,
       configurable: true
     });
   } else {
-    const value = callType === "internal" && entry.pluginType === "method" ? entry.internalValue ?? entry.value : entry.value;
-    Object.defineProperty(target, key2, {
+    const value = callType === "internal" && entry.pluginType === "method" ? entry.bindInternal?.(ctx) ?? entry.internalValue ?? entry.value : entry.value;
+    Object.defineProperty(target, key, {
       value,
       writable: true,
       enumerable: true,
@@ -1908,7 +2028,7 @@ function buildSurface(context, ...maps) {
   sdk[CONTEXT] = context;
   return sdk;
 }
-function buildImports(plugins, importBindings) {
+function buildImports(plugins, importBindings, ctx) {
   const imports = {};
   for (const { binding, id, optional } of importBindings) {
     const entry = plugins[id];
@@ -1921,7 +2041,7 @@ function buildImports(plugins, importBindings) {
       });
       continue;
     }
-    bindValue(imports, binding, entry, "internal");
+    bindValue(imports, binding, entry, "internal", ctx);
   }
   return imports;
 }
@@ -2000,6 +2120,19 @@ function bindResolver(resolver, plugins) {
       const { getProperties } = resolver;
       if (getProperties)
         bound.getProperties = ({ input }) => getProperties({ imports, input });
+      if (resolver.additionalKeys) {
+        const ak = resolver.additionalKeys;
+        const boundAk = {
+          values: isResolverRef(ak.values) ? ak.values : bindResolver(ak.values, plugins),
+          minEntries: ak.minEntries,
+          maxEntries: ak.maxEntries,
+          keyValueType: ak.keyValueType,
+          valueValueType: ak.valueValueType
+        };
+        if (ak.keys)
+          boundAk.keys = isResolverRef(ak.keys) ? ak.keys : bindResolver(ak.keys, plugins);
+        bound.additionalKeys = boundAk;
+      }
       return bound;
     }
     case "array": {
@@ -2055,8 +2188,8 @@ function bindResolver(resolver, plugins) {
 }
 function bindFields(fields, plugins) {
   const out = {};
-  for (const [key2, field] of Object.entries(fields)) {
-    out[key2] = {
+  for (const [key, field] of Object.entries(fields)) {
+    out[key] = {
       ...field,
       resolver: isResolverRef(field.resolver) ? field.resolver : bindResolver(field.resolver, plugins)
     };
@@ -2065,8 +2198,8 @@ function bindFields(fields, plugins) {
 }
 function bindDefinitions(definitions, plugins) {
   const out = {};
-  for (const [key2, def] of Object.entries(definitions)) {
-    out[key2] = bindResolver(def, plugins);
+  for (const [key, def] of Object.entries(definitions)) {
+    out[key] = bindResolver(def, plugins);
   }
   return out;
 }
@@ -2151,6 +2284,7 @@ function buildMethodEntries(descriptors, context, states) {
       name: descriptor.name,
       chain: [],
       inputSchema: descriptor.inputSchema,
+      skipInputValidation: descriptor.skipInputValidation,
       // Derive the presentation type from the output mode when the author did
       // not set one; an explicit meta.type (e.g. "create") still wins.
       meta: out.type === "raw" || descriptor.meta?.type ? descriptor.meta : { ...descriptor.meta, type: out.type },
@@ -2158,17 +2292,17 @@ function buildMethodEntries(descriptors, context, states) {
       // Replaced below; never called.
       value: () => void 0
     };
-    const callRun = (input) => descriptor.run({
-      imports: buildImports(plugins, descriptor.importBindings),
+    const callRun = (input, ctx) => descriptor.run({
+      imports: buildImports(plugins, descriptor.importBindings, ctx),
       state: states.get(id),
       input
     });
-    const fold = (coreFn) => (input) => {
-      let next = coreFn;
+    const fold = (coreFn) => (input, ctx) => {
+      let next = (i) => coreFn(i, ctx);
       for (const wrap of entry.chain) {
         const inner = next;
         next = (i) => wrap.run({
-          imports: buildImports(plugins, wrap.owner.importBindings),
+          imports: buildImports(plugins, wrap.owner.importBindings, ctx),
           next: inner,
           input: i,
           // Overwritten by the chain item's own closure with the owning
@@ -2192,7 +2326,7 @@ function buildMethodEntries(descriptors, context, states) {
         }
       );
     } else if (out.type === "item") {
-      const itemCore = async (input) => callRun(input);
+      const itemCore = async (input, ctx) => callRun(input, ctx);
       entry.value = createFunction(
         fold(itemCore),
         {
@@ -2204,7 +2338,7 @@ function buildMethodEntries(descriptors, context, states) {
       );
     } else {
       entry.value = createRawFunction(
-        (input) => fold(callRun)(input),
+        (input, ctx) => fold(callRun)(input, ctx),
         {
           sdk,
           name: descriptor.name,
@@ -2227,11 +2361,15 @@ function buildMethodEntries(descriptors, context, states) {
         });
         return packed;
       };
+      const internalValue = (...args) => canonicalValue(pack(args), INTERNAL_CALL);
       entry.value = (...args) => canonicalValue(pack(args));
-      entry.internalValue = (...args) => canonicalValue(pack(args), INTERNAL_CALL);
+      entry.internalValue = internalValue;
+      entry.bindInternal = (ctx) => ctx ? (...args) => canonicalValue(pack(args), childCallContext(ctx)) : internalValue;
       entry.positional = names;
     } else {
-      entry.internalValue = (input) => canonicalValue(input, INTERNAL_CALL);
+      const internalValue = (input) => canonicalValue(input, INTERNAL_CALL);
+      entry.internalValue = internalValue;
+      entry.bindInternal = (ctx) => ctx ? (input) => canonicalValue(input, childCallContext(ctx)) : internalValue;
     }
     plugins[id] = entry;
   }
@@ -2471,7 +2609,7 @@ function createSdk(root, options) {
       pluginSurface = {};
       bindValue(pluginSurface, plugin.name, plugins2[plugin.id]);
     }
-    for (const key2 of Object.keys(legacyExports)) context.surface[key2] = key2;
+    for (const key of Object.keys(legacyExports)) context.surface[key] = key;
     if (plugin.pluginType === "aggregate") {
       recordExportSurface(context, plugin.exports);
     } else {
@@ -2610,6 +2748,7 @@ function valueTypeOf(inner) {
   if (inner instanceof z3.ZodEnum) return "string";
   if (inner instanceof z3.ZodArray) return "array";
   if (inner instanceof z3.ZodObject) return "object";
+  if (inner instanceof z3.ZodRecord) return "object";
   return void 0;
 }
 function staticChoicesOf(inner) {
@@ -2620,7 +2759,8 @@ function staticChoicesOf(inner) {
   return void 0;
 }
 function objectShape(schema) {
-  const { inner } = schema ? unwrap(schema) : { inner: void 0 };
+  const canonical = canonicalInputSchema(schema);
+  const { inner } = canonical ? unwrap(canonical) : { inner: void 0 };
   if (inner instanceof z3.ZodObject) {
     return inner.shape;
   }
@@ -2642,7 +2782,7 @@ function topoOrder2(specs) {
 }
 function planParameters(entry) {
   const shape = objectShape(entry.inputSchema);
-  const resolvers = entry.boundResolvers ?? {};
+  const resolvers = entry.resolvers ?? {};
   const names = shape ? [
     ...Object.keys(shape),
     ...Object.keys(resolvers).filter(
@@ -2680,24 +2820,48 @@ function getAtPath(root, path) {
   }
   return node;
 }
+function defineOwn(node, key, value) {
+  Object.defineProperty(node, key, {
+    value,
+    writable: true,
+    enumerable: true,
+    configurable: true
+  });
+}
 function setAtPath(root, path, value) {
   let node = root;
   for (let i = 0; i < path.length - 1; i++) {
     const seg = path[i];
-    if (node[seg] == null || typeof node[seg] !== "object") node[seg] = {};
-    node = node[seg];
+    const existing = Object.prototype.hasOwnProperty.call(node, seg) ? node[seg] : void 0;
+    if (existing != null && typeof existing === "object") {
+      node = existing;
+    } else {
+      const child = {};
+      defineOwn(node, seg, child);
+      node = child;
+    }
   }
-  node[path[path.length - 1]] = value;
+  defineOwn(node, path[path.length - 1], value);
 }
-var key = (path) => path.join(".");
+var SAFE_SEGMENT = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var pathToKey = (path) => {
+  let out = "";
+  for (const segment of path) {
+    if (typeof segment === "number") out += `[${segment}]`;
+    else if (SAFE_SEGMENT.test(segment))
+      out += out === "" ? segment : `.${segment}`;
+    else out += `[${JSON.stringify(segment)}]`;
+  }
+  return out;
+};
 function isSettled(state, path) {
-  return state.settled.includes(key(path));
+  return state.settled.includes(pathToKey(path));
 }
 function remember(state, k) {
   if (!state.settled.includes(k)) state.settled.push(k);
 }
 function settle(state, path) {
-  remember(state, key(path));
+  remember(state, pathToKey(path));
 }
 function clone(state) {
   return JSON.parse(JSON.stringify(state));
@@ -2712,6 +2876,28 @@ function coerce(leaf, raw) {
     if (raw === "true") return true;
     if (raw === "false") return false;
   }
+  if (leaf.valueType === "object") {
+    const trimmed = raw.trim();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      try {
+        return JSON.parse(trimmed);
+      } catch {
+        return raw;
+      }
+    }
+    return raw;
+  }
+  if (leaf.valueType === "array") {
+    const trimmed = raw.trim();
+    if (trimmed.startsWith("[")) {
+      try {
+        return JSON.parse(trimmed);
+      } catch {
+        return raw;
+      }
+    }
+    return raw;
+  }
   return raw;
 }
 async function validationError(leaf, value, state) {
@@ -2769,27 +2955,6 @@ async function objectChildren(resolver, input) {
     return toLeaf(name, field, resolver.definitions);
   });
 }
-function arrayItem(resolver) {
-  const items = resolver.items;
-  const valueType = resolver.itemValueType;
-  if (isRef(items)) {
-    return {
-      name: "",
-      required: true,
-      resolver: resolver.definitions?.[items.ref],
-      extraInput: items.input,
-      valueType,
-      requires: []
-    };
-  }
-  return {
-    name: "",
-    required: true,
-    resolver: items,
-    valueType,
-    requires: []
-  };
-}
 function autoSettles(resolver) {
   return resolver.type === "constant" || resolver.type === "info";
 }
@@ -2809,10 +2974,28 @@ async function leafAt(ctx, path, resolved) {
     const seg = path[i];
     if (typeof seg === "number") {
       if (leaf?.resolver?.type !== "array") return void 0;
-      leaf = arrayItem(leaf.resolver);
+      leaf = boundLeaf(
+        "",
+        leaf.resolver.items,
+        leaf.resolver.definitions,
+        leaf.resolver.itemValueType
+      );
     } else {
-      leaf = children.find((c) => c.name === seg);
-      if (!leaf) return void 0;
+      const parent = leaf;
+      const found = children.find((c) => c.name === seg);
+      if (found) {
+        leaf = found;
+      } else if (parent?.resolver?.type === "object" && parent.resolver.additionalKeys) {
+        const ak = parent.resolver.additionalKeys;
+        leaf = boundLeaf(
+          String(seg),
+          ak.values,
+          parent.resolver.definitions,
+          ak.valueValueType
+        );
+      } else {
+        return void 0;
+      }
     }
     if (i < path.length - 1 && typeof path[i + 1] === "string") {
       if (leaf?.resolver?.type !== "object") return void 0;
@@ -2824,16 +3007,81 @@ async function leafAt(ctx, path, resolved) {
   }
   return leaf;
 }
+function boundLeaf(name, resolverOrRef, definitions, valueType) {
+  if (isRef(resolverOrRef)) {
+    return {
+      name,
+      required: true,
+      resolver: definitions?.[resolverOrRef.ref],
+      extraInput: resolverOrRef.input,
+      valueType,
+      requires: []
+    };
+  }
+  return {
+    name,
+    required: true,
+    resolver: resolverOrRef,
+    valueType,
+    requires: []
+  };
+}
+async function recordInfoAt(ctx, path, resolved) {
+  const leaf = await leafAt(ctx, path, resolved);
+  const resolver = leaf?.resolver;
+  if (resolver?.type !== "object" || !resolver.additionalKeys) {
+    throw new Error(
+      `expected an object resolver with additionalKeys at "${pathToKey(path)}"`
+    );
+  }
+  if (resolver.getProperties) {
+    throw new Error(
+      `object resolver at "${pathToKey(path)}" cannot combine getProperties with additionalKeys`
+    );
+  }
+  const ak = resolver.additionalKeys;
+  const defs = resolver.definitions;
+  const keyLeaf = ak.keys ? boundLeaf("key", ak.keys, defs, ak.keyValueType ?? "string") : {
+    name: "key",
+    required: true,
+    resolver: { type: "static", inputType: "text" },
+    valueType: "string",
+    requires: []
+  };
+  const valueLeaf = boundLeaf("value", ak.values, defs, ak.valueValueType);
+  if (keyLeaf.resolver && keyLeaf.resolver.type !== "static") {
+    throw new Error(
+      `record key resolver at "${pathToKey(path)}" must be a static free-text prompt, not "${keyLeaf.resolver.type}"`
+    );
+  }
+  if (valueLeaf.resolver?.type === "object" || valueLeaf.resolver?.type === "array") {
+    throw new Error(
+      `record value resolver at "${pathToKey(path)}" must be a single value, not "${valueLeaf.resolver.type}"`
+    );
+  }
+  return {
+    min: ak.minEntries ?? 0,
+    max: ak.maxEntries ?? Infinity,
+    keyLeaf,
+    valueLeaf,
+    fixedKeys: Object.keys(resolver.properties ?? {})
+  };
+}
 async function arrayInfoAt(ctx, path, resolved) {
   const leaf = await leafAt(ctx, path, resolved);
   const resolver = leaf?.resolver;
   if (resolver?.type !== "array") {
-    throw new Error(`expected an array resolver at "${key(path)}"`);
+    throw new Error(`expected an array resolver at "${pathToKey(path)}"`);
   }
   return {
     min: resolver.minItems ?? 0,
     max: resolver.maxItems ?? Infinity,
-    item: { ...arrayItem(resolver), name: String(path[path.length - 1]) }
+    item: boundLeaf(
+      String(path[path.length - 1]),
+      resolver.items,
+      resolver.definitions,
+      resolver.itemValueType
+    )
   };
 }
 async function firstPage(result) {
@@ -2914,6 +3162,9 @@ var AFFORDANCE = {
   retry: { action: "retry", description: "Retry loading the options" },
   cancel: { action: "cancel", description: "Cancel resolution" }
 };
+function affordance(base, description) {
+  return { ...base, description };
+}
 function selectActions(leaf, page, multiple) {
   const searchMode = leaf.resolver?.type === "dynamic" && leaf.resolver.inputType === "search";
   if (searchMode && page.position.search === void 0 && page.items.length === 0) {
@@ -3028,7 +3279,7 @@ async function buildQuestion(leaf, path, input) {
     }
   };
 }
-function collectionQuestion(t) {
+function arrayItemsQuestion(t) {
   const actions = [AFFORDANCE.add];
   if (t.count >= t.min) actions.push(AFFORDANCE.done);
   return {
@@ -3044,22 +3295,37 @@ function collectionQuestion(t) {
     actions
   };
 }
-function objectGateQuestion(path) {
+function recordEntriesQuestion(t) {
+  const actions = [
+    affordance(AFFORDANCE.add, "Add another entry")
+  ];
+  if (t.count >= t.min) {
+    actions.push(affordance(AFFORDANCE.done, "Finish the entries"));
+  }
+  return {
+    type: "collection",
+    path: t.path,
+    message: `Add another ${t.path[t.path.length - 1]} entry? (${t.count} so far)`,
+    container: "record",
+    count: t.count,
+    min: t.min,
+    ...Number.isFinite(t.max) ? { max: t.max } : {},
+    actions
+  };
+}
+function objectOptionalQuestion(path) {
   return {
     type: "collection",
     path,
     message: `Add ${path[path.length - 1]}?`,
     container: "object",
     actions: [
-      {
-        action: "add",
-        description: "Provide values for these fields"
-      },
-      { action: "done", description: "Skip these fields" }
+      affordance(AFFORDANCE.add, "Provide values for these fields"),
+      affordance(AFFORDANCE.done, "Skip these fields")
     ]
   };
 }
-function optionalsGateQuestion(path, pending) {
+function objectOptionalPropertiesQuestion(path, pending) {
   return {
     type: "collection",
     path,
@@ -3076,8 +3342,8 @@ function optionalsGateQuestion(path, pending) {
       ...leaf.valueType ? { valueType: leaf.valueType } : {}
     })),
     actions: [
-      { action: "add", description: "Configure the optional fields" },
-      { action: "done", description: "Skip the optional fields" }
+      affordance(AFFORDANCE.add, "Configure the optional fields"),
+      affordance(AFFORDANCE.done, "Skip the optional fields")
     ]
   };
 }
@@ -3095,7 +3361,8 @@ function finalize(ctx, resolved) {
   }));
   return { status: "invalid", issues };
 }
-var optionalsMarker = (path) => `${key(path)}?optionals`;
+var optionalsMarker = (path) => `${pathToKey(path)}?optionals`;
+var UNSAFE_RECORD_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
 async function findInArray(ctx, state, path) {
   if (isSettled(state, path)) return null;
   if (getAtPath(state.resolved, path) == null)
@@ -3116,7 +3383,28 @@ async function findInArray(ctx, state, path) {
     }
   }
   if (len < min) return descendItem(ctx, state, path, len, item);
-  if (len < max) return { kind: "array", path, count: len, min, max };
+  if (len < max) return { type: "array_items", path, count: len, min, max };
+  settle(state, path);
+  return null;
+}
+async function findInRecord(ctx, state, path) {
+  if (isSettled(state, path)) return null;
+  if (getAtPath(state.resolved, path) == null)
+    setAtPath(state.resolved, path, {});
+  if (!state.interactive) {
+    settle(state, path);
+    return null;
+  }
+  const { min, max, keyLeaf, fixedKeys } = await recordInfoAt(
+    ctx,
+    path,
+    state.resolved
+  );
+  const container = getAtPath(state.resolved, path);
+  const fixed = new Set(fixedKeys);
+  const count = Object.keys(container).filter((k) => !fixed.has(k)).length;
+  if (count < min) return { type: "record_key", path, leaf: keyLeaf };
+  if (count < max) return { type: "record_entries", path, count, min, max };
   settle(state, path);
   return null;
 }
@@ -3134,10 +3422,10 @@ function seedItemSlot(state, itemPath, item) {
 }
 async function descendItem(ctx, state, arrayPath, index, item) {
   const itemPath = [...arrayPath, index];
-  const kind = seedItemSlot(state, itemPath, item);
-  if (kind === "object") return findNext(ctx, state, itemPath);
-  if (kind === "array") return findInArray(ctx, state, itemPath);
-  return { kind: "leaf", path: itemPath, leaf: item };
+  const slotType = seedItemSlot(state, itemPath, item);
+  if (slotType === "object") return findNext(ctx, state, itemPath);
+  if (slotType === "array") return findInArray(ctx, state, itemPath);
+  return { type: "leaf", path: itemPath, leaf: item };
 }
 async function findNext(ctx, state, path = []) {
   const container = getAtPath(state.resolved, path) ?? {};
@@ -3162,7 +3450,7 @@ async function findNext(ctx, state, path = []) {
       const pending = ordered.filter(
         (c) => !c.required && asksUser(c) && isPendingChild(c)
       );
-      return { kind: "optionals", path, pending };
+      return { type: "object_optional_properties", path, pending };
     }
     if (leaf.resolver?.type === "object") {
       if (isSettled(state, childPath)) continue;
@@ -3172,7 +3460,7 @@ async function findNext(ctx, state, path = []) {
             settle(state, childPath);
             continue;
           }
-          return { kind: "object", path: childPath, leaf };
+          return { type: "object_optional", path: childPath, leaf };
         }
         setAtPath(state.resolved, childPath, {});
       }
@@ -3204,13 +3492,21 @@ async function findNext(ctx, state, path = []) {
     }
     if (container[leaf.name] !== void 0 || isSettled(state, childPath))
       continue;
-    return { kind: "leaf", path: childPath, leaf };
+    return { type: "leaf", path: childPath, leaf };
+  }
+  if (inObject && !isSettled(state, path)) {
+    const self = await leafAt(ctx, path, state.resolved);
+    if (self?.resolver?.type === "object" && self.resolver.additionalKeys) {
+      const rec = await findInRecord(ctx, state, path);
+      if (rec) return rec;
+    }
   }
   return null;
 }
 async function askLeaf(state, path, leaf, opts = {}) {
   state.current = path;
-  delete state.gate;
+  if (opts.gate) state.gate = opts.gate;
+  else delete state.gate;
   try {
     const { question, pagination } = await buildQuestion(
       leaf,
@@ -3231,6 +3527,28 @@ async function askLeaf(state, path, leaf, opts = {}) {
     return failedResult(state, leaf.name, error);
   }
 }
+async function askRecordKey(state, path, keyLeaf, opts = {}) {
+  return askLeaf(state, path, keyLeaf, { gate: "record_key", ...opts });
+}
+async function autoResolveLeaf(state, path, leaf) {
+  const resolver = leaf.resolver;
+  if (resolver && autoSettles(resolver)) {
+    if (resolver.type === "constant")
+      setAtPath(state.resolved, path, resolver.value);
+    settle(state, path);
+    return true;
+  }
+  const auto = resolver?.type === "dynamic" ? await resolver.tryResolveWithoutPrompt?.({
+    input: mergeInput(state.resolved, leaf.extraInput)
+  }) : void 0;
+  if (auto) {
+    if (auto.resolvedValue !== void 0)
+      setAtPath(state.resolved, path, auto.resolvedValue);
+    settle(state, path);
+    return true;
+  }
+  return false;
+}
 async function advance(ctx, state) {
   for (; ; ) {
     const target = await findNext(ctx, state);
@@ -3240,54 +3558,56 @@ async function advance(ctx, state) {
       delete state.pagination;
       return { state, result: finalize(ctx, state.resolved) };
     }
-    if (target.kind === "array") {
+    if (target.type === "array_items") {
       state.current = target.path;
-      state.gate = "array";
+      state.gate = "array_items";
       delete state.pagination;
       return {
         state,
-        result: { status: "ask", question: collectionQuestion(target) }
+        result: { status: "ask", question: arrayItemsQuestion(target) }
       };
     }
-    if (target.kind === "object") {
+    if (target.type === "object_optional") {
       state.current = target.path;
-      state.gate = "entry";
+      state.gate = "object_optional";
       delete state.pagination;
       return {
         state,
-        result: { status: "ask", question: objectGateQuestion(target.path) }
+        result: {
+          status: "ask",
+          question: objectOptionalQuestion(target.path)
+        }
       };
     }
-    if (target.kind === "optionals") {
+    if (target.type === "object_optional_properties") {
       state.current = target.path;
-      state.gate = "optionals";
+      state.gate = "object_optional_properties";
       delete state.pagination;
       return {
         state,
         result: {
           status: "ask",
-          question: optionalsGateQuestion(target.path, target.pending)
+          question: objectOptionalPropertiesQuestion(
+            target.path,
+            target.pending
+          )
         }
       };
     }
-    const { path, leaf } = target;
-    const resolver = leaf.resolver;
-    if (resolver && autoSettles(resolver)) {
-      if (resolver.type === "constant") {
-        setAtPath(state.resolved, path, resolver.value);
-      }
-      settle(state, path);
-      continue;
+    if (target.type === "record_entries") {
+      state.current = target.path;
+      state.gate = "record_entries";
+      delete state.pagination;
+      return {
+        state,
+        result: { status: "ask", question: recordEntriesQuestion(target) }
+      };
     }
-    const auto = resolver?.type === "dynamic" ? await resolver.tryResolveWithoutPrompt?.({
-      input: mergeInput(state.resolved, leaf.extraInput)
-    }) : void 0;
-    if (auto) {
-      if (auto.resolvedValue !== void 0)
-        setAtPath(state.resolved, path, auto.resolvedValue);
-      settle(state, path);
-      continue;
+    if (target.type === "record_key") {
+      return askRecordKey(state, target.path, target.leaf);
     }
+    const { path, leaf } = target;
+    if (await autoResolveLeaf(state, path, leaf)) continue;
     if (!state.interactive) {
       if (!leaf.required) {
         settle(state, path);
@@ -3320,10 +3640,18 @@ async function step(ctx, prior, action) {
     delete state.pagination;
     return { state, result: { status: "cancelled" } };
   }
+  if (state.gate === "record_key") {
+    return stepRecordKey(ctx, state, action);
+  }
   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 === "next_page" || action.type === "previous_page" || action.type === "retry")) {
+  if (!leaf) {
+    throw new Error(
+      `no resolver for the outstanding question at "${pathToKey(path)}"`
+    );
+  }
+  if (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") {
@@ -3340,19 +3668,26 @@ async function step(ctx, prior, action) {
       settle(state, path);
       return advance(ctx, state);
     }
-    if (gate === "entry") {
+    if (gate === "object_optional") {
       setAtPath(state.resolved, path, {});
       return advance(ctx, state);
     }
-    if (gate === "optionals") {
+    if (gate === "object_optional_properties") {
       remember(state, optionalsMarker(path));
       return advance(ctx, state);
     }
+    if (gate === "record_entries") {
+      const { keyLeaf } = await recordInfoAt(ctx, path, state.resolved);
+      return askRecordKey(state, path, keyLeaf);
+    }
     const items = getAtPath(state.resolved, path) ?? [];
     const { item } = await arrayInfoAt(ctx, path, state.resolved);
     const itemPath = [...path, items.length];
-    if (seedItemSlot(state, itemPath, item) === "leaf")
+    if (seedItemSlot(state, itemPath, item) === "leaf") {
+      if (await autoResolveLeaf(state, itemPath, item))
+        return advance(ctx, state);
       return askLeaf(state, itemPath, item);
+    }
     return advance(ctx, state);
   }
   if (state.gate) {
@@ -3363,81 +3698,37 @@ async function step(ctx, prior, action) {
   switch (action.type) {
     case "choose":
     case "custom": {
-      if (leaf) {
-        let error;
-        try {
-          error = await validationError(leaf, action.value, state);
-        } catch (thrown) {
-          return failedResult(state, leaf.name, thrown);
-        }
-        if (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 });
+      let error;
+      try {
+        error = await validationError(leaf, action.value, state);
+      } catch (thrown) {
+        return failedResult(state, leaf.name, thrown);
+      }
+      if (error) {
+        if (state.pagination && leaf.resolver?.type === "dynamic") {
+          return renderPageAt(state, leaf, path, state.pagination.position, {
+            error
+          });
         }
+        return askLeaf(state, path, leaf, { error });
       }
-      setAtPath(
-        state.resolved,
-        path,
-        leaf ? coerce(leaf, action.value) : action.value
-      );
+      setAtPath(state.resolved, path, coerce(leaf, action.value));
       break;
     }
     case "skip":
       settle(state, path);
       break;
     default:
-      throw new Error(`action "${action.type}" is not supported here`);
+      throw new Error(
+        `action "${action.type}" is not supported here`
+      );
   }
   delete state.current;
   delete state.pagination;
   return advance(ctx, state);
 }
-async function refine(ctx, state, leaf, path, action) {
-  const position = positionAfter(state.pagination, action);
+async function renderPageAt(state, leaf, path, position, opts = {}) {
   try {
-    if (action.type === "search") {
-      const exact = leaf.resolver?.type === "dynamic" ? await leaf.resolver.tryResolveFromSearch?.({
-        input: mergeInput(state.resolved, leaf.extraInput),
-        search: action.term
-      }) : void 0;
-      if (exact) {
-        setAtPath(state.resolved, path, coerce(leaf, exact.resolvedValue));
-        delete state.current;
-        delete state.pagination;
-        return advance(ctx, state);
-      }
-    }
     const context = await resolveContext(leaf, state.resolved);
     const page = await fetchListing(leaf, state.resolved, position, context);
     state.pagination = toPagination(page);
@@ -3445,7 +3736,8 @@ async function refine(ctx, state, leaf, path, action) {
       state,
       result: {
         status: "ask",
-        question: selectQuestion(leaf, path, state.resolved, page, context)
+        question: selectQuestion(leaf, path, state.resolved, page, context),
+        ...opts.error ? { error: opts.error } : {}
       }
     };
   } catch (error) {
@@ -3453,6 +3745,65 @@ async function refine(ctx, state, leaf, path, action) {
     return failedResult(state, leaf.name, error);
   }
 }
+async function refine(ctx, state, leaf, path, action) {
+  const position = positionAfter(state.pagination, action);
+  if (action.type === "search") {
+    try {
+      const exact = leaf.resolver?.type === "dynamic" ? await leaf.resolver.tryResolveFromSearch?.({
+        input: mergeInput(state.resolved, leaf.extraInput),
+        search: action.term
+      }) : void 0;
+      if (exact) {
+        setAtPath(state.resolved, path, coerce(leaf, exact.resolvedValue));
+        delete state.current;
+        delete state.pagination;
+        return advance(ctx, state);
+      }
+    } catch (error) {
+      state.pagination = failedPagination(state.pagination, position);
+      return failedResult(state, leaf.name, error);
+    }
+  }
+  return renderPageAt(state, leaf, path, position);
+}
+async function stepRecordKey(ctx, state, action) {
+  const path = state.current;
+  if (!path)
+    throw new Error("record key step called with no outstanding question");
+  const { keyLeaf, valueLeaf } = await recordInfoAt(ctx, path, state.resolved);
+  if (action.type === "skip") {
+    delete state.gate;
+    delete state.current;
+    delete state.pagination;
+    return advance(ctx, state);
+  }
+  if (action.type !== "custom" && action.type !== "choose") {
+    throw new Error(
+      `action "${action.type}" is not supported while entering a record key`
+    );
+  }
+  const raw = Array.isArray(action.value) ? action.value[0] : action.value;
+  const entryKey = String(coerce(keyLeaf, raw));
+  if (entryKey.trim() === "") {
+    return askRecordKey(state, path, keyLeaf, { error: "A key is required." });
+  }
+  if (UNSAFE_RECORD_KEYS.has(entryKey)) {
+    return askRecordKey(state, path, keyLeaf, {
+      error: `"${entryKey}" is not an allowed key.`
+    });
+  }
+  const container = getAtPath(state.resolved, path);
+  if (Object.prototype.hasOwnProperty.call(container, entryKey)) {
+    return askRecordKey(state, path, keyLeaf, {
+      error: `"${entryKey}" is already set.`
+    });
+  }
+  const valuePath = [...path, entryKey];
+  if (await autoResolveLeaf(state, valuePath, valueLeaf)) {
+    return advance(ctx, state);
+  }
+  return askLeaf(state, valuePath, valueLeaf);
+}
 function failedPagination(pagination, retryPosition) {
   return {
     position: pagination?.position ?? firstPagePosition(),
@@ -3508,7 +3859,7 @@ function projectSummary(entry) {
   };
 }
 function projectMethod(entry) {
-  const inputProperties = toJsonSchema(entry.inputSchema)?.properties;
+  const inputProperties = toJsonSchema(canonicalInputSchema(entry.inputSchema))?.properties;
   const parameters = {};
   for (const spec of planParameters(entry).parameters) {
     const dynamic = spec.resolver?.type === "dynamic" ? spec.resolver : void 0;
@@ -3541,7 +3892,12 @@ function createController(sdk) {
     const entry = entryFor(method);
     return {
       method,
-      schema: entry.inputSchema,
+      // A method that owns its input validation (`skipInputValidation`, e.g.
+      // fetch) must not be re-validated by the controller's final `safeParse`;
+      // drop the schema so `finalize` returns the resolved input untouched.
+      // Planning still reads `entry.inputSchema` directly, so parameters are
+      // unaffected.
+      schema: entry.skipInputValidation ? void 0 : entry.inputSchema,
       parameters: planParameters(entry).parameters
     };
   }
@@ -3606,59 +3962,6 @@ function createCorePlugin(options) {
     }
   });
 }
-
-// src/utils/schema-utils.ts
-import { z as z5 } from "zod";
-function getOutputSchema(inputSchema) {
-  return inputSchema._zod.def.outputSchema;
-}
-function withOutputSchema(inputSchema, outputSchema) {
-  Object.assign(inputSchema._zod.def, {
-    outputSchema
-  });
-  return inputSchema;
-}
-function withResolver(schema, config) {
-  schema._zod.def.resolverMeta = config;
-  return schema;
-}
-function getSchemaDescription(schema) {
-  return schema.description;
-}
-function getFieldDescriptions(schema) {
-  const descriptions = {};
-  const shape = schema.shape;
-  for (const [key2, fieldSchema] of Object.entries(shape)) {
-    if (fieldSchema instanceof z5.ZodType && fieldSchema.description) {
-      descriptions[key2] = fieldSchema.description;
-    }
-  }
-  return descriptions;
-}
-function withPositional(schema) {
-  Object.assign(schema._zod.def, {
-    positionalMeta: { positional: true }
-  });
-  return schema;
-}
-function schemaHasPositionalMeta(schema) {
-  return "positionalMeta" in schema._zod.def;
-}
-function isPositional(schema) {
-  if (schemaHasPositionalMeta(schema) && schema._zod.def.positionalMeta?.positional) {
-    return true;
-  }
-  if (schema instanceof z5.ZodOptional) {
-    return isPositional(schema._zod.def.innerType);
-  }
-  if (schema instanceof z5.ZodDefault) {
-    return isPositional(schema._zod.def.innerType);
-  }
-  return false;
-}
-function openEnum(values, description) {
-  return z5.union([z5.enum(values), z5.string()]).describe(description);
-}
 export {
   CONTEXT,
   CORE_ERROR_SYMBOL,
@@ -3670,6 +3973,7 @@ export {
   CoreErrorCode,
   CoreSignal,
   addPlugin,
+  canonicalInputSchema,
   composePlugins,
   concatLists,
   concatPaginated,