@getsupervisor/agents-studio-sdk 1.22.1 → 1.22.2

package/dist/index.js

@@ -1217,21 +1217,167 @@ function createToolsApi(cfg) {
   };
 }
 
+// src/utils/catalog-voices.ts
+var FALLBACK_LOCALE = "und";
+var FALLBACK_PROVIDER = "catalog";
+function catalogItemToVoice(item) {
+  const metadata = normalizeVoiceMetadata(item.metadata);
+  const locale = metadata.locale ?? metadata.language ?? FALLBACK_LOCALE;
+  return {
+    id: item.id,
+    providerVoiceId: metadata.providerVoiceId ?? item.systemIdentifier,
+    name: item.name,
+    gender: metadata.gender,
+    locale,
+    tags: metadata.tags ?? [],
+    previewUrl: metadata.previewUrl ?? void 0,
+    provider: metadata.provider ?? FALLBACK_PROVIDER
+  };
+}
+function normalizeVoiceMetadata(metadata) {
+  if (!metadata || typeof metadata !== "object") {
+    return {};
+  }
+  const raw = metadata;
+  return {
+    language: pickString(raw.language),
+    locale: pickString(raw.locale, true),
+    gender: pickGender(raw.gender),
+    provider: pickString(raw.provider, true),
+    previewUrl: pickString(raw.previewUrl, true),
+    tags: pickStringArray(raw.tags),
+    providerVoiceId: pickString(raw.providerVoiceId)
+  };
+}
+function pickString(value, allowNull = false) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (allowNull && value === null) {
+    return null;
+  }
+  return void 0;
+}
+function pickStringArray(value) {
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  const items = value.filter(
+    (item) => typeof item === "string"
+  );
+  return items.length > 0 ? items : void 0;
+}
+function pickGender(value) {
+  if (value === "female" || value === "male" || value === "neutral") {
+    return value;
+  }
+  return void 0;
+}
+
+// src/utils/catalog-filter.ts
+import { Query } from "@getsupervisor/api-query-builder";
+function createCatalogTypeQuery(type) {
+  return new Query((qb) => qb.eq("type", type));
+}
+function ensureCatalogTypeFilter(filter, type) {
+  const requiredQuery = createCatalogTypeQuery(type);
+  const requiredExpression = requiredQuery.build();
+  if (filter === void 0 || filter === null) {
+    return requiredQuery;
+  }
+  if (typeof filter === "string") {
+    return ensureTypeForString(filter, requiredQuery, requiredExpression);
+  }
+  if (isQueryBuilderLike(filter)) {
+    return ensureTypeForBuilder(filter, requiredQuery, requiredExpression);
+  }
+  if (isPlainObject2(filter)) {
+    return ensureTypeForObject(filter, type);
+  }
+  return filter;
+}
+function ensureTypeForString(value, requiredQuery, requiredExpression) {
+  const normalized = value.trim();
+  if (!normalized.length) {
+    return requiredQuery;
+  }
+  return containsTypePredicate(normalized, requiredExpression) ? normalized : `and(${requiredExpression},${normalized})`;
+}
+function ensureTypeForBuilder(builder, requiredQuery, requiredExpression) {
+  const normalized = builder.build().trim();
+  if (!normalized.length) {
+    return requiredQuery;
+  }
+  if (containsTypePredicate(normalized, requiredExpression)) {
+    return builder;
+  }
+  const combined = `and(${requiredExpression},${normalized})`;
+  return {
+    build: () => combined
+  };
+}
+function ensureTypeForObject(candidate, type) {
+  if (hasTypeEquality(candidate, type)) {
+    return candidate;
+  }
+  const typeConfig = candidate.type;
+  const normalizedType = isPlainObject2(typeConfig) ? { ...typeConfig, eq: type } : { eq: type };
+  return {
+    ...candidate,
+    type: normalizedType
+  };
+}
+function hasTypeEquality(candidate, type) {
+  const typeConfig = candidate.type;
+  if (typeof typeConfig === "string") {
+    return typeConfig === type;
+  }
+  if (!isPlainObject2(typeConfig)) {
+    return false;
+  }
+  return typeConfig.eq === type;
+}
+function containsTypePredicate(expression, required) {
+  const normalizedExpression = expression.replace(/\s+/g, "").toLowerCase();
+  const normalizedRequired = required.replace(/\s+/g, "").toLowerCase();
+  return normalizedExpression.includes(normalizedRequired);
+}
+function isQueryBuilderLike(candidate) {
+  return !!candidate && typeof candidate === "object" && typeof candidate.build === "function";
+}
+function isPlainObject2(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+
 // src/api/voices.ts
+function mapCatalogResponseToVoiceList(response) {
+  return {
+    data: response.data.filter((item) => item.type === "voice").map(catalogItemToVoice),
+    meta: response.meta
+  };
+}
 function createVoicesApi(cfg) {
   const { base, doFetch } = createHttp(cfg);
   const fetchVoicesPage = async (options = {}) => {
-    const { agentId, agentVersionId, gender, locale } = options;
+    const normalizedOptions = {
+      ...options,
+      filter: ensureCatalogTypeFilter(options.filter, "voice")
+    };
+    const { agentId, agentVersionId, gender, locale } = normalizedOptions;
     const query = serializeListOptions(
       {
-        page: options.page,
-        limit: options.limit ?? options.pageSize,
-        sort: options.sort,
-        fields: options.fields,
-        include: options.include,
-        search: options.search,
-        filter: options.filter,
-        or: options.or
+        page: normalizedOptions.page,
+        limit: normalizedOptions.limit ?? normalizedOptions.pageSize,
+        sort: normalizedOptions.sort,
+        fields: normalizedOptions.fields,
+        include: normalizedOptions.include,
+        search: normalizedOptions.search,
+        filter: normalizedOptions.filter,
+        or: normalizedOptions.or
       },
       {
         agentId,
@@ -1240,11 +1386,12 @@ function createVoicesApi(cfg) {
         locale
       }
     );
-    const res = await doFetch(`${base}/voices`, {
+    const res = await doFetch(`${base}/catalogs/items`, {
       method: "GET",
       query
     });
-    return res.json();
+    const raw = await res.json();
+    return mapCatalogResponseToVoiceList(raw);
   };
   return {
     async list(options = {}) {