@dexto/core 1.1.10 → 1.2.0

package/dist/utils/schema-metadata.cjs

@@ -0,0 +1,235 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var schema_metadata_exports = {};
+__export(schema_metadata_exports, {
+  extractCommonFields: () => extractCommonFields,
+  extractDiscriminatedUnionMetadata: () => extractDiscriminatedUnionMetadata,
+  extractSchemaMetadata: () => extractSchemaMetadata,
+  getFieldDefault: () => getFieldDefault,
+  isFieldRequiredInVariant: () => isFieldRequiredInVariant
+});
+module.exports = __toCommonJS(schema_metadata_exports);
+function extractDefault(def) {
+  if (def.defaultValue !== void 0) {
+    return typeof def.defaultValue === "function" ? def.defaultValue() : def.defaultValue;
+  }
+  if (def.typeName === "ZodBranded" && def.type) {
+    return extractDefault(def.type._def);
+  }
+  if (def.typeName === "ZodOptional" && def.innerType) {
+    return extractDefault(def.innerType._def);
+  }
+  if (def.typeName === "ZodNullable" && def.innerType) {
+    return extractDefault(def.innerType._def);
+  }
+  return void 0;
+}
+function extractEnumValues(def) {
+  if (def.typeName === "ZodBranded" && def.type) {
+    return extractEnumValues(def.type._def);
+  }
+  if (def.typeName === "ZodOptional" && def.innerType) {
+    return extractEnumValues(def.innerType._def);
+  }
+  if (def.typeName === "ZodNullable" && def.innerType) {
+    return extractEnumValues(def.innerType._def);
+  }
+  if (def.typeName === "ZodEffects" && def.schema) {
+    return extractEnumValues(def.schema._def);
+  }
+  if (def.typeName === "ZodEnum") {
+    return def.values;
+  }
+  if (def.typeName === "ZodLiteral") {
+    return [String(def.value)];
+  }
+  return void 0;
+}
+function extractTypeName(def) {
+  if (def.typeName === "ZodBranded" && def.type) {
+    return extractTypeName(def.type._def);
+  }
+  if (def.typeName === "ZodOptional" && def.innerType) {
+    return extractTypeName(def.innerType._def) + "?";
+  }
+  if (def.typeName === "ZodNullable" && def.innerType) {
+    return extractTypeName(def.innerType._def) + "?";
+  }
+  if (def.typeName === "ZodLiteral") {
+    return `literal(${JSON.stringify(def.value)})`;
+  }
+  if (def.typeName === "ZodEnum") {
+    return `enum(${def.values.join("|")})`;
+  }
+  if (def.typeName === "ZodArray") {
+    return `array<${extractTypeName(def.type._def)}>`;
+  }
+  if (def.typeName === "ZodRecord") {
+    return `record<${extractTypeName(def.valueType._def)}>`;
+  }
+  if (def.typeName === "ZodEffects" && def.schema) {
+    return extractTypeName(def.schema._def);
+  }
+  const typeMap = {
+    ZodString: "string",
+    ZodNumber: "number",
+    ZodBoolean: "boolean",
+    ZodObject: "object",
+    ZodArray: "array",
+    ZodRecord: "record",
+    ZodUnion: "union",
+    ZodDiscriminatedUnion: "discriminatedUnion"
+  };
+  return typeMap[def.typeName] || def.typeName?.replace("Zod", "").toLowerCase() || "unknown";
+}
+function isFieldRequired(def) {
+  if (def.defaultValue !== void 0) {
+    return false;
+  }
+  if (def.typeName === "ZodOptional") {
+    return false;
+  }
+  if (def.typeName === "ZodNullable") {
+    return false;
+  }
+  if (def.typeName === "ZodBranded" && def.type) {
+    return isFieldRequired(def.type._def);
+  }
+  return true;
+}
+function extractSchemaMetadata(schema) {
+  const metadata = {
+    defaults: {},
+    requiredFields: [],
+    fieldTypes: {},
+    descriptions: {},
+    enumValues: {}
+  };
+  let def = schema._def;
+  if (def.typeName === "ZodBranded" && def.type) {
+    def = def.type._def;
+  }
+  if (def.typeName !== "ZodObject") {
+    throw new Error(`Expected ZodObject, got ${def.typeName}`);
+  }
+  const shape = def.shape();
+  for (const [fieldName, fieldSchema] of Object.entries(shape)) {
+    const fieldDef = fieldSchema._def;
+    const defaultValue = extractDefault(fieldDef);
+    if (defaultValue !== void 0) {
+      metadata.defaults[fieldName] = defaultValue;
+    }
+    if (isFieldRequired(fieldDef)) {
+      metadata.requiredFields.push(fieldName);
+    }
+    metadata.fieldTypes[fieldName] = extractTypeName(fieldDef);
+    if (fieldDef.description) {
+      metadata.descriptions[fieldName] = fieldDef.description;
+    }
+    const enumVals = extractEnumValues(fieldDef);
+    if (enumVals) {
+      metadata.enumValues[fieldName] = enumVals;
+    }
+  }
+  return metadata;
+}
+function extractDiscriminatedUnionMetadata(schema) {
+  let def = schema._def;
+  if (def.typeName === "ZodBranded" && def.type) {
+    def = def.type._def;
+  }
+  if (def.typeName === "ZodEffects" && def.schema) {
+    def = def.schema._def;
+  }
+  if (def.typeName !== "ZodDiscriminatedUnion") {
+    throw new Error(`Expected ZodDiscriminatedUnion, got ${def.typeName}`);
+  }
+  const discriminator = def.discriminator;
+  const optionsMap = def.optionsMap;
+  const metadata = {
+    discriminator,
+    options: Array.from(optionsMap.keys()),
+    schemas: {}
+  };
+  for (const [optionValue, optionSchema] of optionsMap.entries()) {
+    metadata.schemas[optionValue] = extractSchemaMetadata(optionSchema);
+  }
+  return metadata;
+}
+function extractCommonFields(metadata) {
+  const schemas = Object.values(metadata.schemas);
+  if (schemas.length === 0) {
+    return {
+      defaults: {},
+      requiredFields: [],
+      fieldTypes: {},
+      descriptions: {},
+      enumValues: {}
+    };
+  }
+  const first = schemas[0];
+  const rest = schemas.slice(1);
+  const common = {
+    defaults: { ...first.defaults },
+    requiredFields: [...first.requiredFields],
+    fieldTypes: { ...first.fieldTypes },
+    descriptions: { ...first.descriptions },
+    enumValues: { ...first.enumValues }
+  };
+  for (const schema of rest) {
+    for (const key of Object.keys(common.defaults)) {
+      if (!(key in schema.defaults) || schema.defaults[key] !== common.defaults[key]) {
+        delete common.defaults[key];
+      }
+    }
+    common.requiredFields = common.requiredFields.filter(
+      (field) => schema.requiredFields.includes(field)
+    );
+    for (const key of Object.keys(common.fieldTypes)) {
+      if (!(key in schema.fieldTypes) || schema.fieldTypes[key] !== common.fieldTypes[key]) {
+        delete common.fieldTypes[key];
+      }
+    }
+    for (const key of Object.keys(common.descriptions)) {
+      if (!(key in schema.descriptions) || schema.descriptions[key] !== common.descriptions[key]) {
+        delete common.descriptions[key];
+      }
+    }
+    for (const key of Object.keys(common.enumValues)) {
+      if (!(key in schema.enumValues) || JSON.stringify(schema.enumValues[key]) !== JSON.stringify(common.enumValues[key])) {
+        delete common.enumValues[key];
+      }
+    }
+  }
+  return common;
+}
+function getFieldDefault(metadata, discriminatorValue, fieldName) {
+  return metadata.schemas[discriminatorValue]?.defaults[fieldName];
+}
+function isFieldRequiredInVariant(metadata, discriminatorValue, fieldName) {
+  return metadata.schemas[discriminatorValue]?.requiredFields.includes(fieldName) ?? false;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractCommonFields,
+  extractDiscriminatedUnionMetadata,
+  extractSchemaMetadata,
+  getFieldDefault,
+  isFieldRequiredInVariant
+});

