@cavi-ai/api-client 0.1.0

package/dist/core/gateway/agent/config.js

@@ -0,0 +1,536 @@
+import { GATEWAY_AGENT_CONFIG_API_ENDPOINTS } from "../../../contracts/paths.js";
+import { BaseHttpApiClient } from "../../http/client.js";
+import { isSensitiveKey } from "../../http/redaction.js";
+import { parseAgentVoiceConfig } from "./voice-config.js";
+export const AGENT_PROFILE_CONFIG_CONTRACT = "AGENT_PROFILE_CONFIG_V1";
+export const AGENT_PROFILE_CONFIG_PATCH_CONTRACT = "AGENT_PROFILE_CONFIG_PATCH_V1";
+export class GatewayAgentConfigApiError extends Error {
+    status;
+    path;
+    constructor(message, options) {
+        super(message);
+        this.name = "GatewayAgentConfigApiError";
+        this.status = options?.status;
+        this.path = options?.path;
+    }
+}
+const AGENT_PROFILE_ID_RE = /^(?:default|[a-z0-9][a-z0-9_-]{0,63})$/u;
+const REASONING_EFFORT_OPTIONS = [
+    { value: "", label: "Default" },
+    { value: "none", label: "None" },
+    { value: "minimal", label: "Minimal" },
+    { value: "low", label: "Low" },
+    { value: "medium", label: "Medium" },
+    { value: "high", label: "High" },
+    { value: "xhigh", label: "Extra high" },
+];
+const CLI_TOOLSET_SUGGESTIONS = [
+    "browser",
+    "clarify",
+    "code_execution",
+    "cronjob",
+    "delegation",
+    "file",
+    "image_gen",
+    "memory",
+    "session_search",
+    "skills",
+    "terminal",
+    "todo",
+    "web",
+    "webhook",
+];
+function cleanString(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function asRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function asStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.map(cleanString).filter(Boolean);
+}
+function asNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function asBoolean(value) {
+    return typeof value === "boolean" ? value : null;
+}
+function pathSegments(path) {
+    return path.split(".").map((segment) => segment.trim()).filter(Boolean);
+}
+function getPathValue(config, path) {
+    let current = config;
+    for (const segment of pathSegments(path)) {
+        const record = asRecord(current);
+        if (!(segment in record))
+            return undefined;
+        current = record[segment];
+    }
+    return current;
+}
+function cloneJsonRecord(config) {
+    return JSON.parse(JSON.stringify(config));
+}
+export function setAgentConfigPathValue(config, path, value) {
+    const segments = pathSegments(path);
+    if (segments.length === 0)
+        return config;
+    const next = cloneJsonRecord(config);
+    let cursor = next;
+    for (const segment of segments.slice(0, -1)) {
+        const existing = cursor[segment];
+        if (existing === null || typeof existing !== "object" || Array.isArray(existing)) {
+            cursor[segment] = {};
+        }
+        cursor = cursor[segment];
+    }
+    cursor[segments[segments.length - 1]] = value;
+    return next;
+}
+function flattenConfigPaths(value, prefix = "", out = {}) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        if (prefix)
+            out[prefix] = value;
+        return out;
+    }
+    const record = asRecord(value);
+    const keys = Object.keys(record);
+    if (prefix && keys.length === 0) {
+        out[prefix] = record;
+        return out;
+    }
+    for (const key of keys) {
+        const nextPrefix = prefix ? `${prefix}.${key}` : key;
+        flattenConfigPaths(record[key], nextPrefix, out);
+    }
+    return out;
+}
+function configFieldValue(value) {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value;
+    }
+    if (typeof value === "object") {
+        return value;
+    }
+    return String(value ?? "");
+}
+function titleCase(value) {
+    return value
+        .replace(/[_-]+/gu, " ")
+        .replace(/([a-z0-9])([A-Z])/gu, "$1 $2")
+        .trim()
+        .replace(/\s+/gu, " ")
+        .replace(/\b\w/gu, (char) => char.toUpperCase());
+}
+function labelFromPath(path) {
+    const segments = pathSegments(path);
+    const leaf = segments.length > 0 ? segments[segments.length - 1] : path;
+    return titleCase(leaf);
+}
+function normalizeSchemaField(value) {
+    const record = asRecord(value);
+    const type = cleanString(record.type);
+    const description = cleanString(record.description);
+    const category = cleanString(record.category);
+    const options = Array.isArray(record.options) ? record.options : undefined;
+    return {
+        ...(type ? { type } : {}),
+        ...(description ? { description } : {}),
+        ...(category ? { category } : {}),
+        ...(options ? { options } : {}),
+        ...(asNumber(record.min) !== null ? { min: asNumber(record.min) ?? undefined } : {}),
+        ...(asNumber(record.max) !== null ? { max: asNumber(record.max) ?? undefined } : {}),
+        ...(asNumber(record.step) !== null ? { step: asNumber(record.step) ?? undefined } : {}),
+        ...(!type ? { type: "string" } : {}),
+    };
+}
+function inferSchemaType(value) {
+    if (typeof value === "boolean")
+        return "boolean";
+    if (typeof value === "number")
+        return "number";
+    if (Array.isArray(value))
+        return "list";
+    if (value !== null && typeof value === "object")
+        return "object";
+    return "string";
+}
+function normalizeSchemaOptions(options, currentValue) {
+    const normalized = (options ?? [])
+        .map((option) => {
+        const optionRecord = asRecord(option);
+        const value = cleanString(optionRecord.value) ||
+            cleanString(optionRecord.id) ||
+            cleanString(optionRecord.name) ||
+            (typeof option === "string" || typeof option === "number" || typeof option === "boolean"
+                ? String(option)
+                : "");
+        if (!value)
+            return null;
+        const label = cleanString(optionRecord.label) ||
+            cleanString(optionRecord.name) ||
+            value;
+        return { value, label };
+    })
+        .filter((option) => option !== null);
+    return withOption(normalized, String(currentValue ?? ""), currentValue === null ? "Unset" : undefined);
+}
+export function assertAgentProfileId(agentId) {
+    const clean = cleanString(agentId);
+    if (!AGENT_PROFILE_ID_RE.test(clean)) {
+        throw new GatewayAgentConfigApiError(`Invalid agent profile id "${agentId}". Expected "default" or [a-z0-9][a-z0-9_-]{0,63}.`);
+    }
+    return clean;
+}
+export function agentProfileConfigPath(agentId) {
+    return GATEWAY_AGENT_CONFIG_API_ENDPOINTS.agentConfig(assertAgentProfileId(agentId));
+}
+export function agentProfileConfigSourcePath(agentId) {
+    const id = assertAgentProfileId(agentId);
+    return id === "default"
+        ? "profiles/default/config.yaml"
+        : `profiles/${id}/config.yaml`;
+}
+export function isMissingAgentConfigRouteError(error) {
+    const status = Number(error?.status);
+    return status === 404 || status === 405 || status === 501;
+}
+function field(input) {
+    return input;
+}
+function section(id, label, fields) {
+    return fields.length > 0 ? { id, label, fields } : null;
+}
+function withOption(options, value, label) {
+    if ((!value && !label) || options.some((option) => option.value === value))
+        return options;
+    return [{ value, label: label || value }, ...options];
+}
+export function normalizeAgentProfiles(payload) {
+    const root = asRecord(payload);
+    const profiles = [];
+    for (const value of asArray(root.profiles)) {
+        const profile = asRecord(value);
+        const agentId = cleanString(profile.name);
+        if (!agentId)
+            continue;
+        const sourcePath = cleanString(profile.path);
+        const isActive = asBoolean(profile.is_active);
+        const isDefault = asBoolean(profile.is_default);
+        profiles.push({
+            agentId,
+            agentName: agentId,
+            ...(sourcePath ? { sourcePath } : {}),
+            ...(isActive !== null ? { isActive } : {}),
+            ...(isDefault !== null ? { isDefault } : {}),
+            model: cleanString(profile.model) || null,
+            provider: cleanString(profile.provider) || null,
+        });
+    }
+    return profiles;
+}
+export function findAgentProfile(profiles, agentId) {
+    return profiles.find((profile) => profile.agentId === agentId) ?? null;
+}
+function sourcePathForProfile(profile, agentId, defaultSourcePath) {
+    if (profile?.sourcePath) {
+        const path = profile.sourcePath.trim().replace(/\/+$/u, "");
+        return path.endsWith(".yaml") || path.endsWith(".yml")
+            ? path
+            : `${path}/config.yaml`;
+    }
+    return defaultSourcePath(agentId);
+}
+function normalizeSchemaPayload(payload) {
+    const root = asRecord(payload);
+    const fields = {};
+    for (const [path, schemaField] of Object.entries(asRecord(root.fields))) {
+        if (!path || isSensitiveKey(path))
+            continue;
+        fields[path] = normalizeSchemaField(schemaField);
+    }
+    return {
+        fields,
+        categoryOrder: asStringArray(root.category_order),
+    };
+}
+function categoryForPath(path, schema) {
+    return cleanString(schema?.category) || pathSegments(path)[0] || "general";
+}
+function kindForSchemaField(path, schema, value) {
+    const type = cleanString(schema?.type).toLowerCase() || inferSchemaType(value);
+    if (path === "agent.reasoning_effort") {
+        return {
+            type: "select",
+            options: withOption(REASONING_EFFORT_OPTIONS, String(value ?? "")),
+        };
+    }
+    if (type === "boolean" || type === "bool")
+        return { type: "toggle" };
+    if (type === "number" || type === "integer" || type === "float") {
+        return {
+            type: "number",
+            ...(schema?.min !== undefined ? { min: schema.min } : {}),
+            ...(schema?.max !== undefined ? { max: schema.max } : {}),
+            ...(schema?.step !== undefined ? { step: schema.step } : {}),
+        };
+    }
+    if (type === "select") {
+        const options = normalizeSchemaOptions(schema?.options, value);
+        return options.length > 0
+            ? { type: "select", options }
+            : { type: "text", placeholder: path };
+    }
+    if (type === "list" || Array.isArray(value)) {
+        if (path === "platform_toolsets.cli") {
+            return { type: "chips", suggestions: CLI_TOOLSET_SUGGESTIONS };
+        }
+        if (Array.isArray(value) &&
+            value.every((item) => typeof item === "string" || typeof item === "number")) {
+            return { type: "list", placeholder: "comma-separated values" };
+        }
+        return { type: "json", minRows: 5 };
+    }
+    if (type === "object" || (value !== null && typeof value === "object")) {
+        return { type: "json", minRows: 6 };
+    }
+    if (type === "text" ||
+        path.toLowerCase().includes("prompt") ||
+        (typeof value === "string" && value.length > 120)) {
+        return { type: "multiline", minRows: 4 };
+    }
+    return { type: "text", placeholder: path };
+}
+function defaultValueForKind(kind) {
+    if (kind.type === "toggle")
+        return false;
+    if (kind.type === "number")
+        return 0;
+    if (kind.type === "chips" || kind.type === "list")
+        return [];
+    if (kind.type === "json")
+        return {};
+    return "";
+}
+function compareConfigPaths(a, b, fields, categoryOrder) {
+    const aCategory = categoryForPath(a, fields[a]);
+    const bCategory = categoryForPath(b, fields[b]);
+    const aCategoryIndex = categoryOrder.indexOf(aCategory);
+    const bCategoryIndex = categoryOrder.indexOf(bCategory);
+    const safeAIndex = aCategoryIndex === -1 ? Number.MAX_SAFE_INTEGER : aCategoryIndex;
+    const safeBIndex = bCategoryIndex === -1 ? Number.MAX_SAFE_INTEGER : bCategoryIndex;
+    if (safeAIndex !== safeBIndex)
+        return safeAIndex - safeBIndex;
+    if (aCategory !== bCategory)
+        return aCategory.localeCompare(bCategory);
+    return a.localeCompare(b);
+}
+export function buildAgentConfigFromConfigSnapshot(input) {
+    const agentId = assertAgentProfileId(input.agentId);
+    const profile = input.profile ?? null;
+    const sourcePath = sourcePathForProfile(profile, agentId, input.defaultSourcePath ?? agentProfileConfigSourcePath);
+    const config = asRecord(input.config);
+    const defaults = asRecord(input.defaults);
+    const { fields, categoryOrder } = normalizeSchemaPayload(input.schema ?? {});
+    const paths = new Set();
+    for (const path of Object.keys(fields)) {
+        if (!isSensitiveKey(path))
+            paths.add(path);
+    }
+    for (const path of Object.keys(flattenConfigPaths(config))) {
+        if (!path.startsWith("_") && !isSensitiveKey(path))
+            paths.add(path);
+    }
+    const sectionMap = new Map();
+    for (const path of [...paths].sort((a, b) => compareConfigPaths(a, b, fields, categoryOrder))) {
+        const schema = fields[path];
+        const configValue = getPathValue(config, path);
+        const defaultValue = getPathValue(defaults, path);
+        const rawResolvedValue = configValue !== undefined ? configValue : defaultValue;
+        const kind = kindForSchemaField(path, schema, rawResolvedValue);
+        const resolvedValue = rawResolvedValue === undefined
+            ? defaultValueForKind(kind)
+            : configFieldValue(rawResolvedValue);
+        const category = categoryForPath(path, schema);
+        const bucket = sectionMap.get(category) ?? [];
+        bucket.push(field({
+            key: path,
+            label: labelFromPath(path),
+            description: cleanString(schema?.description) || path,
+            kind,
+            value: resolvedValue,
+            sourcePath: pathSegments(path),
+        }));
+        sectionMap.set(category, bucket);
+    }
+    const identitySection = section("profile", "Profile", [
+        field({
+            key: "profile.name",
+            label: "Profile",
+            description: "Profile that owns this config",
+            kind: { type: "text" },
+            value: profile?.agentName || agentId,
+            editable: false,
+            sourcePath: ["profile", "name"],
+        }),
+        field({
+            key: "profile.configPath",
+            label: "Config source",
+            description: "Profile config source",
+            kind: { type: "text" },
+            value: sourcePath,
+            editable: false,
+            sourcePath: ["profile", "config.yaml"],
+        }),
+    ]);
+    const sectionOrder = [
+        ...categoryOrder,
+        ...[...sectionMap.keys()].filter((category) => !categoryOrder.includes(category)).sort(),
+    ];
+    const configSections = sectionOrder
+        .map((category) => section(category, titleCase(category), sectionMap.get(category) ?? []))
+        .filter((value) => value !== null);
+    const voice = parseAgentVoiceConfig(config);
+    return {
+        agentId,
+        agentName: profile?.agentName || agentId,
+        sourcePath,
+        ...(input.etag ? { etag: input.etag } : {}),
+        sections: [identitySection, ...configSections]
+            .filter((value) => value !== null),
+        ...(voice.voices.length > 0 ? { voice } : {}),
+        fetchedAt: input.fetchedAt ?? Date.now(),
+    };
+}
+function normalizeNativeConfigResponse(payload, agentId, defaultSourcePath) {
+    const root = asRecord(payload);
+    const candidate = asRecord(root.config).sections ? asRecord(root.config) : root;
+    if (Array.isArray(candidate.sections)) {
+        const voice = parseAgentVoiceConfig(candidate);
+        return {
+            agentId: cleanString(candidate.agentId) || agentId,
+            agentName: cleanString(candidate.agentName) || cleanString(candidate.name) || agentId,
+            ...(cleanString(candidate.sourcePath) ? { sourcePath: cleanString(candidate.sourcePath) } : {}),
+            ...(cleanString(candidate.etag) ? { etag: cleanString(candidate.etag) } : {}),
+            sections: candidate.sections,
+            ...(voice.voices.length > 0 ? { voice } : {}),
+            fetchedAt: asNumber(candidate.fetchedAt) ?? Date.now(),
+        };
+    }
+    if (Object.keys(asRecord(root.schema)).length > 0 || Object.keys(asRecord(root.defaults)).length > 0) {
+        return buildAgentConfigFromConfigSnapshot({
+            agentId,
+            config: asRecord(root.config),
+            schema: root.schema,
+            defaults: root.defaults,
+            defaultSourcePath,
+            profile: asRecord(root.profile).name
+                ? {
+                    agentId,
+                    agentName: cleanString(asRecord(root.profile).name) || agentId,
+                    sourcePath: cleanString(asRecord(root.profile).path),
+                }
+                : null,
+            fetchedAt: asNumber(root.fetchedAt) ?? Date.now(),
+            etag: cleanString(root.etag),
+        });
+    }
+    const rawConfig = asRecord(root.rawConfig).model || asRecord(root.rawConfig).agent
+        ? asRecord(root.rawConfig)
+        : asRecord(root.config);
+    if (Object.keys(rawConfig).length > 0) {
+        return buildAgentConfigFromConfigSnapshot({
+            agentId,
+            config: rawConfig,
+            defaultSourcePath,
+            profile: asRecord(root.profile).name
+                ? {
+                    agentId,
+                    agentName: cleanString(asRecord(root.profile).name) || agentId,
+                    sourcePath: cleanString(asRecord(root.profile).path),
+                }
+                : null,
+            fetchedAt: asNumber(root.fetchedAt) ?? Date.now(),
+            etag: cleanString(root.etag),
+        });
+    }
+    return null;
+}
+export function buildAgentProfileConfigPatchBody(params) {
+    const agentId = assertAgentProfileId(params.agentId);
+    const patch = Object.fromEntries(Object.entries(params.diff).filter(([, value]) => value !== undefined));
+    return {
+        contract: AGENT_PROFILE_CONFIG_PATCH_CONTRACT,
+        version: 1,
+        agentId,
+        profile: agentId,
+        source: "profile-config-yaml",
+        sourcePath: cleanString(params.sourcePath) ||
+            (params.defaultSourcePath ?? agentProfileConfigSourcePath)(agentId),
+        patch,
+        ...(params.baseEtag ? { baseEtag: params.baseEtag } : {}),
+    };
+}
+export class GatewayAgentConfigApiClient extends BaseHttpApiClient {
+    endpoints;
+    defaultSourcePath;
+    constructor(options, configOptions = {}) {
+        super(configOptions.surface ?? "gateway-agent-config-api", options);
+        this.endpoints = configOptions.endpoints ?? GATEWAY_AGENT_CONFIG_API_ENDPOINTS;
+        this.defaultSourcePath = configOptions.defaultSourcePath ?? agentProfileConfigSourcePath;
+    }
+    async listProfiles() {
+        try {
+            const nativePayload = await this.requestJson(this.endpoints.agentConfigs);
+            const root = asRecord(nativePayload);
+            const nativeProfiles = normalizeAgentProfiles({ profiles: root.agents ?? root.profiles });
+            if (nativeProfiles.length > 0)
+                return nativeProfiles;
+        }
+        catch (error) {
+            if (!isMissingAgentConfigRouteError(error))
+                throw error;
+        }
+        return normalizeAgentProfiles(await this.requestJson(this.endpoints.profiles));
+    }
+    async getProfileConfig(agentId) {
+        const id = assertAgentProfileId(agentId);
+        const payload = await this.requestJson(this.endpoints.agentConfig(id));
+        const config = normalizeNativeConfigResponse(payload, id, this.defaultSourcePath);
+        if (!config) {
+            throw new GatewayAgentConfigApiError("Agent config API returned an invalid config payload.", { path: this.endpoints.agentConfig(id) });
+        }
+        return config;
+    }
+    async patchProfileConfig(agentId, diff, options = {}) {
+        const id = assertAgentProfileId(agentId);
+        const body = buildAgentProfileConfigPatchBody({
+            agentId: id,
+            diff,
+            baseEtag: options.baseEtag,
+            sourcePath: options.sourcePath,
+            defaultSourcePath: this.defaultSourcePath,
+        });
+        const payload = await this.requestJson(this.endpoints.agentConfig(id), {
+            method: "PATCH",
+            body,
+        });
+        const config = normalizeNativeConfigResponse(payload, id, this.defaultSourcePath);
+        if (config)
+            return config;
+        return this.getProfileConfig(id);
+    }
+}

