@mastra/playground-ui 12.0.0 → 13.0.0

package/dist/index.cjs.js

@@ -72,14 +72,16 @@ const dnd = require('@hello-pangea/dnd');
 const SwitchPrimitives = require('@radix-ui/react-switch');
 const codemirrorThemeGithub = require('@uiw/codemirror-theme-github');
 const AlertDialogPrimitive = require('@radix-ui/react-alert-dialog');
+const features = require('@mastra/core/features');
 const format = require('date-fns/format');
 const observability = require('@mastra/core/observability');
 const Papa = require('papaparse');
 const DropdownMenuPrimitive = require('@radix-ui/react-dropdown-menu');
 const reactDom = require('react-dom');
 const cmdk = require('cmdk');
+const state = require('@codemirror/state');
+const merge = require('@codemirror/merge');
 const reactSyntaxHighlighter$1 = require('react-syntax-highlighter');
-const features = require('@mastra/core/features');
 const compatibility = require('./compatibility-BSJHu6pD.cjs');
 
 function _interopNamespaceDefault(e) {
@@ -609,7 +611,7 @@ const fromTheme = key => {
 };
 const arbitraryValueRegex = /^\[(?:(\w[\w-]*):)?(.+)\]$/i;
 const arbitraryVariableRegex = /^\((?:(\w[\w-]*):)?(.+)\)$/i;
-const fractionRegex = /^\d+\/\d+$/;
+const fractionRegex = /^\d+(?:\.\d+)?\/\d+(?:\.\d+)?$/;
 const tshirtUnitRegex = /^(\d+(\.\d+)?)?(xs|sm|md|lg|xl)$/;
 const lengthUnitRegex = /\d+(%|px|r?em|[sdl]?v([hwib]|min|max)|pt|pc|in|cm|mm|cap|ch|ex|r?lh|cq(w|h|i|b|min|max))|\b(calc|min|max|clamp)\(.+\)|^0$/;
 const colorFunctionRegex = /^(rgba?|hsla?|hwb|(ok)?(lab|lch)|color-mix)\(.+\)$/;
@@ -635,6 +637,8 @@ const isArbitrarySize = value => getIsArbitraryValue(value, isLabelSize, isNever
 const isArbitraryValue = value => arbitraryValueRegex.test(value);
 const isArbitraryLength = value => getIsArbitraryValue(value, isLabelLength, isLengthOnly);
 const isArbitraryNumber = value => getIsArbitraryValue(value, isLabelNumber, isNumber);
+const isArbitraryWeight = value => getIsArbitraryValue(value, isLabelWeight, isAny);
+const isArbitraryFamilyName = value => getIsArbitraryValue(value, isLabelFamilyName, isNever);
 const isArbitraryPosition = value => getIsArbitraryValue(value, isLabelPosition, isNever);
 const isArbitraryImage = value => getIsArbitraryValue(value, isLabelImage, isImage);
 const isArbitraryShadow = value => getIsArbitraryValue(value, isLabelShadow, isShadow);
@@ -645,6 +649,7 @@ const isArbitraryVariablePosition = value => getIsArbitraryVariable(value, isLab
 const isArbitraryVariableSize = value => getIsArbitraryVariable(value, isLabelSize);
 const isArbitraryVariableImage = value => getIsArbitraryVariable(value, isLabelImage);
 const isArbitraryVariableShadow = value => getIsArbitraryVariable(value, isLabelShadow, true);
+const isArbitraryVariableWeight = value => getIsArbitraryVariable(value, isLabelWeight, true);
 // Helpers
 const getIsArbitraryValue = (value, testLabel, testValue) => {
   const result = arbitraryValueRegex.exec(value);
@@ -673,6 +678,7 @@ const isLabelSize = label => label === 'length' || label === 'size' || label ===
 const isLabelLength = label => label === 'length';
 const isLabelNumber = label => label === 'number';
 const isLabelFamilyName = label => label === 'family-name';
+const isLabelWeight = label => label === 'number' || label === 'weight';
 const isLabelShadow = label => label === 'shadow';
 const getDefaultConfig = () => {
   /**
@@ -731,6 +737,8 @@ const getDefaultConfig = () => {
   const scaleAlignSecondaryAxis = () => ['start', 'end', 'center', 'stretch', 'center-safe', 'end-safe'];
   const scaleMargin = () => ['auto', ...scaleUnambiguousSpacing()];
   const scaleSizing = () => [isFraction, 'auto', 'full', 'dvw', 'dvh', 'lvw', 'lvh', 'svw', 'svh', 'min', 'max', 'fit', ...scaleUnambiguousSpacing()];
+  const scaleSizingInline = () => [isFraction, 'screen', 'full', 'dvw', 'lvw', 'svw', 'min', 'max', 'fit', ...scaleUnambiguousSpacing()];
+  const scaleSizingBlock = () => [isFraction, 'screen', 'full', 'lh', 'dvh', 'lvh', 'svh', 'min', 'max', 'fit', ...scaleUnambiguousSpacing()];
   const scaleColor = () => [themeColor, isArbitraryVariable, isArbitraryValue];
   const scaleBgPosition = () => [...scalePosition(), isArbitraryVariablePosition, isArbitraryPosition, {
     position: [isArbitraryVariable, isArbitraryValue]
@@ -929,40 +937,66 @@ const getDefaultConfig = () => {
        */
       position: ['static', 'fixed', 'absolute', 'relative', 'sticky'],
       /**
-       * Top / Right / Bottom / Left
+       * Inset
        * @see https://tailwindcss.com/docs/top-right-bottom-left
        */
       inset: [{
         inset: scaleInset()
       }],
       /**
-       * Right / Left
+       * Inset Inline
        * @see https://tailwindcss.com/docs/top-right-bottom-left
        */
       'inset-x': [{
         'inset-x': scaleInset()
       }],
       /**
-       * Top / Bottom
+       * Inset Block
        * @see https://tailwindcss.com/docs/top-right-bottom-left
        */
       'inset-y': [{
         'inset-y': scaleInset()
       }],
       /**
-       * Start
+       * Inset Inline Start
        * @see https://tailwindcss.com/docs/top-right-bottom-left
+       * @todo class group will be renamed to `inset-s` in next major release
        */
       start: [{
+        'inset-s': scaleInset(),
+        /**
+         * @deprecated since Tailwind CSS v4.2.0 in favor of `inset-s-*` utilities.
+         * @see https://github.com/tailwindlabs/tailwindcss/pull/19613
+         */
         start: scaleInset()
       }],
       /**
-       * End
+       * Inset Inline End
        * @see https://tailwindcss.com/docs/top-right-bottom-left
+       * @todo class group will be renamed to `inset-e` in next major release
        */
       end: [{
+        'inset-e': scaleInset(),
+        /**
+         * @deprecated since Tailwind CSS v4.2.0 in favor of `inset-e-*` utilities.
+         * @see https://github.com/tailwindlabs/tailwindcss/pull/19613
+         */
         end: scaleInset()
       }],
+      /**
+       * Inset Block Start
+       * @see https://tailwindcss.com/docs/top-right-bottom-left
+       */
+      'inset-bs': [{
+        'inset-bs': scaleInset()
+      }],
+      /**
+       * Inset Block End
+       * @see https://tailwindcss.com/docs/top-right-bottom-left
+       */
+      'inset-be': [{
+        'inset-be': scaleInset()
+      }],
       /**
        * Top
        * @see https://tailwindcss.com/docs/top-right-bottom-left
@@ -1229,33 +1263,47 @@ const getDefaultConfig = () => {
         p: scaleUnambiguousSpacing()
       }],
       /**
-       * Padding X
+       * Padding Inline
        * @see https://tailwindcss.com/docs/padding
        */
       px: [{
         px: scaleUnambiguousSpacing()
       }],
       /**
-       * Padding Y
+       * Padding Block
        * @see https://tailwindcss.com/docs/padding
        */
       py: [{
         py: scaleUnambiguousSpacing()
       }],
       /**
-       * Padding Start
+       * Padding Inline Start
        * @see https://tailwindcss.com/docs/padding
        */
       ps: [{
         ps: scaleUnambiguousSpacing()
       }],
       /**
-       * Padding End
+       * Padding Inline End
        * @see https://tailwindcss.com/docs/padding
        */
       pe: [{
         pe: scaleUnambiguousSpacing()
       }],
+      /**
+       * Padding Block Start
+       * @see https://tailwindcss.com/docs/padding
+       */
+      pbs: [{
+        pbs: scaleUnambiguousSpacing()
+      }],
+      /**
+       * Padding Block End
+       * @see https://tailwindcss.com/docs/padding
+       */
+      pbe: [{
+        pbe: scaleUnambiguousSpacing()
+      }],
       /**
        * Padding Top
        * @see https://tailwindcss.com/docs/padding
@@ -1292,33 +1340,47 @@ const getDefaultConfig = () => {
         m: scaleMargin()
       }],
       /**
-       * Margin X
+       * Margin Inline
        * @see https://tailwindcss.com/docs/margin
        */
       mx: [{
         mx: scaleMargin()
       }],
       /**
-       * Margin Y
+       * Margin Block
        * @see https://tailwindcss.com/docs/margin
        */
       my: [{
         my: scaleMargin()
       }],
       /**
-       * Margin Start
+       * Margin Inline Start
        * @see https://tailwindcss.com/docs/margin
        */
       ms: [{
         ms: scaleMargin()
       }],
       /**
-       * Margin End
+       * Margin Inline End
        * @see https://tailwindcss.com/docs/margin
        */
       me: [{
         me: scaleMargin()
       }],
+      /**
+       * Margin Block Start
+       * @see https://tailwindcss.com/docs/margin
+       */
+      mbs: [{
+        mbs: scaleMargin()
+      }],
+      /**
+       * Margin Block End
+       * @see https://tailwindcss.com/docs/margin
+       */
+      mbe: [{
+        mbe: scaleMargin()
+      }],
       /**
        * Margin Top
        * @see https://tailwindcss.com/docs/margin
@@ -1381,6 +1443,48 @@ const getDefaultConfig = () => {
       size: [{
         size: scaleSizing()
       }],
+      /**
+       * Inline Size
+       * @see https://tailwindcss.com/docs/width
+       */
+      'inline-size': [{
+        inline: ['auto', ...scaleSizingInline()]
+      }],
+      /**
+       * Min-Inline Size
+       * @see https://tailwindcss.com/docs/min-width
+       */
+      'min-inline-size': [{
+        'min-inline': ['auto', ...scaleSizingInline()]
+      }],
+      /**
+       * Max-Inline Size
+       * @see https://tailwindcss.com/docs/max-width
+       */
+      'max-inline-size': [{
+        'max-inline': ['none', ...scaleSizingInline()]
+      }],
+      /**
+       * Block Size
+       * @see https://tailwindcss.com/docs/height
+       */
+      'block-size': [{
+        block: ['auto', ...scaleSizingBlock()]
+      }],
+      /**
+       * Min-Block Size
+       * @see https://tailwindcss.com/docs/min-height
+       */
+      'min-block-size': [{
+        'min-block': ['auto', ...scaleSizingBlock()]
+      }],
+      /**
+       * Max-Block Size
+       * @see https://tailwindcss.com/docs/max-height
+       */
+      'max-block-size': [{
+        'max-block': ['none', ...scaleSizingBlock()]
+      }],
       /**
        * Width
        * @see https://tailwindcss.com/docs/width
@@ -1453,7 +1557,7 @@ const getDefaultConfig = () => {
        * @see https://tailwindcss.com/docs/font-weight
        */
       'font-weight': [{
-        font: [themeFontWeight, isArbitraryVariable, isArbitraryNumber]
+        font: [themeFontWeight, isArbitraryVariableWeight, isArbitraryWeight]
       }],
       /**
        * Font Stretch
@@ -1467,7 +1571,14 @@ const getDefaultConfig = () => {
        * @see https://tailwindcss.com/docs/font-family
        */
       'font-family': [{
-        font: [isArbitraryVariableFamilyName, isArbitraryValue, themeFont]
+        font: [isArbitraryVariableFamilyName, isArbitraryFamilyName, themeFont]
+      }],
+      /**
+       * Font Feature Settings
+       * @see https://tailwindcss.com/docs/font-feature-settings
+       */
+      'font-features': [{
+        'font-features': [isArbitraryValue]
       }],
       /**
        * Font Variant Numeric
@@ -1886,33 +1997,47 @@ const getDefaultConfig = () => {
         border: scaleBorderWidth()
       }],
       /**
-       * Border Width X
+       * Border Width Inline
        * @see https://tailwindcss.com/docs/border-width
        */
       'border-w-x': [{
         'border-x': scaleBorderWidth()
       }],
       /**
-       * Border Width Y
+       * Border Width Block
        * @see https://tailwindcss.com/docs/border-width
        */
       'border-w-y': [{
         'border-y': scaleBorderWidth()
       }],
       /**
-       * Border Width Start
+       * Border Width Inline Start
        * @see https://tailwindcss.com/docs/border-width
        */
       'border-w-s': [{
         'border-s': scaleBorderWidth()
       }],
       /**
-       * Border Width End
+       * Border Width Inline End
        * @see https://tailwindcss.com/docs/border-width
        */
       'border-w-e': [{
         'border-e': scaleBorderWidth()
       }],
+      /**
+       * Border Width Block Start
+       * @see https://tailwindcss.com/docs/border-width
+       */
+      'border-w-bs': [{
+        'border-bs': scaleBorderWidth()
+      }],
+      /**
+       * Border Width Block End
+       * @see https://tailwindcss.com/docs/border-width
+       */
+      'border-w-be': [{
+        'border-be': scaleBorderWidth()
+      }],
       /**
        * Border Width Top
        * @see https://tailwindcss.com/docs/border-width
@@ -1987,33 +2112,47 @@ const getDefaultConfig = () => {
         border: scaleColor()
       }],
       /**
-       * Border Color X
+       * Border Color Inline
        * @see https://tailwindcss.com/docs/border-color
        */
       'border-color-x': [{
         'border-x': scaleColor()
       }],
       /**
-       * Border Color Y
+       * Border Color Block
        * @see https://tailwindcss.com/docs/border-color
        */
       'border-color-y': [{
         'border-y': scaleColor()
       }],
       /**
-       * Border Color S
+       * Border Color Inline Start
        * @see https://tailwindcss.com/docs/border-color
        */
       'border-color-s': [{
         'border-s': scaleColor()
       }],
       /**
-       * Border Color E
+       * Border Color Inline End
        * @see https://tailwindcss.com/docs/border-color
        */
       'border-color-e': [{
         'border-e': scaleColor()
       }],
+      /**
+       * Border Color Block Start
+       * @see https://tailwindcss.com/docs/border-color
+       */
+      'border-color-bs': [{
+        'border-bs': scaleColor()
+      }],
+      /**
+       * Border Color Block End
+       * @see https://tailwindcss.com/docs/border-color
+       */
+      'border-color-be': [{
+        'border-be': scaleColor()
+      }],
       /**
        * Border Color Top
        * @see https://tailwindcss.com/docs/border-color
@@ -2874,33 +3013,47 @@ const getDefaultConfig = () => {
         'scroll-m': scaleUnambiguousSpacing()
       }],
       /**
-       * Scroll Margin X
+       * Scroll Margin Inline
        * @see https://tailwindcss.com/docs/scroll-margin
        */
       'scroll-mx': [{
         'scroll-mx': scaleUnambiguousSpacing()
       }],
       /**
-       * Scroll Margin Y
+       * Scroll Margin Block
        * @see https://tailwindcss.com/docs/scroll-margin
        */
       'scroll-my': [{
         'scroll-my': scaleUnambiguousSpacing()
       }],
       /**
-       * Scroll Margin Start
+       * Scroll Margin Inline Start
        * @see https://tailwindcss.com/docs/scroll-margin
        */
       'scroll-ms': [{
         'scroll-ms': scaleUnambiguousSpacing()
       }],
       /**
-       * Scroll Margin End
+       * Scroll Margin Inline End
        * @see https://tailwindcss.com/docs/scroll-margin
        */
       'scroll-me': [{
         'scroll-me': scaleUnambiguousSpacing()
       }],
+      /**
+       * Scroll Margin Block Start
+       * @see https://tailwindcss.com/docs/scroll-margin
+       */
+      'scroll-mbs': [{
+        'scroll-mbs': scaleUnambiguousSpacing()
+      }],
+      /**
+       * Scroll Margin Block End
+       * @see https://tailwindcss.com/docs/scroll-margin
+       */
+      'scroll-mbe': [{
+        'scroll-mbe': scaleUnambiguousSpacing()
+      }],
       /**
        * Scroll Margin Top
        * @see https://tailwindcss.com/docs/scroll-margin
@@ -2937,33 +3090,47 @@ const getDefaultConfig = () => {
         'scroll-p': scaleUnambiguousSpacing()
       }],
       /**
-       * Scroll Padding X
+       * Scroll Padding Inline
        * @see https://tailwindcss.com/docs/scroll-padding
        */
       'scroll-px': [{
         'scroll-px': scaleUnambiguousSpacing()
       }],
       /**
-       * Scroll Padding Y
+       * Scroll Padding Block
        * @see https://tailwindcss.com/docs/scroll-padding
        */
       'scroll-py': [{
         'scroll-py': scaleUnambiguousSpacing()
       }],
       /**
-       * Scroll Padding Start
+       * Scroll Padding Inline Start
        * @see https://tailwindcss.com/docs/scroll-padding
        */
       'scroll-ps': [{
         'scroll-ps': scaleUnambiguousSpacing()
       }],
       /**
-       * Scroll Padding End
+       * Scroll Padding Inline End
        * @see https://tailwindcss.com/docs/scroll-padding
        */
       'scroll-pe': [{
         'scroll-pe': scaleUnambiguousSpacing()
       }],
+      /**
+       * Scroll Padding Block Start
+       * @see https://tailwindcss.com/docs/scroll-padding
+       */
+      'scroll-pbs': [{
+        'scroll-pbs': scaleUnambiguousSpacing()
+      }],
+      /**
+       * Scroll Padding Block End
+       * @see https://tailwindcss.com/docs/scroll-padding
+       */
+      'scroll-pbe': [{
+        'scroll-pbe': scaleUnambiguousSpacing()
+      }],
       /**
        * Scroll Padding Top
        * @see https://tailwindcss.com/docs/scroll-padding
@@ -3098,15 +3265,15 @@ const getDefaultConfig = () => {
     conflictingClassGroups: {
       overflow: ['overflow-x', 'overflow-y'],
       overscroll: ['overscroll-x', 'overscroll-y'],
-      inset: ['inset-x', 'inset-y', 'start', 'end', 'top', 'right', 'bottom', 'left'],
+      inset: ['inset-x', 'inset-y', 'inset-bs', 'inset-be', 'start', 'end', 'top', 'right', 'bottom', 'left'],
       'inset-x': ['right', 'left'],
       'inset-y': ['top', 'bottom'],
       flex: ['basis', 'grow', 'shrink'],
       gap: ['gap-x', 'gap-y'],
-      p: ['px', 'py', 'ps', 'pe', 'pt', 'pr', 'pb', 'pl'],
+      p: ['px', 'py', 'ps', 'pe', 'pbs', 'pbe', 'pt', 'pr', 'pb', 'pl'],
       px: ['pr', 'pl'],
       py: ['pt', 'pb'],
-      m: ['mx', 'my', 'ms', 'me', 'mt', 'mr', 'mb', 'ml'],
+      m: ['mx', 'my', 'ms', 'me', 'mbs', 'mbe', 'mt', 'mr', 'mb', 'ml'],
       mx: ['mr', 'ml'],
       my: ['mt', 'mb'],
       size: ['w', 'h'],
@@ -3126,18 +3293,18 @@ const getDefaultConfig = () => {
       'rounded-b': ['rounded-br', 'rounded-bl'],
       'rounded-l': ['rounded-tl', 'rounded-bl'],
       'border-spacing': ['border-spacing-x', 'border-spacing-y'],
-      'border-w': ['border-w-x', 'border-w-y', 'border-w-s', 'border-w-e', 'border-w-t', 'border-w-r', 'border-w-b', 'border-w-l'],
+      'border-w': ['border-w-x', 'border-w-y', 'border-w-s', 'border-w-e', 'border-w-bs', 'border-w-be', 'border-w-t', 'border-w-r', 'border-w-b', 'border-w-l'],
       'border-w-x': ['border-w-r', 'border-w-l'],
       'border-w-y': ['border-w-t', 'border-w-b'],
-      'border-color': ['border-color-x', 'border-color-y', 'border-color-s', 'border-color-e', 'border-color-t', 'border-color-r', 'border-color-b', 'border-color-l'],
+      'border-color': ['border-color-x', 'border-color-y', 'border-color-s', 'border-color-e', 'border-color-bs', 'border-color-be', 'border-color-t', 'border-color-r', 'border-color-b', 'border-color-l'],
       'border-color-x': ['border-color-r', 'border-color-l'],
       'border-color-y': ['border-color-t', 'border-color-b'],
       translate: ['translate-x', 'translate-y', 'translate-none'],
       'translate-none': ['translate', 'translate-x', 'translate-y', 'translate-z'],
-      'scroll-m': ['scroll-mx', 'scroll-my', 'scroll-ms', 'scroll-me', 'scroll-mt', 'scroll-mr', 'scroll-mb', 'scroll-ml'],
+      'scroll-m': ['scroll-mx', 'scroll-my', 'scroll-ms', 'scroll-me', 'scroll-mbs', 'scroll-mbe', 'scroll-mt', 'scroll-mr', 'scroll-mb', 'scroll-ml'],
       'scroll-mx': ['scroll-mr', 'scroll-ml'],
       'scroll-my': ['scroll-mt', 'scroll-mb'],
-      'scroll-p': ['scroll-px', 'scroll-py', 'scroll-ps', 'scroll-pe', 'scroll-pt', 'scroll-pr', 'scroll-pb', 'scroll-pl'],
+      'scroll-p': ['scroll-px', 'scroll-py', 'scroll-ps', 'scroll-pe', 'scroll-pbs', 'scroll-pbe', 'scroll-pt', 'scroll-pr', 'scroll-pb', 'scroll-pl'],
       'scroll-px': ['scroll-pr', 'scroll-pl'],
       'scroll-py': ['scroll-pt', 'scroll-pb'],
       touch: ['touch-x', 'touch-y', 'touch-pz'],
@@ -7475,8 +7642,17 @@ function SelectField$1({
           required && /* @__PURE__ */ jsxRuntime.jsx("i", { className: "text-neutral2", children: "(required)" })
         ] }) }),
         /* @__PURE__ */ jsxRuntime.jsxs(Select, { name, value, onValueChange, disabled, children: [
-          /* @__PURE__ */ jsxRuntime.jsx(SelectTrigger, { id: `select-${name}`, size, variant, children: /* @__PURE__ */ jsxRuntime.jsx(SelectValue, { placeholder }) }),
-          /* @__PURE__ */ jsxRuntime.jsx(SelectContent, { children: options.map((option) => /* @__PURE__ */ jsxRuntime.jsx(SelectItem, { value: option.value, children: /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "whitespace-nowrap truncate flex items-center gap-2", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            SelectTrigger,
+            {
+              id: `select-${name}`,
+              size,
+              variant,
+              className: "grid grid-cols-[1fr_auto] [&>span]:truncate",
+              children: /* @__PURE__ */ jsxRuntime.jsx(SelectValue, { placeholder })
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(SelectContent, { children: options.map((option) => /* @__PURE__ */ jsxRuntime.jsx(SelectItem, { value: option.value, disabled: option.disabled, children: /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "whitespace-nowrap truncate flex items-center gap-2", children: [
             option.icon,
             option.label
           ] }) }, option.label)) })
@@ -18874,7 +19050,7 @@ function SideDialogHeading({ children, className, as = "h1" }) {
 }
 
 function SideDialogContent({ children, className }) {
-  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: cn("p-6 pl-9 overflow-y-scroll grid gap-6 content-start", className), children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: cn("grid gap-6 mb-8"), children }) });
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: cn("p-6 pl-9 overflow-y-scroll grid gap-6 content-start pb-8", className), children });
 }
 
 function SideDialogHeader({ children, className }) {
@@ -19888,7 +20064,7 @@ const useCompareScorerVersions = ({
   });
 };
 
-function formatTimestamp$1(isoString) {
+function formatTimestamp$2(isoString) {
   const date = new Date(isoString);
   return date.toLocaleDateString(void 0, {
     month: "short",
@@ -19922,7 +20098,7 @@ function ScorerVersionCombobox({
       return {
         label: `v${version.versionNumber}`,
         value: version.id,
-        description: formatTimestamp$1(version.createdAt),
+        description: formatTimestamp$2(version.createdAt),
         end: isPublished ? /* @__PURE__ */ jsxRuntime.jsx(Badge, { variant: "success", children: "Published" }) : isDraft ? /* @__PURE__ */ jsxRuntime.jsx(Badge, { variant: "info", children: "Draft" }) : void 0
       };
     })
@@ -22503,6 +22679,12 @@ const entityConfigSchema = z.z.object({
   description: z.z.string().max(500).optional(),
   rules: ruleGroupSchema.optional()
 });
+const skillConfigSchema = z.z.object({
+  description: z.z.string().optional(),
+  instructions: z.z.string().optional(),
+  pin: z.z.string().optional(),
+  strategy: z.z.enum(["latest", "live"]).optional()
+});
 const scorerConfigSchema = z.z.object({
   description: z.z.string().max(500).optional(),
   sampling: scoringSamplingConfigSchema.optional(),
@@ -22556,6 +22738,22 @@ const memoryConfigSchema = z.z.object({
     path: ["semanticRecall"]
   }
 );
+const inMemoryFileNodeSchema = z.z.lazy(
+  () => z.z.object({
+    id: z.z.string(),
+    name: z.z.string(),
+    type: z.z.enum(["file", "folder"]),
+    content: z.z.string().optional(),
+    children: z.z.array(inMemoryFileNodeSchema).optional()
+  })
+);
+z.z.object({
+  localId: z.z.string(),
+  name: z.z.string().min(1, "Skill name is required"),
+  description: z.z.string(),
+  workspaceId: z.z.string().min(1, "Workspace is required"),
+  files: z.z.array(inMemoryFileNodeSchema)
+});
 const agentFormSchema = z.z.object({
   name: z.z.string().min(1, "Name is required").max(100, "Name must be 100 characters or less"),
   description: z.z.string().max(500, "Description must be 500 characters or less").optional(),
@@ -22577,10 +22775,21 @@ const agentFormSchema = z.z.object({
       id: z.z.string().optional(),
       name: z.z.string().min(1),
       description: z.z.string().optional(),
-      servers: z.z.record(z.z.string(), z.z.any())
+      servers: z.z.record(z.z.string(), z.z.any()),
+      selectedTools: z.z.record(
+        z.z.string(),
+        z.z.object({
+          description: z.z.string().optional()
+        })
+      ).optional().default({})
     })
   ).optional().default([]),
-  mcpClientsToDelete: z.z.array(z.z.string()).optional().default([])
+  mcpClientsToDelete: z.z.array(z.z.string()).optional().default([]),
+  skills: z.z.record(z.z.string(), skillConfigSchema).optional().default({}),
+  workspace: z.z.discriminatedUnion("type", [
+    z.z.object({ type: z.z.literal("id"), workspaceId: z.z.string() }),
+    z.z.object({ type: z.z.literal("inline"), config: z.z.record(z.z.string(), z.z.unknown()) })
+  ]).optional()
 });
 
 const AgentCMSBlocks = ({ items, onChange, className, placeholder, schema }) => {
@@ -22669,7 +22878,8 @@ function useAgentEditForm(options = {}) {
       variables: initialValues?.variables ?? {},
       instructionBlocks: initialValues?.instructionBlocks ?? [createInstructionBlock()],
       mcpClients: initialValues?.mcpClients ?? [],
-      mcpClientsToDelete: []
+      mcpClientsToDelete: [],
+      skills: initialValues?.skills ?? {}
     }
   });
   return { form };
@@ -23807,7 +24017,7 @@ function MemorySection({ control, setValue, readOnly = false }) {
   ] }) });
 }
 
