Skip to content

Voice-to-text dictation app with local (Nvidia Parakeet/Whisper) and cloud models (BYOK). Privacy-first and available cross-platform.

8.2 KB
Raw Blame
const ENTERPRISE_INFERENCE_SCOPES = [
  "dictationCleanup",
  "dictationAgent",
  "noteFormatting",
  "chatIntelligence",
  "dictationTranslation",
];

/** The managed speech-to-text scope; resolved from the Azure `transcription` config section. */
const ENTERPRISE_TRANSCRIPTION_SCOPE = "transcription";

const ENTERPRISE_PROVIDERS = ["bedrock", "azure"];
const PROVIDER_MODES = ["disabled", "managed_default", "managed_required"];
const AWS_ROLE_ARN = /^arn:(aws|aws-us-gov):iam::\d{12}:role\/[A-Za-z0-9+=,.@_/-]{1,512}$/;
const AWS_REGION = /^[a-z]{2}(?:-gov)?-[a-z]+-\d$/;
const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
const AZURE_LEGACY_API_VERSION = /^\d{4}-\d{2}-\d{2}(?:-preview)?$/;

function isNonEmptyString(value) {
  return typeof value === "string" && value.trim().length > 0;
}

function isStringMap(value) {
  return (
    value &&
    typeof value === "object" &&
    !Array.isArray(value) &&
    Object.values(value).every(isNonEmptyString)
  );
}

function isSafeHttpsUrl(value) {
  try {
    const url = new URL(value);
    return (
      url.protocol === "https:" &&
      !url.username &&
      !url.password &&
      (!url.port || url.port === "443")
    );
  } catch {
    return false;
  }
}

// Azure OpenAI resource hosts, including AI Foundry deployments.
const AZURE_HOST_SUFFIXES = [
  ".openai.azure.com",
  ".cognitiveservices.azure.com",
  ".services.ai.azure.com",
];

function isAllowedAzureEndpoint(value) {
  if (!isSafeHttpsUrl(value)) return false;
  const url = new URL(value);
  const hostname = url.hostname.toLowerCase();
  return (
    AZURE_HOST_SUFFIXES.some(
      (suffix) => hostname.endsWith(suffix) && hostname.length > suffix.length
    ) &&
    (url.pathname === "" || url.pathname === "/") &&
    !url.search &&
    !url.hash
  );
}

function isAllowedAzureApiVersion(value) {
  return value === "v1" || value === "preview" || AZURE_LEGACY_API_VERSION.test(value);
}

function isValidLlmSection(allowed, defaults) {
  if (!Array.isArray(allowed) || allowed.length === 0 || !allowed.every(isNonEmptyString)) {
    return false;
  }
  if (!isStringMap(defaults)) return false;
  if (
    !ENTERPRISE_INFERENCE_SCOPES.every((scope) => isNonEmptyString(defaults[scope])) ||
    !Object.keys(defaults).every((scope) => ENTERPRISE_INFERENCE_SCOPES.includes(scope))
  ) {
    return false;
  }
  return Object.values(defaults).every((model) => allowed.includes(model));
}

function isValidTranscriptionSection(transcription) {
  return (
    transcription &&
    typeof transcription === "object" &&
    Array.isArray(transcription.allowedDeployments) &&
    transcription.allowedDeployments.length > 0 &&
    transcription.allowedDeployments.every(isNonEmptyString) &&
    isNonEmptyString(transcription.defaultDeployment) &&
    transcription.allowedDeployments.includes(transcription.defaultDeployment)
  );
}

function isValidProviderConfig(record) {
  if (!record || !ENTERPRISE_PROVIDERS.includes(record.provider)) return false;
  if (!PROVIDER_MODES.includes(record.mode) || typeof record.allowManualSetup !== "boolean") {
    return false;
  }
  if (!Number.isSafeInteger(record.version) || record.version < 1) return false;
  const config = record.config;
  if (!config || typeof config !== "object") return false;

  if (record.provider === "bedrock") {
    const partition = typeof config.roleArn === "string" ? config.roleArn.split(":")[1] : null;
    const isGovRegion = typeof config.region === "string" && config.region.startsWith("us-gov-");
    return (
      isValidLlmSection(config.allowedModels, config.scopeDefaults) &&
      AWS_ROLE_ARN.test(config.roleArn) &&
      AWS_REGION.test(config.region) &&
      (partition === "aws-us-gov") === isGovRegion &&
      !config.region.startsWith("cn-")
    );
  }
  // Azure carries independent text and transcription sections; at least one
  // must be present and every present section must be complete.
  const hasLlmSection =
    config.allowedDeployments !== undefined || config.scopeDefaults !== undefined;
  if (!hasLlmSection && config.transcription === undefined) return false;
  if (hasLlmSection && !isValidLlmSection(config.allowedDeployments, config.scopeDefaults)) {
    return false;
  }
  if (config.transcription !== undefined && !isValidTranscriptionSection(config.transcription)) {
    return false;
  }
  return (
    UUID.test(config.tenantId) &&
    UUID.test(config.clientId) &&
    isAllowedAzureEndpoint(config.endpoint) &&
    isAllowedAzureApiVersion(config.apiVersion)
  );
}