package/dist/utils/schema-metadata.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Schema metadata extraction utilities for Zod schemas
+ *
+ * This module provides utilities to extract metadata from Zod schemas at runtime.
+ *
+ * IMPORTANT: This uses Zod's private `._def` API which is not officially supported
+ * and may break in future Zod versions. We use this approach because:
+ * 1. No public Zod API exists for runtime schema introspection
+ * 2. Benefits of schema-driven UI metadata outweigh version risk
+ * 3. Changes would be caught by TypeScript/tests during upgrades
+ *
+ * TODO: Update web UI to use these helpers to reduce total code volume and improve maintainability. Also fix these helpers if needed.
+ * See packages/webui/components/AgentEditor/CustomizePanel.tsx for the UI side TODO tracking this same goal.
+ *
+ * If Zod provides official introspection APIs in the future, migrate to those.
+ */
+import { z } from 'zod';
+/**
+ * Metadata extracted from a Zod schema
+ */
+export interface SchemaMetadata {
+    /** Default values for each field */
+    defaults: Record<string, unknown>;
+    /** Required fields (not optional, not with defaults) */
+    requiredFields: string[];
+    /** Field type information */
+    fieldTypes: Record<string, string>;
+    /** Field descriptions from .describe() calls */
+    descriptions: Record<string, string>;
+    /** Enum values for enum fields (e.g., provider: ['openai', 'anthropic']) */
+    enumValues: Record<string, string[]>;
+}
+/**
+ * Extract metadata from a discriminated union schema
+ * Handles schemas like McpServerConfigSchema (stdio | sse | http)
+ */
+export interface DiscriminatedUnionMetadata {
+    /** The discriminator field name (e.g., "type") */
+    discriminator: string;
+    /** Possible discriminator values (e.g., ["stdio", "sse", "http"]) */
+    options: string[];
+    /** Metadata for each option */
+    schemas: Record<string, SchemaMetadata>;
+}
+/**
+ * Extract metadata from a Zod object schema
+ *
+ * @param schema - Zod schema to extract metadata from
+ * @returns SchemaMetadata object with defaults, required fields, types, and descriptions
+ */
+export declare function extractSchemaMetadata(schema: z.ZodTypeAny): SchemaMetadata;
+/**
+ * Extract metadata from a discriminated union schema
+ *
+ * @param schema - Zod discriminated union schema
+ * @returns DiscriminatedUnionMetadata with info about each variant
+ */
+export declare function extractDiscriminatedUnionMetadata(schema: z.ZodTypeAny): DiscriminatedUnionMetadata;
+/**
+ * Extract common fields from a discriminated union (fields present in all variants)
+ * Useful for extracting shared defaults like 'timeout' or 'connectionMode'
+ */
+export declare function extractCommonFields(metadata: DiscriminatedUnionMetadata): SchemaMetadata;
+/**
+ * Get default value for a specific field in a discriminated union variant
+ *
+ * @param metadata - Discriminated union metadata
+ * @param discriminatorValue - The discriminator value (e.g., 'stdio', 'http')
+ * @param fieldName - The field to get default for
+ * @returns The default value or undefined
+ */
+export declare function getFieldDefault(metadata: DiscriminatedUnionMetadata, discriminatorValue: string, fieldName: string): unknown;
+/**
+ * Check if a field is required in a specific discriminated union variant
+ *
+ * @param metadata - Discriminated union metadata
+ * @param discriminatorValue - The discriminator value (e.g., 'stdio', 'http')
+ * @param fieldName - The field to check
+ * @returns true if required, false otherwise
+ */
+export declare function isFieldRequiredInVariant(metadata: DiscriminatedUnionMetadata, discriminatorValue: string, fieldName: string): boolean;
+//# sourceMappingURL=schema-metadata.d.ts.map