-function formatTimestamp(isoString) {
+function formatTimestamp$1(isoString) {
   const date = new Date(isoString);
   return date.toLocaleDateString(void 0, {
     month: "short",
@@ -23841,7 +24051,7 @@ function AgentVersionCombobox({
       return {
         label: `v${version.versionNumber}`,
         value: version.id,
-        description: formatTimestamp(version.createdAt),
+        description: formatTimestamp$1(version.createdAt),
         end: isPublished ? /* @__PURE__ */ jsxRuntime.jsx(Badge, { variant: "success", children: "Published" }) : isDraft ? /* @__PURE__ */ jsxRuntime.jsx(Badge, { variant: "info", children: "Draft" }) : void 0
       };
     })
@@ -23880,6 +24090,8 @@ function useSidebarDescriptions(control) {
     const workflowCount = Object.keys(values.workflows ?? {}).length;
     const workflows = workflowCount === 0 ? "None selected" : pluralize(workflowCount, "workflow");
     const memory = values.memory?.enabled ? "Enabled" : "Disabled";
+    const skillCount = Object.keys(values.skills ?? {}).length;
+    const skills = skillCount === 0 ? "None selected" : pluralize(skillCount, "skill");
     const variableCount = Object.keys(values.variables?.properties ?? {}).length;
     const variables = variableCount === 0 ? "None defined" : pluralize(variableCount, "variable");
     return {
@@ -23889,6 +24101,7 @@ function useSidebarDescriptions(control) {
       agents: { description: agents, done: agentCount > 0 },
       scorers: { description: scorers, done: scorerCount > 0 },
       workflows: { description: workflows, done: workflowCount > 0 },
+      skills: { description: skills, done: skillCount > 0 },
       memory: { description: memory, done: !!values.memory?.enabled },
       variables: { description: variables, done: variableCount > 0 }
     };
@@ -23902,6 +24115,7 @@ const AGENT_CMS_SECTIONS = [
   { name: "Agents", pathSuffix: "/agents", descriptionKey: "agents", required: false },
   { name: "Scorers", pathSuffix: "/scorers", descriptionKey: "scorers", required: false },
   { name: "Workflows", pathSuffix: "/workflows", descriptionKey: "workflows", required: false },
+  { name: "Skills", pathSuffix: "/skills", descriptionKey: "skills", required: false },
   { name: "Memory", pathSuffix: "/memory", descriptionKey: "memory", required: false },
   { name: "Variables", pathSuffix: "/variables", descriptionKey: "variables", required: false }
 ];
@@ -24015,14 +24229,24 @@ function AgentCmsBottomBar({ basePath, currentPath }) {
   ] });
 }
 
-function AgentsCmsLayout({ children, currentPath, basePath, versionId }) {
-  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "grid overflow-y-auto h-full bg-surface1 grid-cols-[240px_1fr]", children: [
-    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "overflow-y-auto h-full border-r border-border1", children: /* @__PURE__ */ jsxRuntime.jsx(AgentCmsSidebar, { basePath, currentPath, versionId }) }),
-    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col h-full overflow-hidden", children: [
-      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "overflow-y-auto flex-1 p-8 max-w-5xl w-full", children }),
-      /* @__PURE__ */ jsxRuntime.jsx(AgentCmsBottomBar, { basePath, currentPath })
-    ] })
-  ] });
+function AgentsCmsLayout({ children, currentPath, basePath, versionId, rightPanel }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      className: cn(
+        "grid overflow-y-auto h-full bg-surface1",
+        rightPanel ? "grid-cols-[240px_1fr_240px]" : "grid-cols-[240px_1fr]"
+      ),
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "overflow-y-auto h-full border-r border-border1", children: /* @__PURE__ */ jsxRuntime.jsx(AgentCmsSidebar, { basePath, currentPath, versionId }) }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col h-full overflow-hidden", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "overflow-y-auto flex-1 p-8 max-w-5xl w-full", children }),
+          /* @__PURE__ */ jsxRuntime.jsx(AgentCmsBottomBar, { basePath, currentPath })
+        ] }),
+        rightPanel && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "overflow-y-auto h-full border-l border-border1", children: rightPanel })
+      ]
+    }
+  );
 }
 
 function InformationPage() {
@@ -24646,6 +24870,7 @@ function MCPClientFormSidebar({
   onPreFillFromServer,
   containerRef,
   readOnly,
+  showSubmit,
   submitLabel = "Create MCP Client",
   onTryConnect,
   isTryingConnect
@@ -24859,8 +25084,8 @@ function MCPClientFormSidebar({
         ] })
       ] })
     ] }) }),
-    !readOnly && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex-shrink-0 p-4 flex flex-col gap-2", children: [
-      (() => {
+    (showSubmit ?? !readOnly) && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex-shrink-0 p-4 flex flex-col gap-2", children: [
+      !readOnly && (() => {
         const isDisabled = serverType !== "http" || !url.trim() || isTryingConnect;
         const tooltipContent = serverType !== "http" ? "Only available for HTTP servers" : !url.trim() ? "Enter a URL first" : void 0;
         return tooltipContent ? /* @__PURE__ */ jsxRuntime.jsx(
@@ -24892,7 +25117,14 @@ function MCPClientFormSidebar({
   ] });
 }
 
-function MCPClientToolPreview({ serverType, url, tryConnect }) {
+function MCPClientToolPreview({
+  serverType,
+  url,
+  tryConnect,
+  selectedTools,
+  onToggleTool,
+  onDescriptionChange
+}) {
   if (serverType === "stdio") {
     return /* @__PURE__ */ jsxRuntime.jsx(EmptyState, { children: /* @__PURE__ */ jsxRuntime.jsx(Txt, { className: "text-neutral3", children: "Tool preview is available for HTTP servers. Stdio servers cannot be previewed." }) });
   }
@@ -24909,37 +25141,79 @@ function MCPClientToolPreview({ serverType, url, tryConnect }) {
     ] }),
     tryConnect.isError && /* @__PURE__ */ jsxRuntime.jsx(Txt, { variant: "ui-sm", className: "text-accent2", children: tryConnect.error instanceof Error ? tryConnect.error.message : "Connection failed" }),
     tryConnect.isSuccess && tryConnect.data.tools.length === 0 && /* @__PURE__ */ jsxRuntime.jsx(Txt, { className: "text-neutral3", children: "Connected successfully but no tools were found." }),
-    tryConnect.isSuccess && tryConnect.data.tools.length > 0 && /* @__PURE__ */ jsxRuntime.jsx(ToolList, { tools: tryConnect.data.tools })
+    tryConnect.isSuccess && tryConnect.data.tools.length > 0 && /* @__PURE__ */ jsxRuntime.jsx(
+      ToolList,
+      {
+        tools: tryConnect.data.tools,
+        selectedTools,
+        onToggleTool,
+        onDescriptionChange
+      }
+    )
   ] });
 }
 function EmptyState({ children }) {
   return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex items-center justify-center h-full p-8 text-center", children });
 }
-function ToolList({ tools }) {
+function ToolList({
+  tools,
+  selectedTools = {},
+  onToggleTool,
+  onDescriptionChange
+}) {
+  const selectedCount = Object.keys(selectedTools).length;
   return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "p-5 overflow-y-auto", children: [
     /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "text-neutral6 flex gap-2 items-center", children: [
       /* @__PURE__ */ jsxRuntime.jsx(Icon, { size: "lg", className: "bg-surface4 rounded-md p-1", children: /* @__PURE__ */ jsxRuntime.jsx(McpServerIcon, {}) }),
       /* @__PURE__ */ jsxRuntime.jsxs(Txt, { variant: "header-md", as: "h2", className: "font-medium", children: [
         "Available Tools (",
+        selectedCount,
+        "/",
         tools.length,
-        ")"
+        " selected)"
       ] })
     ] }),
-    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex flex-col gap-2 pt-6", children: tools.map((tool) => /* @__PURE__ */ jsxRuntime.jsxs(Entity, { children: [
-      /* @__PURE__ */ jsxRuntime.jsx(EntityIcon, { children: /* @__PURE__ */ jsxRuntime.jsx(ToolsIcon, { className: "group-hover/entity:text-accent6" }) }),
-      /* @__PURE__ */ jsxRuntime.jsxs(EntityContent, { children: [
-        /* @__PURE__ */ jsxRuntime.jsx(EntityName, { children: tool.name }),
-        tool.description && /* @__PURE__ */ jsxRuntime.jsx(EntityDescription, { children: tool.description })
-      ] })
-    ] }, tool.name)) })
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex flex-col gap-2 pt-6", children: tools.map((tool) => {
+      const isSelected = tool.name in selectedTools;
+      const isDisabled = !onDescriptionChange || !isSelected;
+      return /* @__PURE__ */ jsxRuntime.jsxs(Entity, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(EntityIcon, { children: /* @__PURE__ */ jsxRuntime.jsx(ToolsIcon, { className: "group-hover/entity:text-accent6" }) }),
+        /* @__PURE__ */ jsxRuntime.jsxs(EntityContent, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(EntityName, { children: tool.name }),
+          /* @__PURE__ */ jsxRuntime.jsx(EntityDescription, { children: /* @__PURE__ */ jsxRuntime.jsx(
+            "input",
+            {
+              type: "text",
+              disabled: isDisabled,
+              className: cn(
+                "border border-transparent appearance-none block w-full text-neutral3 bg-transparent",
+                !isDisabled && "border-border1 border-dashed"
+              ),
+              value: isSelected ? selectedTools[tool.name]?.description ?? tool.description ?? "" : tool.description ?? "",
+              onChange: (e) => onDescriptionChange?.(tool.name, e.target.value)
+            }
+          ) })
+        ] }),
+        onToggleTool && /* @__PURE__ */ jsxRuntime.jsx(Switch, { checked: isSelected, onCheckedChange: () => onToggleTool(tool.name, tool.description) })
+      ] }, tool.name);
+    }) })
   ] });
 }
 
-function MCPClientCreateContent({ onAdd, readOnly, initialValues, submitLabel }) {
+function MCPClientCreateContent({
+  onAdd,
+  readOnly,
+  initialValues,
+  initialSelectedTools,
+  submitLabel
+}) {
   const { form } = useMCPClientForm(initialValues);
   const containerRef = React.useRef(null);
   const serverType = reactHookForm.useWatch({ control: form.control, name: "serverType" });
   const url = reactHookForm.useWatch({ control: form.control, name: "url" });
+  const [selectedTools, setSelectedTools] = React.useState(
+    initialSelectedTools ?? {}
+  );
   const tryConnect = useTryConnectMcp();
   const hasAutoConnected = React.useRef(false);
   React.useEffect(() => {
@@ -24953,6 +25227,22 @@ function MCPClientCreateContent({ onAdd, readOnly, initialValues, submitLabel })
       tryConnect.mutate(url);
     }
   }, [serverType, url, tryConnect]);
+  const handleToggleTool = React.useCallback((toolName, description) => {
+    setSelectedTools((prev) => {
+      if (toolName in prev) {
+        const next = { ...prev };
+        delete next[toolName];
+        return next;
+      }
+      return { ...prev, [toolName]: { description } };
+    });
+  }, []);
+  const handleDescriptionChange = React.useCallback((toolName, description) => {
+    setSelectedTools((prev) => ({
+      ...prev,
+      [toolName]: { ...prev[toolName], description }
+    }));
+  }, []);
   const handlePreFillFromServer = (serverId) => {
     const host = window.MASTRA_SERVER_HOST;
     const port = window.MASTRA_SERVER_PORT;
@@ -24994,7 +25284,8 @@ function MCPClientCreateContent({ onAdd, readOnly, initialValues, submitLabel })
     onAdd({
       name: values.name,
       description: values.description || void 0,
-      servers: serverConfig
+      servers: serverConfig,
+      selectedTools
     });
   };
   return /* @__PURE__ */ jsxRuntime.jsx("div", { ref: containerRef, className: "h-full min-h-0 overflow-hidden", children: /* @__PURE__ */ jsxRuntime.jsx(
@@ -25009,12 +25300,23 @@ function MCPClientCreateContent({ onAdd, readOnly, initialValues, submitLabel })
           onPreFillFromServer: handlePreFillFromServer,
           containerRef,
           readOnly,
+          showSubmit: !!onAdd,
           submitLabel,
           onTryConnect: handleTryConnect,
           isTryingConnect: tryConnect.isPending
         }
       ),
-      children: /* @__PURE__ */ jsxRuntime.jsx(MCPClientToolPreview, { serverType, url, tryConnect })
+      children: /* @__PURE__ */ jsxRuntime.jsx(
+        MCPClientToolPreview,
+        {
+          serverType,
+          url,
+          tryConnect,
+          selectedTools,
+          onToggleTool: onAdd ? handleToggleTool : void 0,
+          onDescriptionChange: onAdd ? handleDescriptionChange : void 0
+        }
+      )
     }
   ) });
 }
