@skaile/workspaces 5.4.0 → 5.6.0

package/dist/chunk-FRHE7FFB.js

@@ -0,0 +1,655 @@
+import * as z2 from 'zod';
+
+// types/src/manifests/_shared.ts
+var ArtifactRefSchema = z2.object({
+  id: z2.string().min(1),
+  description: z2.string().optional(),
+  gate: z2.enum(["hard", "soft"]).optional(),
+  path: z2.string().optional()
+});
+var FilePrerequisiteSchema = z2.object({
+  path: z2.string().min(1),
+  gate: z2.enum(["hard", "soft"]).optional(),
+  description: z2.string().optional()
+});
+var UserInputSchema = z2.looseObject({
+  key: z2.string().min(1).optional(),
+  id: z2.string().min(1).optional(),
+  label: z2.string().optional(),
+  prompt: z2.string().optional(),
+  type: z2.string().optional(),
+  required: z2.boolean().optional(),
+  options: z2.array(z2.string()).optional(),
+  values: z2.array(z2.union([z2.string(), z2.number()])).optional(),
+  default: z2.union([z2.string(), z2.number(), z2.boolean(), z2.array(z2.union([z2.string(), z2.number()]))]).optional(),
+  hint: z2.string().optional()
+});
+var FieldSchema = z2.object({
+  key: z2.string().min(1),
+  label: z2.string().optional(),
+  required: z2.boolean().optional(),
+  sensitive: z2.boolean().optional(),
+  type: z2.string().optional(),
+  default: z2.union([z2.string(), z2.number(), z2.boolean()]).optional()
+});
+var CommonMetadataSchema = z2.looseObject({
+  version: z2.string().optional(),
+  author: z2.string().optional(),
+  tags: z2.array(z2.string()).optional(),
+  stage: z2.enum(["alpha", "beta", "stable", "deprecated"]).optional(),
+  source: z2.string().optional(),
+  do_not_invoke: z2.boolean().optional()
+});
+var BaseFrontmatterSchema = z2.object({
+  name: z2.string().min(1),
+  description: z2.string().min(1),
+  version: z2.string().optional(),
+  // Catalog identity (populated at discovery or authoring time)
+  publisher: z2.string().optional(),
+  category: z2.string().optional(),
+  license: z2.string().optional(),
+  keywords: z2.array(z2.string()).optional()
+});
+function validateManifest(schema, data) {
+  const result = schema.safeParse(data);
+  if (result.success) {
+    return { ok: true, data: result.data };
+  }
+  return {
+    ok: false,
+    errors: result.error.issues.map((issue) => ({
+      path: issue.path.join("."),
+      message: issue.message
+    }))
+  };
+}
+
+// types/src/manifests/agent-composition.ts
+var CONVENTION_FILES = [
+  { file: "SOUL.md", kind: "soul", binding: "inline-snapshot" },
+  { file: "RULES.md", kind: "ruleset", binding: "inline-live" },
+  { file: "DUTIES.md", kind: "prompt", binding: "inline-live" }
+];
+var KNOWLEDGE_DIR = "knowledge";
+var stripDotSlash = (ref) => ref.replace(/^\.\//, "").replace(/\/+$/, "");
+function conventionItems(entries) {
+  const present = [...entries].map(stripDotSlash);
+  const items = [];
+  for (const { file, kind, binding } of CONVENTION_FILES) {
+    if (present.includes(file)) items.push({ kind, ref: `./${file}`, binding });
+  }
+  if (present.some((p) => p === KNOWLEDGE_DIR || p.startsWith(`${KNOWLEDGE_DIR}/`))) {
+    items.push({ kind: "knowledge", ref: `./${KNOWLEDGE_DIR}`, binding: "discoverable" });
+  }
+  return items;
+}
+function effectiveComposes(composes, entries) {
+  const declared = composes ?? [];
+  const key = (item) => `${item.kind}\0${stripDotSlash(item.ref)}`;
+  const declaredKeys = new Set(declared.map(key));
+  const implicit = conventionItems(entries).filter((item) => !declaredKeys.has(key(item)));
+  return [...implicit, ...declared];
+}
+var DEPRECATED_TOP_LEVEL = [
+  { field: "skills", replacement: "composes: [{ kind: skill, ref }]" },
+  { field: "abilities", replacement: "composes: [{ kind: skill, ref }]" },
+  { field: "contracts", replacement: "composes: [{ kind: contract, ref }]" },
+  { field: "persona", replacement: "composes: [{ kind: persona, ref }] or SOUL.md" },
+  { field: "rules", replacement: "composes: [{ kind: ruleset, ref }] or RULES.md" },
+  { field: "knowledge", replacement: "composes: [{ kind: knowledge, ref }] or knowledge/" },
+  { field: "requires", replacement: "composes: [{ kind: agent, ref, binding: delegate }]" },
+  { field: "dependencies", replacement: "composes: [{ kind, ref }]" }
+];
+var DEPRECATED_METADATA = [
+  { field: "soul", replacement: "SOUL.md or composes: [{ kind: persona, ref }]" },
+  { field: "orchestrates", replacement: "composes: [{ kind: skill|agent, ref }]" },
+  { field: "routes_to", replacement: "composes: [{ kind: agent, ref, binding: delegate }]" },
+  { field: "knows", replacement: "composes: [{ kind: knowledge, ref }]" }
+];
+function agentDeprecationDiagnostics(parsed) {
+  if (parsed === null || typeof parsed !== "object") return [];
+  const manifest = parsed;
+  const out = [];
+  for (const { field, replacement } of DEPRECATED_TOP_LEVEL) {
+    if (manifest[field] === void 0) continue;
+    out.push({
+      code: `deprecated_agent_${field}`,
+      severity: "warning",
+      message: `agent.yaml field "${field}" is deprecated and no longer read; use ${replacement}`,
+      path: field
+    });
+  }
+  const metadata = manifest.metadata;
+  if (metadata !== null && typeof metadata === "object") {
+    for (const { field, replacement } of DEPRECATED_METADATA) {
+      if (metadata[field] === void 0) continue;
+      out.push({
+        code: `deprecated_agent_metadata_${field}`,
+        severity: "warning",
+        message: `agent.yaml field "metadata.${field}" is deprecated and no longer read; use ${replacement}`,
+        path: `metadata.${field}`
+      });
+    }
+  }
+  return out;
+}
+function composeSlotDiagnostics(parsed) {
+  if (parsed === null || typeof parsed !== "object") return [];
+  const composes = parsed.composes;
+  if (!Array.isArray(composes)) return [];
+  const firstSeen = /* @__PURE__ */ new Map();
+  const out = [];
+  composes.forEach((item, i) => {
+    if (item === null || typeof item !== "object") return;
+    const id = item.id;
+    if (typeof id !== "string") return;
+    const first = firstSeen.get(id);
+    if (first === void 0) {
+      firstSeen.set(id, i);
+      return;
+    }
+    out.push({
+      code: "composition_conflict",
+      severity: "error",
+      message: `composes slot id "${id}" is already used by composes[${first}]`,
+      path: `composes[${i}].id`
+    });
+  });
+  return out;
+}
+var ANTHROPIC_MODEL_ALIASES = ["inherit", "opus", "sonnet", "haiku"];
+var ANTHROPIC_MODEL_FAMILIES = ["opus", "sonnet", "haiku", "fable"];
+var FAMILY_ALT = ANTHROPIC_MODEL_FAMILIES.join("|");
+var FAMILY_VERSION_CORE = `(?:(?:${FAMILY_ALT})-\\d+(?:[-.]\\d+)*|\\d+(?:[-.]\\d+)*-(?:${FAMILY_ALT}))`;
+var ANTHROPIC_FULL_ID_PATTERN = new RegExp(
+  `^(?:[a-z0-9-]+\\/)?claude-${FAMILY_VERSION_CORE}(?:-\\d{8})?$`
+);
+var BEDROCK_MODEL_ID_PATTERN = new RegExp(
+  `^(?:(?:us|eu|apac|global)\\.)?anthropic\\.claude-${FAMILY_VERSION_CORE}(?:-\\d{8})?(?:-v\\d+(?::\\d+)?)?$`
+);
+var VERTEX_MODEL_ID_PATTERN = new RegExp(`^claude-${FAMILY_VERSION_CORE}@\\d{8}$`);
+var ModelIdSchema = z2.union([
+  z2.enum(ANTHROPIC_MODEL_ALIASES),
+  z2.string().regex(
+    ANTHROPIC_FULL_ID_PATTERN,
+    "Invalid Anthropic model ID. Use an alias (opus | sonnet | haiku | inherit), a full ID (e.g. claude-opus-5, claude-sonnet-4-6), a Bedrock ID (e.g. us.anthropic.claude-opus-4-6-v1:0), or a Vertex ID (e.g. claude-sonnet-4-5@20250929)."
+  ),
+  z2.string().regex(BEDROCK_MODEL_ID_PATTERN),
+  z2.string().regex(VERTEX_MODEL_ID_PATTERN)
+]);
+var ANTHROPIC_FIRST_PARTY_HOSTS = ["api.anthropic.com"];
+function isFirstPartyAnthropicEndpoint(baseUrl) {
+  if (!baseUrl) return true;
+  let host;
+  try {
+    host = new URL(baseUrl).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  return ANTHROPIC_FIRST_PARTY_HOSTS.includes(host);
+}
+function requiresAnthropicModelId(target) {
+  if (!target) return true;
+  if (target.surface !== "anthropic-messages") return false;
+  if ((target.transport ?? "direct") !== "direct") return false;
+  return isFirstPartyAnthropicEndpoint(target.base_url);
+}
+var FreeFormModelIdSchema = z2.string().regex(/^\S+$/, "Model ID must be a non-empty string with no whitespace.");
+function modelIdSchemaForTarget(target) {
+  return requiresAnthropicModelId(target) ? ModelIdSchema : FreeFormModelIdSchema;
+}
+function modelIdSchemaForCloud(cloud) {
+  return !cloud || cloud === "default" ? modelIdSchemaForTarget() : FreeFormModelIdSchema;
+}
+function normalizeAnthropicModel(input, fallback = "sonnet") {
+  if (!input) return fallback;
+  if (ANTHROPIC_MODEL_ALIASES.includes(input)) return input;
+  if (ANTHROPIC_FULL_ID_PATTERN.test(input)) return input;
+  if (BEDROCK_MODEL_ID_PATTERN.test(input) || VERTEX_MODEL_ID_PATTERN.test(input)) return input;
+  const familyMatch = input.match(/claude-(opus|sonnet|haiku)/i);
+  if (familyMatch) return familyMatch[1].toLowerCase();
+  return fallback;
+}
+var ModelSelectorSchema = z2.string().regex(
+  /^\S+$/,
+  'Model selector must be a non-empty string with no whitespace: "@role", "provider/model", a model ID, or an Anthropic alias.'
+);
+var ModelConfigSchema = z2.looseObject({
+  preferred: ModelSelectorSchema.optional(),
+  fallback: z2.array(ModelSelectorSchema).optional(),
+  constraints: z2.looseObject({
+    temperature: z2.number().optional(),
+    max_tokens: z2.number().optional()
+  }).optional()
+});
+var ContentBindingValues = ["discoverable", "inline-live", "inline-snapshot"];
+var AgentBindingValues = ["delegate", "run"];
+var BindingValues = [...ContentBindingValues, ...AgentBindingValues];
+var BindingSchema = z2.enum(BindingValues);
+var SLOT_ID_PATTERN = /^[a-z][a-z0-9_-]*$/;
+var SLOT_ID_REQUIRED_KINDS = {
+  connector: true,
+  "mcp-server": true
+};
+var SlotIdSchema = z2.string().regex(SLOT_ID_PATTERN, "id must match [a-z][a-z0-9_-]* (lowercase, starts with a letter)");
+var AgentComposeItemSchema = z2.object({
+  kind: z2.string().min(1),
+  ref: z2.string().min(1),
+  id: SlotIdSchema.optional(),
+  as: z2.string().regex(
+    SLOT_ID_PATTERN,
+    "as must match [a-z][a-z0-9_-]* (it names a rendered file: no path separators or dots)"
+  ).optional(),
+  instance: z2.string().optional(),
+  config: z2.record(z2.string(), z2.unknown()).optional(),
+  binding: BindingSchema.optional()
+}).superRefine((item, ctx) => {
+  if (item.kind === "memory" || item.kind === "trigger") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["kind"],
+      message: `"${item.kind}" is not a composes kind; declare ${item.kind === "memory" ? "memory" : "triggers"} as a top-level field`
+    });
+  }
+  if (Object.hasOwn(SLOT_ID_REQUIRED_KINDS, item.kind) && item.id === void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["id"],
+      message: `composes item of kind "${item.kind}" requires a slot id`
+    });
+  }
+  if (item.binding === void 0) return;
+  const isAgentBinding = AgentBindingValues.includes(item.binding);
+  if (item.kind === "agent" && !isAgentBinding) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["binding"],
+      message: `composes item of kind "agent" accepts binding "delegate" or "run", not "${item.binding}"`
+    });
+  } else if (item.kind !== "agent" && isAgentBinding) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["binding"],
+      message: `binding "${item.binding}" is only valid for kind "agent"`
+    });
+  }
+});
+var AgentToolsSchema = z2.looseObject({
+  /** Tool names the agent may invoke. Empty or absent means "no allowlist". */
+  allowed: z2.array(z2.string().min(1)).optional(),
+  /** Tool names the agent must not invoke. Applied after `allowed`. */
+  denied: z2.array(z2.string().min(1)).optional()
+});
+var AgentLifecycleValues = ["standing", "role"];
+var AgentLifecycleSchema = z2.enum(AgentLifecycleValues);
+var JsonSchemaObject = z2.record(z2.string(), z2.unknown());
+var AgentIoSchema = z2.looseObject({
+  input: JsonSchemaObject.optional(),
+  output: JsonSchemaObject.optional()
+});
+var MemoryScopeValues = ["instance", "user", "workspace"];
+var MemoryScopeSchema = z2.enum(MemoryScopeValues);
+var MemoryBlockSchema = z2.looseObject({
+  name: z2.string().regex(SLOT_ID_PATTERN, "block name must match [a-z][a-z0-9_-]*"),
+  scope: MemoryScopeSchema,
+  max_chars: z2.number().int().positive(),
+  /** Convention file the block is seeded from (e.g. `SOUL.md`). */
+  source: z2.string().min(1).optional()
+});
+var AgentMemorySchema = z2.looseObject({
+  blocks: z2.array(MemoryBlockSchema).optional(),
+  /** Hint only; the host decides. */
+  consolidation: z2.looseObject({
+    strategy: z2.string().min(1),
+    threshold: z2.number().int().positive().optional()
+  }).optional()
+});
+var TriggerIdSchema = z2.string().regex(SLOT_ID_PATTERN, "trigger id must match [a-z][a-z0-9_-]*");
+var AgentTriggerSchema = z2.discriminatedUnion("kind", [
+  z2.looseObject({
+    kind: z2.literal("schedule"),
+    id: TriggerIdSchema,
+    cron: z2.string().min(1),
+    prompt: z2.string().min(1),
+    timezone: z2.string().min(1).optional(),
+    enabled: z2.boolean().optional()
+  }),
+  z2.looseObject({
+    kind: z2.literal("webhook"),
+    id: TriggerIdSchema,
+    prompt: z2.string().min(1),
+    enabled: z2.boolean().optional()
+  }),
+  z2.looseObject({
+    kind: z2.literal("channel"),
+    id: TriggerIdSchema,
+    /** Which channel messages fire the trigger (e.g. `mention`). */
+    when: z2.string().min(1),
+    prompt: z2.string().min(1).optional(),
+    enabled: z2.boolean().optional()
+  }),
+  z2.looseObject({
+    kind: z2.literal("event"),
+    id: TriggerIdSchema,
+    /** Protocol / host event name (e.g. `session_error`). */
+    event: z2.string().min(1),
+    prompt: z2.string().min(1).optional(),
+    enabled: z2.boolean().optional()
+  })
+]);
+var AgentCapabilityRequirementSchema = z2.looseObject({
+  name: z2.string().min(1),
+  connector: SlotIdSchema.optional(),
+  required: z2.boolean().default(false)
+});
+var DeprecatedRequiresItemSchema = z2.looseObject({
+  name: z2.string(),
+  source: z2.string().optional(),
+  version: z2.string().optional()
+});
+var AgentManifestSchema = z2.looseObject({
+  spec_version: z2.string().optional(),
+  name: z2.string().min(1),
+  version: z2.string().optional(),
+  description: z2.string().min(1),
+  extends: z2.string().optional(),
+  model: ModelConfigSchema.optional(),
+  tools: AgentToolsSchema.optional(),
+  delegation: z2.looseObject({ mode: z2.string() }).optional(),
+  runtime: z2.looseObject({
+    max_turns: z2.number().optional(),
+    timeout: z2.number().optional(),
+    /** Role instances only: render the harness sub-agent as a background agent. */
+    background: z2.boolean().optional()
+  }).optional(),
+  author: z2.string().optional(),
+  license: z2.string().optional(),
+  tags: z2.array(z2.string()).optional(),
+  keywords: z2.array(z2.string()).optional(),
+  // spec 0.2
+  /** Default `standing`. */
+  lifecycle: AgentLifecycleSchema.optional(),
+  /** Required when `lifecycle: role`. */
+  io: AgentIoSchema.optional(),
+  memory: AgentMemorySchema.optional(),
+  triggers: z2.array(AgentTriggerSchema).optional(),
+  capabilities: z2.array(AgentCapabilityRequirementSchema).optional(),
+  composes: z2.array(AgentComposeItemSchema).optional(),
+  metadata: z2.record(z2.string(), z2.unknown()).optional(),
+  // Deprecated 0.1 inputs.
+  /** @deprecated Use `composes[{kind: skill}]`. */
+  skills: z2.array(z2.string()).optional(),
+  /** @deprecated Use `composes[{kind: skill}]`. */
+  abilities: z2.array(z2.string()).optional(),
+  /** @deprecated Use `composes[{kind: contract}]`. */
+  contracts: z2.array(z2.string()).optional(),
+  /** @deprecated Use `composes[{kind: persona}]`. */
+  persona: z2.array(z2.string()).optional(),
+  /** @deprecated Use `composes[{kind: ruleset}]`. */
+  rules: z2.array(z2.string()).optional(),
+  /** @deprecated Use `composes[{kind: knowledge}]`. */
+  knowledge: z2.array(z2.string()).optional(),
+  /** @deprecated Use `composes[{kind: agent}]`. */
+  requires: z2.array(DeprecatedRequiresItemSchema).optional()
+}).superRefine((manifest, ctx) => {
+  if (manifest.lifecycle === "role" && manifest.io === void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["io"],
+      message: 'lifecycle "role" requires an io block ({ input, output } JSON Schemas)'
+    });
+  }
+  addDuplicateIssues(
+    ctx,
+    "triggers",
+    (manifest.triggers ?? []).map((t) => t.id),
+    "trigger id"
+  );
+  addDuplicateIssues(
+    ctx,
+    "memory.blocks",
+    (manifest.memory?.blocks ?? []).map((b) => b.name),
+    "memory block name"
+  );
+});
+function addDuplicateIssues(ctx, field, values, label) {
+  const seen = /* @__PURE__ */ new Set();
+  values.forEach((value, i) => {
+    if (seen.has(value)) {
+      ctx.addIssue({
+        code: "custom",
+        path: [...field.split("."), i],
+        message: `duplicate ${label} "${value}"`
+      });
+    }
+    seen.add(value);
+  });
+}
+function validateAgent(data) {
+  return validateManifest(AgentManifestSchema, data);
+}
+var ConnectorManifestSchema = z2.looseObject({
+  name: z2.string().min(1),
+  description: z2.string().min(1),
+  version: z2.string().optional(),
+  entry: z2.string().min(1),
+  npm_deps: z2.object({
+    required: z2.array(z2.string()).optional(),
+    optional: z2.array(z2.string()).optional()
+  }).optional(),
+  fields: z2.array(FieldSchema).optional(),
+  health_check: z2.string().nullable().optional(),
+  keywords: z2.array(z2.string()).optional(),
+  license: z2.string().optional()
+});
+function validateConnector(data) {
+  return validateManifest(ConnectorManifestSchema, data);
+}
+var SkillMetadataSchema = CommonMetadataSchema.extend({
+  parameters: z2.record(z2.string(), z2.unknown()).optional(),
+  artifacts: z2.object({
+    requires: z2.array(ArtifactRefSchema).optional(),
+    produces: z2.array(ArtifactRefSchema).optional(),
+    consumes: z2.array(ArtifactRefSchema).optional()
+  }).optional(),
+  prerequisites: z2.object({
+    files: z2.array(FilePrerequisiteSchema).optional(),
+    inputs_required: z2.array(UserInputSchema).optional(),
+    inputs_optional: z2.array(UserInputSchema).optional(),
+    // Parsed by the resolver's parseSkillRequirements; Zod would strip them otherwise.
+    reads: z2.array(z2.object({ path: z2.string(), description: z2.string().optional() })).optional(),
+    produces: z2.array(z2.object({ path: z2.string(), description: z2.string().optional() })).optional(),
+    resources: z2.array(
+      z2.object({
+        id: z2.string(),
+        operations: z2.array(z2.string()).optional(),
+        optional: z2.boolean().optional(),
+        description: z2.string().optional()
+      })
+    ).optional(),
+    connectors: z2.array(
+      z2.object({
+        driver: z2.string(),
+        access: z2.enum(["read-only", "read-write"]).optional()
+      })
+    ).optional()
+  }).optional(),
+  produces: z2.array(z2.object({ path: z2.string(), description: z2.string().optional() })).optional()
+});
+var SKILL_DESCRIPTION_PLACEHOLDER_PREFIX = "TODO:";
+var SKILL_DESCRIPTION_PLACEHOLDER = `${SKILL_DESCRIPTION_PLACEHOLDER_PREFIX} describe what this skill does and when to use it.`;
+var SKILL_BODY_PLACEHOLDER = "Skill prompt goes here.";
+var SkillManifestSchema = z2.looseObject({
+  name: z2.string().min(1),
+  description: z2.string().refine((d) => d.trim().length > 0, {
+    message: "description is empty \u2014 say what the skill does and when to use it (Agent Skills spec: 1\u20131024 chars)"
+  }).refine((d) => !d.trim().startsWith(SKILL_DESCRIPTION_PLACEHOLDER_PREFIX), {
+    message: `description is still the scaffold placeholder (${SKILL_DESCRIPTION_PLACEHOLDER_PREFIX} \u2026) \u2014 say what the skill does and when to use it`
+  }),
+  version: z2.string().optional(),
+  license: z2.string().optional(),
+  compatibility: z2.string().optional(),
+  keywords: z2.array(z2.string()).optional(),
+  // agentskills.io standard field. Kept as `unknown` (not `string`) so a legacy
+  // array form never hard-fails validateSkill — the string-typing rule is
+  // advisory, owned by checkAgentSkillConformance (warn, not error).
+  "allowed-tools": z2.unknown().optional(),
+  // Legacy fields (SKILL.md convention)
+  source: z2.string().optional(),
+  user_inputs: z2.array(UserInputSchema).optional(),
+  reads_from: z2.array(z2.string()).optional(),
+  writes_to: z2.array(z2.string()).optional(),
+  metadata: SkillMetadataSchema.optional()
+});
+function validateSkill(data) {
+  return validateManifest(SkillManifestSchema, data);
+}
+var ContractManifestSchema = z2.looseObject({
+  name: z2.string().min(1),
+  description: z2.string().min(1),
+  version: z2.string().optional(),
+  keywords: z2.array(z2.string()).optional(),
+  license: z2.string().optional(),
+  metadata: CommonMetadataSchema.optional()
+});
+function validateContract(data) {
+  return validateManifest(ContractManifestSchema, data);
+}
+var McpServerManifestSchema = z2.looseObject({
+  name: z2.string().min(1),
+  description: z2.string().min(1),
+  version: z2.union([z2.string(), z2.number()]).optional(),
+  // "http" is the runtime literal the runner honours (StreamableHTTPClientTransport);
+  // "streamable-http" is accepted as an MCP-spec-aligned alias and normalized to
+  // "http" in mcpDeclFromCatalogEntry. Keep both until the alias is retired.
+  transport: z2.enum(["stdio", "sse", "http", "streamable-http"]).optional(),
+  command: z2.string().optional(),
+  args: z2.array(z2.string()).optional(),
+  env: z2.record(z2.string(), z2.string()).optional(),
+  url: z2.string().optional(),
+  headers: z2.record(z2.string(), z2.string()).optional(),
+  /** Remote only: PEM CA certificate (or a secret ref to one) pinned for this server's TLS. */
+  ca: z2.string().optional(),
+  keywords: z2.array(z2.string()).optional(),
+  license: z2.string().optional(),
+  // Optional runnable payload fetched + sha256-verified by the platform
+  // session-materializer into the asset dir at materialize time (e.g. a bundled
+  // server.js shipped as a GitHub release asset). `dest` defaults to the URL
+  // basename.
+  payload: z2.object({
+    // https only — bare `z.string().url()` also accepts file:/data:/javascript: schemes.
+    url: z2.string().url().refine((u) => u.startsWith("https://"), { message: "payload url must be https" }),
+    sha256: z2.string().regex(/^[a-f0-9]{64}$/),
+    // Plain filename, no path separators — schema-level guard against a traversal dest.
+    dest: z2.string().regex(/^[^/\\]+$/, { message: "dest must be a plain filename, not a path" }).optional()
+  }).optional()
+});
+function validateMcpServer(data) {
+  return validateManifest(McpServerManifestSchema, data);
+}
+var PromptManifestSchema = z2.looseObject({
+  name: z2.string().min(1),
+  description: z2.string().min(1),
+  version: z2.string().optional(),
+  keywords: z2.array(z2.string()).optional(),
+  license: z2.string().optional(),
+  metadata: CommonMetadataSchema.optional()
+});
+function validatePrompt(data) {
+  return validateManifest(PromptManifestSchema, data);
+}
+var PersonaManifestSchema = z2.looseObject({
+  name: z2.string().min(1),
+  description: z2.string().min(1),
+  version: z2.string().optional(),
+  keywords: z2.array(z2.string()).optional(),
+  license: z2.string().optional(),
+  metadata: CommonMetadataSchema.optional()
+});
+function validatePersona(data) {
+  return validateManifest(PersonaManifestSchema, data);
+}
+var PlaceholderTypeValues = [
+  "text",
+  "multiline",
+  "secret",
+  "number",
+  "boolean",
+  "enum",
+  "oauth",
+  "instance-picker"
+];
+var PlaceholderTypeSchema = z2.enum(PlaceholderTypeValues);
+var PlaceholderSchema = z2.object({
+  key: z2.string().min(1),
+  prompt: z2.string().optional(),
+  type: PlaceholderTypeSchema.optional(),
+  required: z2.boolean().optional(),
+  default: z2.union([z2.string(), z2.number(), z2.boolean()]).optional(),
+  values: z2.array(z2.union([z2.string(), z2.number()])).optional()
+});
+var ComposeRefSchema = z2.object({
+  kind: z2.string().min(1),
+  ref: z2.string().min(1)
+});
+var PresetItemSchema = z2.looseObject({
+  /** Asset ref, Library Instance ref, or nested Preset ref. */
+  ref: z2.string().min(1),
+  /** Local item ID for cross-item references (#item-id). */
+  id: z2.string().optional(),
+  /** Author-prefilled non-secret config values. */
+  config: z2.record(z2.string(), z2.unknown()).optional(),
+  /** User/secret values prompted at install. */
+  placeholders: z2.array(PlaceholderSchema).optional(),
+  /** How placeholder values fold into the Instance config. */
+  materialize: z2.record(z2.string(), z2.string()).optional(),
+  /** Composition for agent items. */
+  composes: z2.array(ComposeRefSchema).optional(),
+  /** Outer-Preset-author-supplied placeholder values for nested Presets. */
+  inputs: z2.record(z2.string(), z2.unknown()).optional()
+});
+var PresetInputSchema = z2.object({
+  key: z2.string().min(1),
+  type: PlaceholderTypeSchema.optional(),
+  prompt: z2.string().optional(),
+  required: z2.boolean().optional(),
+  values: z2.array(z2.union([z2.string(), z2.number()])).optional(),
+  default: z2.union([z2.string(), z2.number(), z2.boolean()]).optional()
+});
+var PresetSourceSchema = z2.object({
+  url: z2.string().min(1),
+  pin: z2.string().optional()
+});
+var PresetManifestSchema = z2.looseObject({
+  publisher: z2.string().optional(),
+  name: z2.string().min(1),
+  version: z2.union([z2.string(), z2.number()]),
+  description: z2.string().min(1),
+  category: z2.string().optional(),
+  license: z2.string().optional(),
+  keywords: z2.array(z2.string()).optional(),
+  /** 1+ polymorphic items. */
+  items: z2.array(PresetItemSchema).min(1),
+  /** Preset-level inputs shared across items (rare). */
+  inputs: z2.array(PresetInputSchema).optional(),
+  /** Git sources the dependency items resolve from; `apply` registers these first. */
+  sources: z2.array(PresetSourceSchema).optional()
+});
+function validatePreset(data) {
+  return validateManifest(PresetManifestSchema, data);
+}
+var RulesetManifestSchema = z2.looseObject({
+  name: z2.string().min(1),
+  description: z2.string().min(1),
+  version: z2.string().optional(),
+  keywords: z2.array(z2.string()).optional(),
+  license: z2.string().optional(),
+  metadata: CommonMetadataSchema.optional()
+});
+function validateRuleset(data) {
+  return validateManifest(RulesetManifestSchema, data);
+}
+
+export { ANTHROPIC_FIRST_PARTY_HOSTS, ANTHROPIC_FULL_ID_PATTERN, ANTHROPIC_MODEL_ALIASES, ANTHROPIC_MODEL_FAMILIES, AgentBindingValues, AgentCapabilityRequirementSchema, AgentComposeItemSchema, AgentIoSchema, AgentLifecycleSchema, AgentLifecycleValues, AgentManifestSchema, AgentMemorySchema, AgentToolsSchema, AgentTriggerSchema, ArtifactRefSchema, BEDROCK_MODEL_ID_PATTERN, BaseFrontmatterSchema, BindingSchema, BindingValues, CommonMetadataSchema, ConnectorManifestSchema, ContentBindingValues, ContractManifestSchema, FieldSchema, FilePrerequisiteSchema, FreeFormModelIdSchema, McpServerManifestSchema, MemoryBlockSchema, MemoryScopeSchema, MemoryScopeValues, ModelIdSchema, ModelSelectorSchema, PersonaManifestSchema, PlaceholderSchema, PlaceholderTypeSchema, PresetItemSchema, PresetManifestSchema, PresetSourceSchema, PromptManifestSchema, RulesetManifestSchema, SKILL_BODY_PLACEHOLDER, SKILL_DESCRIPTION_PLACEHOLDER, SKILL_DESCRIPTION_PLACEHOLDER_PREFIX, SLOT_ID_PATTERN, SLOT_ID_REQUIRED_KINDS, SkillManifestSchema, UserInputSchema, VERTEX_MODEL_ID_PATTERN, agentDeprecationDiagnostics, composeSlotDiagnostics, conventionItems, effectiveComposes, isFirstPartyAnthropicEndpoint, modelIdSchemaForCloud, modelIdSchemaForTarget, normalizeAnthropicModel, requiresAnthropicModelId, validateAgent, validateConnector, validateContract, validateManifest, validateMcpServer, validatePersona, validatePreset, validatePrompt, validateRuleset, validateSkill };
+//# sourceMappingURL=chunk-FRHE7FFB.js.map
+//# sourceMappingURL=chunk-FRHE7FFB.js.map