@hasna/skills 0.5.3 → 0.5.4

package/dist/index.js

@@ -19,12 +19,14 @@ var __toESM = (mod, isNodeMode, target) => {
   }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: __accessProp.bind(mod, key),
-        enumerable: true
-      });
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
   if (canCache)
     cache.set(mod, to);
   return to;
@@ -4729,113 +4731,113 @@ function readIfExists(path) {
 // ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/external.js
 var exports_external = {};
 __export(exports_external, {
-  void: () => voidType,
-  util: () => util,
-  unknown: () => unknownType,
-  union: () => unionType,
-  undefined: () => undefinedType,
-  tuple: () => tupleType,
-  transformer: () => effectsType,
-  symbol: () => symbolType,
-  string: () => stringType,
-  strictObject: () => strictObjectType,
-  setErrorMap: () => setErrorMap,
-  set: () => setType,
-  record: () => recordType,
-  quotelessJson: () => quotelessJson,
-  promise: () => promiseType,
-  preprocess: () => preprocessType,
-  pipeline: () => pipelineType,
-  ostring: () => ostring,
-  optional: () => optionalType,
-  onumber: () => onumber,
-  oboolean: () => oboolean,
-  objectUtil: () => objectUtil,
-  object: () => objectType,
-  number: () => numberType,
-  nullable: () => nullableType,
-  null: () => nullType,
-  never: () => neverType,
-  nativeEnum: () => nativeEnumType,
-  nan: () => nanType,
-  map: () => mapType,
-  makeIssue: () => makeIssue,
-  literal: () => literalType,
-  lazy: () => lazyType,
-  late: () => late,
-  isValid: () => isValid,
-  isDirty: () => isDirty,
-  isAsync: () => isAsync,
-  isAborted: () => isAborted,
-  intersection: () => intersectionType,
-  instanceof: () => instanceOfType,
-  getParsedType: () => getParsedType,
-  getErrorMap: () => getErrorMap,
-  function: () => functionType,
-  enum: () => enumType,
-  effect: () => effectsType,
-  discriminatedUnion: () => discriminatedUnionType,
-  defaultErrorMap: () => en_default,
-  datetimeRegex: () => datetimeRegex,
-  date: () => dateType,
-  custom: () => custom,
-  coerce: () => coerce,
-  boolean: () => booleanType,
-  bigint: () => bigIntType,
-  array: () => arrayType,
-  any: () => anyType,
-  addIssueToContext: () => addIssueToContext,
-  ZodVoid: () => ZodVoid,
-  ZodUnknown: () => ZodUnknown,
-  ZodUnion: () => ZodUnion,
-  ZodUndefined: () => ZodUndefined,
-  ZodType: () => ZodType,
-  ZodTuple: () => ZodTuple,
-  ZodTransformer: () => ZodEffects,
-  ZodSymbol: () => ZodSymbol,
-  ZodString: () => ZodString,
-  ZodSet: () => ZodSet,
-  ZodSchema: () => ZodType,
-  ZodRecord: () => ZodRecord,
-  ZodReadonly: () => ZodReadonly,
-  ZodPromise: () => ZodPromise,
-  ZodPipeline: () => ZodPipeline,
-  ZodParsedType: () => ZodParsedType,
-  ZodOptional: () => ZodOptional,
-  ZodObject: () => ZodObject,
-  ZodNumber: () => ZodNumber,
-  ZodNullable: () => ZodNullable,
-  ZodNull: () => ZodNull,
-  ZodNever: () => ZodNever,
-  ZodNativeEnum: () => ZodNativeEnum,
-  ZodNaN: () => ZodNaN,
-  ZodMap: () => ZodMap,
-  ZodLiteral: () => ZodLiteral,
-  ZodLazy: () => ZodLazy,
-  ZodIssueCode: () => ZodIssueCode,
-  ZodIntersection: () => ZodIntersection,
-  ZodFunction: () => ZodFunction,
-  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
-  ZodError: () => ZodError,
-  ZodEnum: () => ZodEnum,
-  ZodEffects: () => ZodEffects,
-  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
-  ZodDefault: () => ZodDefault,
-  ZodDate: () => ZodDate,
-  ZodCatch: () => ZodCatch,
-  ZodBranded: () => ZodBranded,
-  ZodBoolean: () => ZodBoolean,
-  ZodBigInt: () => ZodBigInt,
-  ZodArray: () => ZodArray,
-  ZodAny: () => ZodAny,
-  Schema: () => ZodType,
-  ParseStatus: () => ParseStatus,
-  OK: () => OK,
-  NEVER: () => NEVER,
-  INVALID: () => INVALID,
-  EMPTY_PATH: () => EMPTY_PATH,
+  BRAND: () => BRAND,
   DIRTY: () => DIRTY,
-  BRAND: () => BRAND
+  EMPTY_PATH: () => EMPTY_PATH,
+  INVALID: () => INVALID,
+  NEVER: () => NEVER,
+  OK: () => OK,
+  ParseStatus: () => ParseStatus,
+  Schema: () => ZodType,
+  ZodAny: () => ZodAny,
+  ZodArray: () => ZodArray,
+  ZodBigInt: () => ZodBigInt,
+  ZodBoolean: () => ZodBoolean,
+  ZodBranded: () => ZodBranded,
+  ZodCatch: () => ZodCatch,
+  ZodDate: () => ZodDate,
+  ZodDefault: () => ZodDefault,
+  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
+  ZodEffects: () => ZodEffects,
+  ZodEnum: () => ZodEnum,
+  ZodError: () => ZodError,
+  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
+  ZodFunction: () => ZodFunction,
+  ZodIntersection: () => ZodIntersection,
+  ZodIssueCode: () => ZodIssueCode,
+  ZodLazy: () => ZodLazy,
+  ZodLiteral: () => ZodLiteral,
+  ZodMap: () => ZodMap,
+  ZodNaN: () => ZodNaN,
+  ZodNativeEnum: () => ZodNativeEnum,
+  ZodNever: () => ZodNever,
+  ZodNull: () => ZodNull,
+  ZodNullable: () => ZodNullable,
+  ZodNumber: () => ZodNumber,
+  ZodObject: () => ZodObject,
+  ZodOptional: () => ZodOptional,
+  ZodParsedType: () => ZodParsedType,
+  ZodPipeline: () => ZodPipeline,
+  ZodPromise: () => ZodPromise,
+  ZodReadonly: () => ZodReadonly,
+  ZodRecord: () => ZodRecord,
+  ZodSchema: () => ZodType,
+  ZodSet: () => ZodSet,
+  ZodString: () => ZodString,
+  ZodSymbol: () => ZodSymbol,
+  ZodTransformer: () => ZodEffects,
+  ZodTuple: () => ZodTuple,
+  ZodType: () => ZodType,
+  ZodUndefined: () => ZodUndefined,
+  ZodUnion: () => ZodUnion,
+  ZodUnknown: () => ZodUnknown,
+  ZodVoid: () => ZodVoid,
+  addIssueToContext: () => addIssueToContext,
+  any: () => anyType,
+  array: () => arrayType,
+  bigint: () => bigIntType,
+  boolean: () => booleanType,
+  coerce: () => coerce,
+  custom: () => custom,
+  date: () => dateType,
+  datetimeRegex: () => datetimeRegex,
+  defaultErrorMap: () => en_default,
+  discriminatedUnion: () => discriminatedUnionType,
+  effect: () => effectsType,
+  enum: () => enumType,
+  function: () => functionType,
+  getErrorMap: () => getErrorMap,
+  getParsedType: () => getParsedType,
+  instanceof: () => instanceOfType,
+  intersection: () => intersectionType,
+  isAborted: () => isAborted,
+  isAsync: () => isAsync,
+  isDirty: () => isDirty,
+  isValid: () => isValid,
+  late: () => late,
+  lazy: () => lazyType,
+  literal: () => literalType,
+  makeIssue: () => makeIssue,
+  map: () => mapType,
+  nan: () => nanType,
+  nativeEnum: () => nativeEnumType,
+  never: () => neverType,
+  null: () => nullType,
+  nullable: () => nullableType,
+  number: () => numberType,
+  object: () => objectType,
+  objectUtil: () => objectUtil,
+  oboolean: () => oboolean,
+  onumber: () => onumber,
+  optional: () => optionalType,
+  ostring: () => ostring,
+  pipeline: () => pipelineType,
+  preprocess: () => preprocessType,
+  promise: () => promiseType,
+  quotelessJson: () => quotelessJson,
+  record: () => recordType,
+  set: () => setType,
+  setErrorMap: () => setErrorMap,
+  strictObject: () => strictObjectType,
+  string: () => stringType,
+  symbol: () => symbolType,
+  transformer: () => effectsType,
+  tuple: () => tupleType,
+  undefined: () => undefinedType,
+  union: () => unionType,
+  unknown: () => unknownType,
+  util: () => util,
+  void: () => voidType
 });
 
 // ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/helpers/util.js
@@ -11138,6 +11140,69 @@ function parseUpdatedWorkspace(value) {
   return { organization: { id: organization2.id, slug: organization2.slug, name: organization2.name } };
 }
 
+// src/lib/remote-quote-errors.ts
+var quoteUnavailableMessages = Object.freeze({
+  HOSTED_PROVIDER_UNAVAILABLE: "Hosted execution is temporarily unavailable on this Skills instance.",
+  HOSTED_CONNECTORS_UNAVAILABLE: "Hosted connector execution is unavailable on this Skills instance.",
+  SKILL_IMPLEMENTATION_UNAVAILABLE: "This skill has no hosted execution implementation.",
+  HOSTED_PRICING_UNAVAILABLE: "Hosted execution is unavailable while this skill's pricing is reviewed.",
+  RUNTIME_ALLOWLIST_REQUIRED: "Hosted execution is unavailable until this Skills instance enables its skill catalog.",
+  RUNTIME_SKILL_NOT_ALLOWED: "This skill is not enabled for hosted execution on this Skills instance."
+});
+async function readQuoteUnavailableCode(response) {
+  const maximum = 16 * 1024;
+  const length = response.headers.get("content-length");
+  if (response.status !== 503 || response.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase() !== "application/json" || length !== null && (!/^\d+$/.test(length) || Number(length) > maximum)) {
+    response.body?.cancel().catch(() => {});
+    return null;
+  }
+  const reader = response.body?.getReader();
+  if (!reader)
+    return null;
+  let timer;
+  let deadlineExceeded = false;
+  const expired = Symbol("quote body deadline");
+  const deadline = new Promise((resolve2) => {
+    timer = setTimeout(() => {
+      deadlineExceeded = true;
+      resolve2(expired);
+      reader.cancel().catch(() => {});
+    }, 1500);
+  });
+  const chunks = [];
+  let size = 0;
+  try {
+    while (true) {
+      const next = await Promise.race([reader.read(), deadline]);
+      if (next === expired || deadlineExceeded)
+        return null;
+      if (next.done)
+        break;
+      size += next.value.byteLength;
+      if (size > maximum)
+        return null;
+      chunks.push(next.value);
+    }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    const value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    if (!value || typeof value !== "object" || Array.isArray(value))
+      return null;
+    const code = value.code;
+    return typeof code === "string" && Object.hasOwn(quoteUnavailableMessages, code) ? code : null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+    reader.cancel().catch(() => {});
+    reader.releaseLock();
+  }
+}
+
 // src/lib/remote-client.ts
 class RemoteRouteUnsupportedError extends Error {
   path;
@@ -11163,6 +11228,18 @@ class RemoteRequestError extends Error {
   }
 }
 
+class RemoteQuoteUnavailableError extends RemoteRequestError {
+  code;
+  constructor(path, code) {
+    super(path, 503);
+    this.code = code;
+    if (!Object.hasOwn(quoteUnavailableMessages, code))
+      throw new Error("Unknown quote refusal code");
+    this.name = "RemoteQuoteUnavailableError";
+    this.message = quoteUnavailableMessages[code];
+  }
+}
+
 class RemoteWorkspaceMemberError extends RemoteRequestError {
   code;
   constructor(path, code) {
@@ -11224,6 +11301,11 @@ class RemoteSkillsClient {
       throw new RemoteRouteUnsupportedError(routePath, response.status, this.apiUrl);
     }
     if (!response.ok) {
+      if (opts.quoteRefusal && options?.method === "POST" && /^\/api\/v1\/skills\/[^/?#]+\/quote$/.test(routePath) && response.status === 503) {
+        const code = await readQuoteUnavailableCode(response);
+        if (code)
+          throw new RemoteQuoteUnavailableError(routePath, code);
+      }
       if (path === "/api/v1/billing/checkout" && options?.method === "POST" && response.status === 503 && await responseBodyCarriesCode(response, ["SUBSCRIPTION_CHECKOUT_UNAVAILABLE"])) {
         throw new RemoteCapabilityUnavailableError;
       }
@@ -11281,7 +11363,7 @@ class RemoteSkillsClient {
     const response = await this.requestNewRoute(`/api/v1/skills/${encodeURIComponent(slug)}/quote`, {
       method: "POST",
       body: JSON.stringify({ input, args })
-    });
+    }, { quoteRefusal: true });
     return parseRemoteRunQuote(await response.json());
   }
   getCapabilities() {
@@ -13206,7 +13288,7 @@ import { dirname as dirname7, relative as relative4 } from "path";
 // package.json
 var package_default = {
   name: "@hasna/skills",
-  version: "0.5.3",
+  version: "0.5.4",
   description: "Skills library for AI coding agents",
   type: "module",
   bin: {
@@ -15989,256 +16071,257 @@ class RemoteSkillsAuthClient {
   }
 }
 export {
-  writeStationSnapshot,
-  writeStationHydration,
-  writeRunLogs,
-  writeRegistrySyncArtifact,
-  writeManagedSkillDir,
-  writeManagedAgentSkill,
-  writeCorpusSkill,
-  walkEntries,
-  verifyContentHashFromEntries,
-  verifyContentHash,
-  validateToolPrimitiveCoverage,
-  validateStationId,
-  validateSkillsCliMcpParity,
-  validateSkillDirectory,
-  validateRegistryConsistency,
-  validatePortableSkillDirectory,
-  validatePortableManifestContract,
-  validateCron,
-  validateBlogArticleRunOptions,
-  uploadSkillsSnapshotFilesToS3,
-  updateSkillRun,
-  unsetConfig,
-  unpinSkill,
-  unpinProjectSkill,
-  syncSkillsToAgents,
-  summarizeMcpToolContract,
-  storageCapabilities,
-  skillsPostgresSyncSchemaSql,
-  skillsCredentialOrReason,
-  skillsCredentialFiles,
-  skillsCredentialFilePath,
-  skillExists,
-  signSkillsAwsV4Request,
-  sha256File,
-  setSkillDisabled,
-  setScheduleEnabled,
-  selectsSkillsLocalMode,
-  searchSkills,
-  scaffoldPortableSkill,
-  saveProjectConfig,
-  saveFeedback,
-  saveConfig,
-  sanitizePublicDiscoveryText,
-  runSkill,
-  runPortableSkill,
-  revisionIdOf,
-  resolveSyncAgents,
-  resolveStorageConfig,
-  resolveSkillsNativeStorageConfig,
-  resolveSkillsFleet,
-  resolveSkillsApiOrigin,
-  resolveSkillsApiKey,
-  resolveSkillAlias,
-  requireSkillsFleet,
-  requireSkillsApiOrigin,
-  requireSkillsApiKey,
-  removeSkillForAgent,
-  removeSkill,
-  removeSchedule,
-  removeManagedAgentSkill,
-  recordScheduleRun,
-  readPortableSkillManifest,
-  pullSkills,
-  publicDiscoveryEnvVars,
-  publicDiscoveryDocumentation,
-  publicDiscoveryDependencies,
-  portPortableSkillDirectory,
-  portPortableSkill,
-  pointerSkillMd,
-  planStationSnapshot,
-  planStationHydration,
-  planSkillsS3SnapshotUpload,
-  pinSkill,
-  pinProjectSkill,
-  parseSkillFrontmatter,
-  parseRemoteSkillPayload,
-  parseRemoteRegistryPayload,
-  noticeLocalSkillsMode,
-  normalizeSkillsApiOrigin,
-  normalizeSkillSlug,
-  normalizeRemoteSkillRunContract,
-  normalizePortableSkillName,
-  normalizeLineEndings,
-  loadRemoteSkill,
-  loadRemoteRegistry,
-  loadRegistryProfile,
-  loadRegistry,
-  loadProjectConfig,
-  loadConfig,
-  loadBasicRegistry,
-  listToolPrimitives,
-  listSkillRuns,
-  listSchedules,
-  listPortableSkills,
-  listPortableSkillMetas,
-  listPinnedSkills,
-  listMcpToolContracts,
-  isSyncAgent,
-  isSkillsLocalOptIn,
-  isRegularFile,
-  isPortableWithinSkill,
-  isGatewayBackedSkill,
-  isExcludedSkillFileName,
-  isBasicSkillName,
-  installSkills,
-  installSkillSource,
-  installSkillManifest,
-  installSkillForAgent,
-  installSkill,
-  importSkillsLocalSnapshot,
-  homePathFor,
-  getToolPrimitive,
-  getStorageStatus,
-  getStorageDatabaseUrl,
-  getStorageDatabaseEnv,
-  getSkillsStorageStatus,
-  getSkillsStorageDatabaseUrl,
-  getSkillsStorageDatabaseEnv,
-  getSkillsNativeStorageStatus,
-  getSkillsByTag,
-  getSkillsByCategory,
-  getSkillToolDependencies,
-  getSkillRequirements,
-  getSkillPath,
-  getSkillDocs,
-  getSkillBestDoc,
-  getSkill,
-  getRunExportDir,
-  getPublicSkillDiscovery,
-  getProjectStateDir,
-  getProjectConfigPath,
-  getPortableSkillsRoot,
-  getPortableSkillPath,
-  getPinnedSkills,
-  getNextRun,
-  getMcpToolDescriptions,
-  getMcpResourceContracts,
-  getInstalledSkills,
-  getInstallMeta,
-  getFeedbackDbPath,
-  getDueSchedules,
-  getDisabledSkills,
-  getDisabledProjectSkills,
-  getConfiguredApiUrl,
-  getConfigPath,
-  getCompactSkillDiscovery,
-  getAllTags,
-  getAgentSkillsDir,
-  getAgentSkillPath,
-  generateSkillMd,
-  generateEnvExample,
-  findSkillsParityForMcpTool,
-  findSkillsParityForCliCommand,
-  findSkillRun,
-  findSimilarSkills,
-  findPortableSkill,
-  exportSkillsLocalSnapshot,
-  ensureProjectConfig,
-  enableSkill,
-  disableSkill,
-  destinationFor,
-  describeMcpToolContracts,
-  createSkillsSnapshotSyncRecord,
-  createSkillsS3ObjectStore,
-  createSkillsPostgresSyncStore,
-  createSkillToolDependencies,
-  createSkillRun,
-  createSkillMcpMetadata,
-  createRemoteSkillsClient,
-  createRegistrySyncArtifact,
-  createMcpContractManifest,
-  createLocalSkillManifest,
-  configuredSkillsApiUrl,
-  computeContentHashFromEntries,
-  computeContentHash,
-  completeSkillRun,
-  clearRegistryCache,
-  canonicalizeManifest,
-  buildSkillsS3ObjectUrl,
-  buildSkillsApiUrl,
-  appendRunEvent,
-  agentGlobalSkillsDir,
-  addSchedule,
-  adaptSkillMdForAgent,
-  WorkspaceLeaveInputError,
-  WorkspaceInvitationInputError,
-  WorkspaceIdentityMismatchError,
-  WorkspaceContextInputError,
-  TOOL_PRIMITIVE_SCHEMA_VERSION,
-  TOOL_PRIMITIVES,
-  StationSnapshotError,
-  SkillsS3ObjectStore,
-  SkillsPostgresSyncStore,
-  SkillsFleetCredentialError,
-  SYNC_MARKER_MANAGED_BY,
-  SYNC_MARKER_FILE,
-  SYNC_HOMES,
-  SYNC_AGENTS,
-  STORAGE_TABLES,
-  STATION_SYNC_MANIFEST_SCHEMA,
-  STATION_HYDRATION_MANIFEST_SCHEMA,
-  SKILL_SYSTEM_DEPS_ALLOWLIST,
-  SKILL_SANDBOX_MODES,
-  SKILL_RUNTIMES,
-  SKILL_ALIASES,
-  SKILLS_STORAGE_TABLES,
-  SKILLS_STORAGE_FALLBACK_ENV,
-  SKILLS_STORAGE_ENV,
-  SKILLS_PROJECT_DIR,
-  SKILLS_NATIVE_STORAGE_FALLBACK_ENV,
-  SKILLS_NATIVE_STORAGE_ENV,
-  SKILLS_LOCAL_OPT_IN_ENV_KEYS,
-  SKILLS_CLI_MCP_PARITY,
-  SKILLS_APP,
-  SKILLS_API_URL_ENV_KEYS,
-  SKILLS_API_URL_ENV,
-  SKILLS_API_KEY_ENV_KEYS,
-  SKILLS_API_KEY_ENV,
-  SKILLS,
-  RemoteWorkspaceSelectionError,
-  RemoteWorkspaceMemberError,
-  RemoteWorkspaceLeaveUnconfirmedError,
-  RemoteWorkspaceLeaveError,
-  RemoteWorkspaceInvitationUnconfirmedError,
-  RemoteWorkspaceInvitationReadError,
-  RemoteWorkspaceInvitationError,
-  RemoteSkillsClient,
-  RemoteSkillsAuthClient,
-  RemoteRouteUnsupportedError,
-  RemoteRequestError,
-  RemoteInvitationEmailUnconfirmedError,
-  RemoteInvitationEmailError,
-  RemoteCreditApprovalError,
-  RemoteCapabilityUnavailableError,
-  REMOTE_SKILL_RUN_CONTRACT_VERSION,
-  REFUSED_SCANNER_FLAGGED,
-  PullSkillError,
-  PROJECT_CONFIG_FILE,
-  PORTABLE_SKILL_STANDARD,
-  PORTABLE_SKILL_SCHEMA,
-  PORTABLE_SKILL_DEFAULT_VERSION,
-  MissingSkillsFleetError,
-  MCP_CONTRACT_SCHEMA_VERSION,
-  InvitationEmailInputError,
-  HostedApiError,
-  DEFAULT_EXPORT_DIR,
-  ContentHashInputError,
-  CONTENT_HASH_LIMITS,
-  CATEGORIES,
-  BASIC_SKILL_NAMES,
+  AGENT_TARGETS,
   ARTICLE_GENERATION_SLUG,
-  AGENT_TARGETS
+  BASIC_SKILL_NAMES,
+  CATEGORIES,
+  CONTENT_HASH_LIMITS,
+  ContentHashInputError,
+  DEFAULT_EXPORT_DIR,
+  HostedApiError,
+  InvitationEmailInputError,
+  MCP_CONTRACT_SCHEMA_VERSION,
+  MissingSkillsFleetError,
+  PORTABLE_SKILL_DEFAULT_VERSION,
+  PORTABLE_SKILL_SCHEMA,
+  PORTABLE_SKILL_STANDARD,
+  PROJECT_CONFIG_FILE,
+  PullSkillError,
+  REFUSED_SCANNER_FLAGGED,
+  REMOTE_SKILL_RUN_CONTRACT_VERSION,
+  RemoteCapabilityUnavailableError,
+  RemoteCreditApprovalError,
+  RemoteInvitationEmailError,
+  RemoteInvitationEmailUnconfirmedError,
+  RemoteQuoteUnavailableError,
+  RemoteRequestError,
+  RemoteRouteUnsupportedError,
+  RemoteSkillsAuthClient,
+  RemoteSkillsClient,
+  RemoteWorkspaceInvitationError,
+  RemoteWorkspaceInvitationReadError,
+  RemoteWorkspaceInvitationUnconfirmedError,
+  RemoteWorkspaceLeaveError,
+  RemoteWorkspaceLeaveUnconfirmedError,
+  RemoteWorkspaceMemberError,
+  RemoteWorkspaceSelectionError,
+  SKILLS,
+  SKILLS_API_KEY_ENV,
+  SKILLS_API_KEY_ENV_KEYS,
+  SKILLS_API_URL_ENV,
+  SKILLS_API_URL_ENV_KEYS,
+  SKILLS_APP,
+  SKILLS_CLI_MCP_PARITY,
+  SKILLS_LOCAL_OPT_IN_ENV_KEYS,
+  SKILLS_NATIVE_STORAGE_ENV,
+  SKILLS_NATIVE_STORAGE_FALLBACK_ENV,
+  SKILLS_PROJECT_DIR,
+  SKILLS_STORAGE_ENV,
+  SKILLS_STORAGE_FALLBACK_ENV,
+  SKILLS_STORAGE_TABLES,
+  SKILL_ALIASES,
+  SKILL_RUNTIMES,
+  SKILL_SANDBOX_MODES,
+  SKILL_SYSTEM_DEPS_ALLOWLIST,
+  STATION_HYDRATION_MANIFEST_SCHEMA,
+  STATION_SYNC_MANIFEST_SCHEMA,
+  STORAGE_TABLES,
+  SYNC_AGENTS,
+  SYNC_HOMES,
+  SYNC_MARKER_FILE,
+  SYNC_MARKER_MANAGED_BY,
+  SkillsFleetCredentialError,
+  SkillsPostgresSyncStore,
+  SkillsS3ObjectStore,
+  StationSnapshotError,
+  TOOL_PRIMITIVES,
+  TOOL_PRIMITIVE_SCHEMA_VERSION,
+  WorkspaceContextInputError,
+  WorkspaceIdentityMismatchError,
+  WorkspaceInvitationInputError,
+  WorkspaceLeaveInputError,
+  adaptSkillMdForAgent,
+  addSchedule,
+  agentGlobalSkillsDir,
+  appendRunEvent,
+  buildSkillsApiUrl,
+  buildSkillsS3ObjectUrl,
+  canonicalizeManifest,
+  clearRegistryCache,
+  completeSkillRun,
+  computeContentHash,
+  computeContentHashFromEntries,
+  configuredSkillsApiUrl,
+  createLocalSkillManifest,
+  createMcpContractManifest,
+  createRegistrySyncArtifact,
+  createRemoteSkillsClient,
+  createSkillMcpMetadata,
+  createSkillRun,
+  createSkillToolDependencies,
+  createSkillsPostgresSyncStore,
+  createSkillsS3ObjectStore,
+  createSkillsSnapshotSyncRecord,
+  describeMcpToolContracts,
+  destinationFor,
+  disableSkill,
+  enableSkill,
+  ensureProjectConfig,
+  exportSkillsLocalSnapshot,
+  findPortableSkill,
+  findSimilarSkills,
+  findSkillRun,
+  findSkillsParityForCliCommand,
+  findSkillsParityForMcpTool,
+  generateEnvExample,
+  generateSkillMd,
+  getAgentSkillPath,
+  getAgentSkillsDir,
+  getAllTags,
+  getCompactSkillDiscovery,
+  getConfigPath,
+  getConfiguredApiUrl,
+  getDisabledProjectSkills,
+  getDisabledSkills,
+  getDueSchedules,
+  getFeedbackDbPath,
+  getInstallMeta,
+  getInstalledSkills,
+  getMcpResourceContracts,
+  getMcpToolDescriptions,
+  getNextRun,
+  getPinnedSkills,
+  getPortableSkillPath,
+  getPortableSkillsRoot,
+  getProjectConfigPath,
+  getProjectStateDir,
+  getPublicSkillDiscovery,
+  getRunExportDir,
+  getSkill,
+  getSkillBestDoc,
+  getSkillDocs,
+  getSkillPath,
+  getSkillRequirements,
+  getSkillToolDependencies,
+  getSkillsByCategory,
+  getSkillsByTag,
+  getSkillsNativeStorageStatus,
+  getSkillsStorageDatabaseEnv,
+  getSkillsStorageDatabaseUrl,
+  getSkillsStorageStatus,
+  getStorageDatabaseEnv,
+  getStorageDatabaseUrl,
+  getStorageStatus,
+  getToolPrimitive,
+  homePathFor,
+  importSkillsLocalSnapshot,
+  installSkill,
+  installSkillForAgent,
+  installSkillManifest,
+  installSkillSource,
+  installSkills,
+  isBasicSkillName,
+  isExcludedSkillFileName,
+  isGatewayBackedSkill,
+  isPortableWithinSkill,
+  isRegularFile,
+  isSkillsLocalOptIn,
+  isSyncAgent,
+  listMcpToolContracts,
+  listPinnedSkills,
+  listPortableSkillMetas,
+  listPortableSkills,
+  listSchedules,
+  listSkillRuns,
+  listToolPrimitives,
+  loadBasicRegistry,
+  loadConfig,
+  loadProjectConfig,
+  loadRegistry,
+  loadRegistryProfile,
+  loadRemoteRegistry,
+  loadRemoteSkill,
+  normalizeLineEndings,
+  normalizePortableSkillName,
+  normalizeRemoteSkillRunContract,
+  normalizeSkillSlug,
+  normalizeSkillsApiOrigin,
+  noticeLocalSkillsMode,
+  parseRemoteRegistryPayload,
+  parseRemoteSkillPayload,
+  parseSkillFrontmatter,
+  pinProjectSkill,
+  pinSkill,
+  planSkillsS3SnapshotUpload,
+  planStationHydration,
+  planStationSnapshot,
+  pointerSkillMd,
+  portPortableSkill,
+  portPortableSkillDirectory,
+  publicDiscoveryDependencies,
+  publicDiscoveryDocumentation,
+  publicDiscoveryEnvVars,
+  pullSkills,
+  readPortableSkillManifest,
+  recordScheduleRun,
+  removeManagedAgentSkill,
+  removeSchedule,
+  removeSkill,
+  removeSkillForAgent,
+  requireSkillsApiKey,
+  requireSkillsApiOrigin,
+  requireSkillsFleet,
+  resolveSkillAlias,
+  resolveSkillsApiKey,
+  resolveSkillsApiOrigin,
+  resolveSkillsFleet,
+  resolveSkillsNativeStorageConfig,
+  resolveStorageConfig,
+  resolveSyncAgents,
+  revisionIdOf,
+  runPortableSkill,
+  runSkill,
+  sanitizePublicDiscoveryText,
+  saveConfig,
+  saveFeedback,
+  saveProjectConfig,
+  scaffoldPortableSkill,
+  searchSkills,
+  selectsSkillsLocalMode,
+  setScheduleEnabled,
+  setSkillDisabled,
+  sha256File,
+  signSkillsAwsV4Request,
+  skillExists,
+  skillsCredentialFilePath,
+  skillsCredentialFiles,
+  skillsCredentialOrReason,
+  skillsPostgresSyncSchemaSql,
+  storageCapabilities,
+  summarizeMcpToolContract,
+  syncSkillsToAgents,
+  unpinProjectSkill,
+  unpinSkill,
+  unsetConfig,
+  updateSkillRun,
+  uploadSkillsSnapshotFilesToS3,
+  validateBlogArticleRunOptions,
+  validateCron,
+  validatePortableManifestContract,
+  validatePortableSkillDirectory,
+  validateRegistryConsistency,
+  validateSkillDirectory,
+  validateSkillsCliMcpParity,
+  validateStationId,
+  validateToolPrimitiveCoverage,
+  verifyContentHash,
+  verifyContentHashFromEntries,
+  walkEntries,
+  writeCorpusSkill,
+  writeManagedAgentSkill,
+  writeManagedSkillDir,
+  writeRegistrySyncArtifact,
+  writeRunLogs,
+  writeStationHydration,
+  writeStationSnapshot
 };