skedyul 1.2.41 → 1.2.43

package/dist/skills/types.d.ts

@@ -0,0 +1,355 @@
+import { z } from 'zod/v4';
+/**
+ * Skill YAML schema versions
+ */
+export declare const SKILL_SCHEMA_VERSION = "https://skedyul.com/schemas/skill/v1";
+export declare const SKILL_SCHEMA_VERSION_V2 = "https://skedyul.com/schemas/skill/v2";
+/**
+ * Skill source - where the skill comes from
+ */
+export declare const SkillSourceSchema: z.ZodEnum<{
+    BUILTIN: "BUILTIN";
+    S3: "S3";
+    APP: "APP";
+    EXTERNAL: "EXTERNAL";
+}>;
+export type SkillSource = z.infer<typeof SkillSourceSchema>;
+/**
+ * Skill tool requirement (v1 - legacy)
+ * @deprecated Use SkillToolDefinitionSchema for v2 skills
+ */
+export declare const SkillToolRequirementSchema: z.ZodObject<{
+    requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    provides: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type SkillToolRequirement = z.infer<typeof SkillToolRequirementSchema>;
+/**
+ * Sandbox configuration for skill tools
+ */
+export declare const SkillToolSandboxSchema: z.ZodObject<{
+    mock: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export type SkillToolSandbox = z.infer<typeof SkillToolSandboxSchema>;
+/**
+ * Tool constraints configuration for execution limits and categorization.
+ * Used to control how tools are executed at runtime.
+ */
+export declare const ToolConstraintsSchema: z.ZodObject<{
+    maxCallsPerRun: z.ZodOptional<z.ZodNumber>;
+    idempotent: z.ZodOptional<z.ZodBoolean>;
+    restricted: z.ZodOptional<z.ZodBoolean>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type ToolConstraints = z.infer<typeof ToolConstraintsSchema>;
+/**
+ * Full tool definition owned by a skill (v2)
+ * Skills own their tools with full configuration including descriptions,
+ * overrides, sandbox mocks, approval settings, and execution constraints.
+ */
+export declare const SkillToolDefinitionSchema: z.ZodObject<{
+    tool: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    overrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    sandbox: z.ZodOptional<z.ZodObject<{
+        mock: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>;
+    requiresApproval: z.ZodOptional<z.ZodBoolean>;
+    constraints: z.ZodOptional<z.ZodObject<{
+        maxCallsPerRun: z.ZodOptional<z.ZodNumber>;
+        idempotent: z.ZodOptional<z.ZodBoolean>;
+        restricted: z.ZodOptional<z.ZodBoolean>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SkillToolDefinition = z.infer<typeof SkillToolDefinitionSchema>;
+/**
+ * Tools configuration - supports both v1 (requires array) and v2 (full definitions)
+ */
+export declare const SkillToolsSchema: z.ZodUnion<readonly [z.ZodObject<{
+    requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    provides: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, z.ZodArray<z.ZodObject<{
+    tool: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    overrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    sandbox: z.ZodOptional<z.ZodObject<{
+        mock: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>;
+    requiresApproval: z.ZodOptional<z.ZodBoolean>;
+    constraints: z.ZodOptional<z.ZodObject<{
+        maxCallsPerRun: z.ZodOptional<z.ZodNumber>;
+        idempotent: z.ZodOptional<z.ZodBoolean>;
+        restricted: z.ZodOptional<z.ZodBoolean>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>>]>;
+/**
+ * Skill example - few-shot learning example
+ */
+export declare const SkillExampleSchema: z.ZodObject<{
+    context: z.ZodOptional<z.ZodString>;
+    input: z.ZodString;
+    reasoning: z.ZodOptional<z.ZodString>;
+    output: z.ZodString;
+    tool_call: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SkillExample = z.infer<typeof SkillExampleSchema>;
+/**
+ * Skill evaluation metric
+ */
+export declare const SkillEvaluationMetricSchema: z.ZodObject<{
+    metric: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    threshold: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type SkillEvaluationMetric = z.infer<typeof SkillEvaluationMetricSchema>;
+/**
+ * CRM context configuration - specifies which models and fields to include
+ * in the CRM schema when loading this skill.
+ */
+export declare const CRMContextSchema: z.ZodObject<{
+    models: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type CRMContext = z.infer<typeof CRMContextSchema>;
+/**
+ * Full Skill YAML schema (supports both v1 and v2)
+ *
+ * v1: tools is SkillToolRequirementSchema ({ requires: [...] })
+ * v2: tools is array of SkillToolDefinitionSchema (full tool ownership)
+ */
+export declare const SkillYAMLSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    handle: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    instructions: z.ZodString;
+    tools: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        provides: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+        tool: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        overrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        sandbox: z.ZodOptional<z.ZodObject<{
+            mock: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>>;
+        requiresApproval: z.ZodOptional<z.ZodBoolean>;
+        constraints: z.ZodOptional<z.ZodObject<{
+            maxCallsPerRun: z.ZodOptional<z.ZodNumber>;
+            idempotent: z.ZodOptional<z.ZodBoolean>;
+            restricted: z.ZodOptional<z.ZodBoolean>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>]>>;
+    crmContext: z.ZodOptional<z.ZodObject<{
+        models: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    examples: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        context: z.ZodOptional<z.ZodString>;
+        input: z.ZodString;
+        reasoning: z.ZodOptional<z.ZodString>;
+        output: z.ZodString;
+        tool_call: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    evaluation: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        metric: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        threshold: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type SkillYAML = z.infer<typeof SkillYAMLSchema>;
+/**
+ * Skill YAML v2 schema - explicit v2 with tool ownership
+ * Use this when you want to enforce v2 format with full tool definitions.
+ */
+export declare const SkillYAMLV2Schema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodLiteral<"https://skedyul.com/schemas/skill/v2">>;
+    handle: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    instructions: z.ZodString;
+    tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        tool: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        overrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        sandbox: z.ZodOptional<z.ZodObject<{
+            mock: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>>;
+        requiresApproval: z.ZodOptional<z.ZodBoolean>;
+        constraints: z.ZodOptional<z.ZodObject<{
+            maxCallsPerRun: z.ZodOptional<z.ZodNumber>;
+            idempotent: z.ZodOptional<z.ZodBoolean>;
+            restricted: z.ZodOptional<z.ZodBoolean>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    crmContext: z.ZodOptional<z.ZodObject<{
+        models: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    examples: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        context: z.ZodOptional<z.ZodString>;
+        input: z.ZodString;
+        reasoning: z.ZodOptional<z.ZodString>;
+        output: z.ZodString;
+        tool_call: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    evaluation: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        metric: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        threshold: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type SkillYAMLV2 = z.infer<typeof SkillYAMLV2Schema>;
+/**
+ * Version weight for A/B testing
+ */
+export declare const SkillVersionWeightSchema: z.ZodObject<{
+    version: z.ZodNumber;
+    weight: z.ZodNumber;
+}, z.core.$strip>;
+export type SkillVersionWeight = z.infer<typeof SkillVersionWeightSchema>;
+/**
+ * Skill reference in agent YAML - can be a string handle or object with version config
+ */
+export declare const SkillRefSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    skill: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodNumber>;
+    versions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        version: z.ZodNumber;
+        weight: z.ZodNumber;
+    }, z.core.$strip>>>;
+    instructions: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>]>;
+export type SkillRef = z.infer<typeof SkillRefSchema>;
+/**
+ * Skill metadata (for registry)
+ */
+export declare const SkillMetadataSchema: z.ZodObject<{
+    id: z.ZodString;
+    handle: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    source: z.ZodEnum<{
+        BUILTIN: "BUILTIN";
+        S3: "S3";
+        APP: "APP";
+        EXTERNAL: "EXTERNAL";
+    }>;
+    s3Key: z.ZodOptional<z.ZodString>;
+    appVersionId: z.ZodOptional<z.ZodString>;
+    workplaceId: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SkillMetadata = z.infer<typeof SkillMetadataSchema>;
+/**
+ * Resolved skill - loaded and ready for injection.
+ * Tools are represented as string names for backward compatibility with IR.
+ * Use LoadedSkill for runtime skill loading with full tool definitions.
+ */
+export declare const ResolvedSkillSchema: z.ZodObject<{
+    handle: z.ZodString;
+    name: z.ZodString;
+    instructions: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    examples: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        context: z.ZodOptional<z.ZodString>;
+        input: z.ZodString;
+        reasoning: z.ZodOptional<z.ZodString>;
+        output: z.ZodString;
+        tool_call: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ResolvedSkill = z.infer<typeof ResolvedSkillSchema>;
+/**
+ * Loaded skill - skill loaded at runtime with full tool definitions.
+ * Used by SkillToolRegistry for dynamic tool registration.
+ */
+export declare const LoadedSkillSchema: z.ZodObject<{
+    handle: z.ZodString;
+    name: z.ZodString;
+    instructions: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        tool: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        overrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        sandbox: z.ZodOptional<z.ZodObject<{
+            mock: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>>;
+        requiresApproval: z.ZodOptional<z.ZodBoolean>;
+        constraints: z.ZodOptional<z.ZodObject<{
+            maxCallsPerRun: z.ZodOptional<z.ZodNumber>;
+            idempotent: z.ZodOptional<z.ZodBoolean>;
+            restricted: z.ZodOptional<z.ZodBoolean>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    examples: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        context: z.ZodOptional<z.ZodString>;
+        input: z.ZodString;
+        reasoning: z.ZodOptional<z.ZodString>;
+        output: z.ZodString;
+        tool_call: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type LoadedSkill = z.infer<typeof LoadedSkillSchema>;
+/**
+ * Helper to check if skill tools are v2 format (array of tool definitions)
+ */
+export declare function isV2SkillTools(tools: SkillToolRequirement | SkillToolDefinition[] | undefined): tools is SkillToolDefinition[];
+/**
+ * Helper to extract tool names from either v1 or v2 format
+ */
+export declare function getSkillToolNames(tools: SkillToolRequirement | SkillToolDefinition[] | undefined): string[];
+/**
+ * Helper to convert v1 tool requirements to v2 tool definitions
+ * Used during migration or when loading legacy skills
+ */
+export declare function convertV1ToV2Tools(requires: string[]): SkillToolDefinition[];
+/**
+ * Skill discovery metadata - minimal info for system prompt
+ * Following AI SDK Agent Skills pattern: only name + description at startup
+ */
+export interface SkillDiscoveryInfo {
+    handle: string;
+    name: string;
+    description: string;
+}
+/**
+ * Helper function to define a skill with type safety
+ */
+export declare function defineSkill(skill: SkillYAML): SkillYAML;
+/**
+ * Validate a skill YAML object
+ */
+export declare function validateSkillYAML(skill: unknown): {
+    success: true;
+    data: SkillYAML;
+} | {
+    success: false;
+    error: z.ZodError;
+};
+/**
+ * Format skill instructions for injection into system prompt
+ * @deprecated Use formatSkillDiscovery for AI SDK Agent Skills pattern
+ */
+export declare function formatSkillInstructions(skills: ResolvedSkill[]): string;
+/**
+ * Format skill discovery list for system prompt.
+ * Following AI SDK Agent Skills pattern: only name + description at startup.
+ * Full instructions are loaded on-demand via the loadSkill tool.
+ *
+ * @param skills - Array of skill discovery info objects
+ * @param workflowInstructions - Optional custom workflow instructions for the agent
+ */
+export declare function formatSkillDiscovery(skills: SkillDiscoveryInfo[], workflowInstructions?: string): string;

package/dist/skills/types.js

@@ -0,0 +1,281 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/skills/types.ts
+var types_exports = {};
+__export(types_exports, {
+  CRMContextSchema: () => CRMContextSchema,
+  LoadedSkillSchema: () => LoadedSkillSchema,
+  ResolvedSkillSchema: () => ResolvedSkillSchema,
+  SKILL_SCHEMA_VERSION: () => SKILL_SCHEMA_VERSION,
+  SKILL_SCHEMA_VERSION_V2: () => SKILL_SCHEMA_VERSION_V2,
+  SkillEvaluationMetricSchema: () => SkillEvaluationMetricSchema,
+  SkillExampleSchema: () => SkillExampleSchema,
+  SkillMetadataSchema: () => SkillMetadataSchema,
+  SkillRefSchema: () => SkillRefSchema,
+  SkillSourceSchema: () => SkillSourceSchema,
+  SkillToolDefinitionSchema: () => SkillToolDefinitionSchema,
+  SkillToolRequirementSchema: () => SkillToolRequirementSchema,
+  SkillToolSandboxSchema: () => SkillToolSandboxSchema,
+  SkillToolsSchema: () => SkillToolsSchema,
+  SkillVersionWeightSchema: () => SkillVersionWeightSchema,
+  SkillYAMLSchema: () => SkillYAMLSchema,
+  SkillYAMLV2Schema: () => SkillYAMLV2Schema,
+  ToolConstraintsSchema: () => ToolConstraintsSchema,
+  convertV1ToV2Tools: () => convertV1ToV2Tools,
+  defineSkill: () => defineSkill,
+  formatSkillDiscovery: () => formatSkillDiscovery,
+  formatSkillInstructions: () => formatSkillInstructions,
+  getSkillToolNames: () => getSkillToolNames,
+  isV2SkillTools: () => isV2SkillTools,
+  validateSkillYAML: () => validateSkillYAML
+});
+module.exports = __toCommonJS(types_exports);
+var import_v4 = require("zod/v4");
+var SKILL_SCHEMA_VERSION = "https://skedyul.com/schemas/skill/v1";
+var SKILL_SCHEMA_VERSION_V2 = "https://skedyul.com/schemas/skill/v2";
+var SkillSourceSchema = import_v4.z.enum(["BUILTIN", "S3", "APP", "EXTERNAL"]);
+var SkillToolRequirementSchema = import_v4.z.object({
+  requires: import_v4.z.array(import_v4.z.string()).optional(),
+  provides: import_v4.z.array(import_v4.z.string()).optional()
+});
+var SkillToolSandboxSchema = import_v4.z.object({
+  mock: import_v4.z.unknown().optional()
+});
+var ToolConstraintsSchema = import_v4.z.object({
+  maxCallsPerRun: import_v4.z.number().optional(),
+  idempotent: import_v4.z.boolean().optional(),
+  restricted: import_v4.z.boolean().optional(),
+  tags: import_v4.z.array(import_v4.z.string()).optional()
+});
+var SkillToolDefinitionSchema = import_v4.z.object({
+  tool: import_v4.z.string(),
+  description: import_v4.z.string().optional(),
+  overrides: import_v4.z.record(import_v4.z.string(), import_v4.z.unknown()).optional(),
+  sandbox: SkillToolSandboxSchema.optional(),
+  requiresApproval: import_v4.z.boolean().optional(),
+  constraints: ToolConstraintsSchema.optional()
+});
+var SkillToolsSchema = import_v4.z.union([
+  SkillToolRequirementSchema,
+  import_v4.z.array(SkillToolDefinitionSchema)
+]);
+var SkillExampleSchema = import_v4.z.object({
+  context: import_v4.z.string().optional(),
+  input: import_v4.z.string(),
+  reasoning: import_v4.z.string().optional(),
+  output: import_v4.z.string(),
+  tool_call: import_v4.z.string().optional()
+});
+var SkillEvaluationMetricSchema = import_v4.z.object({
+  metric: import_v4.z.string(),
+  description: import_v4.z.string().optional(),
+  threshold: import_v4.z.number().optional()
+});
+var CRMContextSchema = import_v4.z.object({
+  models: import_v4.z.record(import_v4.z.string(), import_v4.z.array(import_v4.z.string()))
+  // { modelHandle: [fieldHandles] }
+});
+var SkillYAMLSchema = import_v4.z.object({
+  // Schema version
+  $schema: import_v4.z.string().optional(),
+  // Identity
+  handle: import_v4.z.string(),
+  name: import_v4.z.string(),
+  version: import_v4.z.string().optional(),
+  description: import_v4.z.string().optional(),
+  // Instructions injected into agent system prompt
+  instructions: import_v4.z.string(),
+  // Tool configuration - supports both v1 and v2 formats
+  tools: SkillToolsSchema.optional(),
+  // CRM context - specifies which models/fields to include in schema
+  crmContext: CRMContextSchema.optional(),
+  // Few-shot examples
+  examples: import_v4.z.array(SkillExampleSchema).optional(),
+  // Evaluation criteria
+  evaluation: import_v4.z.array(SkillEvaluationMetricSchema).optional(),
+  // Tags for discovery
+  tags: import_v4.z.array(import_v4.z.string()).optional()
+});
+var SkillYAMLV2Schema = import_v4.z.object({
+  $schema: import_v4.z.literal(SKILL_SCHEMA_VERSION_V2).optional(),
+  handle: import_v4.z.string(),
+  name: import_v4.z.string(),
+  version: import_v4.z.string().optional(),
+  description: import_v4.z.string().optional(),
+  instructions: import_v4.z.string(),
+  tools: import_v4.z.array(SkillToolDefinitionSchema).optional(),
+  crmContext: CRMContextSchema.optional(),
+  examples: import_v4.z.array(SkillExampleSchema).optional(),
+  evaluation: import_v4.z.array(SkillEvaluationMetricSchema).optional(),
+  tags: import_v4.z.array(import_v4.z.string()).optional()
+});
+var SkillVersionWeightSchema = import_v4.z.object({
+  version: import_v4.z.number(),
+  weight: import_v4.z.number()
+});
+var SkillRefSchema = import_v4.z.union([
+  import_v4.z.string(),
+  // Just handle - uses latest published version
+  import_v4.z.object({
+    skill: import_v4.z.string(),
+    description: import_v4.z.string().optional(),
+    // For AI SDK Agent Skills discovery
+    // Version selection (pick one):
+    version: import_v4.z.number().optional(),
+    // Pin to specific version number
+    versions: import_v4.z.array(SkillVersionWeightSchema).optional(),
+    // A/B testing weights
+    // Legacy support:
+    instructions: import_v4.z.string().optional(),
+    // Inline instructions (deprecated)
+    enabled: import_v4.z.boolean().optional()
+  })
+]);
+var SkillMetadataSchema = import_v4.z.object({
+  id: import_v4.z.string(),
+  handle: import_v4.z.string(),
+  name: import_v4.z.string(),
+  version: import_v4.z.string().optional(),
+  description: import_v4.z.string().optional(),
+  source: SkillSourceSchema,
+  s3Key: import_v4.z.string().optional(),
+  appVersionId: import_v4.z.string().optional(),
+  workplaceId: import_v4.z.string().optional(),
+  tags: import_v4.z.array(import_v4.z.string()).optional(),
+  createdAt: import_v4.z.string().datetime().optional(),
+  updatedAt: import_v4.z.string().datetime().optional()
+});
+var ResolvedSkillSchema = import_v4.z.object({
+  handle: import_v4.z.string(),
+  name: import_v4.z.string(),
+  instructions: import_v4.z.string().optional(),
+  description: import_v4.z.string().optional(),
+  tools: import_v4.z.array(import_v4.z.string()).optional(),
+  examples: import_v4.z.array(SkillExampleSchema).optional()
+});
+var LoadedSkillSchema = import_v4.z.object({
+  handle: import_v4.z.string(),
+  name: import_v4.z.string(),
+  instructions: import_v4.z.string().optional(),
+  description: import_v4.z.string().optional(),
+  tools: import_v4.z.array(SkillToolDefinitionSchema).optional(),
+  examples: import_v4.z.array(SkillExampleSchema).optional()
+});
+function isV2SkillTools(tools) {
+  if (!tools) return false;
+  return Array.isArray(tools);
+}
+function getSkillToolNames(tools) {
+  if (!tools) return [];
+  if (isV2SkillTools(tools)) {
+    return tools.map((t) => t.tool);
+  }
+  return tools.requires || [];
+}
+function convertV1ToV2Tools(requires) {
+  return requires.map((tool) => ({ tool }));
+}
+function defineSkill(skill) {
+  return SkillYAMLSchema.parse(skill);
+}
+function validateSkillYAML(skill) {
+  const result = SkillYAMLSchema.safeParse(skill);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, error: result.error };
+}
+function formatSkillInstructions(skills) {
+  if (skills.length === 0) return "";
+  const sections = skills.map((skill) => {
+    if (!skill.instructions) {
+      return `## ${skill.name}
+
+${skill.description || "No description available."}`;
+    }
+    let section = `## ${skill.name}
+
+${skill.instructions}`;
+    if (skill.examples && skill.examples.length > 0) {
+      section += "\n\n### Examples\n";
+      for (const example of skill.examples) {
+        section += `
+**Input:** ${example.input}
+`;
+        if (example.reasoning) {
+          section += `**Reasoning:** ${example.reasoning}
+`;
+        }
+        section += `**Output:** ${example.output}
+`;
+      }
+    }
+    return section;
+  });
+  return `# Skills
+
+${sections.join("\n\n---\n\n")}`;
+}
+function formatSkillDiscovery(skills, workflowInstructions) {
+  if (skills.length === 0) return "";
+  const skillsList = skills.map((s) => `- **${s.name}**: ${s.description}`).join("\n");
+  const defaultWorkflow = `WORKFLOW FOR EVERY RESPONSE:
+1. Check the Current Context data to understand the current state
+2. Read the skill descriptions below - each tells you WHEN to use it
+3. Load the matching skill using \`system:skill:load\`
+4. Follow the skill's instructions exactly`;
+  const workflow = workflowInstructions ?? defaultWorkflow;
+  return `## Skills
+
+${workflow}
+
+Available skills:
+${skillsList}
+
+IMPORTANT: Always use the proper tool calls. Do NOT output XML-like tags in your response.`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CRMContextSchema,
+  LoadedSkillSchema,
+  ResolvedSkillSchema,
+  SKILL_SCHEMA_VERSION,
+  SKILL_SCHEMA_VERSION_V2,
+  SkillEvaluationMetricSchema,
+  SkillExampleSchema,
+  SkillMetadataSchema,
+  SkillRefSchema,
+  SkillSourceSchema,
+  SkillToolDefinitionSchema,
+  SkillToolRequirementSchema,
+  SkillToolSandboxSchema,
+  SkillToolsSchema,
+  SkillVersionWeightSchema,
+  SkillYAMLSchema,
+  SkillYAMLV2Schema,
+  ToolConstraintsSchema,
+  convertV1ToV2Tools,
+  defineSkill,
+  formatSkillDiscovery,
+  formatSkillInstructions,
+  getSkillToolNames,
+  isV2SkillTools,
+  validateSkillYAML
+});