package/dist/utils/schema-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-metadata.d.ts","sourceRoot":"","sources":["../../src/utils/schema-metadata.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,MAAM,WAAW,cAAc;IAC3B,oCAAoC;IACpC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,wDAAwD;IACxD,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,6BAA6B;IAC7B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,gDAAgD;IAChD,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,4EAA4E;IAC5E,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CACxC;AAED;;;GAGG;AACH,MAAM,WAAW,0BAA0B;IACvC,kDAAkD;IAClD,aAAa,EAAE,MAAM,CAAC;IACtB,qEAAqE;IACrE,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,+BAA+B;IAC/B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;CAC3C;AA0JD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,GAAG,cAAc,CAqD1E;AAED;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAC7C,MAAM,EAAE,CAAC,CAAC,UAAU,GACrB,0BAA0B,CAgC5B;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,0BAA0B,GAAG,cAAc,CAiExF;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC3B,QAAQ,EAAE,0BAA0B,EACpC,kBAAkB,EAAE,MAAM,EAC1B,SAAS,EAAE,MAAM,GAClB,OAAO,CAET;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACpC,QAAQ,EAAE,0BAA0B,EACpC,kBAAkB,EAAE,MAAM,EAC1B,SAAS,EAAE,MAAM,GAClB,OAAO,CAET"}

