@work-shape/catalyst-asset-schemas 0.0.0-stage → 0.8.0-rc.2

package/dist/index.js

@@ -0,0 +1,1200 @@
+// src/asset-types.ts
+var localeCodes = ["en", "de"];
+var REASONING_EFFORTS = ["none", "low", "medium", "high", "xhigh", "max"];
+var SKILL_STARTERS_MAX = 2;
+var AGENT_STARTERS_MAX = 4;
+var SKILL_STARTER_LINE_MAX_LENGTH = 60;
+var SKILL_SUMMARY_MAX_LENGTH = 120;
+var SKILL_ORIGINS = ["instance", "release"];
+var SKILL_RESOURCE_MEDIA_TYPES = [
+  "text/markdown",
+  "text/plain",
+  "application/json",
+  "application/yaml"
+];
+
+// src/contract-values.ts
+var AUTH_SCOPE_WILDCARD = "*";
+var CHAT_SESSION_AUTH_SCOPES = [
+  "me:read",
+  "me:delete",
+  "config:read",
+  "conversation:read",
+  "conversation:write",
+  "run:start",
+  "run:observe",
+  "run:cancel",
+  "run:command"
+];
+var FIRST_PARTY_AUTH_SCOPES = [
+  AUTH_SCOPE_WILDCARD,
+  ...CHAT_SESSION_AUTH_SCOPES,
+  "collaboration_workspace:read",
+  "collaboration_workspace:manage",
+  "me:write",
+  "governance:read",
+  "governance:write",
+  "user_admin:read",
+  "user_admin:write",
+  "api_access:read",
+  "api_access:write",
+  "config_assets:read",
+  "config_assets:write",
+  // Moving the published pointer of an asset. A credential that writes drafts with
+  // `config_assets:write` publishes none of them without this one.
+  "config_assets:publish",
+  "config_assets:release",
+  // The rows of a Data Store: reading them, and adding or loading them. The definition of a
+  // store and its migrations stay under `config_assets:*`. A scope caps what a key may be
+  // used for; whether its holder may do it is decided by the grants.
+  "data_store_rows:read",
+  "data_store_rows:write"
+];
+var ACTIONS = [
+  "agent.read",
+  "agent.write",
+  "agent.delete",
+  "skill.read",
+  "skill.write",
+  "skill.delete",
+  "skill.approve",
+  "connection.read",
+  "connection.use",
+  "connection.write",
+  "connection.delete",
+  "connection.approve",
+  "app.read",
+  "app.write",
+  "app.publish",
+  "app.approve",
+  "app.delete",
+  "app.use",
+  "workflow.read",
+  "workflow.write",
+  "workflow.publish",
+  "workflow.approve",
+  "workflow.delete",
+  "workflow.use",
+  "workflow.read_run_data",
+  "data_store.read",
+  "data_store.write",
+  "data_store.publish",
+  "data_store.delete",
+  "data_store.insert",
+  "data_store.execute",
+  "knowledge_base.read",
+  "knowledge_base.write",
+  "knowledge_base.publish",
+  "knowledge_base.delete",
+  "knowledge_base.use",
+  "guardrail.read",
+  "guardrail.write",
+  "guardrail.publish",
+  "guardrail.delete",
+  "operations.approve",
+  "users.manage",
+  "usage.view",
+  "audit.view",
+  "api_access.manage",
+  // Creating service principals, giving and taking their rights, enabling and disabling them.
+  // Their keys stay with `api_access.manage`.
+  "service_principals.manage",
+  "agent_models.manage",
+  "assets.release"
+];
+var NAMESPACE_PREFIX_PATTERN = /^[a-z][a-z0-9]*(-[a-z0-9]+)*-$/u;
+var NAMESPACE_PREFIX_MIN_LENGTH = 2;
+var NAMESPACE_PREFIX_MAX_LENGTH = 32;
+var APP_ERROR_STATUS_CODES = {
+  BAD_REQUEST: 400,
+  UNAUTHENTICATED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  CONFLICT: 409,
+  REVISION_CONFLICT: 412,
+  PRECONDITION_REQUIRED: 428,
+  TIMEOUT: 504,
+  VALIDATION_FAILED: 422,
+  RATE_LIMITED: 429,
+  POLICY_DENIED: 403,
+  GUARDRAIL_BLOCKED: 403,
+  DECLINED: 403,
+  IDEMPOTENCY_KEY_REUSED: 409,
+  OPERATION_IN_PROGRESS: 409,
+  OPERATION_EXPIRED: 409,
+  OUTPUT_NOT_RETAINED: 409,
+  INTERNAL: 500
+};
+var IDEMPOTENCY_KEY_MAX_LENGTH = 255;
+var PROVIDER_PORTS = ["models", "mail", "objectStorage", "sandbox", "secrets"];
+var PROVIDER_REGIONS = ["eu", "global"];
+var PROVIDER_CHECK_ERROR_CLASSES = [
+  "unreachable",
+  "timeout",
+  "access_denied",
+  "not_found",
+  // The bucket an object store is configured with does not exist. The check creates none.
+  "bucket_missing",
+  "rejected",
+  "failed"
+];
+var CONNECTION_NAME_PATTERN = /^[a-z][a-z0-9]*([_-][a-z0-9]+)*$/u;
+var CONNECTION_NAME_MAX_LENGTH = 64;
+var GUARDRAIL_NAME_PATTERN = /^[a-z][a-z0-9]*([_-][a-z0-9]+)*$/u;
+var GUARDRAIL_NAME_MAX_LENGTH = 64;
+var CONNECTION_EXPOSURES = ["agent", "bridge", "workflow", "outside"];
+var CONNECTION_HEALTH_STATES = [
+  "unknown",
+  "ok",
+  "failed",
+  "needs_configuration",
+  "secret_unreadable"
+];
+var GRANT_HOLDER_KINDS = ["user", "service_principal", "role", "group"];
+var GRANT_SCOPE_KINDS = ["instance", "workspace", "namespace", "asset"];
+var GRANT_EFFECTS = ["allow", "deny"];
+var ACCESS_SOURCES = ["role", "legacy_ref", "grant", "membership"];
+var POLICY_VALUES = ["allow", "confirm", "approval", "deny"];
+var AUTH_PRINCIPAL_KINDS = ["user", "service"];
+var ADMINISTERED_USER_STATUSES = ["active", "disabled", "deleting"];
+var SERVICE_PRINCIPAL_STATUSES = ["active", "disabled"];
+var SERVICE_PRINCIPAL_PERMISSIONS = [
+  "config_assets.read",
+  "config_assets.release"
+];
+var API_CREDENTIAL_SCOPES = [
+  "config_assets:read",
+  "config_assets:release"
+];
+var APP_ERROR_CODES = [
+  "BAD_REQUEST",
+  "UNAUTHENTICATED",
+  "FORBIDDEN",
+  "NOT_FOUND",
+  "CONFLICT",
+  "REVISION_CONFLICT",
+  "PRECONDITION_REQUIRED",
+  "TIMEOUT",
+  "VALIDATION_FAILED",
+  "RATE_LIMITED",
+  "POLICY_DENIED",
+  "GUARDRAIL_BLOCKED",
+  "DECLINED",
+  "IDEMPOTENCY_KEY_REUSED",
+  "OPERATION_IN_PROGRESS",
+  "OPERATION_EXPIRED",
+  "OUTPUT_NOT_RETAINED",
+  "INTERNAL"
+];
+var OPERATION_EFFECTS = ["reading", "changing"];
+var OPERATION_TARGETS = ["live", "test", "dry_run"];
+var OPERATION_RUN_STATUSES = [
+  "running",
+  "pending_confirmation",
+  "pending_approval",
+  "done",
+  "failed",
+  "denied",
+  "expired"
+];
+var OPERATION_ORIGIN_KINDS = [
+  "agent",
+  "user",
+  "cli",
+  "mcp",
+  "app",
+  "workflow",
+  "schedule"
+];
+var OPERATION_RUN_DECISION_MODES = [
+  "direct",
+  "confirmed",
+  "approved",
+  "declined"
+];
+var OPERATION_RUN_DECISION_REASONS = [
+  "inherited_approval_not_applied",
+  "workflow_publish",
+  "approved_by_caller"
+];
+var OPERATION_DENIAL_REASONS = [
+  "no_grant",
+  "denied",
+  "unknown_action",
+  "holder_inactive",
+  "holder_not_administrable",
+  "user_only",
+  "outside_key_scope"
+];
+var APPROVAL_REQUEST_STATUSES = [
+  "pending",
+  "approved",
+  "rejected",
+  "changes_requested",
+  "superseded",
+  "withdrawn",
+  "reverted"
+];
+var APPROVAL_CHECK_STATUSES = ["passed", "warned", "blocked"];
+var APPROVAL_EXECUTIONS = [
+  "queued",
+  "done",
+  "failed",
+  "interrupted",
+  "refused",
+  "expired"
+];
+var SKILL_CHANGE_TYPES = ["replace", "add", "new_resource"];
+var GUARDRAIL_OUTCOMES = ["allow", "warn", "require_approval", "block"];
+var APP_MODES = ["published", "draft"];
+var ASSET_NAME_REFUSAL_REASONS = ["name_invalid", "name_taken"];
+var ASSET_SYNC_CHANGE_TYPES = ["put", "delete"];
+var ASSET_LIFECYCLES = ["active", "draft_published"];
+var ASSET_REPRESENTATIONS = ["config", "files"];
+var CONFIG_ASSET_KINDS = ["agent", "skill"];
+var CONFIG_ASSET_CHANGE_OPERATIONS = ["create", "update", "delete", "revert"];
+var AGENT_AVAILABILITY_MODES = ["all", "selected"];
+var AGENT_EDITABLE_FIELDS = [
+  "displayName",
+  "description",
+  "welcomeMessage",
+  "welcomeSubtitle",
+  "instructions",
+  "modelBindingId",
+  "reasoningEffort",
+  "maxSteps",
+  "toolNames",
+  "skillNames",
+  "knowledgeBases",
+  "initialPrompts"
+];
+var ASSET_REPO_BUNDLE_KINDS = ["full", "incremental"];
+var WORKSPACE_FILE_KINDS = ["page", "upload", "generated_file"];
+var WORKSPACE_VISIBILITIES = ["discoverable", "private"];
+var WORKSPACE_MEMBERSHIP_ROLES = ["owner", "admin", "member"];
+var WORKSPACE_ACCENT_COLORS = [
+  "garnet",
+  "ruby",
+  "mahogany",
+  "copper",
+  "amber",
+  "olive",
+  "jade",
+  "emerald",
+  "teal",
+  "turquoise",
+  "azure",
+  "sapphire",
+  "indigo",
+  "violet",
+  "magenta",
+  "rose",
+  "stone",
+  "slate"
+];
+var COLLABORATION_WORKSPACE_KINDS = ["personal", "shared"];
+var WORKSPACE_ACCESS_STATES = ["member", "request_pending", "can_request"];
+var DELETION_STATES = ["deleting", "deleted"];
+var WORKSPACE_SECTIONS = ["agents", "apps"];
+var MODEL_USAGE_TIERS = [
+  "very_low",
+  "low",
+  "moderate",
+  "elevated",
+  "high",
+  "very_high"
+];
+var THEME_MODE_PREFERENCES = ["light", "dark", "system"];
+var TOOL_GROUPS = [
+  "documents",
+  "web",
+  "files",
+  "results",
+  "skills",
+  "platform",
+  "instance"
+];
+var INFRASTRUCTURE_SECRET_STATES = ["set", "missing"];
+var INFRASTRUCTURE_WITHHELD_FIELDS = ["endpointHost", "bucket"];
+var OPENAI_COMPATIBLE_APIS = ["chat_completions", "responses"];
+var MODEL_PROVIDER_AUTH_MODES = ["bearer", "api-key"];
+var CONVERSATION_VISIBILITIES = ["workspace", "private"];
+var WEB_SOURCE_PROVIDERS = [
+  "openai-native",
+  "serper",
+  "tavily",
+  "firecrawl",
+  "browserbase",
+  "direct"
+];
+var CHAT_MESSAGE_ROLES = ["user", "assistant", "system", "tool"];
+var CONVERSATION_ATTACHMENT_STATUSES = [
+  "queued",
+  "preprocessing",
+  "ready",
+  "failed",
+  "unsupported",
+  "deleted"
+];
+var ATTACHMENT_CREATE_OUTCOMES = ["created", "already_available"];
+var STRUCTURED_DATA_REVIEW_REASONS = ["uncertain", "conflicting"];
+var AGENT_RUN_STATUSES = [
+  "queued",
+  "running",
+  "waiting_for_decision",
+  "cancelling",
+  "completed",
+  "cancelled",
+  "failed"
+];
+var AGENT_RUN_FAILURE_CATEGORIES = [
+  "app_error",
+  "internal_error",
+  "runtime_interrupted",
+  "abort_error",
+  "unknown_error"
+];
+var TOOL_INPUT_PARSE_ERROR_CODES = ["invalid_json", "invalid_text"];
+var WAITING_OPERATION_RUN_STATUSES = [
+  "pending_confirmation",
+  "pending_approval"
+];
+var OPERATION_CONFIRMATION_DECISIONS = ["confirm", "decline"];
+var TOOL_DECISION_MODES = ["confirm", "approval"];
+var TOOL_DECISION_OUTCOMES = ["confirmed", "declined", "expired", "cancelled"];
+var TOOL_CALL_STATES = [
+  "input_available",
+  "waiting_for_decision",
+  "output_available",
+  "output_error"
+];
+var SUPPORTED_IMAGE_MIME_TYPES = [
+  "image/png",
+  "image/jpeg",
+  "image/webp",
+  "image/gif"
+];
+var ARTIFACT_PREVIEW_IMAGE_FORMATS = ["png", "webp", "jpeg"];
+var ARTIFACT_PREVIEW_STATUSES = ["ready", "pending", "failed", "unsupported"];
+var WORKSPACE_COMMAND_STATUSES = [
+  "queued",
+  "running",
+  "cancelling",
+  "completed",
+  "failed",
+  "cancelled"
+];
+var TOOL_DISPLAY_MODES = ["inline", "side_panel", "fullscreen"];
+var JOB_STATUSES = [
+  "queued",
+  "running",
+  "succeeded",
+  "failed",
+  "dead",
+  "cancelled"
+];
+var AUDIT_ACTOR_KINDS = ["user", "assistant", "service", "system"];
+var AUDIT_TIERS = ["governance", "workflow", "runtime", "telemetry"];
+var AUDIT_OUTCOMES = ["success", "failed", "denied", "warning"];
+var MODEL_USAGE_EVENT_STATUSES = ["pending", "settled", "failed", "abandoned"];
+var MODEL_USAGE_SOURCES = ["provider_reported", "not_reported", "estimated"];
+var USAGE_COST_STATUSES = ["settled", "incomplete", "unpriced"];
+var CONNECTION_OPERATION_STATUSES = [
+  "ready",
+  "awaiting_discovery",
+  "needs_review",
+  "unknown",
+  "disabled"
+];
+var CONNECTION_SECRET_STATES = ["set", "not_set", "unreadable"];
+var CONNECTOR_TEST_STATUSES = [
+  "ready",
+  "unauthorized",
+  "network_denied",
+  "unavailable"
+];
+var CONNECTION_ORIGINS = ["release", "runtime"];
+var CONNECTION_NETWORKS = ["public", "private"];
+var DATA_STORE_SCALAR_TYPES = [
+  "text",
+  "integer",
+  "number",
+  "boolean",
+  "date",
+  "timestamp"
+];
+var DATA_STORE_LOAD_CONFLICT_MODES = ["fail", "skip", "update"];
+var DATA_STORE_INSERT_CONFLICT_MODES = [
+  "fail",
+  "skip"
+];
+var DATA_STORE_CONDITIONS = [
+  "server_databases_open",
+  "sessions_open",
+  "temp_files_unbounded"
+];
+var DATA_STORE_STATUSES = ["provisioning", "ready", "retired"];
+var DATA_STORE_MIGRATION_OUTCOMES = ["none", "pending", "applied", "failed"];
+var KNOWLEDGE_BASE_STATUSES = ["unchecked", "ok", "needs_attention"];
+var DATABASE_RELATION_TYPES = [
+  "table",
+  "view",
+  "materialized_view",
+  "foreign_table"
+];
+var WORKFLOW_RUN_STATUSES = [
+  "queued",
+  "running",
+  "waiting",
+  "done",
+  "failed",
+  "cancelled",
+  "limit_reached"
+];
+var WORKFLOW_STEP_TYPES = [
+  "trigger",
+  "operation",
+  "loop",
+  "code",
+  "output",
+  "agent",
+  "notify",
+  "workflow"
+];
+var WORKFLOW_RESERVED_STEP_TYPES = ["condition", "parallel"];
+var WORKFLOW_TRIGGER_KINDS = ["manual", "schedule", "parent"];
+var NOTIFY_CHANNELS = ["inbox", "mail"];
+var PRINCIPAL_HOLDER_KINDS = [
+  "user",
+  "service_principal"
+];
+var ASSET_OWNER_KINDS = [
+  "instance",
+  "workspace"
+];
+var READING_POLICY_VALUES = ["allow", "deny"];
+var CONNECTION_OPERATION_POLICIES = [
+  "deny",
+  "approval"
+];
+var WORKFLOW_RUN_MODES = ["live", "test"];
+var APP_ACTION_CALL_STATUSES = [
+  "done",
+  "pending_approval"
+];
+var OPERATIONS_AUDIENCES = [
+  "workflow",
+  "app"
+];
+var DECIDED_APPROVAL_REQUEST_STATUSES = [
+  "approved",
+  "rejected",
+  "changes_requested",
+  "superseded",
+  "withdrawn",
+  "reverted"
+];
+var ENDED_APPROVAL_EXECUTIONS = [
+  "done",
+  "failed",
+  "interrupted",
+  "refused",
+  "expired"
+];
+var GUARDRAIL_HIT_OUTCOMES = [
+  "warn",
+  "require_approval",
+  "block"
+];
+var APPROVAL_CHECK_FAILURE_OUTCOMES = [
+  "warn",
+  "block"
+];
+var THEME_MODES = ["light", "dark"];
+var USER_STATUSES = [
+  "active",
+  "disabled"
+];
+var MESSAGE_FINISH_STATUSES = [
+  "completed",
+  "cancelled"
+];
+var ENDED_AGENT_RUN_STATUSES = [
+  "completed",
+  "cancelled",
+  "failed"
+];
+var ACTIVE_AGENT_RUN_STATUSES = [
+  "queued",
+  "running",
+  "waiting_for_decision",
+  "cancelling"
+];
+var ARTIFACT_PREVIEW_IMAGE_MIME_TYPES = [
+  "image/png",
+  "image/jpeg",
+  "image/webp"
+];
+var LIVE_JOB_STATUSES = ["queued", "running"];
+var FAILED_JOB_STATUSES = ["failed", "dead"];
+var AUDIT_EVENT_STATUSES = [
+  "success",
+  "failed",
+  "denied"
+];
+var LISTED_DATA_STORE_STATUSES = [
+  "provisioning",
+  "ready"
+];
+var KNOWLEDGE_CHECK_STATUSES = [
+  "ok",
+  "needs_attention"
+];
+var WORKFLOW_STEP_RUN_STATUSES = [
+  "queued",
+  "running",
+  "waiting",
+  "done",
+  "failed",
+  "cancelled"
+];
+var WORKFLOW_ENDED_STATUSES = [
+  "done",
+  "failed",
+  "cancelled",
+  "limit_reached"
+];
+
+// src/schemas.ts
+import { z } from "zod";
+
+// src/yaml-bounds.ts
+function yamlValueIssue(value, maxDepth = Number.POSITIVE_INFINITY) {
+  const seen = /* @__PURE__ */ new Set();
+  const open = [{ value, depth: 0 }];
+  let deepest = 0;
+  for (let next = open.pop(); next !== void 0; next = open.pop()) {
+    if (typeof next.value !== "object" || next.value === null) continue;
+    if (seen.has(next.value)) return "alias";
+    seen.add(next.value);
+    deepest = Math.max(deepest, next.depth + 1);
+    for (const child of Array.isArray(next.value) ? next.value : Object.values(next.value)) {
+      open.push({ value: child, depth: next.depth + 1 });
+    }
+  }
+  return deepest > maxDepth ? "depth" : void 0;
+}
+function yamlValueIssueSentence(issue, maxDepth) {
+  return issue === "alias" ? "it uses a YAML anchor with an alias or a merge key, which is not read: write the value out where it is used" : `it nests deeper than ${maxDepth ?? "its reader takes"} levels`;
+}
+
+// src/schemas.ts
+var localizedStringMapSchema = z.object({
+  en: z.string().min(1).optional(),
+  de: z.string().min(1).optional()
+}).strict().refine((value) => value.en !== void 0 || value.de !== void 0, {
+  message: "At least one localized value is required"
+});
+var localizedStringSchema = z.union([z.string().min(1), localizedStringMapSchema]);
+var SKILL_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_.-]*$/u;
+var SKILL_NAME_RULE = "Skill name must start with a letter or a number and contain only letters, numbers, dots, underscores, or hyphens";
+var SKILL_PORTABLE_NAME_MAX_CHARS = 64;
+var SKILL_PORTABLE_DESCRIPTION_MAX_CHARS = 1024;
+var SKILL_PORTABLE_NAME_PATTERN = /^[a-z0-9]+(-[a-z0-9]+)*$/u;
+function skillPortabilityIssues(skill) {
+  const issues = [];
+  if (typeof skill.name === "string" && (!SKILL_PORTABLE_NAME_PATTERN.test(skill.name) || skill.name.length > SKILL_PORTABLE_NAME_MAX_CHARS)) {
+    issues.push({
+      code: "skill_name_not_portable",
+      message: `The name '${skill.name}' is outside the public skill convention: lowercase letters, digits and single hyphens, at most ${SKILL_PORTABLE_NAME_MAX_CHARS} characters. The skill works here and may not be taken as it is elsewhere.`
+    });
+  }
+  if (typeof skill.description === "string" && skill.description.length > SKILL_PORTABLE_DESCRIPTION_MAX_CHARS) {
+    issues.push({
+      code: "skill_description_not_portable",
+      message: `The description has ${skill.description.length} characters. The public skill convention takes at most ${SKILL_PORTABLE_DESCRIPTION_MAX_CHARS}.`
+    });
+  }
+  return issues;
+}
+var skillNameSchema = z.string().min(1).regex(SKILL_NAME_PATTERN, { message: SKILL_NAME_RULE });
+var skillResourcePathSchema = z.string().min(1).superRefine((path, context) => {
+  const segments = path.split("/");
+  if (path.startsWith("/") || /^[A-Za-z]:/u.test(path) || path.includes("\\") || /[\u0000-\u001f\u007f]/u.test(path) || segments.some((segment) => segment === "" || segment === "." || segment === "..")) {
+    context.addIssue({
+      code: "custom",
+      message: "Skill resource path must be a normalized relative path"
+    });
+  }
+  if (path.toLowerCase() === "skill.md" || path.toLowerCase().endsWith("/skill.md")) {
+    context.addIssue({
+      code: "custom",
+      message: "SKILL.md is the skill root and cannot also be a resource"
+    });
+  }
+});
+function skillResourceMediaTypeForPath(path) {
+  const extension = path.slice(path.lastIndexOf(".")).toLowerCase();
+  switch (extension) {
+    case ".md":
+      return "text/markdown";
+    case ".txt":
+      return "text/plain";
+    case ".json":
+      return "application/json";
+    case ".yaml":
+    case ".yml":
+      return "application/yaml";
+    default:
+      return void 0;
+  }
+}
+var skillResourceConfigSchema = z.object({
+  path: skillResourcePathSchema,
+  mediaType: z.enum(SKILL_RESOURCE_MEDIA_TYPES),
+  content: z.string().refine((content) => !content.includes("\0"), {
+    message: "Skill resources must contain text, not binary data"
+  })
+}).superRefine((resource, context) => {
+  const expectedMediaType = skillResourceMediaTypeForPath(resource.path);
+  if (!expectedMediaType) {
+    context.addIssue({
+      code: "custom",
+      path: ["path"],
+      message: "Unsupported skill resource extension"
+    });
+  } else if (resource.mediaType !== expectedMediaType) {
+    context.addIssue({
+      code: "custom",
+      path: ["mediaType"],
+      message: `Skill resource '${resource.path}' must use media type '${expectedMediaType}'`
+    });
+  }
+});
+var starterLineSchema = localizedStringSchema.refine(
+  (value) => (typeof value === "string" ? [value] : Object.values(value)).every(
+    (line) => line.length <= SKILL_STARTER_LINE_MAX_LENGTH && !/[\r\n]/u.test(line)
+  ),
+  { message: `Must be one line of at most ${SKILL_STARTER_LINE_MAX_LENGTH} characters` }
+);
+var skillStarterSchema = z.strictObject({
+  title: starterLineSchema,
+  hint: starterLineSchema.optional(),
+  prompt: localizedStringSchema,
+  tools: z.array(z.string().min(1)).optional()
+});
+var SKILL_FRONTMATTER_MAX_BYTES = 8192;
+var SKILL_FRONTMATTER_MAX_DEPTH = 8;
+var SKILL_FRONTMATTER_FIELDS = [
+  "name",
+  "title",
+  "description",
+  "summary",
+  "starters"
+];
+var skillFileEntrySchema = z.object({
+  path: z.string().min(1),
+  sha256: z.string().regex(/^[0-9a-f]{64}$/u),
+  bytes: z.number().int().min(0),
+  mediaType: z.string().min(1)
+});
+var skillConfigObjectSchema = z.object({
+  name: skillNameSchema,
+  title: z.string().min(1),
+  description: z.string().min(1),
+  summary: z.string().min(1).max(SKILL_SUMMARY_MAX_LENGTH, {
+    message: `Skill summary must be at most ${SKILL_SUMMARY_MAX_LENGTH} characters`
+  }).refine((summary) => !/[\r\n]/u.test(summary), {
+    message: "Skill summary must be one line"
+  }).optional(),
+  starters: z.array(skillStarterSchema).max(SKILL_STARTERS_MAX, {
+    message: `A skill carries at most ${SKILL_STARTERS_MAX} starters`
+  }).optional(),
+  content: z.string().min(1),
+  resources: z.array(skillResourceConfigSchema).optional(),
+  files: z.array(skillFileEntrySchema).optional(),
+  frontmatter: z.record(z.string(), z.unknown()).optional().refine(
+    (frontmatter) => frontmatter === void 0 || yamlValueIssue(frontmatter, SKILL_FRONTMATTER_MAX_DEPTH) === void 0 && JSON.stringify(frontmatter).length <= SKILL_FRONTMATTER_MAX_BYTES,
+    {
+      message: `Skill frontmatter holds at most ${SKILL_FRONTMATTER_MAX_BYTES} characters as JSON, nested at most ${SKILL_FRONTMATTER_MAX_DEPTH} levels`
+    }
+  ),
+  origin: z.literal("release").optional(),
+  icon: z.string().min(1).optional()
+});
+var skillConfigSchema = skillConfigObjectSchema.superRefine((skill, context) => {
+  for (const key of SKILL_FRONTMATTER_FIELDS) {
+    if (skill.frontmatter && Object.hasOwn(skill.frontmatter, key)) {
+      context.addIssue({
+        code: "custom",
+        path: ["frontmatter", key],
+        message: `Skill frontmatter cannot hold '${key}': it is a field of the skill itself`
+      });
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, resource] of (skill.resources ?? []).entries()) {
+    const pathKey = resource.path.toLowerCase();
+    if (seen.has(pathKey)) {
+      context.addIssue({
+        code: "custom",
+        path: ["resources", index, "path"],
+        message: `Duplicate skill resource path: ${resource.path}`
+      });
+    }
+    seen.add(pathKey);
+  }
+});
+var skillFileFrontmatterSchema = z.looseObject({
+  name: skillNameSchema.optional(),
+  title: z.string().min(1).optional(),
+  description: z.string().min(1),
+  summary: skillConfigObjectSchema.shape.summary,
+  starters: skillConfigObjectSchema.shape.starters
+});
+var welcomeSubtitleSchema = z.union([
+  z.string(),
+  z.object({
+    en: z.string().optional(),
+    de: z.string().optional()
+  }).strict().refine((value) => value.en !== void 0 || value.de !== void 0, {
+    message: "At least one localized value is required"
+  })
+]);
+var agentNameSchema = z.string().min(1).refine((name) => name !== "." && name !== "..", {
+  message: "Agent name must not be '.' or '..'"
+});
+var agentConfigSchema = z.object({
+  name: agentNameSchema,
+  displayName: localizedStringSchema,
+  description: localizedStringSchema.optional(),
+  welcomeMessage: localizedStringSchema.optional(),
+  welcomeSubtitle: welcomeSubtitleSchema.optional(),
+  instructions: z.string().min(1),
+  modelProviderId: z.string().min(1).optional(),
+  modelBindingId: z.string().min(1).optional(),
+  reasoningEffort: z.enum(REASONING_EFFORTS).optional(),
+  fastMode: z.boolean().optional(),
+  userSelectableModelBindingIds: z.array(z.string().min(1)).optional(),
+  modelReasoningEfforts: z.record(z.string().min(1), z.enum(REASONING_EFFORTS)).optional(),
+  maxSteps: z.number().int().positive().optional(),
+  toolNames: z.array(z.string().min(1)).default([]),
+  skillNames: z.array(skillNameSchema).default([]),
+  knowledgeBases: z.array(z.string().min(1)).refine((names) => new Set(names).size === names.length, {
+    message: "A Knowledge Base is listed once"
+  }).optional(),
+  initialPrompts: z.array(
+    z.object({
+      title: localizedStringSchema,
+      prompt: localizedStringSchema
+    })
+  ).default([])
+});
+var WORKFLOW_NAME_PATTERN = /^[a-z][a-z0-9_-]{0,62}$/u;
+var WORKFLOW_NAME_RULE = "A Workflow id starts with a lowercase letter and holds lowercase letters, digits, '_' and '-', at most 63 characters";
+var workflowConfigSchema = z.strictObject({
+  name: z.string(),
+  manifest: z.looseObject({
+    id: z.string(),
+    name: z.string().min(1),
+    description: z.string().optional()
+  }),
+  files: z.array(z.strictObject({ path: z.string(), content: z.string() })).optional()
+});
+
+// src/skill-markdown.ts
+import yaml from "js-yaml";
+
+// src/yaml-data.ts
+import { JSON_SCHEMA, YAMLException, load } from "js-yaml";
+var YAML_DATA_MAX_VALUES = 1e5;
+function isStorableText(text) {
+  return !text.includes("\0") && !/\p{Surrogate}/u.test(text);
+}
+function checkStorableTexts(value, maxValues) {
+  const pending = [value];
+  for (let seen = 1; pending.length > 0; seen += 1) {
+    if (seen > maxValues) return "too_large";
+    const next = pending.pop();
+    if (typeof next === "string") {
+      if (!isStorableText(next)) return "unstorable";
+    } else if (Array.isArray(next)) {
+      for (const entry of next) pending.push(entry);
+    } else if (typeof next === "object" && next !== null) {
+      for (const [key, entry] of Object.entries(next)) {
+        if (!isStorableText(key)) return "unstorable";
+        pending.push(entry);
+      }
+    }
+  }
+  return "storable";
+}
+function readYamlData(text, file, options = {}) {
+  const fail = (code, message, line, column) => ({
+    ok: false,
+    issue: {
+      code,
+      message,
+      ...line === void 0 ? {} : { line },
+      ...column === void 0 ? {} : { column }
+    }
+  });
+  let value;
+  try {
+    value = load(text, { schema: JSON_SCHEMA, filename: file });
+  } catch (error) {
+    if (error instanceof YAMLException) {
+      const markLine = error.mark?.line;
+      const line = markLine === void 0 ? void 0 : markLine + 1;
+      const markColumn = error.mark?.column;
+      const column = markColumn === void 0 ? void 0 : markColumn + 1;
+      return error.reason.startsWith("nesting exceeded") ? fail("yaml_too_deep", `'${file}' ${error.reason}.`, line) : fail("yaml_invalid", `'${file}' is not valid YAML: ${error.reason}.`, line, column);
+    }
+    throw error;
+  }
+  if (options.refuseAliases && yamlValueIssue(value) === "alias") {
+    return fail("yaml_alias", `'${file}' is not read: ${yamlValueIssueSentence("alias")}.`);
+  }
+  const texts = checkStorableTexts(value, YAML_DATA_MAX_VALUES);
+  if (texts === "too_large") {
+    return fail(
+      "yaml_too_large",
+      `'${file}' holds more than ${YAML_DATA_MAX_VALUES} values once its aliases are followed (YAML_DATA_MAX_VALUES).`
+    );
+  }
+  if (texts === "unstorable") {
+    return fail(
+      "text_invalid",
+      `'${file}' holds a NUL character or half of a surrogate pair, which cannot be stored.`
+    );
+  }
+  return { ok: true, value };
+}
+var YamlDataError = class extends Error {
+  issue;
+  constructor(issue) {
+    super(issue.message);
+    this.name = "YamlDataError";
+    this.issue = issue;
+  }
+};
+function loadYamlData(text, file) {
+  const read = readYamlData(text, file);
+  if (!read.ok) throw new YamlDataError(read.issue);
+  return read.value;
+}
+
+// src/skill-markdown.ts
+var SkillMarkdownError = class extends Error {
+  details;
+  reason;
+  constructor(message, details, reason) {
+    super(message);
+    this.name = "SkillMarkdownError";
+    this.details = details;
+    this.reason = reason;
+  }
+};
+function parseSkillMarkdown(contents, skillFile, skillPath) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/u.exec(contents);
+  if (!match) {
+    throw new SkillMarkdownError(`Skill file '${skillFile}' must start with YAML frontmatter`);
+  }
+  const frontmatterRaw = loadFrontmatter(match[1] ?? "", skillFile);
+  if (yamlValueIssue(frontmatterRaw, SKILL_FRONTMATTER_MAX_DEPTH) === "depth") {
+    throw new SkillMarkdownError(
+      `Skill file '${skillFile}' frontmatter is not read: ${yamlValueIssueSentence("depth", SKILL_FRONTMATTER_MAX_DEPTH)}`,
+      void 0,
+      "skill_frontmatter_too_deep"
+    );
+  }
+  const frontmatter = skillFileFrontmatterSchema.safeParse(frontmatterRaw);
+  if (!frontmatter.success) {
+    throw new SkillMarkdownError(`Skill file '${skillFile}' frontmatter is invalid`, {
+      issues: frontmatter.error.issues
+    });
+  }
+  const content = (match[2] ?? "").trim();
+  const { name: named, title, description, summary, starters, ...others } = frontmatter.data;
+  const name = named ?? deriveSkillName(skillPath);
+  const json = JSON.stringify(others);
+  if (json.length > SKILL_FRONTMATTER_MAX_BYTES) {
+    throw new SkillMarkdownError(
+      `Skill file '${skillFile}' holds ${json.length} characters of frontmatter beside the fields of the skill (${SKILL_FRONTMATTER_FIELDS.join(", ")}). It holds at most ${SKILL_FRONTMATTER_MAX_BYTES} (SKILL_FRONTMATTER_MAX_BYTES)`,
+      void 0,
+      "skill_frontmatter_too_large"
+    );
+  }
+  const kept = JSON.parse(json);
+  return {
+    name,
+    title: title ?? deriveSkillTitle(name, content),
+    description,
+    ...summary === void 0 ? {} : { summary },
+    ...starters === void 0 ? {} : { starters },
+    content,
+    ...Object.keys(others).length > 0 ? { frontmatter: kept } : {}
+  };
+}
+function loadFrontmatter(text, skillFile) {
+  const read = readYamlData(text, skillFile, { refuseAliases: true });
+  if (read.ok) return read.value;
+  const { issue } = read;
+  if (issue.code === "yaml_alias") {
+    throw new SkillMarkdownError(
+      `Skill file '${skillFile}' frontmatter is not read: ${yamlValueIssueSentence("alias")}`,
+      void 0,
+      "skill_frontmatter_alias"
+    );
+  }
+  if (issue.code === "yaml_too_deep") {
+    throw new SkillMarkdownError(
+      `Skill file '${skillFile}' frontmatter is not read: ${yamlValueIssueSentence("depth", SKILL_FRONTMATTER_MAX_DEPTH)}`,
+      void 0,
+      "skill_frontmatter_too_deep"
+    );
+  }
+  if (issue.code !== "yaml_invalid" || issue.line === void 0 || issue.column === void 0) {
+    throw new SkillMarkdownError(`Skill file '${skillFile}' frontmatter: ${issue.message}`);
+  }
+  const line = issue.line + 1;
+  const { column } = issue;
+  throw new SkillMarkdownError(
+    `Skill file '${skillFile}' frontmatter is not valid YAML at line ${line}, column ${column}: ${issue.message} A value that holds a colon and a space, as a description often does, is written in quotes: description: "Use this when: the user asks"`,
+    { issues: [{ message: issue.message, path: [], line, column }] }
+  );
+}
+function deriveSkillTitle(name, content) {
+  let fence;
+  for (const line of content.split(/\r?\n/u)) {
+    const marker = /^\s{0,3}(`{3,}|~{3,})/u.exec(line)?.[1];
+    if (marker) {
+      fence = fence === void 0 ? marker : marker.startsWith(fence) ? void 0 : fence;
+      continue;
+    }
+    const heading = fence === void 0 ? /^ {0,3}#{1,6}\s+(.+?)(?:\s+#+)?\s*$/u.exec(line) : null;
+    if (heading?.[1]) return heading[1];
+  }
+  const words = name.replace(/[-_]+/gu, " ").trim();
+  return words === "" ? name : words.charAt(0).toUpperCase() + words.slice(1);
+}
+function formatSkillMarkdown(skill) {
+  const content = skill.content.trim();
+  const frontmatter = yaml.dump(
+    {
+      name: skill.name,
+      ...skill.title === deriveSkillTitle(skill.name, content) ? {} : { title: skill.title },
+      description: skill.description,
+      ...skill.summary === void 0 ? {} : { summary: skill.summary },
+      ...skill.starters === void 0 ? {} : { starters: skill.starters },
+      ...skill.frontmatter
+    },
+    { lineWidth: -1, noCompatMode: true, noRefs: true, sortKeys: false }
+  );
+  return `---
+${frontmatter}---
+
+${content}
+`;
+}
+function deriveSkillName(skillPath) {
+  const filename = lastSegment(skillPath);
+  const sourceName = filename.toLowerCase() === "skill.md" ? lastSegment(parentPath(skillPath)) : withoutExtension(filename);
+  return sourceName.trim().toLowerCase().replace(/[^a-z0-9]+/gu, "_").replace(/^_+|_+$/gu, "");
+}
+function withoutTrailingSeparators(path) {
+  let end = path.length;
+  while (end > 0 && path[end - 1] === "/") {
+    end -= 1;
+  }
+  return path.slice(0, end);
+}
+function lastSegment(path) {
+  const trimmed = withoutTrailingSeparators(path);
+  return trimmed.slice(trimmed.lastIndexOf("/") + 1);
+}
+function parentPath(path) {
+  const trimmed = withoutTrailingSeparators(path);
+  return trimmed.slice(0, Math.max(trimmed.lastIndexOf("/"), 0));
+}
+function withoutExtension(filename) {
+  const dot = filename.lastIndexOf(".");
+  return dot > 0 ? filename.slice(0, dot) : filename;
+}
+export {
+  ACCESS_SOURCES,
+  ACTIONS,
+  ACTIVE_AGENT_RUN_STATUSES,
+  ADMINISTERED_USER_STATUSES,
+  AGENT_AVAILABILITY_MODES,
+  AGENT_EDITABLE_FIELDS,
+  AGENT_RUN_FAILURE_CATEGORIES,
+  AGENT_RUN_STATUSES,
+  AGENT_STARTERS_MAX,
+  API_CREDENTIAL_SCOPES,
+  APPROVAL_CHECK_FAILURE_OUTCOMES,
+  APPROVAL_CHECK_STATUSES,
+  APPROVAL_EXECUTIONS,
+  APPROVAL_REQUEST_STATUSES,
+  APP_ACTION_CALL_STATUSES,
+  APP_ERROR_CODES,
+  APP_ERROR_STATUS_CODES,
+  APP_MODES,
+  ARTIFACT_PREVIEW_IMAGE_FORMATS,
+  ARTIFACT_PREVIEW_IMAGE_MIME_TYPES,
+  ARTIFACT_PREVIEW_STATUSES,
+  ASSET_LIFECYCLES,
+  ASSET_NAME_REFUSAL_REASONS,
+  ASSET_OWNER_KINDS,
+  ASSET_REPO_BUNDLE_KINDS,
+  ASSET_REPRESENTATIONS,
+  ASSET_SYNC_CHANGE_TYPES,
+  ATTACHMENT_CREATE_OUTCOMES,
+  AUDIT_ACTOR_KINDS,
+  AUDIT_EVENT_STATUSES,
+  AUDIT_OUTCOMES,
+  AUDIT_TIERS,
+  AUTH_PRINCIPAL_KINDS,
+  AUTH_SCOPE_WILDCARD,
+  CHAT_MESSAGE_ROLES,
+  CHAT_SESSION_AUTH_SCOPES,
+  COLLABORATION_WORKSPACE_KINDS,
+  CONFIG_ASSET_CHANGE_OPERATIONS,
+  CONFIG_ASSET_KINDS,
+  CONNECTION_EXPOSURES,
+  CONNECTION_HEALTH_STATES,
+  CONNECTION_NAME_MAX_LENGTH,
+  CONNECTION_NAME_PATTERN,
+  CONNECTION_NETWORKS,
+  CONNECTION_OPERATION_POLICIES,
+  CONNECTION_OPERATION_STATUSES,
+  CONNECTION_ORIGINS,
+  CONNECTION_SECRET_STATES,
+  CONNECTOR_TEST_STATUSES,
+  CONVERSATION_ATTACHMENT_STATUSES,
+  CONVERSATION_VISIBILITIES,
+  DATABASE_RELATION_TYPES,
+  DATA_STORE_CONDITIONS,
+  DATA_STORE_INSERT_CONFLICT_MODES,
+  DATA_STORE_LOAD_CONFLICT_MODES,
+  DATA_STORE_MIGRATION_OUTCOMES,
+  DATA_STORE_SCALAR_TYPES,
+  DATA_STORE_STATUSES,
+  DECIDED_APPROVAL_REQUEST_STATUSES,
+  DELETION_STATES,
+  ENDED_AGENT_RUN_STATUSES,
+  ENDED_APPROVAL_EXECUTIONS,
+  FAILED_JOB_STATUSES,
+  FIRST_PARTY_AUTH_SCOPES,
+  GRANT_EFFECTS,
+  GRANT_HOLDER_KINDS,
+  GRANT_SCOPE_KINDS,
+  GUARDRAIL_HIT_OUTCOMES,
+  GUARDRAIL_NAME_MAX_LENGTH,
+  GUARDRAIL_NAME_PATTERN,
+  GUARDRAIL_OUTCOMES,
+  IDEMPOTENCY_KEY_MAX_LENGTH,
+  INFRASTRUCTURE_SECRET_STATES,
+  INFRASTRUCTURE_WITHHELD_FIELDS,
+  JOB_STATUSES,
+  KNOWLEDGE_BASE_STATUSES,
+  KNOWLEDGE_CHECK_STATUSES,
+  LISTED_DATA_STORE_STATUSES,
+  LIVE_JOB_STATUSES,
+  MESSAGE_FINISH_STATUSES,
+  MODEL_PROVIDER_AUTH_MODES,
+  MODEL_USAGE_EVENT_STATUSES,
+  MODEL_USAGE_SOURCES,
+  MODEL_USAGE_TIERS,
+  NAMESPACE_PREFIX_MAX_LENGTH,
+  NAMESPACE_PREFIX_MIN_LENGTH,
+  NAMESPACE_PREFIX_PATTERN,
+  NOTIFY_CHANNELS,
+  OPENAI_COMPATIBLE_APIS,
+  OPERATIONS_AUDIENCES,
+  OPERATION_CONFIRMATION_DECISIONS,
+  OPERATION_DENIAL_REASONS,
+  OPERATION_EFFECTS,
+  OPERATION_ORIGIN_KINDS,
+  OPERATION_RUN_DECISION_MODES,
+  OPERATION_RUN_DECISION_REASONS,
+  OPERATION_RUN_STATUSES,
+  OPERATION_TARGETS,
+  POLICY_VALUES,
+  PRINCIPAL_HOLDER_KINDS,
+  PROVIDER_CHECK_ERROR_CLASSES,
+  PROVIDER_PORTS,
+  PROVIDER_REGIONS,
+  READING_POLICY_VALUES,
+  REASONING_EFFORTS,
+  SERVICE_PRINCIPAL_PERMISSIONS,
+  SERVICE_PRINCIPAL_STATUSES,
+  SKILL_CHANGE_TYPES,
+  SKILL_FRONTMATTER_FIELDS,
+  SKILL_FRONTMATTER_MAX_BYTES,
+  SKILL_FRONTMATTER_MAX_DEPTH,
+  SKILL_NAME_PATTERN,
+  SKILL_NAME_RULE,
+  SKILL_ORIGINS,
+  SKILL_PORTABLE_DESCRIPTION_MAX_CHARS,
+  SKILL_PORTABLE_NAME_MAX_CHARS,
+  SKILL_RESOURCE_MEDIA_TYPES,
+  SKILL_STARTERS_MAX,
+  SKILL_STARTER_LINE_MAX_LENGTH,
+  SKILL_SUMMARY_MAX_LENGTH,
+  STRUCTURED_DATA_REVIEW_REASONS,
+  SUPPORTED_IMAGE_MIME_TYPES,
+  SkillMarkdownError,
+  THEME_MODES,
+  THEME_MODE_PREFERENCES,
+  TOOL_CALL_STATES,
+  TOOL_DECISION_MODES,
+  TOOL_DECISION_OUTCOMES,
+  TOOL_DISPLAY_MODES,
+  TOOL_GROUPS,
+  TOOL_INPUT_PARSE_ERROR_CODES,
+  USAGE_COST_STATUSES,
+  USER_STATUSES,
+  WAITING_OPERATION_RUN_STATUSES,
+  WEB_SOURCE_PROVIDERS,
+  WORKFLOW_ENDED_STATUSES,
+  WORKFLOW_NAME_PATTERN,
+  WORKFLOW_NAME_RULE,
+  WORKFLOW_RESERVED_STEP_TYPES,
+  WORKFLOW_RUN_MODES,
+  WORKFLOW_RUN_STATUSES,
+  WORKFLOW_STEP_RUN_STATUSES,
+  WORKFLOW_STEP_TYPES,
+  WORKFLOW_TRIGGER_KINDS,
+  WORKSPACE_ACCENT_COLORS,
+  WORKSPACE_ACCESS_STATES,
+  WORKSPACE_COMMAND_STATUSES,
+  WORKSPACE_FILE_KINDS,
+  WORKSPACE_MEMBERSHIP_ROLES,
+  WORKSPACE_SECTIONS,
+  WORKSPACE_VISIBILITIES,
+  YAML_DATA_MAX_VALUES,
+  YamlDataError,
+  agentConfigSchema,
+  checkStorableTexts,
+  deriveSkillTitle,
+  formatSkillMarkdown,
+  isStorableText,
+  loadYamlData,
+  localeCodes,
+  localizedStringSchema,
+  parseSkillMarkdown,
+  readYamlData,
+  skillConfigSchema,
+  skillFileEntrySchema,
+  skillFileFrontmatterSchema,
+  skillNameSchema,
+  skillPortabilityIssues,
+  skillResourceConfigSchema,
+  skillResourceMediaTypeForPath,
+  skillResourcePathSchema,
+  skillStarterSchema,
+  workflowConfigSchema,
+  yamlValueIssue,
+  yamlValueIssueSentence
+};