function validateManagedEnterpriseEnvelope(value, expectedWorkspaceId) {
  if (!value || typeof value !== "object" || value.workspaceId !== expectedWorkspaceId) return null;
  if (!Number.isSafeInteger(value.version) || value.version < 0) return null;
  const generation = value.generation ?? value.version;
  if (!Number.isSafeInteger(generation) || generation < 0) return null;
  if (!value.identity || typeof value.identity !== "object" || !Array.isArray(value.providers)) {
    return null;
  }
  if (
    !isSafeHttpsUrl(value.identity.issuer) ||
    !isSafeHttpsUrl(value.identity.jwksUri) ||
    value.identity.subject !== `workspace:${expectedWorkspaceId}` ||
    value.identity.audiences?.bedrock !== "sts.amazonaws.com" ||
    value.identity.audiences?.azure !== "api://AzureADTokenExchange"
  ) {
    return null;
  }
  if (!value.providers.every(isValidProviderConfig)) return null;
  if (
    value.refreshAfter !== undefined &&
    (typeof value.refreshAfter !== "string" || Number.isNaN(Date.parse(value.refreshAfter)))
  ) {
    return null;
  }
  if (
    value.azureEndpointContract !== undefined &&
    value.azureEndpointContract !== "resource-origin"
  ) {
    return null;
  }
  return { ...value, generation };
}

function resolutionError(code, message) {
  return { kind: "error", code, message };
}

function managedModelFor(record, scope) {
  if (scope === ENTERPRISE_TRANSCRIPTION_SCOPE) {
    return record.config.transcription?.defaultDeployment;
  }
  return record.config.scopeDefaults?.[scope];
}

function resolveManagedEnterpriseScope(envelope, scope, setupMode = "auto") {
  if (!ENTERPRISE_INFERENCE_SCOPES.includes(scope) && scope !== ENTERPRISE_TRANSCRIPTION_SCOPE) {
    return resolutionError("MANAGED_SCOPE_INVALID", "The requested inference scope is invalid.");
  }
  if (!envelope?.providers?.length) return { kind: "manual" };

  const configured = envelope.providers.filter(
    (record) => record.mode !== "disabled" && isNonEmptyString(managedModelFor(record, scope))
  );
  if (!configured.length) return { kind: "manual" };

  const enforced = configured.filter(
    (record) => record.mode === "managed_required" || !record.allowManualSetup
  );
  const candidates = enforced.length ? enforced : setupMode === "manual" ? [] : configured;
  if (!candidates.length) return { kind: "manual" };

  if (candidates.length !== 1) {
    return resolutionError(
      "MANAGED_CONFIG_AMBIGUOUS",
      "Managed enterprise configuration is inconsistent. Contact your IT administrator."
    );
  }
  const [record] = candidates;
  return {
    kind: "managed",
    provider: record.provider,
    model: managedModelFor(record, scope),
    mode: record.mode,
    allowManualSetup: record.allowManualSetup,
    record,
  };
}

/**
 * Scopes any active record resolves a managed model for, and the subset that
 * is enforced (managed_required or manual setup disallowed). Enforcement is
 * per scope: a text-only workspace must never fail transcription closed.
 */
function managedScopesForConfig(config) {
  const managed = [];
  const enforced = [];
  for (const record of config?.providers ?? []) {
    if (record.mode === "disabled") continue;
    const isEnforced = record.mode === "managed_required" || !record.allowManualSetup;
    for (const scope of [...ENTERPRISE_INFERENCE_SCOPES, ENTERPRISE_TRANSCRIPTION_SCOPE]) {
      if (!isNonEmptyString(managedModelFor(record, scope))) continue;
      if (!managed.includes(scope)) managed.push(scope);
      if (isEnforced && !enforced.includes(scope)) enforced.push(scope);
    }
  }
  return { managed, enforced };
}

export {
  AZURE_HOST_SUFFIXES,
  ENTERPRISE_INFERENCE_SCOPES,
  ENTERPRISE_TRANSCRIPTION_SCOPE,
  ENTERPRISE_PROVIDERS,
  isAllowedAzureEndpoint,
  validateManagedEnterpriseEnvelope,
  resolveManagedEnterpriseScope,
  managedScopesForConfig,
};