@@ -25048,11 +25350,29 @@ function MCPClientList() {
   const handleAdd = (config) => {
     const current = form.getValues("mcpClients") ?? [];
     form.setValue("mcpClients", [...current, config]);
+    if (Object.keys(config.selectedTools).length > 0) {
+      const currentTools = form.getValues("tools") ?? {};
+      const next = { ...currentTools };
+      for (const [name, toolConfig] of Object.entries(config.selectedTools)) {
+        next[name] = { description: toolConfig.description };
+      }
+      form.setValue("tools", next);
+    }
     setIsCreateOpen(false);
   };
   const handleUpdate = (config) => {
     if (viewIndex === null) return;
     const current = form.getValues("mcpClients") ?? [];
+    const oldClient = current[viewIndex];
+    const currentTools = form.getValues("tools") ?? {};
+    const next = { ...currentTools };
+    for (const name of Object.keys(oldClient?.selectedTools ?? {})) {
+      delete next[name];
+    }
+    for (const [name, toolConfig] of Object.entries(config.selectedTools)) {
+      next[name] = { description: toolConfig.description };
+    }
+    form.setValue("tools", next);
     const updated = [...current];
     updated[viewIndex] = { ...updated[viewIndex], ...config };
     form.setValue("mcpClients", updated);
@@ -25061,6 +25381,14 @@ function MCPClientList() {
   const handleRemove = (index) => {
     const current = form.getValues("mcpClients") ?? [];
     const removed = current[index];
+    if (removed?.selectedTools) {
+      const currentTools = form.getValues("tools") ?? {};
+      const next = { ...currentTools };
+      for (const name of Object.keys(removed.selectedTools)) {
+        delete next[name];
+      }
+      form.setValue("tools", next);
+    }
     if (removed?.id) {
       const toDelete = form.getValues("mcpClientsToDelete") ?? [];
       form.setValue("mcpClientsToDelete", [...toDelete, removed.id]);
@@ -25162,8 +25490,9 @@ function MCPClientList() {
             {
               readOnly: isViewingPersisted,
               initialValues: viewFormValues,
-              onAdd: isViewingPersisted ? void 0 : handleUpdate,
-              submitLabel: isViewingPersisted ? void 0 : "Update MCP Client"
+              initialSelectedTools: viewingClient?.selectedTools,
+              onAdd: readOnly ? void 0 : handleUpdate,
+              submitLabel: isViewingPersisted ? "Update tool selection" : "Update MCP Client"
             }
           )
         ]
@@ -25205,25 +25534,37 @@ function ToolsPage() {
     if (isSet) {
       const next = { ...selectedTools };
       delete next[toolId];
-      form.setValue("tools", next);
+      form.setValue("tools", next, { shouldDirty: true });
     } else {
-      form.setValue("tools", {
-        ...selectedTools,
-        [toolId]: { ...selectedTools?.[toolId], description: getOriginalDescription(toolId) }
-      });
+      form.setValue(
+        "tools",
+        {
+          ...selectedTools,
+          [toolId]: { ...selectedTools?.[toolId], description: getOriginalDescription(toolId) }
+        },
+        { shouldDirty: true }
+      );
     }
   };
   const handleDescriptionChange = (toolId, description) => {
-    form.setValue("tools", {
-      ...selectedTools,
-      [toolId]: { ...selectedTools?.[toolId], description }
-    });
+    form.setValue(
+      "tools",
+      {
+        ...selectedTools,
+        [toolId]: { ...selectedTools?.[toolId], description }
+      },
+      { shouldDirty: true }
+    );
   };
   const handleRulesChange = (toolId, rules) => {
-    form.setValue("tools", {
-      ...selectedTools,
-      [toolId]: { ...selectedTools?.[toolId], rules }
-    });
+    form.setValue(
+      "tools",
+      {
+        ...selectedTools,
+        [toolId]: { ...selectedTools?.[toolId], rules }
+      },
+      { shouldDirty: true }
+    );
   };
   const handleIntegrationToolsSubmit = React.useCallback(
     (providerId, tools2) => {
@@ -25236,7 +25577,7 @@ function ToolsPage() {
       for (const [id, description] of tools2) {
         next[id] = selectedIntegrationTools?.[id] || { description };
       }
-      form.setValue("integrationTools", next);
+      form.setValue("integrationTools", next, { shouldDirty: true });
     },
     [form, selectedIntegrationTools]
   );
@@ -25335,25 +25676,37 @@ function AgentsPage() {
     if (isSet) {
       const next = { ...selectedAgents };
       delete next[agentId];
-      form.setValue("agents", next);
+      form.setValue("agents", next, { shouldDirty: true });
     } else {
-      form.setValue("agents", {
-        ...selectedAgents,
-        [agentId]: { ...selectedAgents?.[agentId], description: getOriginalDescription(agentId) }
-      });
+      form.setValue(
+        "agents",
+        {
+          ...selectedAgents,
+          [agentId]: { ...selectedAgents?.[agentId], description: getOriginalDescription(agentId) }
+        },
+        { shouldDirty: true }
+      );
     }
   };
   const handleDescriptionChange = (agentId, description) => {
-    form.setValue("agents", {
-      ...selectedAgents,
-      [agentId]: { ...selectedAgents?.[agentId], description }
-    });
+    form.setValue(
+      "agents",
+      {
+        ...selectedAgents,
+        [agentId]: { ...selectedAgents?.[agentId], description }
+      },
+      { shouldDirty: true }
+    );
   };
   const handleRulesChange = (agentId, rules) => {
-    form.setValue("agents", {
-      ...selectedAgents,
-      [agentId]: { ...selectedAgents?.[agentId], rules }
-    });
+    form.setValue(
+      "agents",
+      {
+        ...selectedAgents,
+        [agentId]: { ...selectedAgents?.[agentId], rules }
+      },
+      { shouldDirty: true }
+    );
   };
   const filteredOptions = React.useMemo(() => {
     return options.filter((option) => option.label.toLowerCase().includes(search.toLowerCase()));
@@ -25437,31 +25790,47 @@ function ScorersPage() {
     if (isSet) {
       const next = { ...selectedScorers };
       delete next[scorerId];
-      form.setValue("scorers", next);
+      form.setValue("scorers", next, { shouldDirty: true });
     } else {
-      form.setValue("scorers", {
-        ...selectedScorers,
-        [scorerId]: { ...selectedScorers?.[scorerId], description: getOriginalDescription(scorerId) }
-      });
+      form.setValue(
+        "scorers",
+        {
+          ...selectedScorers,
+          [scorerId]: { ...selectedScorers?.[scorerId], description: getOriginalDescription(scorerId) }
+        },
+        { shouldDirty: true }
+      );
     }
   };
   const handleDescriptionChange = (scorerId, description) => {
-    form.setValue("scorers", {
-      ...selectedScorers,
-      [scorerId]: { ...selectedScorers?.[scorerId], description }
-    });
+    form.setValue(
+      "scorers",
+      {
+        ...selectedScorers,
+        [scorerId]: { ...selectedScorers?.[scorerId], description }
+      },
+      { shouldDirty: true }
+    );
   };
   const handleSamplingChange = (scorerId, samplingConfig) => {
-    form.setValue("scorers", {
-      ...selectedScorers,
-      [scorerId]: { ...selectedScorers?.[scorerId], sampling: samplingConfig }
-    });
+    form.setValue(
+      "scorers",
+      {
+        ...selectedScorers,
+        [scorerId]: { ...selectedScorers?.[scorerId], sampling: samplingConfig }
+      },
+      { shouldDirty: true }
+    );
   };
   const handleRulesChange = (scorerId, rules) => {
-    form.setValue("scorers", {
-      ...selectedScorers,
-      [scorerId]: { ...selectedScorers?.[scorerId], rules }
-    });
+    form.setValue(
+      "scorers",
+      {
+        ...selectedScorers,
+        [scorerId]: { ...selectedScorers?.[scorerId], rules }
+      },
+      { shouldDirty: true }
+    );
   };
   const filteredOptions = React.useMemo(() => {
     return options.filter((option) => option.label.toLowerCase().includes(search.toLowerCase()));
@@ -25605,25 +25974,37 @@ function WorkflowsPage() {
     if (isSet) {
       const next = { ...selectedWorkflows };
       delete next[workflowId];
-      form.setValue("workflows", next);
+      form.setValue("workflows", next, { shouldDirty: true });
     } else {
-      form.setValue("workflows", {
-        ...selectedWorkflows,
-        [workflowId]: { ...selectedWorkflows?.[workflowId], description: getOriginalDescription(workflowId) }
-      });
+      form.setValue(
+        "workflows",
+        {
+          ...selectedWorkflows,
+          [workflowId]: { ...selectedWorkflows?.[workflowId], description: getOriginalDescription(workflowId) }
+        },
+        { shouldDirty: true }
+      );
     }
   };
   const handleDescriptionChange = (workflowId, description) => {
-    form.setValue("workflows", {
-      ...selectedWorkflows,
-      [workflowId]: { ...selectedWorkflows?.[workflowId], description }
-    });
+    form.setValue(
+      "workflows",
+      {
+        ...selectedWorkflows,
+        [workflowId]: { ...selectedWorkflows?.[workflowId], description }
+      },
+      { shouldDirty: true }
+    );
   };
   const handleRulesChange = (workflowId, rules) => {
-    form.setValue("workflows", {
-      ...selectedWorkflows,
-      [workflowId]: { ...selectedWorkflows?.[workflowId], rules }
-    });
+    form.setValue(
+      "workflows",
+      {
+        ...selectedWorkflows,
+        [workflowId]: { ...selectedWorkflows?.[workflowId], rules }
+      },
+      { shouldDirty: true }
+    );
   };
   const filteredOptions = React.useMemo(() => {
     return options.filter((option) => option.label.toLowerCase().includes(search.toLowerCase()));
@@ -25720,22 +26101,45 @@ function MemoryPage() {
       }
     ) }),
     isEnabled && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-2", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(ObservationalMemoryEntity, {}),
       /* @__PURE__ */ jsxRuntime.jsx(LastMessagesEntity, {}),
       /* @__PURE__ */ jsxRuntime.jsx(SemanticRecallEntity, {}),
-      /* @__PURE__ */ jsxRuntime.jsx(ReadOnlyEntity, {}),
-      /* @__PURE__ */ jsxRuntime.jsx(ObservationalMemoryEntity, {})
+      /* @__PURE__ */ jsxRuntime.jsx(ReadOnlyEntity, {})
     ] })
   ] }) });
 }
 function LastMessagesEntity() {
   const { form, readOnly } = useAgentEditFormContext();
   const { control } = form;
+  const lastMessages = reactHookForm.useWatch({ control, name: "memory.lastMessages" });
+  const lastMessagesEnabled = lastMessages !== false;
   return /* @__PURE__ */ jsxRuntime.jsxs(Entity, { className: "flex-col gap-0 p-0 overflow-hidden", children: [
-    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex gap-3 py-3 px-4", children: /* @__PURE__ */ jsxRuntime.jsxs(EntityContent, { children: [
-      /* @__PURE__ */ jsxRuntime.jsx(EntityName, { children: "Last Messages" }),
-      /* @__PURE__ */ jsxRuntime.jsx(EntityDescription, { children: "Number of recent messages to include in context" })
-    ] }) }),
-    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "bg-surface2 border-t border-border1 p-4", children: /* @__PURE__ */ jsxRuntime.jsx(
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex gap-3 py-3 px-4", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(EntityContent, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(EntityName, { children: "Message History" }),
+        /* @__PURE__ */ jsxRuntime.jsx(EntityDescription, { children: "Number of recent messages to include in context" })
+      ] }),
+      !readOnly && /* @__PURE__ */ jsxRuntime.jsx(
+        reactHookForm.Controller,
+        {
+          name: "memory.lastMessages",
+          control,
+          render: ({ field }) => /* @__PURE__ */ jsxRuntime.jsx(
+            Switch,
+            {
+              checked: lastMessagesEnabled,
+              onCheckedChange: (checked) => {
+                field.onChange(checked ? 40 : false);
+                if (checked) {
+                  form.setValue("memory.observationalMemory.enabled", false, { shouldDirty: true });
+                }
+              }
+            }
+          )
+        }
+      )
+    ] }),
+    lastMessagesEnabled && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "bg-surface2 border-t border-border1 p-4", children: /* @__PURE__ */ jsxRuntime.jsx(
       reactHookForm.Controller,
       {
         name: "memory.lastMessages",
@@ -25856,7 +26260,18 @@ function ObservationalMemoryEntity() {
         {
           name: "memory.observationalMemory.enabled",
           control,
-          render: ({ field }) => /* @__PURE__ */ jsxRuntime.jsx(Switch, { checked: field.value ?? false, onCheckedChange: field.onChange })
+          render: ({ field }) => /* @__PURE__ */ jsxRuntime.jsx(
+            Switch,
+            {
+              checked: field.value ?? false,
+              onCheckedChange: (checked) => {
+                field.onChange(checked);
+                if (checked) {
+                  form.setValue("memory.lastMessages", false, { shouldDirty: true });
+                }
+              }
+            }
+          )
         }
       )
     ] }),
@@ -25885,7 +26300,7 @@ function ObservationalMemoryFields() {
                 value: field.value ?? "",
                 onValueChange: (v) => {
                   field.onChange(v);
-                  setValue("memory.observationalMemory.model.name", "");
+                  setValue("memory.observationalMemory.model.name", "", { shouldDirty: true });
                 },
                 variant: "light"
               }
@@ -25976,7 +26391,7 @@ function ObserverFields({ observerProvider }) {
                 value: field.value ?? "",
                 onValueChange: (v) => {
                   field.onChange(v);
-                  setValue("memory.observationalMemory.observation.model.name", "");
+                  setValue("memory.observationalMemory.observation.model.name", "", { shouldDirty: true });
                 },
                 variant: "light"
               }
@@ -26173,7 +26588,7 @@ function ReflectorFields({ reflectorProvider }) {
                 value: field.value ?? "",
                 onValueChange: (v) => {
                   field.onChange(v);
-                  setValue("memory.observationalMemory.reflection.model.name", "");
+                  setValue("memory.observationalMemory.reflection.model.name", "", { shouldDirty: true });
                 },
                 variant: "light"
               }
@@ -26842,118 +27257,1466 @@ function VariablesPage() {
   ] }) });
 }
 