package/dist/utils/schema-metadata.js

@@ -0,0 +1,208 @@
+import "../chunk-C6A6W6XS.js";
+function extractDefault(def) {
+  if (def.defaultValue !== void 0) {
+    return typeof def.defaultValue === "function" ? def.defaultValue() : def.defaultValue;
+  }
+  if (def.typeName === "ZodBranded" && def.type) {
+    return extractDefault(def.type._def);
+  }
+  if (def.typeName === "ZodOptional" && def.innerType) {
+    return extractDefault(def.innerType._def);
+  }
+  if (def.typeName === "ZodNullable" && def.innerType) {
+    return extractDefault(def.innerType._def);
+  }
+  return void 0;
+}
+function extractEnumValues(def) {
+  if (def.typeName === "ZodBranded" && def.type) {
+    return extractEnumValues(def.type._def);
+  }
+  if (def.typeName === "ZodOptional" && def.innerType) {
+    return extractEnumValues(def.innerType._def);
+  }
+  if (def.typeName === "ZodNullable" && def.innerType) {
+    return extractEnumValues(def.innerType._def);
+  }
+  if (def.typeName === "ZodEffects" && def.schema) {
+    return extractEnumValues(def.schema._def);
+  }
+  if (def.typeName === "ZodEnum") {
+    return def.values;
+  }
+  if (def.typeName === "ZodLiteral") {
+    return [String(def.value)];
+  }
+  return void 0;
+}
+function extractTypeName(def) {
+  if (def.typeName === "ZodBranded" && def.type) {
+    return extractTypeName(def.type._def);
+  }
+  if (def.typeName === "ZodOptional" && def.innerType) {
+    return extractTypeName(def.innerType._def) + "?";
+  }
+  if (def.typeName === "ZodNullable" && def.innerType) {
+    return extractTypeName(def.innerType._def) + "?";
+  }
+  if (def.typeName === "ZodLiteral") {
+    return `literal(${JSON.stringify(def.value)})`;
+  }
+  if (def.typeName === "ZodEnum") {
+    return `enum(${def.values.join("|")})`;
+  }
+  if (def.typeName === "ZodArray") {
+    return `array<${extractTypeName(def.type._def)}>`;
+  }
+  if (def.typeName === "ZodRecord") {
+    return `record<${extractTypeName(def.valueType._def)}>`;
+  }
+  if (def.typeName === "ZodEffects" && def.schema) {
+    return extractTypeName(def.schema._def);
+  }
+  const typeMap = {
+    ZodString: "string",
+    ZodNumber: "number",
+    ZodBoolean: "boolean",
+    ZodObject: "object",
+    ZodArray: "array",
+    ZodRecord: "record",
+    ZodUnion: "union",
+    ZodDiscriminatedUnion: "discriminatedUnion"
+  };
+  return typeMap[def.typeName] || def.typeName?.replace("Zod", "").toLowerCase() || "unknown";
+}
+function isFieldRequired(def) {
+  if (def.defaultValue !== void 0) {
+    return false;
+  }
+  if (def.typeName === "ZodOptional") {
+    return false;
+  }
+  if (def.typeName === "ZodNullable") {
+    return false;
+  }
+  if (def.typeName === "ZodBranded" && def.type) {
+    return isFieldRequired(def.type._def);
+  }
+  return true;
+}
+function extractSchemaMetadata(schema) {
+  const metadata = {
+    defaults: {},
+    requiredFields: [],
+    fieldTypes: {},
+    descriptions: {},
+    enumValues: {}
+  };
+  let def = schema._def;
+  if (def.typeName === "ZodBranded" && def.type) {
+    def = def.type._def;
+  }
+  if (def.typeName !== "ZodObject") {
+    throw new Error(`Expected ZodObject, got ${def.typeName}`);
+  }
+  const shape = def.shape();
+  for (const [fieldName, fieldSchema] of Object.entries(shape)) {
+    const fieldDef = fieldSchema._def;
+    const defaultValue = extractDefault(fieldDef);
+    if (defaultValue !== void 0) {
+      metadata.defaults[fieldName] = defaultValue;
+    }
+    if (isFieldRequired(fieldDef)) {
+      metadata.requiredFields.push(fieldName);
+    }
+    metadata.fieldTypes[fieldName] = extractTypeName(fieldDef);
+    if (fieldDef.description) {
+      metadata.descriptions[fieldName] = fieldDef.description;
+    }
+    const enumVals = extractEnumValues(fieldDef);
+    if (enumVals) {
+      metadata.enumValues[fieldName] = enumVals;
+    }
+  }
+  return metadata;
+}
+function extractDiscriminatedUnionMetadata(schema) {
+  let def = schema._def;
+  if (def.typeName === "ZodBranded" && def.type) {
+    def = def.type._def;
+  }
+  if (def.typeName === "ZodEffects" && def.schema) {
+    def = def.schema._def;
+  }
+  if (def.typeName !== "ZodDiscriminatedUnion") {
+    throw new Error(`Expected ZodDiscriminatedUnion, got ${def.typeName}`);
+  }
+  const discriminator = def.discriminator;
+  const optionsMap = def.optionsMap;
+  const metadata = {
+    discriminator,
+    options: Array.from(optionsMap.keys()),
+    schemas: {}
+  };
+  for (const [optionValue, optionSchema] of optionsMap.entries()) {
+    metadata.schemas[optionValue] = extractSchemaMetadata(optionSchema);
+  }
+  return metadata;
+}
+function extractCommonFields(metadata) {
+  const schemas = Object.values(metadata.schemas);
+  if (schemas.length === 0) {
+    return {
+      defaults: {},
+      requiredFields: [],
+      fieldTypes: {},
+      descriptions: {},
+      enumValues: {}
+    };
+  }
+  const first = schemas[0];
+  const rest = schemas.slice(1);
+  const common = {
+    defaults: { ...first.defaults },
+    requiredFields: [...first.requiredFields],
+    fieldTypes: { ...first.fieldTypes },
+    descriptions: { ...first.descriptions },
+    enumValues: { ...first.enumValues }
+  };
+  for (const schema of rest) {
+    for (const key of Object.keys(common.defaults)) {
+      if (!(key in schema.defaults) || schema.defaults[key] !== common.defaults[key]) {
+        delete common.defaults[key];
+      }
+    }
+    common.requiredFields = common.requiredFields.filter(
+      (field) => schema.requiredFields.includes(field)
+    );
+    for (const key of Object.keys(common.fieldTypes)) {
+      if (!(key in schema.fieldTypes) || schema.fieldTypes[key] !== common.fieldTypes[key]) {
+        delete common.fieldTypes[key];
+      }
+    }
+    for (const key of Object.keys(common.descriptions)) {
+      if (!(key in schema.descriptions) || schema.descriptions[key] !== common.descriptions[key]) {
+        delete common.descriptions[key];
+      }
+    }
+    for (const key of Object.keys(common.enumValues)) {
+      if (!(key in schema.enumValues) || JSON.stringify(schema.enumValues[key]) !== JSON.stringify(common.enumValues[key])) {
+        delete common.enumValues[key];
+      }
+    }
+  }
+  return common;
+}
+function getFieldDefault(metadata, discriminatorValue, fieldName) {
+  return metadata.schemas[discriminatorValue]?.defaults[fieldName];
+}
+function isFieldRequiredInVariant(metadata, discriminatorValue, fieldName) {
+  return metadata.schemas[discriminatorValue]?.requiredFields.includes(fieldName) ?? false;
+}
+export {
+  extractCommonFields,
+  extractDiscriminatedUnionMetadata,
+  extractSchemaMetadata,
+  getFieldDefault,
+  isFieldRequiredInVariant
+};

package/dist/utils/schema.d.ts

@@ -1,6 +1,5 @@
 /**
  * Convert Zod schema to JSON Schema format for tool parameters
  */
-declare function convertZodSchemaToJsonSchema(zodSchema: any): any;
-
-export { convertZodSchemaToJsonSchema };
+export declare function convertZodSchemaToJsonSchema(zodSchema: any): any;
+//# sourceMappingURL=schema.d.ts.map

package/dist/utils/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/utils/schema.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,GAAG,GAAG,GAAG,CAchE"}

package/dist/utils/schema.js

@@ -1,3 +1,4 @@
+import "../chunk-C6A6W6XS.js";
 import { zodToJsonSchema } from "zod-to-json-schema";
 import { logger } from "../logger/index.js";
 function convertZodSchemaToJsonSchema(zodSchema) {