package/dist/core/gateway/agent/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./commands.js";
+export * from "./config.js";
+export * from "./voice-config.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/gateway/agent/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/gateway/agent/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC"}

package/dist/core/gateway/agent/index.js

@@ -0,0 +1,3 @@
+export * from "./commands.js";
+export * from "./config.js";
+export * from "./voice-config.js";

package/dist/core/gateway/agent/voice-config.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Pure parsing for the `tts` block inside a raw agent config payload. Tolerates
+ * both snake_case (native YAML) and camelCase (gateway serialisation); every
+ * field is optional and the parser is fully defensive against missing data.
+ */
+/** Voice capabilities for a single TTS provider as configured for this agent. */
+export type AgentTtsProviderVoice = {
+    provider: string;
+    isActive: boolean;
+    voiceId: string | null;
+    model: string | null;
+    extras?: Record<string, string | number>;
+};
+/** Aggregated voice configuration for an agent, parsed from its raw config payload. */
+export type AgentVoiceConfig = {
+    activeProvider: string | null;
+    voices: AgentTtsProviderVoice[];
+};
+export declare function parseAgentVoiceConfig(rawConfig: unknown): AgentVoiceConfig;
+//# sourceMappingURL=voice-config.d.ts.map

package/dist/core/gateway/agent/voice-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"voice-config.d.ts","sourceRoot":"","sources":["../../../../src/core/gateway/agent/voice-config.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAYH,iFAAiF;AACjF,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC;CAC1C,CAAC;AAEF,uFAAuF;AACvF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,MAAM,EAAE,qBAAqB,EAAE,CAAC;CACjC,CAAC;AAIF,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,OAAO,GAAG,gBAAgB,CAyD1E"}