-const arrayToRecord = (arr) => {
-  const record = {};
-  for (const id of arr) {
-    record[id] = { description: void 0 };
-  }
-  return record;
+function useStoredSkills() {
+  const client = react$1.useMastraClient();
+  return reactQuery.useQuery({
+    queryKey: ["stored-skills"],
+    queryFn: () => client.listStoredSkills()
+  });
+}
+
+const useWorkspaceInfo = (workspaceId) => {
+  const client = react$1.useMastraClient();
+  return reactQuery.useQuery({
+    queryKey: ["workspace", "info", workspaceId],
+    queryFn: async () => {
+      if (!compatibility.isWorkspaceV1Supported(client)) {
+        throw new Error("Workspace v1 not supported by core or client");
+      }
+      if (!workspaceId) {
+        throw new Error("workspaceId is required");
+      }
+      const workspace = client.getWorkspace(workspaceId);
+      return workspace.info();
+    },
+    enabled: !!workspaceId && compatibility.isWorkspaceV1Supported(client),
+    retry: compatibility.shouldRetryWorkspaceQuery
+  });
 };
-const normalizeToolsToRecord = (tools) => {
-  if (!tools) return {};
-  if (!Array.isArray(tools)) return { ...tools };
-  const result = {};
-  for (const item of tools) {
-    if (typeof item === "string") {
-      result[item] = { description: void 0 };
-    } else {
-      Object.assign(result, item.value);
-    }
-  }
-  return result;
+const useWorkspaces = () => {
+  const client = react$1.useMastraClient();
+  return reactQuery.useQuery({
+    queryKey: ["workspaces"],
+    queryFn: async () => {
+      if (!compatibility.isWorkspaceV1Supported(client)) {
+        throw new Error("Workspace v1 not supported by core or client");
+      }
+      return client.listWorkspaces();
+    },
+    retry: compatibility.shouldRetryWorkspaceQuery
+  });
 };
-const splitModelId = (id) => {
-  if (!id) return void 0;
-  const [p, ...rest] = id.split("/");
-  const n = rest.join("/");
-  return p && n ? { provider: p, name: n } : void 0;
+const useWorkspaceFiles = (path, options) => {
+  const client = react$1.useMastraClient();
+  return reactQuery.useQuery({
+    queryKey: ["workspace", "files", path, options?.recursive, options?.workspaceId],
+    queryFn: async () => {
+      if (!compatibility.isWorkspaceV1Supported(client)) {
+        throw new Error("Workspace v1 not supported by core or client");
+      }
+      if (!options?.workspaceId) {
+        throw new Error("workspaceId is required");
+      }
+      const workspace = client.getWorkspace(options.workspaceId);
+      return workspace.listFiles(path, options?.recursive);
+    },
+    enabled: options?.enabled !== false && !!path && !!options?.workspaceId && compatibility.isWorkspaceV1Supported(client),
+    retry: compatibility.shouldRetryWorkspaceQuery
+  });
 };
-const joinModelId = (m) => m?.provider && m?.name ? `${m.provider}/${m.name}` : void 0;
-const transformIntegrationToolsForApi = (integrationTools) => {
-  if (!integrationTools || Object.keys(integrationTools).length === 0) return void 0;
-  const result = {};
-  for (const [compositeKey, config] of Object.entries(integrationTools)) {
-    const separatorIndex = compositeKey.indexOf(":");
-    if (separatorIndex === -1) continue;
-    const providerId = compositeKey.slice(0, separatorIndex);
-    const toolSlug = compositeKey.slice(separatorIndex + 1);
-    if (!result[providerId]) {
-      result[providerId] = { tools: {} };
-    }
-    result[providerId].tools[toolSlug] = { description: config.description, rules: config.rules };
-  }
-  return result;
+const useWorkspaceFile = (path, options) => {
+  const client = react$1.useMastraClient();
+  return reactQuery.useQuery({
+    queryKey: ["workspace", "file", path, options?.workspaceId],
+    queryFn: async () => {
+      if (!compatibility.isWorkspaceV1Supported(client)) {
+        throw new Error("Workspace v1 not supported by core or client");
+      }
+      if (!options?.workspaceId) {
+        throw new Error("workspaceId is required");
+      }
+      const workspace = client.getWorkspace(options.workspaceId);
+      return workspace.readFile(path, options?.encoding);
+    },
+    enabled: options?.enabled !== false && !!path && !!options?.workspaceId && compatibility.isWorkspaceV1Supported(client),
+    retry: compatibility.shouldRetryWorkspaceQuery
+  });
 };
-const normalizeIntegrationToolsToRecord = (integrationTools) => {
-  if (!integrationTools) return {};
-  const result = {};
-  for (const [providerId, providerConfig] of Object.entries(integrationTools)) {
-    if (providerConfig.tools) {
-      for (const [toolSlug, toolConfig] of Object.entries(providerConfig.tools)) {
-        result[`${providerId}:${toolSlug}`] = { description: toolConfig.description, rules: toolConfig.rules };
+const useWorkspaceFileStat = (path, options) => {
+  const client = react$1.useMastraClient();
+  return reactQuery.useQuery({
+    queryKey: ["workspace", "stat", path, options?.workspaceId],
+    queryFn: async () => {
+      if (!compatibility.isWorkspaceV1Supported(client)) {
+        throw new Error("Workspace v1 not supported by core or client");
+      }
+      if (!options?.workspaceId) {
+        throw new Error("workspaceId is required");
+      }
+      const workspace = client.getWorkspace(options.workspaceId);
+      return workspace.stat(path);
+    },
+    enabled: options?.enabled !== false && !!path && !!options?.workspaceId && compatibility.isWorkspaceV1Supported(client),
+    retry: compatibility.shouldRetryWorkspaceQuery
+  });
+};
+const useWriteWorkspaceFile = () => {
+  const client = react$1.useMastraClient();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (params) => {
+      if (!compatibility.isWorkspaceV1Supported(client)) {
+        throw new Error("Workspace v1 not supported by core or client");
       }
+      const workspace = client.getWorkspace(params.workspaceId);
+      return workspace.writeFile(params.path, params.content, {
+        encoding: params.encoding,
+        recursive: params.recursive ?? true
+      });
+    },
+    onSuccess: (_, variables) => {
+      const parentPath = variables.path.split("/").slice(0, -1).join("/") || "/";
+      queryClient.invalidateQueries({ queryKey: ["workspace", "files", parentPath] });
+      queryClient.invalidateQueries({ queryKey: ["workspace", "file", variables.path] });
     }
-  }
-  return result;
+  });
 };
-const mapInstructionBlocksToApi = (blocks) => (blocks ?? []).map((block) => ({
-  type: block.type,
-  content: block.content,
-  rules: block.rules
-}));
-const mapInstructionBlocksFromApi = (instructionsRaw) => {
-  const instructionsString = Array.isArray(instructionsRaw) ? instructionsRaw.map((b) => b.type === "prompt_block" ? b.content : "").filter(Boolean).join("\n\n") : instructionsRaw || "";
-  const instructionBlocks = Array.isArray(instructionsRaw) ? instructionsRaw.filter(
-    (b) => b.type === "prompt_block"
-  ).map((b) => createInstructionBlock(b.content, b.rules)) : [createInstructionBlock(instructionsRaw || "")];
-  return { instructionsString, instructionBlocks };
+const useWriteWorkspaceFileFromFile = () => {
+  const client = react$1.useMastraClient();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (params) => {
+      if (!compatibility.isWorkspaceV1Supported(client)) {
+        throw new Error("Workspace v1 not supported by core or client");
+      }
+      const arrayBuffer = await params.file.arrayBuffer();
+      const base64 = btoa(new Uint8Array(arrayBuffer).reduce((data, byte) => data + String.fromCharCode(byte), ""));
+      const workspace = client.getWorkspace(params.workspaceId);
+      return workspace.writeFile(params.path, base64, {
+        encoding: "base64",
+        recursive: params.recursive ?? true
+      });
+    },
+    onSuccess: (_, variables) => {
+      const parentPath = variables.path.split("/").slice(0, -1).join("/") || "/";
+      queryClient.invalidateQueries({ queryKey: ["workspace", "files", parentPath] });
+      queryClient.invalidateQueries({ queryKey: ["workspace", "file", variables.path] });
+    }
+  });
 };
-const mapScorersToApi = (scorers) => {
-  const entries = scorers ? Object.entries(scorers) : void 0;
-  if (!entries) return void 0;
-  return Object.fromEntries(
-    entries.map(([key, value]) => [
-      key,
-      {
-        description: value.description,
-        sampling: value.sampling ? {
-          type: value.sampling.type,
-          rate: value.sampling.rate || 0
-        } : void 0,
-        rules: value.rules
+const useDeleteWorkspaceFile = () => {
+  const client = react$1.useMastraClient();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (params) => {
+      if (!compatibility.isWorkspaceV1Supported(client)) {
+        throw new Error("Workspace v1 not supported by core or client");
       }
-    ])
-  );
+      const workspace = client.getWorkspace(params.workspaceId);
+      return workspace.delete(params.path, {
+        recursive: params.recursive,
+        force: params.force
+      });
+    },
+    onSuccess: (_, variables) => {
+      const parentPath = variables.path.split("/").slice(0, -1).join("/") || "/";
+      queryClient.invalidateQueries({ queryKey: ["workspace", "files", parentPath] });
+      queryClient.invalidateQueries({ queryKey: ["workspace", "file", variables.path] });
+    }
+  });
 };
-const normalizeScorersFromApi = (scorers) => {
-  if (!scorers) return {};
-  let record;
-  if (Array.isArray(scorers)) {
-    record = {};
-    for (const variant of scorers) {
-      Object.assign(record, variant.value);
+const useCreateWorkspaceDirectory = () => {
+  const client = react$1.useMastraClient();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (params) => {
+      if (!compatibility.isWorkspaceV1Supported(client)) {
+        throw new Error("Workspace v1 not supported by core or client");
+      }
+      const workspace = client.getWorkspace(params.workspaceId);
+      return workspace.mkdir(params.path, params.recursive);
+    },
+    onSuccess: (_, variables) => {
+      const parentPath = variables.path.split("/").slice(0, -1).join("/") || "/";
+      queryClient.invalidateQueries({ queryKey: ["workspace", "files", parentPath] });
     }
-  } else {
-    record = scorers;
-  }
-  const result = {};
-  for (const [key, value] of Object.entries(record)) {
-    result[key] = {
-      description: value.description,
-      sampling: value.sampling?.type === "ratio" ? { type: "ratio", rate: value.sampling.rate } : void 0,
-      rules: value.rules
-    };
-  }
-  return result;
+  });
 };
-const buildObservationalMemoryForApi = (om) => {
-  if (!om?.enabled) return void 0;
-  const modelId = joinModelId(om.model);
-  const obsModelId = joinModelId(om.observation?.model);
-  const observation = obsModelId || om.observation?.messageTokens || om.observation?.maxTokensPerBatch || om.observation?.bufferTokens !== void 0 || om.observation?.bufferActivation !== void 0 || om.observation?.blockAfter !== void 0 ? {
-    model: obsModelId,
-    messageTokens: om.observation?.messageTokens,
-    maxTokensPerBatch: om.observation?.maxTokensPerBatch,
+const useSearchWorkspace = () => {
+  const client = react$1.useMastraClient();
+  return reactQuery.useMutation({
+    mutationFn: async (params) => {
+      if (!compatibility.isWorkspaceV1Supported(client)) {
+        throw new Error("Workspace v1 not supported by core or client");
+      }
+      const workspace = client.getWorkspace(params.workspaceId);
+      return workspace.search({
+        query: params.query,
+        topK: params.topK,
+        mode: params.mode,
+        minScore: params.minScore
+      });
+    }
+  });
+};
+const useIndexWorkspaceContent = () => {
+  const client = react$1.useMastraClient();
+  return reactQuery.useMutation({
+    mutationFn: async (params) => {
+      if (!compatibility.isWorkspaceV1Supported(client)) {
+        throw new Error("Workspace v1 not supported by core or client");
+      }
+      const workspace = client.getWorkspace(params.workspaceId);
+      return workspace.index({
+        path: params.path,
+        content: params.content,
+        metadata: params.metadata
+      });
+    }
+  });
+};
+
+const useWorkspaceSkills = (options) => {
+  const client = react$1.useMastraClient();
+  return reactQuery.useQuery({
+    queryKey: ["workspace", "skills", options?.workspaceId],
+    queryFn: async () => {
+      if (!compatibility.isWorkspaceV1Supported(client)) {
+        throw new Error("Workspace v1 not supported by core or client");
+      }
+      if (!options?.workspaceId) {
+        throw new Error("workspaceId is required");
+      }
+      const workspace = client.getWorkspace(options.workspaceId);
+      return workspace.listSkills();
+    },
+    enabled: !!options?.workspaceId && compatibility.isWorkspaceV1Supported(client),
+    retry: compatibility.shouldRetryWorkspaceQuery
+  });
+};
+const useWorkspaceSkill = (skillName, options) => {
+  const client = react$1.useMastraClient();
+  return reactQuery.useQuery({
+    queryKey: ["workspace", "skills", skillName, options?.workspaceId],
+    queryFn: async () => {
+      if (!compatibility.isWorkspaceV1Supported(client)) {
+        throw new Error("Workspace v1 not supported by core or client");
+      }
+      if (!options?.workspaceId) {
+        throw new Error("workspaceId is required");
+      }
+      const workspace = client.getWorkspace(options.workspaceId);
+      const skill = workspace.getSkill(skillName);
+      return skill.details();
+    },
+    enabled: options?.enabled !== false && !!skillName && !!options?.workspaceId && compatibility.isWorkspaceV1Supported(client),
+    retry: compatibility.shouldRetryWorkspaceQuery
+  });
+};
+const useWorkspaceSkillReferences = (skillName, options) => {
+  const client = react$1.useMastraClient();
+  return reactQuery.useQuery({
+    queryKey: ["workspace", "skills", skillName, "references", options?.workspaceId],
+    queryFn: async () => {
+      if (!compatibility.isWorkspaceV1Supported(client)) {
+        throw new Error("Workspace v1 not supported by core or client");
+      }
+      if (!options?.workspaceId) {
+        throw new Error("workspaceId is required");
+      }
+      const workspace = client.getWorkspace(options.workspaceId);
+      const skill = workspace.getSkill(skillName);
+      return skill.listReferences();
+    },
+    enabled: options?.enabled !== false && !!skillName && !!options?.workspaceId && compatibility.isWorkspaceV1Supported(client),
+    retry: compatibility.shouldRetryWorkspaceQuery
+  });
+};
+const useWorkspaceSkillReference = (skillName, referencePath, options) => {
+  const client = react$1.useMastraClient();
+  return reactQuery.useQuery({
+    queryKey: ["workspace", "skills", skillName, "references", referencePath, options?.workspaceId],
+    queryFn: async () => {
+      if (!compatibility.isWorkspaceV1Supported(client)) {
+        throw new Error("Workspace v1 not supported by core or client");
+      }
+      if (!options?.workspaceId) {
+        throw new Error("workspaceId is required");
+      }
+      const workspace = client.getWorkspace(options.workspaceId);
+      const skill = workspace.getSkill(skillName);
+      return skill.getReference(referencePath);
+    },
+    enabled: options?.enabled !== false && !!skillName && !!referencePath && !!options?.workspaceId && compatibility.isWorkspaceV1Supported(client),
+    retry: compatibility.shouldRetryWorkspaceQuery
+  });
+};
+const useSearchWorkspaceSkills = () => {
+  const client = react$1.useMastraClient();
+  return reactQuery.useMutation({
+    mutationFn: async (params) => {
+      if (!compatibility.isWorkspaceV1Supported(client)) {
+        throw new Error("Workspace v1 not supported by core or client");
+      }
+      const workspace = client.getWorkspace(params.workspaceId);
+      return workspace.searchSkills(params);
+    }
+  });
+};
+const useAgentSkill = (agentId, skillName, options) => {
+  const client = react$1.useMastraClient();
+  return reactQuery.useQuery({
+    queryKey: ["agents", agentId, "skills", skillName, options?.workspaceId],
+    queryFn: async () => {
+      if (!compatibility.isWorkspaceV1Supported(client)) {
+        throw new Error("Workspace v1 not supported by core or client");
+      }
+      if (!options?.workspaceId) {
+        throw new Error("workspaceId is required");
+      }
+      const workspace = client.getWorkspace(options.workspaceId);
+      const skill = workspace.getSkill(skillName);
+      return skill.details();
+    },
+    enabled: options?.enabled !== false && !!agentId && !!skillName && !!options?.workspaceId && compatibility.isWorkspaceV1Supported(client),
+    retry: compatibility.shouldRetryWorkspaceQuery
+  });
+};
+
+const useSearchSkillsSh = (workspaceId) => {
+  const client = react$1.useMastraClient();
+  return reactQuery.useMutation({
+    mutationFn: async (query) => {
+      if (!workspaceId) {
+        throw new Error("Workspace ID is required");
+      }
+      const baseUrl = client.options.baseUrl || "";
+      const url = `${baseUrl}/api/workspaces/${workspaceId}/skills-sh/search?q=${encodeURIComponent(query)}&limit=10`;
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`Failed to search skills: ${response.statusText}`);
+      }
+      return response.json().catch(() => {
+        throw new Error("Invalid response from server");
+      });
+    }
+  });
+};
+const usePopularSkillsSh = (workspaceId) => {
+  const client = react$1.useMastraClient();
+  return reactQuery.useQuery({
+    queryKey: ["skills-sh", "popular", workspaceId],
+    queryFn: async () => {
+      if (!workspaceId) {
+        throw new Error("Workspace ID is required");
+      }
+      const baseUrl = client.options.baseUrl || "";
+      const url = `${baseUrl}/api/workspaces/${workspaceId}/skills-sh/popular?limit=10&offset=0`;
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch popular skills: ${response.statusText}`);
+      }
+      return response.json().catch(() => {
+        throw new Error("Invalid response from server");
+      });
+    },
+    staleTime: 5 * 60 * 1e3,
+    // 5 minutes
+    enabled: !!workspaceId
+  });
+};
+const useSkillPreview = (workspaceId, owner, repo, skillPath, options) => {
+  const client = react$1.useMastraClient();
+  return reactQuery.useQuery({
+    queryKey: ["skills-sh", "preview", workspaceId, owner, repo, skillPath],
+    queryFn: async () => {
+      if (!workspaceId || !owner || !repo || !skillPath) {
+        throw new Error("workspaceId, owner, repo, and skillPath are required");
+      }
+      const baseUrl = client.options.baseUrl || "";
+      const params = new URLSearchParams({ owner, repo, path: skillPath });
+      const url = `${baseUrl}/api/workspaces/${workspaceId}/skills-sh/preview?${params}`;
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch preview: ${response.statusText}`);
+      }
+      const data = await response.json().catch(() => {
+        throw new Error("Invalid response from server");
+      });
+      return data.content;
+    },
+    enabled: options?.enabled !== false && !!workspaceId && !!owner && !!repo && !!skillPath,
+    retry: false
+  });
+};
+const useInstallSkill = () => {
+  const client = react$1.useMastraClient();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (params) => {
+      const [owner, repo] = params.repository.split("/");
+      if (!owner || !repo) {
+        throw new Error("Invalid repository format. Expected owner/repo");
+      }
+      const baseUrl = client.options.baseUrl || "";
+      const url = `${baseUrl}/api/workspaces/${params.workspaceId}/skills-sh/install`;
+      const body = { owner, repo, skillName: params.skillName };
+      if (params.mount) {
+        body.mount = params.mount;
+      }
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        throw new Error(error.error || error.message || `Failed to install skill: ${response.statusText}`);
+      }
+      return response.json().catch(() => {
+        throw new Error("Invalid response from server");
+      });
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({ queryKey: ["workspace", "skills", variables.workspaceId] });
+    }
+  });
+};
+const useUpdateSkills = () => {
+  const client = react$1.useMastraClient();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (params) => {
+      const baseUrl = client.options.baseUrl || "";
+      const url = `${baseUrl}/api/workspaces/${params.workspaceId}/skills-sh/update`;
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ skillName: params.skillName })
+      });
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        throw new Error(error.error || error.message || `Failed to update skill: ${response.statusText}`);
+      }
+      return response.json().catch(() => {
+        throw new Error("Invalid response from server");
+      });
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({ queryKey: ["workspace", "skills", variables.workspaceId] });
+    }
+  });
+};
+const useRemoveSkill = () => {
+  const client = react$1.useMastraClient();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (params) => {
+      const baseUrl = client.options.baseUrl || "";
+      const url = `${baseUrl}/api/workspaces/${params.workspaceId}/skills-sh/remove`;
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ skillName: params.skillName })
+      });
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        throw new Error(error.error || error.message || `Failed to remove skill: ${response.statusText}`);
+      }
+      return response.json().catch(() => {
+        throw new Error("Invalid response from server");
+      });
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({ queryKey: ["workspace", "skills", variables.workspaceId] });
+    }
+  });
+};
+function parseSkillSource(topSource, skillName) {
+  let cleanSource = topSource.replace(/^https?:\/\//, "");
+  cleanSource = cleanSource.replace(/^github\.com\//, "");
+  cleanSource = cleanSource.replace(/\/$/, "");
+  const parts = cleanSource.split("/").filter(Boolean);
+  if (parts.length < 2) {
+    return null;
+  }
+  const owner = parts[0];
+  const repo = parts[1];
+  let skillPath;
+  if (parts.length > 2) {
+    skillPath = parts.slice(2).join("/");
+  } else if (skillName) {
+    skillPath = skillName;
+  } else {
+    return null;
+  }
+  return {
+    owner,
+    repo,
+    skillPath
+  };
+}
+
+const TreeContext = React__namespace.createContext(null);
+function TreeProvider({ children, value }) {
+  return /* @__PURE__ */ jsxRuntime.jsx(TreeContext.Provider, { value, children });
+}
+function useTreeContext() {
+  return React__namespace.useContext(TreeContext);
+}
+const TreeDepthContext = React__namespace.createContext(0);
+function TreeDepthProvider({ children, depth }) {
+  return /* @__PURE__ */ jsxRuntime.jsx(TreeDepthContext.Provider, { value: depth, children });
+}
+function useTreeDepth() {
+  return React__namespace.useContext(TreeDepthContext);
+}
+
+const TreeRoot = React__namespace.forwardRef(
+  ({ selectedId, onSelect, className, children }, ref) => {
+    const contextValue = React__namespace.useMemo(() => ({ selectedId, onSelect }), [selectedId, onSelect]);
+    return /* @__PURE__ */ jsxRuntime.jsx(TreeProvider, { value: contextValue, children: /* @__PURE__ */ jsxRuntime.jsx(TreeDepthProvider, { depth: 0, children: /* @__PURE__ */ jsxRuntime.jsx("ul", { ref, role: "tree", className: cn("flex flex-col text-xs", className), children }) }) });
+  }
+);
+TreeRoot.displayName = "Tree";
+
+const TreeFolder = React__namespace.forwardRef(
+  ({ defaultOpen, open, onOpenChange, className, children }, ref) => {
+    return /* @__PURE__ */ jsxRuntime.jsx("li", { ref, role: "treeitem", className: cn("flex flex-col", className), children: /* @__PURE__ */ jsxRuntime.jsx(Collapsible, { defaultOpen, open, onOpenChange, children }) });
+  }
+);
+TreeFolder.displayName = "Tree.Folder";
+
+const TreeFolderTrigger = React__namespace.forwardRef(
+  ({ className, children, actions }, ref) => {
+    const depth = useTreeDepth();
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        ref,
+        className: cn(
+          "group flex h-7 min-w-0 w-full items-center rounded-sm hover:bg-surface4",
+          transitions.colors,
+          className
+        ),
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsxs(
+            CollapsibleTrigger,
+            {
+              className: cn(
+                "flex h-7 min-w-0 flex-1 cursor-pointer items-center gap-1.5 rounded-sm px-1",
+                focusRing.visible
+              ),
+              style: { paddingLeft: depth * 12 },
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ChevronRight, { className: "size-3 shrink-0 text-neutral3" }),
+                children
+              ]
+            }
+          ),
+          actions && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "shrink-0 pr-1", onClick: (e) => e.stopPropagation(), children: actions })
+        ]
+      }
+    );
+  }
+);
+TreeFolderTrigger.displayName = "Tree.FolderTrigger";
+
+const TreeFolderContent = React__namespace.forwardRef(
+  ({ className, children }, ref) => {
+    const depth = useTreeDepth();
+    return /* @__PURE__ */ jsxRuntime.jsx(CollapsibleContent, { ref, className: cn(className), children: /* @__PURE__ */ jsxRuntime.jsx(TreeDepthProvider, { depth: depth + 1, children: /* @__PURE__ */ jsxRuntime.jsx("ul", { role: "group", className: "flex flex-col", children }) }) });
+  }
+);
+TreeFolderContent.displayName = "Tree.FolderContent";
+
+const TreeFile = React__namespace.forwardRef(({ id, className, children }, ref) => {
+  const treeCtx = useTreeContext();
+  const depth = useTreeDepth();
+  const isSelected = id != null && treeCtx?.selectedId === id;
+  const handleClick = () => {
+    if (id != null && treeCtx?.onSelect) {
+      treeCtx.onSelect(id);
+    }
+  };
+  const handleKeyDown = (e) => {
+    if ((e.key === "Enter" || e.key === " ") && id != null && treeCtx?.onSelect) {
+      e.preventDefault();
+      treeCtx.onSelect(id);
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "li",
+    {
+      ref,
+      role: "treeitem",
+      "aria-selected": isSelected || void 0,
+      tabIndex: 0,
+      className: cn(
+        "group flex h-7 min-w-0 cursor-pointer items-center gap-1.5 rounded-sm px-1",
+        transitions.colors,
+        focusRing.visible,
+        "hover:bg-surface4",
+        isSelected && "bg-surface4 text-neutral6",
+        className
+      ),
+      style: { paddingLeft: depth * 12 + 18 },
+      onClick: handleClick,
+      onKeyDown: handleKeyDown,
+      children
+    }
+  );
+});
+TreeFile.displayName = "Tree.File";
+
+const TreeIcon = React__namespace.forwardRef(({ className, children }, ref) => /* @__PURE__ */ jsxRuntime.jsx("span", { ref, className: cn("flex shrink-0 items-center [&>svg]:size-3.5", className), children }));
+TreeIcon.displayName = "Tree.Icon";
+
+const TreeLabel = React__namespace.forwardRef(({ className, children }, ref) => /* @__PURE__ */ jsxRuntime.jsx("span", { ref, className: cn("truncate text-neutral5", className), children }));
+TreeLabel.displayName = "Tree.Label";
+
+const TreeInput = React__namespace.forwardRef(
+  ({ type, onSubmit, onCancel, defaultValue = "", placeholder, autoFocus = true, className }, ref) => {
+    const depth = useTreeDepth();
+    const inputRef = React__namespace.useRef(null);
+    const submittedRef = React__namespace.useRef(false);
+    const handleSubmit = React__namespace.useCallback(
+      (value) => {
+        if (submittedRef.current) return;
+        const trimmed = value.trim();
+        if (trimmed) {
+          submittedRef.current = true;
+          onSubmit(trimmed);
+        } else {
+          onCancel?.();
+        }
+      },
+      [onSubmit, onCancel]
+    );
+    const handleKeyDown = React__namespace.useCallback(
+      (e) => {
+        if (e.key === "Enter") {
+          e.preventDefault();
+          handleSubmit(e.currentTarget.value);
+        } else if (e.key === "Escape") {
+          e.preventDefault();
+          onCancel?.();
+        }
+      },
+      [handleSubmit, onCancel]
+    );
+    const handleBlur = React__namespace.useCallback(
+      (e) => {
+        handleSubmit(e.currentTarget.value);
+      },
+      [handleSubmit]
+    );
+    const handleFocus = React__namespace.useCallback((e) => {
+      e.currentTarget.select();
+    }, []);
+    const Icon = type === "folder" ? lucideReact.Folder : lucideReact.File;
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "li",
+      {
+        ref,
+        role: "treeitem",
+        className: cn(
+          "group flex h-7 min-w-0 items-center gap-1.5 rounded-sm px-1",
+          transitions.colors,
+          "focus-within:outline-none focus-within:ring-1 focus-within:ring-accent1 focus-within:shadow-focus-ring",
+          className
+        ),
+        style: { paddingLeft: depth * 12 + 18 },
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "flex shrink-0 items-center [&>svg]:size-3.5", children: /* @__PURE__ */ jsxRuntime.jsx(Icon, { className: "text-neutral3" }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "input",
+            {
+              ref: inputRef,
+              type: "text",
+              defaultValue,
+              placeholder,
+              autoFocus,
+              onKeyDown: handleKeyDown,
+              onBlur: handleBlur,
+              onFocus: handleFocus,
+              className: "min-w-0 flex-1 border-none bg-transparent text-xs text-neutral5 outline-none placeholder:text-neutral3"
+            }
+          )
+        ]
+      }
+    );
+  }
+);
+TreeInput.displayName = "Tree.Input";
+
+const Tree = Object.assign(TreeRoot, {
+  Folder: TreeFolder,
+  FolderTrigger: TreeFolderTrigger,
+  FolderContent: TreeFolderContent,
+  File: TreeFile,
+  Icon: TreeIcon,
+  Label: TreeLabel,
+  Input: TreeInput
+});
+
+const STRUCTURAL_IDS = /* @__PURE__ */ new Set(["root", "skill-md", "license-md", "references", "scripts", "assets"]);
+function slugify(name) {
+  return name.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function createInitialStructure(name) {
+  const slug = slugify(name) || "untitled";
+  return [
+    {
+      id: "root",
+      name: slug,
+      type: "folder",
+      children: [
+        { id: "skill-md", name: "SKILL.md", type: "file", content: "" },
+        { id: "license-md", name: "LICENSE.md", type: "file", content: "" },
+        { id: "references", name: "references", type: "folder", children: [] },
+        { id: "scripts", name: "scripts", type: "folder", children: [] },
+        { id: "assets", name: "assets", type: "folder", children: [] }
+      ]
+    }
+  ];
+}
+function updateRootFolderName(files, name) {
+  const slug = slugify(name) || "untitled";
+  return files.map((node) => node.id === "root" ? { ...node, name: slug } : node);
+}
+function extractSkillInstructions(files) {
+  const root = files.find((n) => n.id === "root");
+  if (!root?.children) return "";
+  const skillMd = root.children.find((n) => n.id === "skill-md");
+  return skillMd?.content ?? "";
+}
+function extractSkillLicense(files) {
+  const root = files.find((n) => n.id === "root");
+  if (!root?.children) return void 0;
+  const licenseMd = root.children.find((n) => n.id === "license-md");
+  const content = licenseMd?.content?.trim();
+  return content || void 0;
+}
+function isImageContent(content) {
+  return !!content && content.startsWith("data:image/");
+}
+function getFileIcon$1(name) {
+  const ext = name.split(".").pop()?.toLowerCase();
+  switch (ext) {
+    case "ts":
+    case "tsx":
+    case "js":
+    case "jsx":
+      return /* @__PURE__ */ jsxRuntime.jsx(lucideReact.FileCode, { className: "text-blue-400" });
+    case "json":
+      return /* @__PURE__ */ jsxRuntime.jsx(lucideReact.FileJson, { className: "text-yellow-400" });
+    case "md":
+    case "mdx":
+      return /* @__PURE__ */ jsxRuntime.jsx(lucideReact.FileText, { className: "text-neutral4" });
+    case "png":
+    case "jpg":
+    case "jpeg":
+    case "gif":
+    case "svg":
+    case "webp":
+      return /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Image, { className: "text-purple-400" });
+    default:
+      return /* @__PURE__ */ jsxRuntime.jsx(lucideReact.File, { className: "text-neutral4" });
+  }
+}
+function getFolderIcon(isOpen) {
+  return isOpen ? /* @__PURE__ */ jsxRuntime.jsx(lucideReact.FolderOpen, { className: "text-amber-400" }) : /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Folder, { className: "text-amber-400" });
+}
+function insertNode(nodes, parentId, newNode) {
+  return nodes.map((node) => {
+    if (node.id === parentId && node.type === "folder") {
+      return { ...node, children: [...node.children ?? [], newNode] };
+    }
+    if (node.children) {
+      return { ...node, children: insertNode(node.children, parentId, newNode) };
+    }
+    return node;
+  });
+}
+function removeNode(nodes, nodeId) {
+  return nodes.filter((node) => node.id !== nodeId).map((node) => {
+    if (node.children) {
+      return { ...node, children: removeNode(node.children, nodeId) };
+    }
+    return node;
+  });
+}
+function updateNodeContent(nodes, nodeId, content) {
+  return nodes.map((node) => {
+    if (node.id === nodeId) {
+      return { ...node, content };
+    }
+    if (node.children) {
+      return { ...node, children: updateNodeContent(node.children, nodeId, content) };
+    }
+    return node;
+  });
+}
+function FolderAddAction({ tooltip, onClick }) {
+  return /* @__PURE__ */ jsxRuntime.jsx("span", { className: "opacity-0 group-hover:opacity-100", children: /* @__PURE__ */ jsxRuntime.jsx(IconButton, { size: "sm", variant: "ghost", tooltip, onClick, children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Plus, {}) }) });
+}
+function FileDeleteAction({ nodeId, onRemove }) {
+  return /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ml-auto shrink-0 opacity-0 group-hover:opacity-100", children: /* @__PURE__ */ jsxRuntime.jsx(
+    IconButton,
+    {
+      size: "sm",
+      variant: "ghost",
+      tooltip: "Delete file",
+      onClick: (e) => {
+        e.stopPropagation();
+        onRemove(nodeId);
+      },
+      children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Trash2, {})
+    }
+  ) });
+}
+function UserFileList({
+  nodes,
+  readOnly,
+  onRemove
+}) {
+  return nodes.filter((n) => !STRUCTURAL_IDS.has(n.id)).map((node) => /* @__PURE__ */ jsxRuntime.jsxs(Tree.File, { id: node.id, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(Tree.Icon, { children: getFileIcon$1(node.name) }),
+    /* @__PURE__ */ jsxRuntime.jsx(Tree.Label, { children: node.name }),
+    !readOnly && !STRUCTURAL_IDS.has(node.id) && /* @__PURE__ */ jsxRuntime.jsx(FileDeleteAction, { nodeId: node.id, onRemove })
+  ] }, node.id));
+}
+function SkillFileTree({ files, onChange, selectedFileId, onSelectFile, readOnly }) {
+  const [pendingInput, setPendingInput] = React.useState(null);
+  const [openFolders, setOpenFolders] = React.useState({
+    references: true,
+    scripts: true,
+    assets: true
+  });
+  const imageInputRef = React.useRef(null);
+  const setFolderOpen = React.useCallback((folderId, open) => {
+    setOpenFolders((prev) => ({ ...prev, [folderId]: open }));
+  }, []);
+  const handleAddFile = React.useCallback(
+    (parentId) => {
+      setFolderOpen(parentId, true);
+      setPendingInput({ parentId, type: "file" });
+    },
+    [setFolderOpen]
+  );
+  const handleAddImage = React.useCallback(() => {
+    setFolderOpen("assets", true);
+    imageInputRef.current?.click();
+  }, [setFolderOpen]);
+  const handleImagePicked = React.useCallback(
+    (e) => {
+      const file = e.target.files?.[0];
+      if (!file) return;
+      const reader = new FileReader();
+      reader.onload = () => {
+        const base64 = reader.result;
+        const newNode = {
+          id: uuid.v4(),
+          name: file.name,
+          type: "file",
+          content: base64
+        };
+        onChange(insertNode(files, "assets", newNode));
+        onSelectFile(newNode.id);
+      };
+      reader.readAsDataURL(file);
+      e.target.value = "";
+    },
+    [files, onChange, onSelectFile]
+  );
+  const handleInputSubmit = React.useCallback(
+    (name) => {
+      if (!pendingInput) return;
+      const newNode = {
+        id: uuid.v4(),
+        name,
+        type: "file",
+        content: ""
+      };
+      onChange(insertNode(files, pendingInput.parentId, newNode));
+      setPendingInput(null);
+    },
+    [pendingInput, files, onChange]
+  );
+  const handleInputCancel = React.useCallback(() => {
+    setPendingInput(null);
+  }, []);
+  const handleRemove = React.useCallback(
+    (nodeId) => {
+      if (STRUCTURAL_IDS.has(nodeId)) return;
+      if (selectedFileId === nodeId) {
+        onSelectFile(null);
+      }
+      onChange(removeNode(files, nodeId));
+    },
+    [files, onChange, selectedFileId, onSelectFile]
+  );
+  const root = files.find((n) => n.id === "root");
+  if (!root?.children) return null;
+  const referencesFolder = root.children.find((n) => n.id === "references");
+  const scriptsFolder = root.children.find((n) => n.id === "scripts");
+  const assetsFolder = root.children.find((n) => n.id === "assets");
+  return /* @__PURE__ */ jsxRuntime.jsxs(TooltipProvider, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx("input", { ref: imageInputRef, type: "file", accept: "image/*", className: "hidden", onChange: handleImagePicked }),
+    /* @__PURE__ */ jsxRuntime.jsx(Tree, { selectedId: selectedFileId ?? void 0, onSelect: onSelectFile, children: /* @__PURE__ */ jsxRuntime.jsxs(Tree.Folder, { defaultOpen: true, children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(Tree.FolderTrigger, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(Tree.Icon, { children: getFolderIcon(true) }),
+        /* @__PURE__ */ jsxRuntime.jsx(Tree.Label, { children: root.name })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs(Tree.FolderContent, { children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(Tree.File, { id: "skill-md", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(Tree.Icon, { children: getFileIcon$1("SKILL.md") }),
+          /* @__PURE__ */ jsxRuntime.jsx(Tree.Label, { children: "SKILL.md" })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs(Tree.File, { id: "license-md", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(Tree.Icon, { children: getFileIcon$1("LICENSE.md") }),
+          /* @__PURE__ */ jsxRuntime.jsx(Tree.Label, { children: "LICENSE.md" })
+        ] }),
+        referencesFolder && /* @__PURE__ */ jsxRuntime.jsxs(Tree.Folder, { open: openFolders.references, onOpenChange: (open) => setFolderOpen("references", open), children: [
+          /* @__PURE__ */ jsxRuntime.jsxs(
+            Tree.FolderTrigger,
+            {
+              actions: !readOnly && /* @__PURE__ */ jsxRuntime.jsx(FolderAddAction, { tooltip: "New file", onClick: () => handleAddFile("references") }),
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx(Tree.Icon, { children: getFolderIcon(openFolders.references) }),
+                /* @__PURE__ */ jsxRuntime.jsx(Tree.Label, { children: "references" })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsxs(Tree.FolderContent, { children: [
+            /* @__PURE__ */ jsxRuntime.jsx(UserFileList, { nodes: referencesFolder.children ?? [], readOnly, onRemove: handleRemove }),
+            pendingInput?.parentId === "references" && /* @__PURE__ */ jsxRuntime.jsx(Tree.Input, { type: "file", onSubmit: handleInputSubmit, onCancel: handleInputCancel })
+          ] })
+        ] }),
+        scriptsFolder && /* @__PURE__ */ jsxRuntime.jsxs(Tree.Folder, { open: openFolders.scripts, onOpenChange: (open) => setFolderOpen("scripts", open), children: [
+          /* @__PURE__ */ jsxRuntime.jsxs(
+            Tree.FolderTrigger,
+            {
+              actions: !readOnly && /* @__PURE__ */ jsxRuntime.jsx(FolderAddAction, { tooltip: "New file", onClick: () => handleAddFile("scripts") }),
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx(Tree.Icon, { children: getFolderIcon(openFolders.scripts) }),
+                /* @__PURE__ */ jsxRuntime.jsx(Tree.Label, { children: "scripts" })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsxs(Tree.FolderContent, { children: [
+            /* @__PURE__ */ jsxRuntime.jsx(UserFileList, { nodes: scriptsFolder.children ?? [], readOnly, onRemove: handleRemove }),
+            pendingInput?.parentId === "scripts" && /* @__PURE__ */ jsxRuntime.jsx(Tree.Input, { type: "file", onSubmit: handleInputSubmit, onCancel: handleInputCancel })
+          ] })
+        ] }),
+        assetsFolder && /* @__PURE__ */ jsxRuntime.jsxs(Tree.Folder, { open: openFolders.assets, onOpenChange: (open) => setFolderOpen("assets", open), children: [
+          /* @__PURE__ */ jsxRuntime.jsxs(
+            Tree.FolderTrigger,
+            {
+              actions: !readOnly && /* @__PURE__ */ jsxRuntime.jsx(FolderAddAction, { tooltip: "Add image", onClick: handleAddImage }),
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx(Tree.Icon, { children: getFolderIcon(openFolders.assets) }),
+                /* @__PURE__ */ jsxRuntime.jsx(Tree.Label, { children: "assets" })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(Tree.FolderContent, { children: /* @__PURE__ */ jsxRuntime.jsx(UserFileList, { nodes: assetsFolder.children ?? [], readOnly, onRemove: handleRemove }) })
+        ] })
+      ] })
+    ] }) })
+  ] });
+}
+
+function flattenFiles(nodes, basePath) {
+  const results = [];
+  for (const node of nodes) {
+    const nodePath = basePath ? `${basePath}/${node.name}` : node.name;
+    if (node.type === "file" && node.content !== void 0) {
+      results.push({ path: nodePath, content: node.content });
+    } else if (node.type === "folder" && node.children) {
+      results.push(...flattenFiles(node.children, nodePath));
+    }
+  }
+  return results;
+}
+function useCreateSkill() {
+  const client = react$1.useMastraClient();
+  const queryClient = reactQuery.useQueryClient();
+  const writeFile = useWriteWorkspaceFile();
+  return reactQuery.useMutation({
+    mutationFn: async (params) => {
+      const { name, description, workspaceId, files } = params;
+      const filesToWrite = flattenFiles(files, "");
+      await Promise.all(
+        filesToWrite.map(
+          (file) => writeFile.mutateAsync({
+            workspaceId,
+            path: `skills/${file.path}`,
+            content: file.content,
+            recursive: true
+          })
+        )
+      );
+      return client.createStoredSkill({
+        name,
+        description,
+        instructions: extractSkillInstructions(files),
+        license: extractSkillLicense(files),
+        files
+      });
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({ queryKey: ["stored-skills"] });
+      queryClient.invalidateQueries({ queryKey: ["workspace", "skills", variables.workspaceId] });
+      toast.success("Skill created");
+    },
+    onError: (error) => {
+      toast.error(`Failed to create skill: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  });
+}
+
+function findFileContent(nodes, fileId) {
+  for (const node of nodes) {
+    if (node.id === fileId && node.type === "file") return node.content ?? "";
+    if (node.children) {
+      const found = findFileContent(node.children, fileId);
+      if (found !== void 0) return found;
+    }
+  }
+  return void 0;
+}
+function findFileName(nodes, fileId) {
+  for (const node of nodes) {
+    if (node.id === fileId) return node.name;
+    if (node.children) {
+      const found = findFileName(node.children, fileId);
+      if (found !== void 0) return found;
+    }
+  }
+  return void 0;
+}
+function SkillFolder({
+  files,
+  onChange,
+  readOnly,
+  workspaceId,
+  setWorkspaceId,
+  workspaceOptions
+}) {
+  const [selectedFileId, setSelectedFileId] = React.useState(null);
+  const handleFileContentChange = React.useCallback(
+    (content) => {
+      if (!selectedFileId) return;
+      onChange(updateNodeContent(files, selectedFileId, content));
+    },
+    [selectedFileId, files, onChange]
+  );
+  const selectedFileContent = React.useMemo(() => {
+    if (!selectedFileId) return void 0;
+    return findFileContent(files, selectedFileId);
+  }, [files, selectedFileId]);
+  const selectedFileName = React.useMemo(() => {
+    if (!selectedFileId) return void 0;
+    return findFileName(files, selectedFileId);
+  }, [files, selectedFileId]);
+  const editorLanguage = React.useMemo(() => {
+    if (!selectedFileName) return void 0;
+    if (selectedFileName.endsWith(".md")) return "markdown";
+    if (selectedFileName.endsWith(".json")) return "json";
+    return void 0;
+  }, [selectedFileName]);
+  const isFileSelected = selectedFileId !== null && selectedFileContent !== void 0;
+  const isImage = isImageContent(selectedFileContent);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "grid grid-cols-[300px_1fr] h-full", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "overflow-y-auto h-full border-r border-border1 p-4", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-1.5 pb-4", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(Txt, { as: "label", variant: "ui-sm", className: "text-neutral3", children: "Workspace" }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          Combobox,
+          {
+            options: workspaceOptions,
+            value: workspaceId,
+            onValueChange: setWorkspaceId,
+            placeholder: "Select a workspace...",
+            disabled: readOnly,
+            variant: "default"
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        SkillFileTree,
+        {
+          files,
+          onChange,
+          selectedFileId,
+          onSelectFile: setSelectedFileId,
+          readOnly
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "h-full p-4", children: isFileSelected ? /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: isImage ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex items-center justify-center flex-1 p-4 bg-surface2", children: /* @__PURE__ */ jsxRuntime.jsx(
+      "img",
+      {
+        src: selectedFileContent,
+        alt: selectedFileName,
+        className: "max-w-full max-h-[300px] rounded-md object-contain"
+      }
+    ) }) : /* @__PURE__ */ jsxRuntime.jsx(
+      CodeEditor,
+      {
+        language: editorLanguage,
+        value: selectedFileContent,
+        onChange: readOnly ? void 0 : (val) => handleFileContentChange(val ?? ""),
+        showCopyButton: false,
+        autoFocus: true,
+        className: "h-full"
+      },
+      selectedFileId
+    ) }) : /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex items-center justify-center h-full text-xs text-neutral3", children: "Select a file to edit its content" }) })
+  ] });
+}
+
+function SkillEditDialog({ isOpen, onClose, onSkillCreated, readOnly }) {
+  const [name, setName] = React.useState("");
+  const [description, setDescription] = React.useState("");
+  const [workspaceId, setWorkspaceId] = React.useState("");
+  const [files, setFiles] = React.useState([]);
+  const prevNameRef = React.useRef("");
+  const createSkill = useCreateSkill();
+  const { data: workspacesData } = useWorkspaces();
+  const workspaceOptions = React.useMemo(
+    () => (workspacesData?.workspaces ?? []).map((ws) => ({ value: ws.id, label: ws.name })),
+    [workspacesData]
+  );
+  React.useEffect(() => {
+    if (isOpen) {
+      setName("");
+      setDescription("");
+      setWorkspaceId(workspaceOptions.length === 1 ? workspaceOptions[0].value : "");
+      setFiles([]);
+      prevNameRef.current = "";
+    }
+  }, [isOpen, workspaceOptions]);
+  const handleNameChange = React.useCallback(
+    (newName) => {
+      setName(newName);
+      const hasStructure = files.some((n) => n.id === "root");
+      if (!hasStructure && newName.trim()) {
+        setFiles(createInitialStructure(newName));
+      } else if (hasStructure) {
+        setFiles((prev) => updateRootFolderName(prev, newName));
+      }
+      prevNameRef.current = newName;
+    },
+    [files]
+  );
+  const handleSave = React.useCallback(async () => {
+    const result = await createSkill.mutateAsync({
+      name,
+      description,
+      workspaceId,
+      files
+    });
+    onSkillCreated(result, workspaceId);
+    onClose();
+  }, [name, description, workspaceId, files, createSkill, onSkillCreated, onClose]);
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    SideDialog,
+    {
+      dialogTitle: "Add Skill",
+      dialogDescription: "Configure skill details and workspace files",
+      isOpen,
+      onClose,
+      className: "h-full",
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(SideDialog.Top, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "flex-1", children: "New Skill" }),
+          !readOnly && /* @__PURE__ */ jsxRuntime.jsx(
+            Button,
+            {
+              variant: "primary",
+              size: "sm",
+              onClick: handleSave,
+              disabled: !name.trim() || !workspaceId || createSkill.isPending,
+              className: "mr-6",
+              children: createSkill.isPending ? "Creating..." : "Save"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs(SideDialog.Content, { className: "overflow-y-auto h-full grid-rows-[auto_1fr]", children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-4", children: [
+            /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-1.5", children: [
+              /* @__PURE__ */ jsxRuntime.jsx(Txt, { as: "label", variant: "ui-sm", className: "text-neutral3", children: "Name" }),
+              /* @__PURE__ */ jsxRuntime.jsx(
+                Input,
+                {
+                  value: name,
+                  onChange: (e) => handleNameChange(e.target.value),
+                  placeholder: "Skill name",
+                  disabled: readOnly
+                }
+              )
+            ] }),
+            /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-1.5", children: [
+              /* @__PURE__ */ jsxRuntime.jsx(Txt, { as: "label", variant: "ui-sm", className: "text-neutral3", children: "Description" }),
+              /* @__PURE__ */ jsxRuntime.jsx(
+                Input,
+                {
+                  value: description,
+                  onChange: (e) => setDescription(e.target.value),
+                  placeholder: "Brief description of the skill",
+                  disabled: readOnly
+                }
+              )
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "h-full border border-border1 rounded-lg overflow-hidden", children: /* @__PURE__ */ jsxRuntime.jsx(
+            SkillFolder,
+            {
+              files,
+              onChange: setFiles,
+              readOnly,
+              workspaceOptions,
+              workspaceId,
+              setWorkspaceId
+            }
+          ) })
+        ] })
+      ]
+    }
+  );
+}
+
+function SkillsPage() {
+  const { form, readOnly } = useAgentEditFormContext();
+  const { control } = form;
+  const { data: storedSkillsResponse, isLoading } = useStoredSkills();
+  const [dialogOpen, setDialogOpen] = React.useState(false);
+  const [search, setSearch] = React.useState("");
+  const selectedSkills = reactHookForm.useWatch({ control, name: "skills" }) ?? {};
+  const selectedSkillIds = Object.keys(selectedSkills);
+  const storedSkills = storedSkillsResponse?.skills ?? [];
+  const getSkillDescription = (skillId) => {
+    const skill = storedSkills.find((s) => s.id === skillId);
+    return skill?.description || "";
+  };
+  const handleToggleSkill = (skillId) => {
+    const currentSkills = form.getValues("skills") ?? {};
+    const isSelected = currentSkills[skillId] !== void 0;
+    if (isSelected) {
+      const next = { ...currentSkills };
+      delete next[skillId];
+      form.setValue("skills", next);
+    } else {
+      form.setValue("skills", {
+        ...currentSkills,
+        [skillId]: { description: getSkillDescription(skillId) }
+      });
+    }
+  };
+  const handleSkillCreated = (skill, workspaceId) => {
+    const currentSkills = form.getValues("skills") ?? {};
+    form.setValue("skills", {
+      ...currentSkills,
+      [skill.id]: { description: skill.description || "" }
+    });
+    form.setValue("workspace", { type: "id", workspaceId });
+    setDialogOpen(false);
+  };
+  const filteredSkills = storedSkills.filter((skill) => skill.name.toLowerCase().includes(search.toLowerCase()));
+  const totalCount = selectedSkillIds.length;
+  return /* @__PURE__ */ jsxRuntime.jsxs(ScrollArea, { className: "h-full", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-6", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          SectionHeader$1,
+          {
+            title: "Skills",
+            subtitle: `Give your agent specialized knowledge by using skills.${totalCount > 0 ? ` (${totalCount} selected)` : ""}`
+          }
+        ),
+        !readOnly && /* @__PURE__ */ jsxRuntime.jsxs(Button, { variant: "outline", size: "sm", onClick: () => setDialogOpen(true), children: [
+          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Plus, { className: "size-3" }),
+          "Add a skill"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx(Searchbar, { onSearch: setSearch, label: "Search skills", placeholder: "Search skills" }),
+      filteredSkills.length > 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex flex-col gap-2", children: filteredSkills.map((skill) => /* @__PURE__ */ jsxRuntime.jsxs(Entity, { className: "bg-surface2", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(EntityContent, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(EntityName, { children: skill.name }),
+          /* @__PURE__ */ jsxRuntime.jsx(EntityDescription, { children: skill.description || "No description" })
+        ] }),
+        !readOnly && /* @__PURE__ */ jsxRuntime.jsx(
+          Switch,
+          {
+            checked: selectedSkillIds.includes(skill.id),
+            onCheckedChange: () => handleToggleSkill(skill.id)
+          }
+        )
+      ] }, skill.id)) }),
+      !isLoading && storedSkills.length === 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "py-12", children: /* @__PURE__ */ jsxRuntime.jsx(
+        EmptyState$1,
+        {
+          iconSlot: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Drill, { height: 40, width: 40 }),
+          titleSlot: "No skills available",
+          descriptionSlot: "Create a skill to give your agent specialized knowledge.",
+          actionSlot: !readOnly ? /* @__PURE__ */ jsxRuntime.jsxs(Button, { variant: "outline", size: "sm", onClick: () => setDialogOpen(true), children: [
+            /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Plus, { className: "size-3" }),
+            "Add a skill"
+          ] }) : void 0
+        }
+      ) })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      SkillEditDialog,
+      {
+        isOpen: dialogOpen,
+        onClose: () => setDialogOpen(false),
+        onSkillCreated: handleSkillCreated,
+        readOnly
+      }
+    )
+  ] });
+}
+
+const arrayToRecord = (arr) => {
+  const record = {};
+  for (const id of arr) {
+    record[id] = { description: void 0 };
+  }
+  return record;
+};
+const normalizeToolsToRecord = (tools) => {
+  if (!tools) return {};
+  if (!Array.isArray(tools)) return { ...tools };
+  const result = {};
+  for (const item of tools) {
+    if (typeof item === "string") {
+      result[item] = { description: void 0 };
+    } else {
+      Object.assign(result, item.value);
+    }
+  }
+  return result;
+};
+const splitModelId = (id) => {
+  if (!id) return void 0;
+  const [p, ...rest] = id.split("/");
+  const n = rest.join("/");
+  return p && n ? { provider: p, name: n } : void 0;
+};
+const joinModelId = (m) => m?.provider && m?.name ? `${m.provider}/${m.name}` : void 0;
+const transformIntegrationToolsForApi = (integrationTools) => {
+  if (!integrationTools || Object.keys(integrationTools).length === 0) return void 0;
+  const result = {};
+  for (const [compositeKey, config] of Object.entries(integrationTools)) {
+    const separatorIndex = compositeKey.indexOf(":");
+    if (separatorIndex === -1) continue;
+    const providerId = compositeKey.slice(0, separatorIndex);
+    const toolSlug = compositeKey.slice(separatorIndex + 1);
+    if (!result[providerId]) {
+      result[providerId] = { tools: {} };
+    }
+    result[providerId].tools[toolSlug] = { description: config.description, rules: config.rules };
+  }
+  return result;
+};
+const normalizeIntegrationToolsToRecord = (integrationTools) => {
+  if (!integrationTools) return {};
+  const result = {};
+  for (const [providerId, providerConfig] of Object.entries(integrationTools)) {
+    if (providerConfig.tools) {
+      for (const [toolSlug, toolConfig] of Object.entries(providerConfig.tools)) {
+        result[`${providerId}:${toolSlug}`] = { description: toolConfig.description, rules: toolConfig.rules };
+      }
+    }
+  }
+  return result;
+};
+const normalizeSkillsFromApi = (skills) => {
+  if (!skills) return {};
+  if (Array.isArray(skills)) {
+    const result2 = {};
+    for (const variant of skills) {
+      for (const [key, value] of Object.entries(variant.value)) {
+        result2[key] = {
+          description: value.description,
+          instructions: value.instructions,
+          pin: value.pin,
+          strategy: value.strategy
+        };
+      }
+    }
+    return result2;
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(skills)) {
+    result[key] = {
+      description: value.description,
+      instructions: value.instructions,
+      pin: value.pin,
+      strategy: value.strategy
+    };
+  }
+  return result;
+};
+const normalizeWorkspaceFromApi = (workspace) => {
+  if (!workspace) return void 0;
+  if (Array.isArray(workspace)) {
+    return workspace[0]?.value;
+  }
+  return workspace;
+};
+const mapInstructionBlocksToApi = (blocks) => (blocks ?? []).map((block) => ({
+  type: block.type,
+  content: block.content,
+  rules: block.rules
+}));
+const mapInstructionBlocksFromApi = (instructionsRaw) => {
+  const instructionsString = Array.isArray(instructionsRaw) ? instructionsRaw.map((b) => b.type === "prompt_block" ? b.content : "").filter(Boolean).join("\n\n") : instructionsRaw || "";
+  const instructionBlocks = Array.isArray(instructionsRaw) ? instructionsRaw.filter(
+    (b) => b.type === "prompt_block"
+  ).map((b) => createInstructionBlock(b.content, b.rules)) : [createInstructionBlock(instructionsRaw || "")];
+  return { instructionsString, instructionBlocks };
+};
+const mapScorersToApi = (scorers) => {
+  const entries = scorers ? Object.entries(scorers) : void 0;
+  if (!entries) return void 0;
+  return Object.fromEntries(
+    entries.map(([key, value]) => [
+      key,
+      {
+        description: value.description,
+        sampling: value.sampling ? {
+          type: value.sampling.type,
+          rate: value.sampling.rate || 0
+        } : void 0,
+        rules: value.rules
+      }
+    ])
+  );
+};
+const normalizeScorersFromApi = (scorers) => {
+  if (!scorers) return {};
+  let record;
+  if (Array.isArray(scorers)) {
+    record = {};
+    for (const variant of scorers) {
+      Object.assign(record, variant.value);
+    }
+  } else {
+    record = scorers;
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(record)) {
+    result[key] = {
+      description: value.description,
+      sampling: value.sampling?.type === "ratio" ? { type: "ratio", rate: value.sampling.rate } : void 0,
+      rules: value.rules
+    };
+  }
+  return result;
+};
+const buildObservationalMemoryForApi = (om) => {
+  if (!om?.enabled) return void 0;
+  const modelId = joinModelId(om.model);
+  const obsModelId = joinModelId(om.observation?.model);
+  const observation = obsModelId || om.observation?.messageTokens || om.observation?.maxTokensPerBatch || om.observation?.bufferTokens !== void 0 || om.observation?.bufferActivation !== void 0 || om.observation?.blockAfter !== void 0 ? {
+    model: obsModelId,
+    messageTokens: om.observation?.messageTokens,
+    maxTokensPerBatch: om.observation?.maxTokensPerBatch,
     bufferTokens: om.observation?.bufferTokens,
     bufferActivation: om.observation?.bufferActivation,
     blockAfter: om.observation?.blockAfter
@@ -27039,6 +28802,8 @@ function computeAgentInitialValues(dataSource) {
       observationalMemory: parseObservationalMemoryFromApi(memoryData.observationalMemory)
     } : void 0,
     instructionBlocks,
+    skills: normalizeSkillsFromApi(dataSource.skills),
+    workspace: normalizeWorkspaceFromApi(dataSource.workspace),
     variables: dataSource.requestContextSchema
   };
 }
@@ -27064,15 +28829,22 @@ function useAgentCmsForm(options) {
     const ids = Object.keys(mcpClientRecord ?? {});
     if (ids.length === 0) return;
     Promise.all(ids.map((id) => client.getStoredMCPClient(id).details())).then((results) => {
-      form.setValue(
-        "mcpClients",
-        results.map((r) => ({
-          id: r.id,
-          name: r.name,
-          description: r.description,
-          servers: r.servers
-        }))
-      );
+      const mcpClientValues = results.map((r) => ({
+        id: r.id,
+        name: r.name,
+        description: r.description,
+        servers: r.servers,
+        selectedTools: mcpClientRecord?.[r.id]?.tools ?? {}
+      }));
+      form.setValue("mcpClients", mcpClientValues, { shouldDirty: true });
+      const currentTools = form.getValues("tools") ?? {};
+      const next = { ...currentTools };
+      for (const mcpClient of mcpClientValues) {
+        for (const [name, config] of Object.entries(mcpClient.selectedTools ?? {})) {
+          next[name] = { description: config.description };
+        }
+      }
+      form.setValue("tools", next, { shouldDirty: true });
     }).catch(() => {
     });
   });
@@ -27086,19 +28858,38 @@ function useAgentCmsForm(options) {
         const mcpClientsToDelete = values.mcpClientsToDelete ?? [];
         await Promise.all(mcpClientsToDelete.map((id) => client.getStoredMCPClient(id).delete()));
       }
+      const mcpToolNames = /* @__PURE__ */ new Set();
+      for (const c of values.mcpClients ?? []) {
+        for (const name of Object.keys(c.selectedTools ?? {})) {
+          mcpToolNames.add(name);
+        }
+      }
+      const registryTools = {};
+      for (const [name, config] of Object.entries(values.tools ?? {})) {
+        if (!mcpToolNames.has(name)) {
+          registryTools[name] = config;
+        }
+      }
       const mcpClientIds = await collectMCPClientIds(values.mcpClients ?? [], client);
-      const mcpClientsParam = Object.fromEntries(mcpClientIds.map((id) => [id, {}]));
+      const mcpClientsParam = Object.fromEntries(
+        mcpClientIds.map((id, index) => {
+          const selectedTools = values.mcpClients?.[index]?.selectedTools ?? {};
+          return [id, { tools: selectedTools }];
+        })
+      );
       return {
         name: values.name,
         description: values.description || void 0,
         instructions: mapInstructionBlocksToApi(values.instructionBlocks),
         model: values.model,
-        tools: values.tools && Object.keys(values.tools).length > 0 ? values.tools : void 0,
+        tools: Object.keys(registryTools).length > 0 ? registryTools : void 0,
         integrationTools: transformIntegrationToolsForApi(values.integrationTools),
         workflows: values.workflows && Object.keys(values.workflows).length > 0 ? values.workflows : void 0,
         agents: values.agents && Object.keys(values.agents).length > 0 ? values.agents : void 0,
         mcpClients: mcpClientsParam,
         scorers: mapScorersToApi(values.scorers),
+        skills: values.skills,
+        workspace: values.workspace,
         requestContextSchema: values.variables ? Object.fromEntries(Object.entries(values.variables)) : void 0
       };
     },
@@ -27136,6 +28927,7 @@ function useAgentCmsForm(options) {
         ...sharedParams,
         memory: editMemory
       });
+      form.reset(values);
       queryClient.invalidateQueries({ queryKey: ["agent-versions", agentId] });
       toast.success("Draft saved");
     } catch (error) {
@@ -27154,17 +28946,16 @@ function useAgentCmsForm(options) {
     setIsSubmitting(true);
     try {
       if (isEdit) {
-        const sharedParams = await buildSharedParams(values);
-        const editMemory = buildMemoryParams(values);
-        await updateStoredAgent.mutateAsync({
-          ...sharedParams,
-          memory: editMemory
-        });
-        const versionsResponse = await client.getStoredAgent(options.agentId).listVersions({ sortDirection: "DESC", perPage: 1 });
+        const [agentDetails, versionsResponse] = await Promise.all([
+          client.getStoredAgent(options.agentId).details(),
+          client.getStoredAgent(options.agentId).listVersions({ sortDirection: "DESC", perPage: 1 })
+        ]);
         const latestVersion = versionsResponse.versions[0];
-        if (latestVersion) {
-          await client.getStoredAgent(options.agentId).activateVersion(latestVersion.id);
+        if (!latestVersion || latestVersion.id === agentDetails.activeVersionId) {
+          toast.error("No draft changes to publish. Save a draft first.");
+          return;
         }
+        await client.getStoredAgent(options.agentId).activateVersion(latestVersion.id);
         await Promise.all([
           queryClient.invalidateQueries({ queryKey: ["agent-versions", agentId] }),
           queryClient.invalidateQueries({ queryKey: ["stored-agent", agentId] }),
@@ -27197,25 +28988,15 @@ function useAgentCmsForm(options) {
     } finally {
       setIsSubmitting(false);
     }
-  }, [
-    form,
-    isEdit,
-    client,
-    createStoredAgent,
-    updateStoredAgent,
-    options,
-    agentId,
-    buildSharedParams,
-    buildMemoryParams,
-    queryClient
-  ]);
+  }, [form, isEdit, client, createStoredAgent, options, agentId, buildSharedParams, queryClient]);
   const watched = reactHookForm.useWatch({ control: form.control });
   const canPublish = React.useMemo(() => {
     const identityDone = !!watched.name && !!watched.model?.provider && !!watched.model?.name;
     const instructionsDone = (watched.instructionBlocks ?? []).some((b) => b.content?.trim());
     return identityDone && instructionsDone;
   }, [watched.name, watched.model?.provider, watched.model?.name, watched.instructionBlocks]);
-  return { form, handlePublish, handleSaveDraft, isSubmitting, isSavingDraft, canPublish };
+  const isDirty = form.formState.isDirty;
+  return { form, handlePublish, handleSaveDraft, isSubmitting, isSavingDraft, canPublish, isDirty };
 }
 
 function AgentCmsFormShell({
@@ -27231,7 +29012,8 @@ function AgentCmsFormShell({
   currentPath,
   banner,
   children,
-  versionId
+  versionId,
+  rightPanel
 }) {
   return /* @__PURE__ */ jsxRuntime.jsx(
     AgentEditFormProvider,
@@ -27244,7 +29026,7 @@ function AgentCmsFormShell({
       handlePublish,
       handleSaveDraft,
       readOnly,
-      children: /* @__PURE__ */ jsxRuntime.jsxs(AgentsCmsLayout, { basePath, currentPath, versionId, children: [
+      children: /* @__PURE__ */ jsxRuntime.jsxs(AgentsCmsLayout, { basePath, currentPath, versionId, rightPanel, children: [
         banner,
         children
       ] })
@@ -27252,6 +29034,61 @@ function AgentCmsFormShell({
   );
 }
 
+function formatTimestamp(isoString) {
+  const date = new Date(isoString);
+  return date.toLocaleDateString(void 0, {
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+}
+function AgentVersionPanel({
+  agentId,
+  selectedVersionId,
+  onVersionSelect,
+  activeVersionId
+}) {
+  const { data, isLoading } = useAgentVersions({
+    agentId,
+    params: { sortDirection: "DESC" }
+  });
+  const versions = data?.versions ?? [];
+  const activeVersion = activeVersionId ? versions.find((v) => v.id === activeVersionId) : void 0;
+  const activeVersionNumber = activeVersion?.versionNumber;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "h-full flex flex-col", children: [
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "px-3 py-3 border-b border-border1", children: /* @__PURE__ */ jsxRuntime.jsx(Txt, { variant: "ui-sm", className: "font-medium text-neutral5", children: "Version history" }) }),
+    /* @__PURE__ */ jsxRuntime.jsx(ScrollArea, { className: "flex-1 min-h-0", children: isLoading ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "px-3 py-4", children: /* @__PURE__ */ jsxRuntime.jsx(Txt, { variant: "ui-xs", className: "text-neutral2", children: "Loading versions..." }) }) : /* @__PURE__ */ jsxRuntime.jsx("ul", { className: "flex flex-col", children: versions.map((version) => {
+      const isSelected = selectedVersionId === version.id || !selectedVersionId && version.id === versions[0]?.id;
+      const isPublished = version.id === activeVersionId;
+      const isDraft = activeVersionNumber !== void 0 && version.versionNumber > activeVersionNumber;
+      return /* @__PURE__ */ jsxRuntime.jsx("li", { children: /* @__PURE__ */ jsxRuntime.jsxs(
+        "button",
+        {
+          type: "button",
+          onClick: () => onVersionSelect(version.id),
+          className: cn(
+            "w-full text-left px-3 py-2.5 text-sm transition-colors border-l-2",
+            isSelected ? "bg-surface2 text-neutral5 border-accent1" : "border-transparent text-neutral3 hover:bg-surface3 hover:text-neutral5"
+          ),
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between gap-2", children: [
+              /* @__PURE__ */ jsxRuntime.jsxs(Txt, { variant: "ui-sm", className: "text-inherit", children: [
+                "v",
+                version.versionNumber
+              ] }),
+              isPublished && /* @__PURE__ */ jsxRuntime.jsx(Badge, { variant: "success", children: "Published" }),
+              isDraft && /* @__PURE__ */ jsxRuntime.jsx(Badge, { variant: "info", children: "Draft" })
+            ] }),
+            /* @__PURE__ */ jsxRuntime.jsx(Txt, { variant: "ui-xs", className: "text-neutral2 mt-0.5", children: formatTimestamp(version.createdAt) })
+          ]
+        }
+      ) }, version.id);
+    }) }) })
+  ] });
+}
+
 const NameCell$3 = ({ row }) => {
   const { Link, paths } = useLinkComponent();
   const processor = row.original;
@@ -30773,7 +32610,7 @@ const useDatasetItemVersions = (datasetId, itemId) => {
     enabled: Boolean(datasetId) && Boolean(itemId)
   });
 };
-const useDatasetItemVersion = (datasetId, itemId, datasetVersion) => {
+const useDatasetItemVersion = (datasetId, itemId, datasetVersion, latestVersion) => {
   const client = react$1.useMastraClient();
   return reactQuery.useQuery({
     queryKey: ["dataset-item-version", datasetId, itemId, datasetVersion],
@@ -30786,11 +32623,11 @@ const useDatasetItemVersion = (datasetId, itemId, datasetVersion) => {
         input: v.input,
         groundTruth: v.groundTruth,
         metadata: v.metadata,
-        validTo: v.validTo,
-        isDeleted: v.isDeleted,
+        validTo: v.validTo ?? null,
+        isDeleted: v.isDeleted ?? false,
         createdAt: v.createdAt,
         updatedAt: v.updatedAt,
-        isLatest: false
+        isLatest: latestVersion != null ? datasetVersion === latestVersion : false
       };
     },
     enabled: Boolean(datasetId) && Boolean(itemId) && datasetVersion > 0
@@ -32437,6 +34274,52 @@ function DeleteDatasetDialog({
   ] }) });
 }
 
+function DatasetCombobox({
+  value,
+  onValueChange,
+  placeholder = "Select a dataset...",
+  searchPlaceholder = "Search datasets...",
+  emptyText = "No datasets found.",
+  className,
+  disabled = false,
+  variant = "default"
+}) {
+  const { data, isLoading, isError, error } = useDatasets();
+  const { navigate, paths } = useLinkComponent();
+  React.useEffect(() => {
+    if (isError) {
+      const errorMessage = error instanceof Error ? error.message : "Failed to load datasets";
+      toast.error(`Error loading datasets: ${errorMessage}`);
+    }
+  }, [isError, error]);
+  const datasets = data?.datasets ?? [];
+  const datasetOptions = datasets.map((d) => ({
+    label: d.name,
+    value: d.id
+  }));
+  const handleValueChange = (newDatasetId) => {
+    if (onValueChange) {
+      onValueChange(newDatasetId);
+    } else if (newDatasetId && newDatasetId !== value) {
+      navigate(paths.datasetLink(newDatasetId));
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    Combobox,
+    {
+      options: datasetOptions,
+      value,
+      onValueChange: handleValueChange,
+      placeholder: isLoading ? "Loading datasets..." : placeholder,
+      searchPlaceholder,
+      emptyText,
+      className,
+      disabled: disabled || isLoading || isError,
+      variant
+    }
+  );
+}
+
 function ItemListRoot({ children, className }) {
   return /* @__PURE__ */ jsxRuntime.jsx("div", { className: cn("grid grid-rows-[auto_1fr] overflow-y-auto", className), children });
 }
@@ -33221,24 +35104,18 @@ function ItemDetailToolbar({
       !isEditing && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
         /* @__PURE__ */ jsxRuntime.jsxs(Button, { variant: "standard", size: "default", href: `/datasets/${datasetId}/items/${itemId}`, as: Link, children: [
           /* @__PURE__ */ jsxRuntime.jsx(lucideReact.History, {}),
-          "History"
+          "Versions"
         ] }),
-        /* @__PURE__ */ jsxRuntime.jsxs(ButtonsGroup, { spacing: "close", children: [
-          /* @__PURE__ */ jsxRuntime.jsxs(Button, { variant: "standard", size: "default", onClick: onEdit, children: [
-            /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Pencil, {}),
-            "Edit"
-          ] }),
-          /* @__PURE__ */ jsxRuntime.jsxs(DropdownMenu, { children: [
-            /* @__PURE__ */ jsxRuntime.jsx(DropdownMenu.Trigger, { asChild: true, children: /* @__PURE__ */ jsxRuntime.jsx(Button, { variant: "standard", size: "default", "aria-label": "Actions menu", children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ChevronDownIcon, {}) }) }),
-            /* @__PURE__ */ jsxRuntime.jsxs(DropdownMenu.Content, { align: "end", className: "w-48", children: [
-              /* @__PURE__ */ jsxRuntime.jsxs(DropdownMenu.Item, { onSelect: onDelete, className: "text-red-500 focus:text-red-400", children: [
-                /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Trash2, {}),
-                /* @__PURE__ */ jsxRuntime.jsx("span", { children: "Delete Item" })
-              ] }),
-              /* @__PURE__ */ jsxRuntime.jsxs(DropdownMenu.Item, { disabled: true, children: [
-                /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Copy, {}),
-                /* @__PURE__ */ jsxRuntime.jsx("span", { children: "Duplicate Item (Coming Soon)" })
-              ] })
+        /* @__PURE__ */ jsxRuntime.jsxs(DropdownMenu, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(DropdownMenu.Trigger, { asChild: true, children: /* @__PURE__ */ jsxRuntime.jsx(Button, { variant: "standard", size: "default", "aria-label": "Actions menu", children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.EllipsisVerticalIcon, {}) }) }),
+          /* @__PURE__ */ jsxRuntime.jsxs(DropdownMenu.Content, { align: "end", className: "w-48", children: [
+            /* @__PURE__ */ jsxRuntime.jsxs(DropdownMenu.Item, { onSelect: onEdit, children: [
+              /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Pencil, {}),
+              "Edit"
+            ] }),
+            /* @__PURE__ */ jsxRuntime.jsxs(DropdownMenu.Item, { onSelect: onDelete, className: "text-red-500 focus:text-red-400", children: [
+              /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Trash2, {}),
+              "Delete Item"
             ] })
           ] })
         ] })
@@ -36170,9 +38047,9 @@ function ExperimentResultPanel({
   onClose,
   onShowTrace
 }) {
-  const hasError = Boolean(result.error);
-  const inputStr = formatValue$1(result.input);
-  const outputStr = formatValue$1(result.output);
+  const hasError = Boolean(result?.error);
+  const inputStr = formatValue$1(result?.input);
+  const outputStr = formatValue$1(result?.output);
   return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
     /* @__PURE__ */ jsxRuntime.jsxs(ListAndDetails.ColumnToolbar, { children: [
       /* @__PURE__ */ jsxRuntime.jsx(
@@ -36205,6 +38082,15 @@ function ExperimentResultPanel({
           result.itemId
         ] }) })
       ] }) }),
+      hasError && /* @__PURE__ */ jsxRuntime.jsxs(Notice, { variant: "destructive", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(lucideReact.OctagonAlertIcon, {}),
+        /* @__PURE__ */ jsxRuntime.jsxs(Notice.Message, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx("strong", { children: "Error: " }),
+          formatValue$1(
+            result?.error && typeof result.error === "object" ? result.error.message : result?.error
+          )
+        ] })
+      ] }),
       /* @__PURE__ */ jsxRuntime.jsx(SideDialog.CodeSection, { title: "Input", icon: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.FileCodeIcon, {}), codeStr: inputStr }),
       /* @__PURE__ */ jsxRuntime.jsx(SideDialog.CodeSection, { title: "Output", icon: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.FileOutputIcon, {}), codeStr: outputStr }),
       /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "grid gap-2", children: [
@@ -36213,16 +38099,6 @@ function ExperimentResultPanel({
           " Created"
         ] }),
         /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-neutral4", children: format.format(new Date(result.createdAt), "MMM d, yyyy 'at' h:mm a") })
-      ] }),
-      hasError && /* @__PURE__ */ jsxRuntime.jsxs(Section, { children: [
-        /* @__PURE__ */ jsxRuntime.jsxs(Section.Header, { children: [
-          /* @__PURE__ */ jsxRuntime.jsxs(Section.Heading, { children: [
-            /* @__PURE__ */ jsxRuntime.jsx(lucideReact.AlertCircleIcon, {}),
-            " Error"
-          ] }),
-          /* @__PURE__ */ jsxRuntime.jsx(CopyButton, { content: result.error || "" })
-        ] }),
-        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "bg-black/20 p-4 overflow-hidden rounded-xl border border-white/10 text-neutral4 text-ui-md", children: /* @__PURE__ */ jsxRuntime.jsx("pre", { className: "text-wrap font-mono text-sm whitespace-pre-wrap break-all", children: result.error }) })
       ] })
     ] })
   ] });
@@ -37322,8 +39198,9 @@ function DatasetItemVersionsPanel({
     }
   };
   const columnsToRender = isSelectionActive ? versionsListColumnsWithCheckbox : versionsListColumns;
-  return /* @__PURE__ */ jsxRuntime.jsxs(Column, { className: "min-w-[20rem]", children: [
+  return /* @__PURE__ */ jsxRuntime.jsxs(Column, { className: "min-w-[17rem]", children: [
     isSelectionActive ? /* @__PURE__ */ jsxRuntime.jsx(Column.Toolbar, { className: "grid justify-stretch gap-3 w-full", children: /* @__PURE__ */ jsxRuntime.jsxs(ButtonsGroup, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(Button, { variant: "standard", size: "default", onClick: handleCancelSelection, children: "Cancel" }),
       /* @__PURE__ */ jsxRuntime.jsx(
         ButtonWithTooltip,
         {
@@ -37331,14 +39208,14 @@ function DatasetItemVersionsPanel({
           size: "default",
           disabled: selectedIds.size !== 2,
           onClick: handleExecuteCompare,
-          tooltipContent: selectedIds.size !== 2 ? "Select exactly 2 versions to compare" : void 0,
-          children: "Compare Versions"
+          tooltipContent: selectedIds.size !== 2 ? "Check 2 versions to compare" : void 0,
+          className: "grow",
+          children: "Compare Selected"
         }
-      ),
-      /* @__PURE__ */ jsxRuntime.jsx(Button, { variant: "standard", size: "default", onClick: handleCancelSelection, children: "Cancel" })
-    ] }) }) : /* @__PURE__ */ jsxRuntime.jsx(Column.Toolbar, { children: /* @__PURE__ */ jsxRuntime.jsxs(Button, { variant: "standard", size: "default", onClick: handleCompareClick, children: [
-      /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ScaleIcon, {}),
-      " Compare"
+      )
+    ] }) }) : /* @__PURE__ */ jsxRuntime.jsx(Column.Toolbar, { children: /* @__PURE__ */ jsxRuntime.jsxs(Button, { variant: "standard", size: "default", onClick: handleCompareClick, className: "w-full", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(lucideReact.GitCompareIcon, {}),
+      " Compare Versions"
     ] }) }),
     isLoading ? /* @__PURE__ */ jsxRuntime.jsx(DatasetItemVersionsListSkeleton, {}) : /* @__PURE__ */ jsxRuntime.jsxs(ItemList, { children: [
       /* @__PURE__ */ jsxRuntime.jsx("div", { className: "grid grid-rows-[1fr_auto] gap-4", children: /* @__PURE__ */ jsxRuntime.jsx(ItemList.Header, { columns: columnsToRender, children: columnsToRender.map(
@@ -37346,7 +39223,7 @@ function DatasetItemVersionsPanel({
       ) }) }),
       /* @__PURE__ */ jsxRuntime.jsx(ItemList.Scroller, { children: /* @__PURE__ */ jsxRuntime.jsx(ItemList.Items, { children: versions?.map((item, index) => {
         const versionKey = String(item.datasetVersion);
-        const createdAtDate = typeof item.createdAt === "string" ? new Date(item.createdAt) : item.createdAt;
+        const versionDate = typeof item.updatedAt === "string" ? new Date(item.updatedAt) : item.updatedAt;
         return /* @__PURE__ */ jsxRuntime.jsxs(
           ItemList.Row,
           {
@@ -37356,11 +39233,14 @@ function DatasetItemVersionsPanel({
                 Checkbox,
                 {
                   checked: selectedIds.has(versionKey),
+                  disabled: item.isDeleted,
                   onCheckedChange: () => {
                   },
                   onClick: (e) => {
                     e.stopPropagation();
-                    handleToggleSelection(versionKey);
+                    if (!item.isDeleted) {
+                      handleToggleSelection(versionKey);
+                    }
                   },
                   "aria-label": `Select version ${item.datasetVersion}`
                 }
@@ -37373,13 +39253,18 @@ function DatasetItemVersionsPanel({
                   isSelected: isSelectionActive ? selectedIds.has(versionKey) : isVersionSelected(item),
                   onClick: () => handleVersionClick(item),
                   className: "py-3",
-                  children: /* @__PURE__ */ jsxRuntime.jsxs(ItemList.FlexCell, { className: "w-full text-neutral flex gap-4 items-baseline text-neutral3", children: [
-                    /* @__PURE__ */ jsxRuntime.jsxs("strong", { className: "min-w-8", children: [
-                      "v",
-                      item.datasetVersion
+                  children: /* @__PURE__ */ jsxRuntime.jsxs(ItemList.FlexCell, { className: "w-full text-neutral grid text-neutral3", children: [
+                    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex", children: [
+                      /* @__PURE__ */ jsxRuntime.jsxs("strong", { className: "min-w-11", children: [
+                        "v",
+                        item.datasetVersion
+                      ] }),
+                      /* @__PURE__ */ jsxRuntime.jsx("em", { children: versionDate ? dateFns.format(versionDate, "MMM d, yyyy HH:mm") : null })
                     ] }),
-                    /* @__PURE__ */ jsxRuntime.jsx("em", { children: createdAtDate ? dateFns.format(createdAtDate, "MMM d, yyyy HH:mm") : null }),
-                    item.isLatest && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ml-auto inline-block text-neutral4 text-xs p-1 px-2 leading-none rounded-sm bg-cyan-800", children: "Latest" })
+                    (item.isLatest || item.isDeleted) && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex gap-2 pl-11  ", children: [
+                      item.isLatest && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "inline-block text-neutral4 text-xs p-1 px-2 leading-none rounded-sm bg-cyan-900", children: "Latest" }),
+                      item.isDeleted && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "inline-block text-neutral4 text-xs p-1 px-2 leading-none rounded-sm bg-red-900", children: "Deleted" })
+                    ] })
                   ] })
                 }
               )
@@ -37961,6 +39846,83 @@ function PageHeader({ title, description, icon, className }) {
   ] });
 }
 
+const diffOverrides = view.EditorView.theme({
+  "&.cm-editor .cm-changedLine": {
+    backgroundColor: "transparent",
+    backgroundImage: "none",
+    borderLeft: "none"
+  },
+  "&.cm-editor .cm-changedText": {
+    backgroundImage: "none",
+    backgroundColor: "#880000",
+    padding: "1px 5px",
+    display: "inline-block",
+    borderRadius: "4px"
+  },
+  "&.cm-editor .cm-changedText, &.cm-editor .cm-changedText *": {
+    color: "white"
+  },
+  "&.cm-editor .cm-line": {
+    lineHeight: "1.5",
+    opacity: "0.5"
+  },
+  "&.cm-editor .cm-line.cm-changedLine": {
+    opacity: "1"
+  },
+  "&.cm-editor .cm-gutters": {
+    display: "none"
+  }
+});
+const theme = codemirrorThemeDracula.draculaInit({
+  settings: {
+    fontFamily: "var(--geist-mono)",
+    fontSize: "0.8125rem",
+    lineHighlight: "transparent",
+    gutterBackground: "transparent",
+    gutterForeground: "#939393",
+    background: "transparent"
+  },
+  styles: [{ tag: [highlight$1.tags.className, highlight$1.tags.propertyName] }]
+});
+function CodeDiff({ codeA, codeB }) {
+  const containerRef = React.useRef(null);
+  const viewRef = React.useRef(null);
+  React.useEffect(() => {
+    if (!containerRef.current) return;
+    if (viewRef.current) {
+      viewRef.current.destroy();
+    }
+    const extensions = [langJson.json(), theme, diffOverrides, view.EditorView.lineWrapping, state.EditorState.readOnly.of(true)];
+    const mergeView = new merge.MergeView({
+      parent: containerRef.current,
+      a: {
+        doc: codeA,
+        extensions
+      },
+      b: {
+        doc: codeB,
+        extensions
+      },
+      collapseUnchanged: { margin: 3, minSize: 4 }
+    });
+    viewRef.current = mergeView;
+    return () => {
+      mergeView.destroy();
+      viewRef.current = null;
+    };
+  }, [codeA, codeB]);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "relative overflow-auto rounded-xl border border-white/10 bg-black/20", children: [
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "absolute left-1/2 top-0 h-full w-px bg-white/10 z-10" }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        ref: containerRef,
+        className: "[&_.cm-mergeViewEditor]:flex-1 [&_.cm-editor]:bg-transparent [&_.cm-editor]:p-6 [&_.cm-gutters]:bg-transparent"
+      }
+    )
+  ] });
+}
+
 const PlaygroundQueryClient = ({ children, options }) => {
   const queryClient = new reactQuery.QueryClient(options);
   return /* @__PURE__ */ jsxRuntime.jsx(reactQuery.QueryClientProvider, { client: queryClient, children });
@@ -39473,180 +41435,6 @@ function ReferenceViewerDialog({
   ] });
 }
 
-const useSearchSkillsSh = (workspaceId) => {
-  const client = react$1.useMastraClient();
-  return reactQuery.useMutation({
-    mutationFn: async (query) => {
-      if (!workspaceId) {
-        throw new Error("Workspace ID is required");
-      }
-      const baseUrl = client.options.baseUrl || "";
-      const url = `${baseUrl}/api/workspaces/${workspaceId}/skills-sh/search?q=${encodeURIComponent(query)}&limit=10`;
-      const response = await fetch(url);
-      if (!response.ok) {
-        throw new Error(`Failed to search skills: ${response.statusText}`);
-      }
-      return response.json().catch(() => {
-        throw new Error("Invalid response from server");
-      });
-    }
-  });
-};
-const usePopularSkillsSh = (workspaceId) => {
-  const client = react$1.useMastraClient();
-  return reactQuery.useQuery({
-    queryKey: ["skills-sh", "popular", workspaceId],
-    queryFn: async () => {
-      if (!workspaceId) {
-        throw new Error("Workspace ID is required");
-      }
-      const baseUrl = client.options.baseUrl || "";
-      const url = `${baseUrl}/api/workspaces/${workspaceId}/skills-sh/popular?limit=10&offset=0`;
-      const response = await fetch(url);
-      if (!response.ok) {
-        throw new Error(`Failed to fetch popular skills: ${response.statusText}`);
-      }
-      return response.json().catch(() => {
-        throw new Error("Invalid response from server");
-      });
-    },
-    staleTime: 5 * 60 * 1e3,
-    // 5 minutes
-    enabled: !!workspaceId
-  });
-};
-const useSkillPreview = (workspaceId, owner, repo, skillPath, options) => {
-  const client = react$1.useMastraClient();
-  return reactQuery.useQuery({
-    queryKey: ["skills-sh", "preview", workspaceId, owner, repo, skillPath],
-    queryFn: async () => {
-      if (!workspaceId || !owner || !repo || !skillPath) {
-        throw new Error("workspaceId, owner, repo, and skillPath are required");
-      }
-      const baseUrl = client.options.baseUrl || "";
-      const params = new URLSearchParams({ owner, repo, path: skillPath });
-      const url = `${baseUrl}/api/workspaces/${workspaceId}/skills-sh/preview?${params}`;
-      const response = await fetch(url);
-      if (!response.ok) {
-        throw new Error(`Failed to fetch preview: ${response.statusText}`);
-      }
-      const data = await response.json().catch(() => {
-        throw new Error("Invalid response from server");
-      });
-      return data.content;
-    },
-    enabled: options?.enabled !== false && !!workspaceId && !!owner && !!repo && !!skillPath,
-    retry: false
-  });
-};
-const useInstallSkill = () => {
-  const client = react$1.useMastraClient();
-  const queryClient = reactQuery.useQueryClient();
-  return reactQuery.useMutation({
-    mutationFn: async (params) => {
-      const [owner, repo] = params.repository.split("/");
-      if (!owner || !repo) {
-        throw new Error("Invalid repository format. Expected owner/repo");
-      }
-      const baseUrl = client.options.baseUrl || "";
-      const url = `${baseUrl}/api/workspaces/${params.workspaceId}/skills-sh/install`;
-      const body = { owner, repo, skillName: params.skillName };
-      if (params.mount) {
-        body.mount = params.mount;
-      }
-      const response = await fetch(url, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(body)
-      });
-      if (!response.ok) {
-        const error = await response.json().catch(() => ({}));
-        throw new Error(error.error || error.message || `Failed to install skill: ${response.statusText}`);
-      }
-      return response.json().catch(() => {
-        throw new Error("Invalid response from server");
-      });
-    },
-    onSuccess: (_, variables) => {
-      queryClient.invalidateQueries({ queryKey: ["workspace", "skills", variables.workspaceId] });
-    }
-  });
-};
-const useUpdateSkills = () => {
-  const client = react$1.useMastraClient();
-  const queryClient = reactQuery.useQueryClient();
-  return reactQuery.useMutation({
-    mutationFn: async (params) => {
-      const baseUrl = client.options.baseUrl || "";
-      const url = `${baseUrl}/api/workspaces/${params.workspaceId}/skills-sh/update`;
-      const response = await fetch(url, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ skillName: params.skillName })
-      });
-      if (!response.ok) {
-        const error = await response.json().catch(() => ({}));
-        throw new Error(error.error || error.message || `Failed to update skill: ${response.statusText}`);
-      }
-      return response.json().catch(() => {
-        throw new Error("Invalid response from server");
-      });
-    },
-    onSuccess: (_, variables) => {
-      queryClient.invalidateQueries({ queryKey: ["workspace", "skills", variables.workspaceId] });
-    }
-  });
-};
-const useRemoveSkill = () => {
-  const client = react$1.useMastraClient();
-  const queryClient = reactQuery.useQueryClient();
-  return reactQuery.useMutation({
-    mutationFn: async (params) => {
-      const baseUrl = client.options.baseUrl || "";
-      const url = `${baseUrl}/api/workspaces/${params.workspaceId}/skills-sh/remove`;
-      const response = await fetch(url, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ skillName: params.skillName })
-      });
-      if (!response.ok) {
-        const error = await response.json().catch(() => ({}));
-        throw new Error(error.error || error.message || `Failed to remove skill: ${response.statusText}`);
-      }
-      return response.json().catch(() => {
-        throw new Error("Invalid response from server");
-      });
-    },
-    onSuccess: (_, variables) => {
-      queryClient.invalidateQueries({ queryKey: ["workspace", "skills", variables.workspaceId] });
-    }
-  });
-};
-function parseSkillSource(topSource, skillName) {
-  let cleanSource = topSource.replace(/^https?:\/\//, "");
-  cleanSource = cleanSource.replace(/^github\.com\//, "");
-  cleanSource = cleanSource.replace(/\/$/, "");
-  const parts = cleanSource.split("/").filter(Boolean);
-  if (parts.length < 2) {
-    return null;
-  }
-  const owner = parts[0];
-  const repo = parts[1];
-  let skillPath;
-  if (parts.length > 2) {
-    skillPath = parts.slice(2).join("/");
-  } else if (skillName) {
-    skillPath = skillName;
-  } else {
-    return null;
-  }
-  return {
-    owner,
-    repo,
-    skillPath
-  };
-}
-
 function getSkillUniqueId(skill) {
   return `${skill.topSource}/${skill.name}`;
 }
@@ -39909,314 +41697,6 @@ function AddSkillDialog({
   ] }) });
 }
 
-const useWorkspaceInfo = (workspaceId) => {
-  const client = react$1.useMastraClient();
-  return reactQuery.useQuery({
-    queryKey: ["workspace", "info", workspaceId],
-    queryFn: async () => {
-      if (!compatibility.isWorkspaceV1Supported(client)) {
-        throw new Error("Workspace v1 not supported by core or client");
-      }
-      if (!workspaceId) {
-        throw new Error("workspaceId is required");
-      }
-      const workspace = client.getWorkspace(workspaceId);
-      return workspace.info();
-    },
-    enabled: !!workspaceId && compatibility.isWorkspaceV1Supported(client),
-    retry: compatibility.shouldRetryWorkspaceQuery
-  });
-};
-const useWorkspaces = () => {
-  const client = react$1.useMastraClient();
-  return reactQuery.useQuery({
-    queryKey: ["workspaces"],
-    queryFn: async () => {
-      if (!compatibility.isWorkspaceV1Supported(client)) {
-        throw new Error("Workspace v1 not supported by core or client");
-      }
-      return client.listWorkspaces();
-    },
-    retry: compatibility.shouldRetryWorkspaceQuery
-  });
-};
-const useWorkspaceFiles = (path, options) => {
-  const client = react$1.useMastraClient();
-  return reactQuery.useQuery({
-    queryKey: ["workspace", "files", path, options?.recursive, options?.workspaceId],
-    queryFn: async () => {
-      if (!compatibility.isWorkspaceV1Supported(client)) {
-        throw new Error("Workspace v1 not supported by core or client");
-      }
-      if (!options?.workspaceId) {
-        throw new Error("workspaceId is required");
-      }
-      const workspace = client.getWorkspace(options.workspaceId);
-      return workspace.listFiles(path, options?.recursive);
-    },
-    enabled: options?.enabled !== false && !!path && !!options?.workspaceId && compatibility.isWorkspaceV1Supported(client),
-    retry: compatibility.shouldRetryWorkspaceQuery
-  });
-};
-const useWorkspaceFile = (path, options) => {
-  const client = react$1.useMastraClient();
-  return reactQuery.useQuery({
-    queryKey: ["workspace", "file", path, options?.workspaceId],
-    queryFn: async () => {
-      if (!compatibility.isWorkspaceV1Supported(client)) {
-        throw new Error("Workspace v1 not supported by core or client");
-      }
-      if (!options?.workspaceId) {
-        throw new Error("workspaceId is required");
-      }
-      const workspace = client.getWorkspace(options.workspaceId);
-      return workspace.readFile(path, options?.encoding);
-    },
-    enabled: options?.enabled !== false && !!path && !!options?.workspaceId && compatibility.isWorkspaceV1Supported(client),
-    retry: compatibility.shouldRetryWorkspaceQuery
-  });
-};
-const useWorkspaceFileStat = (path, options) => {
-  const client = react$1.useMastraClient();
-  return reactQuery.useQuery({
-    queryKey: ["workspace", "stat", path, options?.workspaceId],
-    queryFn: async () => {
-      if (!compatibility.isWorkspaceV1Supported(client)) {
-        throw new Error("Workspace v1 not supported by core or client");
-      }
-      if (!options?.workspaceId) {
-        throw new Error("workspaceId is required");
-      }
-      const workspace = client.getWorkspace(options.workspaceId);
-      return workspace.stat(path);
-    },
-    enabled: options?.enabled !== false && !!path && !!options?.workspaceId && compatibility.isWorkspaceV1Supported(client),
-    retry: compatibility.shouldRetryWorkspaceQuery
-  });
-};
-const useWriteWorkspaceFile = () => {
-  const client = react$1.useMastraClient();
-  const queryClient = reactQuery.useQueryClient();
-  return reactQuery.useMutation({
-    mutationFn: async (params) => {
-      if (!compatibility.isWorkspaceV1Supported(client)) {
-        throw new Error("Workspace v1 not supported by core or client");
-      }
-      const workspace = client.getWorkspace(params.workspaceId);
-      return workspace.writeFile(params.path, params.content, {
-        encoding: params.encoding,
-        recursive: params.recursive ?? true
-      });
-    },
-    onSuccess: (_, variables) => {
-      const parentPath = variables.path.split("/").slice(0, -1).join("/") || "/";
-      queryClient.invalidateQueries({ queryKey: ["workspace", "files", parentPath] });
-      queryClient.invalidateQueries({ queryKey: ["workspace", "file", variables.path] });
-    }
-  });
-};
-const useWriteWorkspaceFileFromFile = () => {
-  const client = react$1.useMastraClient();
-  const queryClient = reactQuery.useQueryClient();
-  return reactQuery.useMutation({
-    mutationFn: async (params) => {
-      if (!compatibility.isWorkspaceV1Supported(client)) {
-        throw new Error("Workspace v1 not supported by core or client");
-      }
-      const arrayBuffer = await params.file.arrayBuffer();
-      const base64 = btoa(new Uint8Array(arrayBuffer).reduce((data, byte) => data + String.fromCharCode(byte), ""));
-      const workspace = client.getWorkspace(params.workspaceId);
-      return workspace.writeFile(params.path, base64, {
-        encoding: "base64",
-        recursive: params.recursive ?? true
-      });
-    },
-    onSuccess: (_, variables) => {
-      const parentPath = variables.path.split("/").slice(0, -1).join("/") || "/";
-      queryClient.invalidateQueries({ queryKey: ["workspace", "files", parentPath] });
-      queryClient.invalidateQueries({ queryKey: ["workspace", "file", variables.path] });
-    }
-  });
-};
-const useDeleteWorkspaceFile = () => {
-  const client = react$1.useMastraClient();
-  const queryClient = reactQuery.useQueryClient();
-  return reactQuery.useMutation({
-    mutationFn: async (params) => {
-      if (!compatibility.isWorkspaceV1Supported(client)) {
-        throw new Error("Workspace v1 not supported by core or client");
-      }
-      const workspace = client.getWorkspace(params.workspaceId);
-      return workspace.delete(params.path, {
-        recursive: params.recursive,
-        force: params.force
-      });
-    },
-    onSuccess: (_, variables) => {
-      const parentPath = variables.path.split("/").slice(0, -1).join("/") || "/";
-      queryClient.invalidateQueries({ queryKey: ["workspace", "files", parentPath] });
-      queryClient.invalidateQueries({ queryKey: ["workspace", "file", variables.path] });
-    }
-  });
-};
-const useCreateWorkspaceDirectory = () => {
-  const client = react$1.useMastraClient();
-  const queryClient = reactQuery.useQueryClient();
-  return reactQuery.useMutation({
-    mutationFn: async (params) => {
-      if (!compatibility.isWorkspaceV1Supported(client)) {
-        throw new Error("Workspace v1 not supported by core or client");
-      }
-      const workspace = client.getWorkspace(params.workspaceId);
-      return workspace.mkdir(params.path, params.recursive);
-    },
-    onSuccess: (_, variables) => {
-      const parentPath = variables.path.split("/").slice(0, -1).join("/") || "/";
-      queryClient.invalidateQueries({ queryKey: ["workspace", "files", parentPath] });
-    }
-  });
-};
-const useSearchWorkspace = () => {
-  const client = react$1.useMastraClient();
-  return reactQuery.useMutation({
-    mutationFn: async (params) => {
-      if (!compatibility.isWorkspaceV1Supported(client)) {
-        throw new Error("Workspace v1 not supported by core or client");
-      }
-      const workspace = client.getWorkspace(params.workspaceId);
-      return workspace.search({
-        query: params.query,
-        topK: params.topK,
-        mode: params.mode,
-        minScore: params.minScore
-      });
-    }
-  });
-};
-const useIndexWorkspaceContent = () => {
-  const client = react$1.useMastraClient();
-  return reactQuery.useMutation({
-    mutationFn: async (params) => {
-      if (!compatibility.isWorkspaceV1Supported(client)) {
-        throw new Error("Workspace v1 not supported by core or client");
-      }
-      const workspace = client.getWorkspace(params.workspaceId);
-      return workspace.index({
-        path: params.path,
-        content: params.content,
-        metadata: params.metadata
-      });
-    }
-  });
-};
-
-const useWorkspaceSkills = (options) => {
-  const client = react$1.useMastraClient();
-  return reactQuery.useQuery({
-    queryKey: ["workspace", "skills", options?.workspaceId],
-    queryFn: async () => {
-      if (!compatibility.isWorkspaceV1Supported(client)) {
-        throw new Error("Workspace v1 not supported by core or client");
-      }
-      if (!options?.workspaceId) {
-        throw new Error("workspaceId is required");
-      }
-      const workspace = client.getWorkspace(options.workspaceId);
-      return workspace.listSkills();
-    },
-    enabled: !!options?.workspaceId && compatibility.isWorkspaceV1Supported(client),
-    retry: compatibility.shouldRetryWorkspaceQuery
-  });
-};
-const useWorkspaceSkill = (skillName, options) => {
-  const client = react$1.useMastraClient();
-  return reactQuery.useQuery({
-    queryKey: ["workspace", "skills", skillName, options?.workspaceId],
-    queryFn: async () => {
-      if (!compatibility.isWorkspaceV1Supported(client)) {
-        throw new Error("Workspace v1 not supported by core or client");
-      }
-      if (!options?.workspaceId) {
-        throw new Error("workspaceId is required");
-      }
-      const workspace = client.getWorkspace(options.workspaceId);
-      const skill = workspace.getSkill(skillName);
-      return skill.details();
-    },
-    enabled: options?.enabled !== false && !!skillName && !!options?.workspaceId && compatibility.isWorkspaceV1Supported(client),
-    retry: compatibility.shouldRetryWorkspaceQuery
-  });
-};
-const useWorkspaceSkillReferences = (skillName, options) => {
-  const client = react$1.useMastraClient();
-  return reactQuery.useQuery({
-    queryKey: ["workspace", "skills", skillName, "references", options?.workspaceId],
-    queryFn: async () => {
-      if (!compatibility.isWorkspaceV1Supported(client)) {
-        throw new Error("Workspace v1 not supported by core or client");
-      }
-      if (!options?.workspaceId) {
-        throw new Error("workspaceId is required");
-      }
-      const workspace = client.getWorkspace(options.workspaceId);
-      const skill = workspace.getSkill(skillName);
-      return skill.listReferences();
-    },
-    enabled: options?.enabled !== false && !!skillName && !!options?.workspaceId && compatibility.isWorkspaceV1Supported(client),
-    retry: compatibility.shouldRetryWorkspaceQuery
-  });
-};
-const useWorkspaceSkillReference = (skillName, referencePath, options) => {
-  const client = react$1.useMastraClient();
-  return reactQuery.useQuery({
-    queryKey: ["workspace", "skills", skillName, "references", referencePath, options?.workspaceId],
-    queryFn: async () => {
-      if (!compatibility.isWorkspaceV1Supported(client)) {
-        throw new Error("Workspace v1 not supported by core or client");
-      }
-      if (!options?.workspaceId) {
-        throw new Error("workspaceId is required");
-      }
-      const workspace = client.getWorkspace(options.workspaceId);
-      const skill = workspace.getSkill(skillName);
-      return skill.getReference(referencePath);
-    },
-    enabled: options?.enabled !== false && !!skillName && !!referencePath && !!options?.workspaceId && compatibility.isWorkspaceV1Supported(client),
-    retry: compatibility.shouldRetryWorkspaceQuery
-  });
-};
-const useSearchWorkspaceSkills = () => {
-  const client = react$1.useMastraClient();
-  return reactQuery.useMutation({
-    mutationFn: async (params) => {
-      if (!compatibility.isWorkspaceV1Supported(client)) {
-        throw new Error("Workspace v1 not supported by core or client");
-      }
-      const workspace = client.getWorkspace(params.workspaceId);
-      return workspace.searchSkills(params);
-    }
-  });
-};
-const useAgentSkill = (agentId, skillName, options) => {
-  const client = react$1.useMastraClient();
-  return reactQuery.useQuery({
-    queryKey: ["agents", agentId, "skills", skillName, options?.workspaceId],
-    queryFn: async () => {
-      if (!compatibility.isWorkspaceV1Supported(client)) {
-        throw new Error("Workspace v1 not supported by core or client");
-      }
-      if (!options?.workspaceId) {
-        throw new Error("workspaceId is required");
-      }
-      const workspace = client.getWorkspace(options.workspaceId);
-      const skill = workspace.getSkill(skillName);
-      return skill.details();
-    },
-    enabled: options?.enabled !== false && !!agentId && !!skillName && !!options?.workspaceId && compatibility.isWorkspaceV1Supported(client),
-    retry: compatibility.shouldRetryWorkspaceQuery
-  });
-};
-
 const useMastraPlatform = () => {
   const mastraPlatformEndpoint = window.MASTRA_CLOUD_API_ENDPOINT;
   const isMastraPlatform = Boolean(mastraPlatformEndpoint);
@@ -40499,6 +41979,7 @@ exports.AgentSettingsProvider = AgentSettingsProvider;
 exports.AgentSourceIcon = AgentSourceIcon;
 exports.AgentToolPanel = AgentToolPanel;
 exports.AgentVersionCombobox = AgentVersionCombobox;
+exports.AgentVersionPanel = AgentVersionPanel;
 exports.AgentsCmsLayout = AgentsCmsLayout;
 exports.AgentsPage = AgentsPage;
 exports.AgentsSection = AgentsSection;
@@ -40523,6 +42004,7 @@ exports.ChatThreads = ChatThreads;
 exports.CheckIcon = CheckIcon;
 exports.Checkbox = Checkbox;
 exports.ChevronIcon = ChevronIcon;
+exports.CodeDiff = CodeDiff;
 exports.CodeEditor = CodeEditor;
 exports.Collapsible = Collapsible;
 exports.CollapsibleContent = CollapsibleContent;
@@ -40550,6 +42032,7 @@ exports.CreateDatasetDialog = CreateDatasetDialog;
 exports.CreateDatasetFromItemsDialog = CreateDatasetFromItemsDialog;
 exports.CrossIcon = CrossIcon;
 exports.Crumb = Crumb;
+exports.DatasetCombobox = DatasetCombobox;
 exports.DatasetCompareVersionToolbar = DatasetCompareVersionToolbar;
 exports.DatasetCompareVersionsList = DatasetCompareVersionsList;
 exports.DatasetExperiments = DatasetExperiments;
@@ -40754,6 +42237,7 @@ exports.SkillIcon = SkillIcon;
 exports.SkillRemoveButton = SkillRemoveButton;
 exports.SkillUpdateButton = SkillUpdateButton;
 exports.SkillsNotConfigured = SkillsNotConfigured;
+exports.SkillsPage = SkillsPage;
 exports.SkillsTable = SkillsTable;
 exports.SlashIcon = SlashIcon;
 exports.Slider = Slider;
@@ -40817,6 +42301,7 @@ exports.TracesList = TracesList;
 exports.TracesTools = TracesTools;
 exports.TracingSettingsContext = TracingSettingsContext;
 exports.TracingSettingsProvider = TracingSettingsProvider;
+exports.Tree = Tree;
 exports.Truncate = Truncate;
 exports.TsIcon = TsIcon;
 exports.Txt = Txt;
@@ -40893,7 +42378,9 @@ exports.mapInstructionBlocksToApi = mapInstructionBlocksToApi;
 exports.mapScorersToApi = mapScorersToApi;
 exports.normalizeIntegrationToolsToRecord = normalizeIntegrationToolsToRecord;
 exports.normalizeScorersFromApi = normalizeScorersFromApi;
+exports.normalizeSkillsFromApi = normalizeSkillsFromApi;
 exports.normalizeToolsToRecord = normalizeToolsToRecord;
+exports.normalizeWorkspaceFromApi = normalizeWorkspaceFromApi;
 exports.parseError = parseError;
 exports.parseFieldPath = parseFieldPath;
 exports.parseJSONCell = parseJSONCell;
@@ -40936,6 +42423,7 @@ exports.useCompareExperiments = useCompareExperiments;
 exports.useCompareScorerVersions = useCompareScorerVersions;
 exports.useCreateAgentVersion = useCreateAgentVersion;
 exports.useCreateScorerVersion = useCreateScorerVersion;
+exports.useCreateSkill = useCreateSkill;
 exports.useCreateWorkspaceDirectory = useCreateWorkspaceDirectory;
 exports.useCurrentRun = useCurrentRun;
 exports.useDataset = useDataset;
@@ -41018,6 +42506,7 @@ exports.useStoredAgentMutations = useStoredAgentMutations;
 exports.useStoredAgents = useStoredAgents;
 exports.useStoredScorer = useStoredScorer;
 exports.useStoredScorerMutations = useStoredScorerMutations;
+exports.useStoredSkills = useStoredSkills;
 exports.useStudioConfig = useStudioConfig;
 exports.useTableKeyboardNavigation = useTableKeyboardNavigation;
 exports.useThreadInput = useThreadInput;