@zapier/kitcore 0.13.0 → 0.15.0

package/dist/index.cjs

@@ -29,7 +29,13 @@ __export(index_exports, {
   CoreError: () => CoreError,
   CoreErrorCode: () => CoreErrorCode,
   CoreSignal: () => CoreSignal,
+  RETRY_HTTP_REQUEST_OPTIONS_ID: () => RETRY_HTTP_REQUEST_OPTIONS_ID,
+  STABILITY_LEVELS: () => STABILITY_LEVELS,
+  STABILITY_TITLES: () => STABILITY_TITLES,
   addPlugin: () => addPlugin,
+  applyStabilityLabel: () => applyStabilityLabel,
+  attemptHttpRequestPlugin: () => attemptHttpRequestPlugin,
+  authorizeHttpRequestPlugin: () => authorizeHttpRequestPlugin,
   canonicalInputSchema: () => canonicalInputSchema,
   composePlugins: () => composePlugins,
   concatLists: () => concatLists,
@@ -47,6 +53,7 @@ __export(index_exports, {
   createPluginStack: () => createPluginStack,
   createPrefixedCursor: () => createPrefixedCursor,
   createSdk: () => createSdk,
+  createStabilityNoticeLogger: () => createStabilityNoticeLogger,
   createValidator: () => createValidator,
   dangerousContextPlugin: () => dangerousContextPlugin,
   declareDefault: () => declareDefault,
@@ -56,6 +63,7 @@ __export(index_exports, {
   declarePlugin: () => declarePlugin,
   declareProperty: () => declareProperty,
   decodeIncomingCursor: () => decodeIncomingCursor,
+  defaultConnectionSchemePlugin: () => defaultConnectionSchemePlugin,
   defaultLogDeprecation: () => defaultLogDeprecation,
   defineFormatter: () => defineFormatter,
   defineHook: () => defineHook,
@@ -65,7 +73,9 @@ __export(index_exports, {
   definePlugin: () => definePlugin,
   defineProperty: () => defineProperty,
   defineResolver: () => defineResolver,
+  dispatchHttpRequestPlugin: () => dispatchHttpRequestPlugin,
   disposeSdk: () => disposeSdk,
+  fetchPlugin: () => fetchPlugin,
   fromFunctionPlugin: () => fromFunctionPlugin,
   getContext: () => getContext,
   getCoreErrorCause: () => getCoreErrorCause,
@@ -77,21 +87,32 @@ __export(index_exports, {
   getOutputSchema: () => getOutputSchema,
   getRegistryPlugin: () => getRegistryPlugin,
   getSchemaDescription: () => getSchemaDescription,
+  initializeHttpRequestPlugin: () => initializeHttpRequestPlugin,
   isCoreCancelledSignal: () => isCoreCancelledSignal,
   isCoreError: () => isCoreError,
   isCoreSignal: () => isCoreSignal,
   isNestedMethodCall: () => isNestedMethodCall,
   isPositional: () => isPositional,
   isTelemetryNested: () => isTelemetryNested,
+  normalizeConnectionPlugin: () => normalizeConnectionPlugin,
+  normalizeStability: () => normalizeStability,
   omitExports: () => omitExports,
   openEnum: () => openEnum,
   paginate: () => paginate,
   paginateBuffered: () => paginateBuffered,
   paginateMaxItems: () => paginateMaxItems,
+  prepareHttpRequestPlugin: () => prepareHttpRequestPlugin,
+  receiveHttpResponsePlugin: () => receiveHttpResponsePlugin,
+  redactHeaders: () => redactHeaders,
+  redactHttpRequest: () => redactHttpRequest,
+  resolveConnectionPlugin: () => resolveConnectionPlugin,
   resolvePlugin: () => resolvePlugin,
+  retryHttpRequestOptionsPluginRef: () => retryHttpRequestOptionsPluginRef,
+  retryHttpRequestPlugin: () => retryHttpRequestPlugin,
   runInMethodScope: () => runInMethodScope,
   runWithTelemetryContext: () => runWithTelemetryContext,
   selectExports: () => selectExports,
+  sendHttpRequestPlugin: () => sendHttpRequestPlugin,
   splitPrefixedCursor: () => splitPrefixedCursor,
   toIterable: () => toIterable,
   toSnakeCase: () => toSnakeCase,
@@ -194,6 +215,28 @@ function openEnum(values, description) {
   return import_zod.z.union([import_zod.z.enum(values), import_zod.z.string()]).describe(description);
 }
 
+// src/utils/stability.ts
+var STABILITY_LEVELS = ["stable", "beta", "experimental"];
+var STABILITY_TITLES = {
+  stable: "Stable",
+  beta: "Beta",
+  experimental: "Experimental"
+};
+function normalizeStability(meta) {
+  if (meta.stability !== void 0) {
+    return STABILITY_LEVELS.includes(meta.stability) ? meta.stability : "experimental";
+  }
+  return meta.experimental ? "experimental" : "stable";
+}
+function applyStabilityLabel({
+  description,
+  stability,
+  placement = "suffix"
+}) {
+  if (stability === void 0 || stability === "stable") return description;
+  return placement === "prefix" ? `[${STABILITY_TITLES[stability]}] ${description}` : `${description} (${stability})`;
+}
+
 // src/registry.ts
 function resolveCategoryDefinition(ref) {
   const def = typeof ref === "string" ? { key: ref } : ref;
@@ -238,6 +281,7 @@ function buildRegistry({
     return typeof rootProperty === "object" && rootProperty !== null;
   }).map((key) => {
     const m = meta[key];
+    const stability = normalizeStability(m);
     return {
       name: key,
       description: m.description,
@@ -253,7 +297,11 @@ function buildRegistry({
       ),
       resolvers: resolvers?.[key],
       formatter: formatters?.[key],
-      experimental: m.experimental,
+      stability,
+      // Deprecated derived read, literal by name: only the experimental
+      // tier reads true. Beta reads false — the "not stable" warning duty
+      // lives in `stability` and the runtime notice, not this boolean.
+      experimental: stability === "experimental",
       packages: m.packages,
       confirm: m.confirm ?? (m.type === "delete" ? "delete" : void 0),
       deprecation: m.deprecation,
@@ -342,6 +390,20 @@ function createDeprecationLogger(tag) {
   };
 }
 var { logDeprecation, resetDeprecationWarnings } = createDeprecationLogger("core");
+function createStabilityNoticeLogger(tag) {
+  const loggedNotices = /* @__PURE__ */ new Set();
+  return {
+    logStabilityNotice(message) {
+      if (loggedNotices.has(message)) return;
+      loggedNotices.add(message);
+      console.warn(`[${tag}] ${message}`);
+    },
+    resetStabilityNotices() {
+      loggedNotices.clear();
+    }
+  };
+}
+var { logStabilityNotice, resetStabilityNotices } = createStabilityNoticeLogger("core");
 
 // src/types/errors.ts
 var CORE_ERROR_SYMBOL = Symbol.for("kitcore.error");
@@ -824,6 +886,19 @@ function defaultLogDeprecation({
 }) {
   logDeprecation(`${methodName}() is deprecated. ${deprecation.message}`);
 }
+var STABILITY_NOTICE_DETAILS = {
+  beta: "Its API shape is settled, but it is not yet covered by stable-tier guarantees.",
+  experimental: "It may change shape or disappear without notice."
+};
+function defaultLogStabilityNotice({
+  methodName,
+  stability
+}) {
+  if (stability === "stable") return;
+  logStabilityNotice(
+    `${methodName}() is a ${stability} API. ${STABILITY_NOTICE_DETAILS[stability]}`
+  );
+}
 var CORE_OPTIONS_ID = "kitcore/coreOptions";
 
 // src/utils/function-utils.ts
@@ -872,6 +947,18 @@ function signalDeprecation(context, methodName, getDeprecation) {
   const handler = resolveCoreOptions(context)?.logDeprecation ?? defaultLogDeprecation;
   runIsolatedObserver(() => handler(warning));
 }
+function signalStability(context, methodName, getStability) {
+  if (isInsideObserver()) return;
+  const stability = getStability?.();
+  if (!stability || stability === "stable") return;
+  const notice = {
+    type: "stability",
+    methodName,
+    stability
+  };
+  const handler = resolveCoreOptions(context)?.logStabilityNotice ?? defaultLogStabilityNotice;
+  runIsolatedObserver(() => handler(notice));
+}
 function normalizeError(error, adaptError) {
   if (error instanceof Error) return error;
   const message = typeof error === "object" && error !== null && "message" in error && typeof error.message === "string" ? error.message : String(error);
@@ -885,7 +972,7 @@ function normalizeError(error, adaptError) {
   );
 }
 function createFunction(coreFn, options) {
-  const { sdk, schema, name, annotator, getDeprecation } = options;
+  const { sdk, schema, name, annotator, getDeprecation, getStability } = options;
   const functionName = name || coreFn.name;
   const namedFunctions = {
     [functionName]: async function(callOptions) {
@@ -893,6 +980,7 @@ function createFunction(coreFn, options) {
       const context = resolveCallContext(internal);
       if (!isCallContext(internal) && internal !== INTERNAL_CALL) {
         signalDeprecation(sdk.context, functionName, getDeprecation);
+        signalStability(sdk.context, functionName, getStability);
       }
       return runInMethodScope(async () => {
         const startTime = Date.now();
@@ -959,12 +1047,21 @@ function createFunction(coreFn, options) {
   return namedFunctions[functionName];
 }
 function createRawFunction(coreFn, options) {
-  const { sdk, name, schema, positional, annotator, getDeprecation } = options;
+  const {
+    sdk,
+    name,
+    schema,
+    positional,
+    annotator,
+    getDeprecation,
+    getStability
+  } = options;
   return function(rawInput) {
     const internal = arguments[1];
     const context = resolveCallContext(internal);
     if (!isCallContext(internal) && internal !== INTERNAL_CALL) {
       signalDeprecation(sdk.context, name, getDeprecation);
+      signalStability(sdk.context, name, getStability);
     }
     return runInMethodScope(() => {
       const startTime = Date.now();
@@ -1070,7 +1167,8 @@ function createPaginatedFunction(coreFn, options) {
     adaptPage,
     annotator,
     finalizePage,
-    getDeprecation
+    getDeprecation,
+    getStability
   } = options;
   const pageFunction = createPageFunction(coreFn, {
     sdk,
@@ -1084,6 +1182,7 @@ function createPaginatedFunction(coreFn, options) {
       const context = resolveCallContext(internal);
       if (!isCallContext(internal) && internal !== INTERNAL_CALL) {
         signalDeprecation(sdk.context, functionName, getDeprecation);
+        signalStability(sdk.context, functionName, getStability);
       }
       return runInMethodScope(() => {
         const startTime = Date.now();
@@ -1528,6 +1627,7 @@ var LEAF_META_KEYS = [
   "returnType",
   "outputSchema",
   "packages",
+  "stability",
   "experimental",
   "confirm",
   "deprecation",
@@ -2795,7 +2895,8 @@ function buildMethodEntries(descriptors, context, states) {
           // (item mode's sibling); dropped paths surface as `[].x` in the page's
           // `meta`, unioned across items.
           finalizePage: (page) => applyListOutputPolicy(page, outputPolicy()),
-          getDeprecation: () => entry.meta?.deprecation
+          getDeprecation: () => entry.meta?.deprecation,
+          getStability: () => entry.meta ? normalizeStability(entry.meta) : void 0
         }
       );
     } else if (out.type === "item") {
@@ -2807,7 +2908,8 @@ function buildMethodEntries(descriptors, context, states) {
           schema: descriptor.inputSchema,
           name: descriptor.name,
           annotator: boundAnnotator,
-          getDeprecation: () => entry.meta?.deprecation
+          getDeprecation: () => entry.meta?.deprecation,
+          getStability: () => entry.meta ? normalizeStability(entry.meta) : void 0
         }
       );
     } else {
@@ -2821,8 +2923,10 @@ function buildMethodEntries(descriptors, context, states) {
           annotator: boundAnnotator,
           // The boundary reads the deprecation LIVE off the entry, so a
           // deprecation merged after build (defineMethodOverride, addPlugin)
-          // fires too.
-          getDeprecation: () => entry.meta?.deprecation
+          // fires too. Same for the stability level, normalized from the
+          // entry meta (declared level or legacy `experimental` boolean).
+          getDeprecation: () => entry.meta?.deprecation,
+          getStability: () => entry.meta ? normalizeStability(entry.meta) : void 0
         }
       );
     }
@@ -4485,6 +4589,392 @@ function createCorePlugin(options) {
     }
   });
 }
+
+// src/transport/attempt-http-request.ts
+var import_zod9 = require("zod");
+
+// src/transport/authorize-http-request.ts
+var import_zod5 = require("zod");
+function describeUnclaimedConnection(connection) {
+  const delimiterIndex = connection.indexOf(":");
+  if (delimiterIndex === -1) {
+    return 'no auth provider claimed this connection, and it carries no "scheme:" prefix';
+  }
+  return `no auth provider claimed the "${connection.slice(0, delimiterIndex)}" connection scheme`;
+}
+var authorizeHttpRequestPlugin = defineMethod({
+  name: "authorizeHttpRequest",
+  namespace: "kitcore",
+  inputSchema: import_zod5.z.custom(),
+  skipInputValidation: true,
+  run: async ({ input }) => {
+    const { connection } = input.request;
+    if (connection != null) {
+      throw createCoreError({
+        code: CoreErrorCode.Unknown,
+        message: `authorizeHttpRequest: ${describeUnclaimedConnection(connection)}, so the request was not sent.`
+      });
+    }
+    return input.request;
+  }
+});
+
+// src/transport/dispatch-http-request.ts
+var import_zod6 = require("zod");
+function toFetchInput(request) {
+  const init = { ...request };
+  const { url } = request;
+  delete init.url;
+  delete init.connection;
+  return { url, init };
+}
+var dispatchHttpRequestPlugin = defineMethod({
+  name: "dispatchHttpRequest",
+  namespace: "kitcore",
+  inputSchema: import_zod6.z.custom(),
+  skipInputValidation: true,
+  run: async ({ input }) => {
+    const { url, init } = toFetchInput(input.request);
+    return fetch(url, init);
+  }
+});
+
+// src/transport/prepare-http-request.ts
+var import_zod7 = require("zod");
+var prepareHttpRequestPlugin = defineMethod({
+  name: "prepareHttpRequest",
+  namespace: "kitcore",
+  inputSchema: import_zod7.z.custom(),
+  skipInputValidation: true,
+  run: async ({ input }) => input.request
+});
+
+// src/transport/receive-http-response.ts
+var import_zod8 = require("zod");
+var receiveHttpResponsePlugin = defineMethod({
+  name: "receiveHttpResponse",
+  namespace: "kitcore",
+  inputSchema: import_zod8.z.custom(),
+  skipInputValidation: true,
+  run: async ({ input }) => input.response
+});
+
+// src/transport/attempt-http-request.ts
+var attemptHttpRequestPlugin = defineMethod({
+  name: "attemptHttpRequest",
+  namespace: "kitcore",
+  imports: [
+    declareDefault({ plugin: prepareHttpRequestPlugin }),
+    declareDefault({ plugin: authorizeHttpRequestPlugin }),
+    declareDefault({ plugin: dispatchHttpRequestPlugin }),
+    declareDefault({ plugin: receiveHttpResponsePlugin })
+  ],
+  inputSchema: import_zod9.z.custom(),
+  skipInputValidation: true,
+  run: async ({ input, imports }) => {
+    const { attempt } = input;
+    const preparedRequest = await imports.prepareHttpRequest({
+      request: input.request,
+      attempt
+    });
+    const authorizedRequest = await imports.authorizeHttpRequest({
+      request: preparedRequest,
+      attempt
+    });
+    const response = await imports.dispatchHttpRequest({
+      request: authorizedRequest,
+      attempt
+    });
+    return imports.receiveHttpResponse({
+      request: authorizedRequest,
+      response,
+      attempt
+    });
+  }
+});
+
+// src/transport/initialize-http-request.ts
+var import_zod10 = require("zod");
+function isReplayableBody(body) {
+  if (body == null || typeof body !== "object") return true;
+  return typeof Blob !== "undefined" && body instanceof Blob || // File extends Blob
+  typeof FormData !== "undefined" && body instanceof FormData || typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams || body instanceof ArrayBuffer || ArrayBuffer.isView(body);
+}
+function withStringUrl(request) {
+  return typeof request.url === "string" ? request : { ...request, url: String(request.url) };
+}
+var initializeHttpRequestPlugin = defineMethod({
+  name: "initializeHttpRequest",
+  namespace: "kitcore",
+  inputSchema: import_zod10.z.custom(),
+  skipInputValidation: true,
+  run: async ({ input }) => {
+    const request = withStringUrl(input.request);
+    return {
+      ...input.operation,
+      request,
+      replayable: isReplayableBody(request.body)
+    };
+  }
+});
+
+// src/transport/retry-http-request.ts
+var RETRY_HTTP_REQUEST_OPTIONS_ID = "kitcore/retryHttpRequestOptions";
+var retryHttpRequestOptionsPluginRef = declareOptionalProperty({ id: RETRY_HTTP_REQUEST_OPTIONS_ID });
+var DEFAULT_MAX_ATTEMPTS = 3;
+var DEFAULT_MAX_DELAY_MILLISECONDS = 6e4;
+var DEFAULT_RETRY_STATUSES = [429, 500, 502, 503, 504];
+var DEFAULT_NON_IDEMPOTENT_RETRY_STATUSES = [429];
+var DEFAULT_IDEMPOTENT_METHODS = [
+  "GET",
+  "HEAD",
+  "PUT",
+  "DELETE",
+  "OPTIONS",
+  "TRACE"
+];
+var BASE_BACKOFF_MILLISECONDS = 1e3;
+var JITTER_FACTOR = 0.5;
+function directedDelayMilliseconds(response) {
+  const retryAfter = response.headers.get("retry-after");
+  if (retryAfter) {
+    const seconds = Number.parseInt(retryAfter, 10);
+    if (!Number.isNaN(seconds)) return Math.max(0, seconds * 1e3);
+    const date = Date.parse(retryAfter);
+    if (!Number.isNaN(date)) return Math.max(0, date - Date.now());
+  }
+  const reset = response.headers.get("x-ratelimit-reset");
+  if (reset) {
+    const resetSeconds = Number.parseInt(reset, 10);
+    if (!Number.isNaN(resetSeconds)) {
+      return Math.max(0, resetSeconds * 1e3 - Date.now());
+    }
+  }
+  return void 0;
+}
+function backoffMilliseconds(attemptNumber) {
+  const base = BASE_BACKOFF_MILLISECONDS * 2 ** (attemptNumber - 1);
+  return base + Math.random() * JITTER_FACTOR * base;
+}
+function abortReason(signal) {
+  const reason = signal?.reason;
+  return reason ?? new Error("The request was aborted.");
+}
+function sleep(milliseconds, signal) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(finish, milliseconds);
+    function finish() {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", cancel);
+      resolve();
+    }
+    function cancel() {
+      clearTimeout(timer);
+      reject(abortReason(signal));
+    }
+    if (signal?.aborted) return cancel();
+    signal?.addEventListener("abort", cancel, { once: true });
+  });
+}
+function isIdempotent(request, idempotentMethods) {
+  const method = (request.method ?? "GET").toUpperCase();
+  return idempotentMethods.includes(method);
+}
+var retryHttpRequestPlugin = defineHook({
+  name: "retryHttpRequest",
+  imports: [attemptHttpRequestPlugin, retryHttpRequestOptionsPluginRef],
+  wrap: {
+    attemptHttpRequest: async ({ input, imports, next }) => {
+      const options = imports.retryHttpRequestOptions ?? {};
+      const maxAttempts = options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+      const maxDelayMilliseconds = options.maxDelayMilliseconds ?? DEFAULT_MAX_DELAY_MILLISECONDS;
+      const idempotentMethods = options.idempotentMethods ?? DEFAULT_IDEMPOTENT_METHODS;
+      const statuses = isIdempotent(input.request, idempotentMethods) ? options.retryStatuses ?? DEFAULT_RETRY_STATUSES : options.nonIdempotentRetryStatuses ?? DEFAULT_NON_IDEMPOTENT_RETRY_STATUSES;
+      for (let attemptNumber = 1; ; attemptNumber++) {
+        const attempt = {
+          ...input.attempt,
+          attemptNumber,
+          // Per-attempt scratch: a cross-stage handoff from a previous attempt
+          // describes a request that is no longer in flight. `operation` rides
+          // through unchanged, so the id and the caller's original request are
+          // the same for every attempt.
+          state: {}
+        };
+        let response;
+        try {
+          response = await next({ ...input, attempt });
+        } catch (error) {
+          if (!options.retryOnError || !canRetry(
+            attemptNumber,
+            maxAttempts,
+            input.attempt.operation.replayable
+          )) {
+            throw error;
+          }
+          await sleep(
+            Math.min(backoffMilliseconds(attemptNumber), maxDelayMilliseconds),
+            attempt.signal
+          );
+          continue;
+        }
+        if (!statuses.includes(response.status) || !canRetry(
+          attemptNumber,
+          maxAttempts,
+          input.attempt.operation.replayable
+        )) {
+          return response;
+        }
+        const directed = directedDelayMilliseconds(response);
+        if (directed != null && directed > maxDelayMilliseconds)
+          return response;
+        const delay = Math.min(
+          directed ?? backoffMilliseconds(attemptNumber),
+          maxDelayMilliseconds
+        );
+        await response.body?.cancel().catch(() => {
+        });
+        await sleep(delay, attempt.signal);
+      }
+    }
+  }
+});
+function canRetry(attemptNumber, maxAttempts, replayable) {
+  return attemptNumber < maxAttempts && replayable;
+}
+
+// src/transport/send-http-request.ts
+var import_zod11 = require("zod");
+function createOperationId() {
+  return globalThis.crypto?.randomUUID?.() ?? `http-${Date.now()}`;
+}
+var sendHttpRequestPlugin = defineMethod({
+  name: "sendHttpRequest",
+  namespace: "kitcore",
+  imports: [
+    declareDefault({ plugin: initializeHttpRequestPlugin }),
+    declareDefault({ plugin: attemptHttpRequestPlugin })
+  ],
+  inputSchema: import_zod11.z.custom(),
+  skipInputValidation: true,
+  run: async ({ input, imports }) => {
+    const start2 = {
+      operationId: createOperationId(),
+      signal: input.signal
+    };
+    const operation = await imports.initializeHttpRequest({
+      request: input,
+      operation: start2
+    });
+    return imports.attemptHttpRequest({
+      request: operation.request,
+      attempt: {
+        attemptNumber: 1,
+        operation,
+        signal: operation.signal,
+        state: {}
+      }
+    });
+  }
+});
+
+// src/transport/fetch.ts
+var import_zod12 = require("zod");
+var fetchPlugin = defineMethod({
+  name: "fetch",
+  namespace: "kitcore",
+  imports: [declareDefault({ plugin: sendHttpRequestPlugin })],
+  positional: ["url", "init"],
+  inputSchema: import_zod12.z.custom(),
+  skipInputValidation: true,
+  run: ({ input, imports }) => {
+    const { url, init } = input;
+    return imports.sendHttpRequest({ url, ...init });
+  }
+});
+
+// src/transport/redact.ts
+var CREDENTIAL_HEADERS = ["authorization", "x-api-key"];
+function maskSecret(secret) {
+  if (secret.length > 12) {
+    return `${secret.slice(0, 4)}...${secret.slice(-4)}`;
+  }
+  return `${secret.charAt(0)}...`;
+}
+function maskCredentialHeader(value) {
+  const spaceIndex = value.indexOf(" ");
+  if (spaceIndex > 0 && spaceIndex < value.length - 1) {
+    return `${value.slice(0, spaceIndex + 1)}${maskSecret(value.slice(spaceIndex + 1))}`;
+  }
+  return maskSecret(value);
+}
+function redactHeaders(headers) {
+  if (!headers) return headers;
+  const normalized = new Headers(headers);
+  for (const [name, value] of normalized.entries()) {
+    if (CREDENTIAL_HEADERS.includes(name.toLowerCase())) {
+      normalized.set(name, maskCredentialHeader(value));
+    }
+  }
+  return Object.fromEntries(normalized);
+}
+function redactHttpRequest(request) {
+  const redacted = { ...request };
+  if (request.headers) redacted.headers = redactHeaders(request.headers);
+  if (request.connection != null) {
+    redacted.connection = maskSecret(request.connection);
+  }
+  return redacted;
+}
+
+// src/connections/default-connection-scheme.ts
+var import_zod13 = require("zod");
+var defaultConnectionSchemePlugin = defineMethod({
+  name: "defaultConnectionScheme",
+  namespace: "kitcore",
+  inputSchema: import_zod13.z.custom(),
+  skipInputValidation: true,
+  run: () => void 0
+});
+
+// src/connections/normalize-connection.ts
+var import_zod14 = require("zod");
+var normalizeConnectionPlugin = defineMethod({
+  name: "normalizeConnection",
+  namespace: "kitcore",
+  imports: [declareDefault({ plugin: defaultConnectionSchemePlugin })],
+  inputSchema: import_zod14.z.custom(),
+  skipInputValidation: true,
+  run: ({ input, imports }) => {
+    const { connection } = input;
+    if (connection == null) {
+      return void 0;
+    }
+    const delimiterIndex = connection.indexOf(":");
+    if (delimiterIndex !== -1) {
+      return {
+        connection,
+        scheme: connection.slice(0, delimiterIndex),
+        value: connection.slice(delimiterIndex + 1)
+      };
+    }
+    const scheme = imports.defaultConnectionScheme({ connection });
+    return {
+      connection,
+      scheme,
+      value: connection
+    };
+  }
+});
+
+// src/connections/resolve-connection.ts
+var import_zod15 = require("zod");
+var resolveConnectionPlugin = defineMethod({
+  name: "resolveConnection",
+  namespace: "kitcore",
+  inputSchema: import_zod15.z.custom(),
+  skipInputValidation: true,
+  run: ({ input }) => input.connection
+});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CONTEXT,
@@ -4496,7 +4986,13 @@ function createCorePlugin(options) {
   CoreError,
   CoreErrorCode,
   CoreSignal,
+  RETRY_HTTP_REQUEST_OPTIONS_ID,
+  STABILITY_LEVELS,
+  STABILITY_TITLES,
   addPlugin,
+  applyStabilityLabel,
+  attemptHttpRequestPlugin,
+  authorizeHttpRequestPlugin,
   canonicalInputSchema,
   composePlugins,
   concatLists,
@@ -4514,6 +5010,7 @@ function createCorePlugin(options) {
   createPluginStack,
   createPrefixedCursor,
   createSdk,
+  createStabilityNoticeLogger,
   createValidator,
   dangerousContextPlugin,
   declareDefault,
@@ -4523,6 +5020,7 @@ function createCorePlugin(options) {
   declarePlugin,
   declareProperty,
   decodeIncomingCursor,
+  defaultConnectionSchemePlugin,
   defaultLogDeprecation,
   defineFormatter,
   defineHook,
@@ -4532,7 +5030,9 @@ function createCorePlugin(options) {
   definePlugin,
   defineProperty,
   defineResolver,
+  dispatchHttpRequestPlugin,
   disposeSdk,
+  fetchPlugin,
   fromFunctionPlugin,
   getContext,
   getCoreErrorCause,
@@ -4544,21 +5044,32 @@ function createCorePlugin(options) {
   getOutputSchema,
   getRegistryPlugin,
   getSchemaDescription,
+  initializeHttpRequestPlugin,
   isCoreCancelledSignal,
   isCoreError,
   isCoreSignal,
   isNestedMethodCall,
   isPositional,
   isTelemetryNested,
+  normalizeConnectionPlugin,
+  normalizeStability,
   omitExports,
   openEnum,
   paginate,
   paginateBuffered,
   paginateMaxItems,
+  prepareHttpRequestPlugin,
+  receiveHttpResponsePlugin,
+  redactHeaders,
+  redactHttpRequest,
+  resolveConnectionPlugin,
   resolvePlugin,
+  retryHttpRequestOptionsPluginRef,
+  retryHttpRequestPlugin,
   runInMethodScope,
   runWithTelemetryContext,
   selectExports,
+  sendHttpRequestPlugin,
   splitPrefixedCursor,
   toIterable,
   toSnakeCase,