package/dist/core/gateway/agent/voice-config.js

@@ -0,0 +1,65 @@
+/**
+ * Pure parsing for the `tts` block inside a raw agent config payload. Tolerates
+ * both snake_case (native YAML) and camelCase (gateway serialisation); every
+ * field is optional and the parser is fully defensive against missing data.
+ */
+function asRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function cleanString(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+const TTS_META_KEYS = new Set(["provider"]);
+export function parseAgentVoiceConfig(rawConfig) {
+    const root = asRecord(rawConfig);
+    const ttsBlock = asRecord(root.tts).provider !== undefined ||
+        Object.keys(asRecord(root.tts)).length > 0
+        ? asRecord(root.tts)
+        : asRecord(asRecord(root.config).tts);
+    const activeProvider = cleanString(ttsBlock.provider) || null;
+    const voices = [];
+    for (const [key, value] of Object.entries(ttsBlock)) {
+        if (TTS_META_KEYS.has(key))
+            continue;
+        if (typeof value !== "object" || value === null || Array.isArray(value))
+            continue;
+        const sub = asRecord(value);
+        const voiceId = cleanString(sub.voice_id) ||
+            cleanString(sub.voiceId) ||
+            cleanString(sub.voice) ||
+            null;
+        const model = cleanString(sub.model_id) ||
+            cleanString(sub.modelId) ||
+            cleanString(sub.model) ||
+            null;
+        const knownVoiceKeys = new Set(["voice_id", "voiceId", "voice", "model_id", "modelId", "model"]);
+        const extras = {};
+        for (const [subKey, subValue] of Object.entries(sub)) {
+            if (knownVoiceKeys.has(subKey))
+                continue;
+            if (typeof subValue === "string" && subValue.trim() !== "") {
+                extras[subKey] = subValue.trim();
+            }
+            else if (typeof subValue === "number" && Number.isFinite(subValue)) {
+                extras[subKey] = subValue;
+            }
+        }
+        voices.push({
+            provider: key,
+            isActive: key === activeProvider,
+            voiceId,
+            model,
+            ...(Object.keys(extras).length > 0 ? { extras } : {}),
+        });
+    }
+    voices.sort((a, b) => {
+        if (a.isActive && !b.isActive)
+            return -1;
+        if (!a.isActive && b.isActive)
+            return 1;
+        return a.provider.localeCompare(b.provider);
+    });
+    return { activeProvider, voices };
+}

package/dist/core/gateway/client/capabilities.d.ts

@@ -0,0 +1,28 @@
+import { type GatewayMediaKind, type GatewayMediaProvider, type GatewayMediaProviderList } from "../resources/media.js";
+import type { GatewayCapabilities } from "./client.js";
+export type GatewayMediaCapabilityMap = Record<GatewayMediaKind, boolean>;
+export type NormalizedGatewayFeatureCapabilities = {
+    media: boolean;
+    mediaKinds: GatewayMediaCapabilityMap;
+    textToSpeech: boolean;
+    wiki: boolean;
+    sse: boolean;
+    websocket: boolean;
+    rpc: boolean;
+    rpcMethods: readonly string[];
+    actions: readonly string[];
+    commands: readonly string[];
+    rawFeatures: Record<string, unknown>;
+};
+export type GatewayMediaProviderCapabilityInput = GatewayMediaProviderList | readonly GatewayMediaProvider[] | readonly GatewayMediaProviderList[];
+export type NormalizeGatewayFeatureCapabilitiesOptions = {
+    capabilities?: GatewayCapabilities | null;
+    mediaProviders?: GatewayMediaProviderCapabilityInput | null;
+};
+export type GatewayFeatureCapabilityInput = GatewayCapabilities | NormalizedGatewayFeatureCapabilities | null | undefined;
+export declare function normalizeGatewayFeatureCapabilities(options?: NormalizeGatewayFeatureCapabilitiesOptions): NormalizedGatewayFeatureCapabilities;
+export declare function gatewaySupportsMediaKind(input: GatewayFeatureCapabilityInput, kind: GatewayMediaKind | string): boolean;
+export declare function gatewaySupportsTextToSpeech(input: GatewayFeatureCapabilityInput): boolean;
+export declare function gatewaySupportsAction(input: GatewayFeatureCapabilityInput, action: string): boolean;
+export declare function gatewaySupportsRpcMethod(input: GatewayFeatureCapabilityInput, method: string): boolean;
+//# sourceMappingURL=capabilities.d.ts.map

package/dist/core/gateway/client/capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../../../../src/core/gateway/client/capabilities.ts"],"names":[],"mappings":"AAIA,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC9B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAEvD,MAAM,MAAM,yBAAyB,GAAG,MAAM,CAAC,gBAAgB,EAAE,OAAO,CAAC,CAAC;AAE1E,MAAM,MAAM,oCAAoC,GAAG;IACjD,KAAK,EAAE,OAAO,CAAC;IACf,UAAU,EAAE,yBAAyB,CAAC;IACtC,YAAY,EAAE,OAAO,CAAC;IACtB,IAAI,EAAE,OAAO,CAAC;IACd,GAAG,EAAE,OAAO,CAAC;IACb,SAAS,EAAE,OAAO,CAAC;IACnB,GAAG,EAAE,OAAO,CAAC;IACb,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,mCAAmC,GAC3C,wBAAwB,GACxB,SAAS,oBAAoB,EAAE,GAC/B,SAAS,wBAAwB,EAAE,CAAC;AAExC,MAAM,MAAM,0CAA0C,GAAG;IACvD,YAAY,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAC1C,cAAc,CAAC,EAAE,mCAAmC,GAAG,IAAI,CAAC;CAC7D,CAAC;AAEF,MAAM,MAAM,6BAA6B,GACrC,mBAAmB,GACnB,oCAAoC,GACpC,IAAI,GACJ,SAAS,CAAC;AAgPd,wBAAgB,mCAAmC,CACjD,OAAO,GAAE,0CAA+C,GACvD,oCAAoC,CA+DtC;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,6BAA6B,EACpC,IAAI,EAAE,gBAAgB,GAAG,MAAM,GAC9B,OAAO,CAIT;AAED,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,6BAA6B,GACnC,OAAO,CAET;AAED,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,6BAA6B,EACpC,MAAM,EAAE,MAAM,GACb,OAAO,CAMT;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,6BAA6B,EACpC,MAAM,EAAE,MAAM,GACb,OAAO,CAMT"}